@swisspost/internet-header 1.17.1 → 10.2.0

package/dist/cjs/_commonjsHelpers-BJu3ubxk.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+exports.commonjsGlobal = commonjsGlobal;
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;

package/dist/cjs/ar-B-n6-52-.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-BJu3ubxk.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 ar$2 = {};
+
+var hasRequiredAr;
+
+function requireAr () {
+	if (hasRequiredAr) return ar$2;
+	hasRequiredAr = 1;
+
+	Object.defineProperty(ar$2, "__esModule", {
+	  value: true
+	});
+	ar$2.default = void 0;
+	var _default = {
+	  days: ['الأحد', 'الأثنين', 'الثلاثاء', 'الأربعاء', 'الخميس', 'الجمعه', 'السبت'],
+	  daysShort: ['الأحد', 'الأثنين', 'الثلاثاء', 'الأربعاء', 'الخميس', 'الجمعه', 'السبت'],
+	  daysMin: ['الأحد', 'الأثنين', 'الثلاثاء', 'الأربعاء', 'الخميس', 'الجمعه', 'السبت'],
+	  months: ['يناير', 'فبراير', 'مارس', 'أبريل', 'مايو', 'يونيو', 'يوليو', 'أغسطس', 'سبتمبر', 'اكتوبر', 'نوفمبر', 'ديسمبر'],
+	  monthsShort: ['يناير', 'فبراير', 'مارس', 'أبريل', 'مايو', 'يونيو', 'يوليو', 'أغسطس', 'سبتمبر', 'اكتوبر', 'نوفمبر', 'ديسمبر'],
+	  today: 'اليوم',
+	  clear: 'حذف',
+	  dateFormat: 'dd/MM/yyyy',
+	  timeFormat: 'hh:mm aa',
+	  firstDay: 0
+	};
+	ar$2.default = _default;
+	return ar$2;
+}
+
+var arExports = requireAr();
+var ar = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(arExports);
+
+var ar$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: ar
+}, [arExports]);
+
+exports.ar = ar$1;

package/dist/cjs/bg-DXwp1AJo.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-BJu3ubxk.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 bg$2 = {};
+
+var hasRequiredBg;
+
+function requireBg () {
+	if (hasRequiredBg) return bg$2;
+	hasRequiredBg = 1;
+
+	Object.defineProperty(bg$2, "__esModule", {
+	  value: true
+	});
+	bg$2.default = void 0;
+	var _default = {
+	  days: ["Неделя", "Понеделник", "Вторник", "Сряда", "Четвъртък", "Петък", "Събота"],
+	  daysShort: ["Нед", "Пон", "Вто", "Сря", "Чет", "Пет", "Съб"],
+	  daysMin: ["Нд", "Пн", "Вт", "Ср", "Чт", "Пт", "Сб"],
+	  months: ["Януари", "Февруари", "Март", "Април", "Май", "Юни", "Юли", "Август", "Септември", "Октомври", "Ноември", "Декември"],
+	  monthsShort: ["Яну", "Фев", "Мар", "Апр", "Май", "Юни", "Юли", "Авг", "Сеп", "Окт", "Ное", "Дек"],
+	  today: "Днес",
+	  clear: "Изчисти",
+	  dateFormat: "dd.MM.yyyy",
+	  timeFormat: 'HH:mm',
+	  firstDay: 1
+	};
+	bg$2.default = _default;
+	return bg$2;
+}
+
+var bgExports = requireBg();
+var bg = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(bgExports);
+
+var bg$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: bg
+}, [bgExports]);
+
+exports.bg = bg$1;

package/dist/cjs/breakpoints-CI0Xuh1L.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var index = require('./index-CggFmZ8n.js');
+
+class Breakpoint {
+    constructor() {
+        this.breakpoints = [
+            { key: 'xl', device: 'desktop', minWidth: 1280 },
+            { key: 'lg', device: 'desktop', minWidth: 1024 },
+            { key: 'md', device: 'tablet', minWidth: 780 },
+            { key: 'sm', device: 'tablet', minWidth: 600 },
+            { key: 'xs', device: 'mobile', minWidth: 0 },
+        ];
+        this.resizeObserver = globalThis.ResizeObserver
+            ? new ResizeObserver(() => this.updateCurrentBreakpoint())
+            : null;
+        this.updateCurrentBreakpoint = index.throttle(50, (options = { emitEvents: true }) => {
+            const previousBreakpoint = this.currentBreakpoint;
+            const newBreakpoint = this.breakpoints.find(breakpoint => {
+                return breakpoint.minWidth <= innerWidth;
+            });
+            if (!newBreakpoint)
+                return;
+            this.currentBreakpoint = newBreakpoint;
+            if (!options.emitEvents)
+                return;
+            Object.keys(this.currentBreakpoint)
+                .filter(key => !previousBreakpoint || this.currentBreakpoint[key] !== previousBreakpoint[key])
+                .forEach((key) => this.dispatchEvent(key));
+        });
+        if (this.resizeObserver) {
+            this.updateCurrentBreakpoint({ emitEvents: false });
+            this.resizeObserver.observe(document.body);
+        }
+    }
+    dispatchEvent(property) {
+        globalThis.dispatchEvent(new CustomEvent(`postBreakpoint:${property}`, { detail: this.currentBreakpoint[property] }));
+    }
+    get(property) {
+        this.updateCurrentBreakpoint({ emitEvents: false });
+        return this.currentBreakpoint[property];
+    }
+}
+const breakpoint = new Breakpoint();
+
+exports.breakpoint = breakpoint;

package/dist/cjs/ca-DzXDkiON.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-BJu3ubxk.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 ca$2 = {};
+
+var hasRequiredCa;
+
+function requireCa () {
+	if (hasRequiredCa) return ca$2;
+	hasRequiredCa = 1;
+
+	Object.defineProperty(ca$2, "__esModule", {
+	  value: true
+	});
+	ca$2.default = void 0;
+	var _default = {
+	  days: ["Diumenge", "Dilluns", "Dimarts", "Dimecres", "Dijous", "Divendres", "Dissabte"],
+	  daysShort: ["Diu", "Dil", "Dmt", "Dmc", "Dij", "Div", "Dis"],
+	  daysMin: ["dg", "dl", "dt", "dc", "dj", "dv", "ds"],
+	  months: ["Gener", "Febrer", "Març", "Abril", "Maig", "Juny", "Juliol", "Agost", "Setembre", "Octubre", "Novembre", "Desembre"],
+	  monthsShort: ["Gen", "Feb", "Mar", "Abr", "Mai", "Jun", "Jul", "Ago", "Set", "Oct", "Nov", "Des"],
+	  today: "Avui",
+	  clear: 'Neteja',
+	  dateFormat: 'dd/MM/yyyy',
+	  timeFormat: 'hh:mm aa',
+	  firstDay: 1
+	};
+	ca$2.default = _default;
+	return ca$2;
+}
+
+var caExports = requireCa();
+var ca = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(caExports);
+
+var ca$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: ca
+}, [caExports]);
+
+exports.ca = ca$1;

package/dist/cjs/component-on-ready-CifOTqw1.js

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * Invoke the `componentOnReady` method if it is available, simulate it otherwise
+ * @see https://stenciljs.com/docs/api#componentonready
+ */
+function componentOnReady(el) {
+    if (typeof el.componentOnReady === 'function') {
+        return el.componentOnReady();
+    }
+    else {
+        return new Promise(resolve => customOnReady(() => {
+            resolve(el);
+        }));
+    }
+}
+function customOnReady(callback) {
+    if (typeof requestAnimationFrame === 'function') {
+        return requestAnimationFrame(callback);
+    }
+    return setTimeout(callback);
+}
+
+exports.componentOnReady = componentOnReady;

package/dist/cjs/create-validator-decorator-CJK3Xf77.js

@@ -0,0 +1,223 @@
+'use strict';
+
+var index = require('./index-B5ypPkK3.js');
+
+const EMPTY_VALUES = [undefined, null, '', Number.NaN];
+function isValueEmpty(value) {
+    return EMPTY_VALUES.some(v => Object.is(v, value));
+}
+
+/** Tracks prototypes whose `componentDidLoad` lifecycle has already been wrapped. */
+const patchedTargets = new WeakSet();
+/** Tracks component instances that already completed the first load cycle. */
+const loadedInstances = new WeakSet();
+/** Stores validators per component prototype and property name. */
+const validatorsByTarget = new WeakMap();
+/** Stores all properties that use a validator decorator for each component prototype. */
+const decoratedPropertiesByTarget = new WeakMap();
+/** Stores per-instance property values captured by dynamically created accessors. */
+const propertyValuesByInstance = new WeakMap();
+/** Stores dependency relationships per prototype: dependencyProp -> Set<dependentProp>. */
+const dependenciesByTarget = new WeakMap();
+/**
+ * Returns the value for a key in a {@link WeakMap} and lazily creates it when missing.
+ *
+ * @template K WeakMap key type.
+ * @template T WeakMap value type.
+ * @param map WeakMap used as storage.
+ * @param key Object key used to retrieve or initialize the value.
+ * @param factory Factory creating the value when no entry exists for the key.
+ * @returns Existing or newly created value associated with the key.
+ */
+function getOrCreate(map, key, factory) {
+    let value = map.get(key);
+    if (!value) {
+        value = factory();
+        map.set(key, value);
+    }
+    return value;
+}
+/**
+ * Returns the mutable validator list registered for a property on a component prototype.
+ *
+ * @param target Component prototype where decorators were applied.
+ * @param property Decorated property name.
+ * @returns Validator list for the property.
+ */
+function getValidators(target, property) {
+    const validatorsByProperty = getOrCreate(validatorsByTarget, target, () => new Map());
+    return getOrCreate(validatorsByProperty, property, () => []);
+}
+/**
+ * Returns all property names decorated with validator decorators for a prototype.
+ *
+ * @param target Component prototype where decorators were applied.
+ * @returns Set of decorated property names.
+ */
+function getDecoratedProperties(target) {
+    return getOrCreate(decoratedPropertiesByTarget, target, () => new Set());
+}
+/**
+ * Returns the map containing tracked property values for a component instance.
+ *
+ * @param instance Component instance.
+ * @returns Map keyed by property name with last assigned values.
+ */
+function getValuesByProperty(instance) {
+    return getOrCreate(propertyValuesByInstance, instance, () => new Map());
+}
+/**
+ * Registers that `dependentProp` should be re-validated when `dependencyProp` changes.
+ * Ensures the dependency property has an accessor so its setter can trigger dependents.
+ */
+function registerDependency(target, dependencyProp, dependentProp) {
+    // Ensure dependency has an accessor so its setter can run dependent validators
+    createPropertyAccessor(target, dependencyProp);
+    const depsByProp = getOrCreate(dependenciesByTarget, target, () => new Map());
+    const dependents = getOrCreate(depsByProp, dependencyProp, () => new Set());
+    dependents.add(dependentProp);
+}
+/**
+ * Defines an accessor for a decorated property that stores values per instance and
+ * triggers validation after the component first loads.
+ *
+ * Accessor creation is skipped when a getter already exists to avoid overriding
+ * component-defined accessors.
+ *
+ * @param target Component prototype receiving the accessor.
+ * @param property Decorated property name.
+ */
+function createPropertyAccessor(target, property) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, property);
+    if (descriptor && descriptor.get)
+        return;
+    Object.defineProperty(target, property, {
+        get() {
+            return getValuesByProperty(this).get(property);
+        },
+        set(newValue) {
+            getValuesByProperty(this).set(property, newValue);
+            if (loadedInstances.has(this)) {
+                runValidators(this, property);
+                // Run validators for any properties that depend on this property.
+                const proto = Object.getPrototypeOf(this);
+                const depsByProp = dependenciesByTarget.get(proto);
+                if (depsByProp) {
+                    const dependents = depsByProp.get(property);
+                    if (dependents) {
+                        for (const dependent of dependents) {
+                            runValidators(this, dependent);
+                        }
+                    }
+                }
+            }
+        },
+        enumerable: true,
+        configurable: true,
+    });
+}
+/**
+ * Wraps `componentDidLoad` once per prototype to execute validators on initial render.
+ *
+ * Existing `componentDidLoad` behavior is preserved and called after validation.
+ *
+ * @param target Component prototype to patch.
+ */
+function patchComponentDidLoad(target) {
+    if (patchedTargets.has(target))
+        return;
+    patchedTargets.add(target);
+    const original = 'componentDidLoad' in target && typeof target.componentDidLoad === 'function'
+        ? target.componentDidLoad
+        : undefined;
+    Object.defineProperty(target, 'componentDidLoad', {
+        writable: true,
+        configurable: true,
+        value: function (...args) {
+            loadedInstances.add(this);
+            const decoratedProperties = getDecoratedProperties(Object.getPrototypeOf(this));
+            for (const property of decoratedProperties) {
+                runValidators(this, property);
+            }
+            if (original) {
+                return original.apply(this, args);
+            }
+        },
+    });
+}
+/**
+ * Executes all validators for a property in ascending priority order.
+ *
+ * Validation is skipped for empty values unless a validator explicitly opts in via
+ * `validateEmptyValues`. Execution stops when a blocking validator fails.
+ *
+ * @param component Component instance.
+ * @param property Property name to validate.
+ */
+function runValidators(component, property) {
+    const prototype = Object.getPrototypeOf(component);
+    const validatorsByProperty = validatorsByTarget.get(prototype);
+    if (!validatorsByProperty)
+        return;
+    const validators = validatorsByProperty.get(property);
+    if (!validators || validators.length === 0)
+        return;
+    const sortedValidators = [...validators].sort((a, b) => a.priority - b.priority);
+    const value = component[property];
+    const valueIsEmpty = isValueEmpty(value);
+    for (const validator of sortedValidators) {
+        if (valueIsEmpty && !validator.validateEmptyValues) {
+            continue;
+        }
+        const passed = validator.run(component, property);
+        if (!passed && validator.blocking)
+            break;
+    }
+}
+/**
+ * Creates a property decorator that registers a validator for a component property.
+ *
+ * The returned decorator ensures property access is intercepted, initial-load
+ * validation is enabled, and the provided validator is stored for execution.
+ *
+ * @param validator Validator definition to register.
+ * @returns Property decorator compatible with TypeScript decorator syntax.
+ */
+function createValidatorDecorator(validator) {
+    return function (target, property) {
+        createPropertyAccessor(target, property);
+        patchComponentDidLoad(target);
+        getDecoratedProperties(target).add(property);
+        getValidators(target, property).push(validator);
+    };
+}
+/**
+ * Builds a validation context for a decorated component property.
+ *
+ * The returned context includes:
+ * - `value`: current property value.
+ * - `showError(constraint)`: helper that logs a consistent error format and includes
+ *   the host element for easier debugging in browser consoles.
+ *
+ * Message format: `[componentName] Property "property" <constraint>. Received: <value>.`
+ *
+ * @param component Component instance containing the validated property.
+ * @param property Property name being validated.
+ * @returns Validation context used by individual validator implementations.
+ */
+function getValidationContext(component, property) {
+    const host = index.getElement(component);
+    const componentName = host.localName;
+    const value = component[property];
+    return {
+        value,
+        showError(constraint) {
+            console.error(`[${componentName}] Property "${String(property)}" ${constraint}. Received: ${JSON.stringify(value)}.`, host);
+        },
+    };
+}
+
+exports.createValidatorDecorator = createValidatorDecorator;
+exports.getValidationContext = getValidationContext;
+exports.isValueEmpty = isValueEmpty;
+exports.registerDependency = registerDependency;

package/dist/cjs/cs-c0Y4EfUF.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-BJu3ubxk.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 cs$2 = {};
+
+var hasRequiredCs;
+
+function requireCs () {
+	if (hasRequiredCs) return cs$2;
+	hasRequiredCs = 1;
+
+	Object.defineProperty(cs$2, "__esModule", {
+	  value: true
+	});
+	cs$2.default = void 0;
+	var _default = {
+	  days: ['Neděle', 'Pondělí', 'Úterý', 'Středa', 'Čtvrtek', 'Pátek', 'Sobota'],
+	  daysShort: ['Ne', 'Po', 'Út', 'St', 'Čt', 'Pá', 'So'],
+	  daysMin: ['Ne', 'Po', 'Út', 'St', 'Čt', 'Pá', 'So'],
+	  months: ['Leden', 'Únor', 'Březen', 'Duben', 'Květen', 'Červen', 'Červenec', 'Srpen', 'Září', 'Říjen', 'Listopad', 'Prosinec'],
+	  monthsShort: ['Led', 'Úno', 'Bře', 'Dub', 'Kvě', 'Čvn', 'Čvc', 'Srp', 'Zář', 'Říj', 'Lis', 'Pro'],
+	  today: 'Dnes',
+	  clear: 'Vymazat',
+	  dateFormat: 'dd.MM.yyyy',
+	  timeFormat: 'HH:mm',
+	  firstDay: 1
+	};
+	cs$2.default = _default;
+	return cs$2;
+}
+
+var csExports = requireCs();
+var cs = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(csExports);
+
+var cs$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: cs
+}, [csExports]);
+
+exports.cs = cs$1;

package/dist/cjs/da-DFMBgc6C.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-BJu3ubxk.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 da$2 = {};
+
+var hasRequiredDa;
+
+function requireDa () {
+	if (hasRequiredDa) return da$2;
+	hasRequiredDa = 1;
+
+	Object.defineProperty(da$2, "__esModule", {
+	  value: true
+	});
+	da$2.default = void 0;
+	var _default = {
+	  days: ['Søndag', 'Mandag', 'Tirsdag', 'Onsdag', 'Torsdag', 'Fredag', 'Lørdag'],
+	  daysShort: ['Søn', 'Man', 'Tir', 'Ons', 'Tor', 'Fre', 'Lør'],
+	  daysMin: ['Sø', 'Ma', 'Ti', 'On', 'To', 'Fr', 'Lø'],
+	  months: ['Januar', 'Februar', 'Marts', 'April', 'Maj', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'December'],
+	  monthsShort: ['Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dec'],
+	  today: 'I dag',
+	  clear: 'Nulstil',
+	  dateFormat: 'dd/MM/yyyy',
+	  timeFormat: 'HH:mm',
+	  firstDay: 1
+	};
+	da$2.default = _default;
+	return da$2;
+}
+
+var daExports = requireDa();
+var da = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(daExports);
+
+var da$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: da
+}, [daExports]);
+
+exports.da = da$1;

package/dist/cjs/de-DUAVb6Ak.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-BJu3ubxk.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 de$2 = {};
+
+var hasRequiredDe;
+
+function requireDe () {
+	if (hasRequiredDe) return de$2;
+	hasRequiredDe = 1;
+
+	Object.defineProperty(de$2, "__esModule", {
+	  value: true
+	});
+	de$2.default = void 0;
+	var _default = {
+	  days: ['Sonntag', 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag'],
+	  daysShort: ['Son', 'Mon', 'Die', 'Mit', 'Don', 'Fre', 'Sam'],
+	  daysMin: ['So', 'Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa'],
+	  months: ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'],
+	  monthsShort: ['Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dez'],
+	  today: 'Heute',
+	  clear: 'Löschen',
+	  dateFormat: 'dd.MM.yyyy',
+	  timeFormat: 'HH:mm',
+	  firstDay: 1
+	};
+	de$2.default = _default;
+	return de$2;
+}
+
+var deExports = requireDe();
+var de = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(deExports);
+
+var de$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: de
+}, [deExports]);
+
+exports.de = de$1;

package/dist/cjs/debounce-BsIBi_-2.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function debounce(callback, timeout = 200) {
+    let id;
+    return (...args) => {
+        if (id) {
+            clearTimeout(id);
+        }
+        id = setTimeout(callback, timeout, ...args);
+    };
+}
+
+exports.debounce = debounce;