@quidgest/ui 0.14.12 → 0.14.13

package/esm/composables/useDropZone/index.d.ts

@@ -0,0 +1,38 @@
+import { MaybeRef, Ref } from 'vue';
+interface DropZoneOptions {
+    /** Callback fired when valid files are dropped */
+    onDrop?: (files: File[]) => void;
+    /** Callback fired when files are dragged over the drop zone */
+    onDragOver?: (event: DragEvent) => void;
+    /** Callback fired when files are dragged out of the drop zone */
+    onDragLeave?: (event: DragEvent) => void;
+    /** Array of accepted MIME types or file patterns (e.g., 'image/*', '.pdf') */
+    accept?: MaybeRef<string[]>;
+    /** Whether to allow multiple files to be dropped */
+    multiple?: MaybeRef<boolean>;
+    /** Maximum allowed file size in bytes */
+    maxSize?: number;
+    /** Whether the drop zone is enabled */
+    enabled?: MaybeRef<boolean>;
+}
+interface UseDropZoneReturn {
+    /** Whether files are currently being dragged over the drop zone */
+    isOverDropZone: Ref<boolean>;
+    /** Whether the currently dragged files match the accepted types */
+    isValid: Ref<boolean>;
+    /** Whether the drop zone is currently enabled */
+    isEnabled: Ref<boolean>;
+    /** Function to enable the drop zone */
+    enable: () => void;
+    /** Function to disable the drop zone */
+    disable: () => void;
+}
+/**
+ * Vue composable for handling file drag and drop with validation
+ *
+ * @param elementRef - Ref to the HTML element that will act as the drop zone
+ * @param options - Configuration options for the drop zone
+ */
+export declare function useDropZone(elementRef: Ref<HTMLElement | null>, options?: DropZoneOptions): UseDropZoneReturn;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/esm/composables/useDropZone/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composables/useDropZone/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAKxC,UAAU,eAAe;IACxB,kDAAkD;IAClD,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,CAAA;IAChC,+DAA+D;IAC/D,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IACvC,iEAAiE;IACjE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IACxC,8EAA8E;IAC9E,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;IAC5B,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,uCAAuC;IACvC,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAC3B;AAED,UAAU,iBAAiB;IAC1B,mEAAmE;IACnE,cAAc,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC5B,mEAAmE;IACnE,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACrB,iDAAiD;IACjD,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACvB,uCAAuC;IACvC,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,wCAAwC;IACxC,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAC1B,UAAU,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,EACnC,OAAO,GAAE,eAAoB,GAC3B,iBAAiB,CAmJnB"}

package/esm/composables/useDropZone/index.js

@@ -0,0 +1,62 @@
+import { ref as v, unref as c, isRef as C, watch as M, onMounted as O, onUnmounted as U } from "vue";
+function k(p, s = {}) {
+  const {
+    onDrop: m,
+    onDragOver: i,
+    onDragLeave: d,
+    accept: y = [],
+    multiple: F,
+    maxSize: g,
+    enabled: T = !0
+  } = s;
+  let a = 0;
+  const l = v(!1), u = v(!1), t = v(c(T)), E = (e) => {
+    const r = c(y);
+    return r.length === 0 || r.some((n) => e.match(n));
+  }, x = (e) => !(g && e.size > g || !E(e.type)), f = () => {
+    a = 0, l.value = !1, u.value = !1;
+  }, L = (e) => {
+    var o;
+    if (!t.value) return;
+    e.preventDefault(), f();
+    const r = Array.from(((o = e.dataTransfer) == null ? void 0 : o.files) || []);
+    if (!c(F) && r.length > 1)
+      return;
+    const n = r.filter(x);
+    n.length && m && m(n);
+  }, h = (e) => {
+    var n;
+    if (!t.value) return;
+    e.preventDefault();
+    const r = Array.from(((n = e.dataTransfer) == null ? void 0 : n.items) || []).map((o) => o.type);
+    u.value = r.some(E), a++, a === 1 && (l.value = !0, i == null || i(e));
+  }, D = (e) => {
+    t.value && (e.preventDefault(), a--, a === 0 && (l.value = !1, u.value = !1, d == null || d(e)));
+  }, b = (e) => {
+    t.value && e.preventDefault();
+  }, z = () => {
+    t.value = !0;
+  }, A = () => {
+    t.value = !1, f();
+  };
+  s.enabled && C(s.enabled) && M(s.enabled, (e) => {
+    t.value = e, e || f();
+  });
+  const S = () => {
+    const e = p.value;
+    e && (e.addEventListener("drop", L), e.addEventListener("dragenter", h), e.addEventListener("dragleave", D), e.addEventListener("dragover", b));
+  }, Z = () => {
+    const e = p.value;
+    e && (e.removeEventListener("drop", L), e.removeEventListener("dragenter", h), e.removeEventListener("dragleave", D), e.removeEventListener("dragover", b));
+  };
+  return O(S), U(Z), {
+    isOverDropZone: l,
+    isValid: u,
+    isEnabled: t,
+    enable: z,
+    disable: A
+  };
+}
+export {
+  k as useDropZone
+};

package/esm/index.d.ts

@@ -9,6 +9,7 @@ declare module '@vue/runtime-core' {
 	export interface GlobalComponents {
 		QAccordion: typeof import('@quidgest/ui/components')['QAccordion']
 		QBadge: typeof import('@quidgest/ui/components')['QBadge']
+		QBadgeIndicator: typeof import('@quidgest/ui/components')['QBadgeIndicator']
 		QButton: typeof import('@quidgest/ui/components')['QButton']
 		QButtonGroup: typeof import('@quidgest/ui/components')['QButtonGroup']
 		QButtonToggle: typeof import('@quidgest/ui/components')['QButtonToggle']
@@ -17,9 +18,11 @@ declare module '@vue/runtime-core' {
 		QCollapsible: typeof import('@quidgest/ui/components')['QCollapsible']
 		QColorPicker: typeof import('@quidgest/ui/components')['QColorPicker']
 		QCombobox: typeof import('@quidgest/ui/components')['QCombobox']
+		QDateTimePicker: typeof import('@quidgest/ui/components')['QDateTimePicker']
 		QDialog: typeof import('@quidgest/ui/components')['QDialog']
 		QDropdownMenu: typeof import('@quidgest/ui/components')['QDropdownMenu']
 		QField: typeof import('@quidgest/ui/components')['QField']
+		QFileUpload: typeof import('@quidgest/ui/components')['QFileUpload']
 		QIcon: typeof import('@quidgest/ui/components')['QIcon']
 		QIconFont: typeof import('@quidgest/ui/components')['QIconFont']
 		QIconImg: typeof import('@quidgest/ui/components')['QIconImg']

package/esm/utils/color.js

@@ -1,41 +1,49 @@
-function h(t, n = !1) {
-  return n ? /^#[a-fA-F0-9]{6}$/.test(t) : /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/.test(t);
+function h(t, r = !1) {
+  return r ? /^#[a-fA-F0-9]{6}$/.test(t) : /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/.test(t);
 }
 function d(t) {
-  const n = t.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/);
-  if (n) {
-    const s = parseInt(n[1], 10), e = parseInt(n[2], 10), r = parseInt(n[3], 10);
-    return { r: s, g: e, b: r };
+  const r = t.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/);
+  if (r) {
+    const n = parseInt(r[1], 10), s = parseInt(r[2], 10), e = parseInt(r[3], 10);
+    return { r: n, g: s, b: e };
   }
 }
-function o(t) {
+function b(t) {
   if (h(t)) {
     t.length === 4 && (t = "#" + t[1] + t[1] + t[2] + t[2] + t[3] + t[3]);
-    const n = parseInt(t.slice(1, 3), 16), s = parseInt(t.slice(3, 5), 16), e = parseInt(t.slice(5, 7), 16);
-    return { r: n, g: s, b: e };
+    const r = parseInt(t.slice(1, 3), 16), n = parseInt(t.slice(3, 5), 16), s = parseInt(t.slice(5, 7), 16);
+    return { r, g: n, b: s };
   } else {
-    const n = d(t);
-    if (n) return n;
+    const r = d(t);
+    if (r) return r;
   }
   throw new Error("Invalid color format");
 }
-function b(t) {
-  const n = t.r / 255, s = t.g / 255, e = t.b / 255, r = Math.max(n, s, e), i = Math.min(n, s, e);
+function p(t, r) {
+  const n = g(t), s = r / 100;
+  return n.l = n.l - s * n.l, l(n);
+}
+function M(t) {
+  const r = t.r.toString(16).padStart(2, "0"), n = t.g.toString(16).padStart(2, "0"), s = t.b.toString(16).padStart(2, "0");
+  return `#${r}${n}${s}`;
+}
+function g(t) {
+  const r = t.r / 255, n = t.g / 255, s = t.b / 255, e = Math.max(r, n, s), o = Math.min(r, n, s);
   let a = 0, c;
-  const u = (r + i) / 2;
-  if (r === i)
+  const i = (e + o) / 2;
+  if (e === o)
     a = c = 0;
   else {
-    const f = r - i;
-    switch (c = u > 0.5 ? f / (2 - r - i) : f / (r + i), r) {
+    const u = e - o;
+    switch (c = i > 0.5 ? u / (2 - e - o) : u / (e + o), e) {
+      case r:
+        a = (n - s) / u + (n < s ? 6 : 0);
+        break;
       case n:
-        a = (s - e) / f + (s < e ? 6 : 0);
+        a = (s - r) / u + 2;
         break;
       case s:
-        a = (e - n) / f + 2;
-        break;
-      case e:
-        a = (n - s) / f + 4;
+        a = (r - n) / u + 4;
         break;
     }
     a /= 6;
@@ -43,16 +51,38 @@ function b(t) {
   return {
     h: Math.round(a * 360),
     s: Math.round(c * 100),
-    l: Math.round(u * 100)
+    l: Math.round(i * 100)
   };
 }
-function g(t) {
+function l(t) {
+  const r = t.h / 360, n = t.s / 100, s = t.l / 100;
+  let e, o, a;
+  if (n === 0)
+    e = o = a = s;
+  else {
+    const c = s < 0.5 ? s * (1 + n) : s + n - s * n, i = 2 * s - c;
+    e = f(i, c, r + 1 / 3), o = f(i, c, r), a = f(i, c, r - 1 / 3);
+  }
+  return {
+    r: Math.round(e * 255),
+    g: Math.round(o * 255),
+    b: Math.round(a * 255)
+  };
+}
+function f(t, r, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? t + (r - t) * 6 * n : n < 1 / 2 ? r : n < 2 / 3 ? t + (r - t) * (2 / 3 - n) * 6 : t;
+}
+function m(t) {
   return t > 50 ? "#000" : "#fff";
 }
 export {
-  g as getContrastingColor,
+  M as colorToHex,
+  p as darken,
+  m as getContrastingColor,
+  l as hslToRgb,
+  f as hueToRgb,
   h as isValidHex,
-  o as parseColor,
-  b as rgbToHsl,
+  b as parseColor,
+  g as rgbToHsl,
   d as tryParseRgb
 };

package/esm/utils/date/date.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Converts a Unicode date format pattern
+ * into a mask string compatible with the Maska library.
+ *
+ * @param pattern - The Unicode date format pattern to be converted.
+ * @returns The corresponding mask string for the Maska library.
+ */
+export declare function convertDatePatternToMask(format: string): string | string[];
+//# sourceMappingURL=date.d.ts.map

package/esm/utils/date/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/utils/date/date.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CA8C1E"}

package/esm/utils/date/date.js

@@ -0,0 +1,91 @@
+import { tokenizeFormat as g, staticTokensMap as h, isUnitRepetition as y, dynamicTokensMap as E } from "./tokens.js";
+function x(n) {
+  const r = g(n);
+  if (!r)
+    throw Error("Failed to tokenize format string.");
+  const i = [...r.sort((e, a) => a.length - e.length)], t = [n];
+  if (r.filter((e) => h[e] !== void 0).forEach((e) => {
+    const a = h[e];
+    d(a, t, e);
+    const c = i.indexOf(e);
+    i.splice(c, 1);
+  }), [...i].forEach((e) => {
+    if (!y(e))
+      throw new Error(`Invalid token format: ${e}. Tokens must be repeated characters.`);
+    const a = e[0], c = w(a, e.length);
+    d(c, t, e);
+    const f = i.indexOf(e);
+    i.splice(f, 1);
+  }), i.length > 0)
+    throw new Error(`Unhandled tokens remain: ${i.join(", ")}`);
+  return t.forEach((e, a) => {
+    t[a] = T(e);
+  }), t.length === 1 ? t[0] : t;
+}
+function T(n) {
+  const r = "\0";
+  return n.replace(/'((?:[^']|'')+)'/g, (i, t) => t.replace(/''/g, r).split("").map((e) => e === r ? "!'" : "!" + e).join(""));
+}
+function w(n, r) {
+  const i = [], t = E[n];
+  if (t === void 0)
+    throw new Error(`Dynamic token '${n}' not found.`);
+  if (typeof t == "string") {
+    const s = p(t, r);
+    i.push(s);
+  } else Array.isArray(i) && t.forEach((o) => {
+    const s = p(o, r);
+    i.push(s);
+  });
+  return i;
+}
+function p(n, r) {
+  const i = n.startsWith("-");
+  return i && (n = n.substring(1)), n = n.repeat(r), i && (n = `-${n}`), n;
+}
+function d(n, r, i) {
+  if (typeof n == "string") {
+    const t = n;
+    r.forEach((o, s) => {
+      r[s] = u(o, i, t);
+    });
+  } else if (Array.isArray(n)) {
+    const t = n.length, o = [...r], s = o.length;
+    for (let e = 1; e < t; e++)
+      r.push(...o);
+    n.forEach((e, a) => {
+      const c = a * s, f = c + s - 1;
+      for (let l = c; l <= f; l++)
+        r[l] = u(r[l], i, e);
+    });
+  }
+}
+function u(n, r, i) {
+  let t = "", o = 0, s = !1, e = "";
+  const a = r.length;
+  for (; o < n.length; ) {
+    const c = n[o];
+    if (!s && (c === "'" || c === '"')) {
+      s = !0, e = c, t += c, o++;
+      continue;
+    }
+    if (s)
+      if (c === e)
+        if (o + 1 < n.length && n[o + 1] === e) {
+          t += e + e, o += 2;
+          continue;
+        } else {
+          s = !1, t += c, o++;
+          continue;
+        }
+      else {
+        t += c, o++;
+        continue;
+      }
+    n.substring(o, o + a) === r ? (t += i, o += a) : (t += c, o++);
+  }
+  return t;
+}
+export {
+  x as convertDatePatternToMask
+};

package/esm/utils/date/index.d.ts

@@ -0,0 +1,4 @@
+import { convertDatePatternToMask } from './date';
+import { isTimeOnlyFormat } from './tokens';
+export { convertDatePatternToMask, isTimeOnlyFormat };
+//# sourceMappingURL=index.d.ts.map

package/esm/utils/date/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/date/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE3C,OAAO,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,CAAA"}

package/esm/utils/date/tokens.d.ts

@@ -0,0 +1,49 @@
+export type TokenMap = {
+    [token: string]: string | string[];
+};
+export declare const staticTokensMap: TokenMap;
+export declare const dynamicTokensMap: TokenMap;
+/**
+ * Tokenizes a given format string by matching against both variable and fixed token patterns.
+ *
+ * This function dynamically constructs a regular expression that first targets variable tokens
+ * (allowing for 1 to 4 greedy occurrences) and then fixed tokens (sorted in descending order of length).
+ * It escapes any special regex characters in both token maps to ensure that they are correctly interpreted
+ * as literal strings in the resulting Regex.
+ *
+ * @remarks
+ * The generated regular expression is used to match and extract tokens from the provided format string.
+ * If any tokens are found based on the specified patterns from `variableTokensMap` and `tokensMap`, an array
+ * of tokens is returned; otherwise, `null` is returned.
+ *
+ * @param format - The string containing the format to be tokenized.
+ * @returns An array of matched tokens if present, or `null` if no tokens match.
+ *
+ * @example
+ * ```ts
+ * const tokens = tokenizeFormat("YYYY-MM-DD");
+ * console.log(tokens); // ['YYYY', 'MM', 'DD']
+ * ```
+ *
+ * @see dynamicTokensMap
+ * @see staticTokensMap
+ */
+export declare function tokenizeFormat(format: string): RegExpMatchArray | null;
+/**
+ * Determines if a given format string represents a time-only format.
+ *
+ * @param format - The format string to check (e.g., 'HH:mm:ss', 'YYYY-MM-DD HH:mm').
+ * @returns `true` if the format is time-only, `false` if it includes date components.
+ */
+export declare function isTimeOnlyFormat(format: string): boolean;
+/**
+ * Checks whether the given token is not composed entirely of a single repeated character.
+ *
+ * A valid unit repetition (e.g., 'yyyy') consists of the same character repeated. This function
+ * returns false if the token consists solely of one repeating character, and true otherwise.
+ *
+ * @param token - The string token to evaluate.
+ * @returns False if the token is a unit repetition; true if it is not.
+ */
+export declare function isUnitRepetition(token: string): boolean;
+//# sourceMappingURL=tokens.d.ts.map

package/esm/utils/date/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/utils/date/tokens.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,QAAQ,GAAG;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAA;AA0I7D,eAAO,MAAM,eAAe,EAAE,QAG7B,CAAA;AAuBD,eAAO,MAAM,gBAAgB,EAAE,QAG9B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAuBtE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAOxD;AA4BD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,WAG7C"}

package/esm/utils/date/tokens.js

@@ -0,0 +1,243 @@
+const c = {
+  // Era
+  GGGGG: "A",
+  // A, B
+  GGGG: "S",
+  // Anno Domini, Before Christ
+  GGG: "AA",
+  // AD, BC
+  GG: "AA",
+  // AD, BC
+  G: "AA",
+  // AD, BC
+  // Calendar year (y)
+  yy: "##",
+  // 44, 01, 00, 17
+  y: "N",
+  // 44, 1, 1900, 2017, 9999
+  // Local week-numbering year (Y)
+  YY: "##",
+  // 44, 01, 00, 17
+  Y: "N",
+  // 44, 1, 1900, 2017, 9999
+  // Quarter (formatting) – Q tokens
+  QQQQQ: "#",
+  // 1, 2, 3, 4
+  QQQQ: "#aa W",
+  // 1st quarter, 2nd quarter, ...
+  QQQ: "Q#",
+  // Q1, Q2, Q3, Q4
+  QQ: "##",
+  // 01, 02, 03, 04
+  Q: "#",
+  // 1, 2, 3, 4
+  // Quarter (stand-alone) – q tokens
+  qqqqq: "#",
+  // 1, 2, 3, 4
+  qqqq: "#aa W",
+  // 1st quarter, 2nd quarter, ...
+  qqq: "Q#",
+  // Q1, Q2, Q3, Q4
+  qq: "##",
+  // 01, 02, 03, 04
+  q: "#",
+  // 1, 2, 3, 4
+  // Month (formatting) – M tokens
+  MMMMM: "A",
+  // J, F, ..., D
+  MMMM: "W",
+  // January, February, ..., December
+  MMM: "Aaa",
+  // Jan, Feb, ..., Dec
+  MM: "##",
+  // 01, 02, ..., 12
+  M: "#n",
+  // 1, 2, ..., 12
+  // Month (stand-alone) – L tokens
+  LLLLL: "A",
+  // J, F, ..., D
+  LLLL: "W",
+  // January, February, ..., December
+  LLL: "Aaa",
+  // Jan, Feb, ..., Dec
+  LL: "##",
+  // 01, 02, ..., 12
+  L: "#n",
+  // 1, 2, ..., 12
+  // Local week of year (w tokens)
+  ww: "##",
+  // 01, 02, ..., 53
+  w: "#n",
+  // 1, 2, ..., 53
+  // Day of month (d tokens)
+  dd: "##",
+  // 01, 02, ..., 31
+  d: "#n",
+  // 1, 2, ..., 31
+  // Day of week (formatting) using E tokens
+  EEEEEE: "Aa",
+  // Mo, Tu, We, Th, Fr, Sa, Su
+  EEEEE: "A",
+  // M, T, W, T, F, S, S
+  EEEE: "W",
+  // Monday, Tuesday, ..., Sunday
+  EEE: "Aaa",
+  // Mon, Tue, Wed, ..., Sun
+  EE: "Aaa",
+  // Mon, Tue, Wed, ..., Sun
+  E: "Aaa",
+  // Mon, Tue, Wed, ..., Sun
+  // Local day of week (formatting) using e tokens
+  eeeeee: "Aa",
+  // Mo, Tu, We, Th, Fr, Sa, Su
+  eeeee: "A",
+  // M, T, W, T, F, S, S
+  eeee: "W",
+  // Monday, Tuesday, ..., Sunday
+  eee: "Aaa",
+  // Mon, Tue, Wed, ..., Sun
+  ee: "##",
+  // 02, 03, ..., 01
+  e: "#",
+  // 2, 3, 4, ..., 1
+  // Local day of week (stand-alone) using c tokens
+  cccccc: "Aa",
+  // Mo, Tu, We, Th, Fr, Sa, Su
+  ccccc: "A",
+  // M, T, W, T, F, S, S
+  cccc: "W",
+  // Monday, Tuesday, ..., Sunday
+  ccc: "Aaa",
+  // Mon, Tue, Wed, ..., Sun
+  cc: "##",
+  // 02, 03, ..., 01
+  c: "#"
+  // 2, 3, 4, ..., 1
+}, o = {
+  // AM, PM (a tokens)
+  aaaaa: "a",
+  // a, p
+  aaaa: "a.a.",
+  // a.m., p.m.
+  aaa: "AA",
+  // AM, PM
+  aa: "AA",
+  // AM, PM
+  a: "AA",
+  // AM, PM
+  // AM, PM, noon, midnight (b tokens)
+  bbbbb: "a",
+  // a, p
+  bbbb: "a.a.",
+  // a.m., p.m.
+  bbb: "AA",
+  // AM, PM
+  bb: "AA",
+  // AM, PM
+  b: "AA",
+  // AM, PM
+  // Flexible day period (B tokens)
+  B: "S",
+  // AM, PM, noon, midnight
+  // Hour [1-12] (h tokens)
+  hh: "##",
+  // 01, 02, ..., 11, 12
+  h: "#n",
+  // 1, 2, ..., 11, 12
+  // Hour [0-23] (H tokens)
+  HH: "##",
+  // 00, 01, 02, ..., 23
+  H: "#n",
+  // 0, 1, 2, ..., 23
+  // Hour [0-11] (K tokens)
+  KK: "##",
+  // 01, 02, ..., 11, 00
+  K: "#n",
+  // 1, 2, ..., 11, 0
+  // Hour [1-24] (k tokens)
+  kk: "##",
+  // 24, 01, 02, ..., 23
+  k: "#n",
+  // 24, 1, 2, ..., 23
+  // Minute (m tokens)
+  mm: "##",
+  // 00, 01, ..., 59
+  m: "#n",
+  // 0, 1, ..., 59
+  // Second (s tokens)
+  ss: "##",
+  // 00, 01, ..., 59
+  s: "#n",
+  // 0, 1, ..., 59,
+  // Timezone (ISO-8601 with Z) – X tokens
+  XXXXX: ["-##:##", "+##:##", "-##:##:##", "+##:##:##", "Z"],
+  // -08:00, +05:30, Z, +12:34:56
+  XXXX: ["-####", "+####", "-######", "+######", "Z"],
+  // -0800, +0530, Z, +123456
+  XXX: ["-##:##", "+##:##", "Z"],
+  // -08:00, +05:30, Z
+  XX: ["-####", "+####", "Z"],
+  // -0800, +0530, Z
+  X: ["-##", "+##", "-####", "+####", "Z"],
+  // -08, +0530, Z
+  // Timezone (ISO-8601 without Z) – x tokens
+  xxxxx: ["-##:##", "+##:##", "-##:##:##", "+##:##:##"],
+  // -08:00, +05:30, +00:00, +12:34:56
+  xxxx: ["-####", "+####", "-######", "+######"],
+  // -0800, +0530, +0000, +123456
+  xxx: ["-##:##", "+##:##"],
+  // -08:00, +05:30, +00:00
+  xx: ["-####", "+####"],
+  // -0800, +0530, +0000
+  x: ["-##", "+##", "-####", "+####"]
+  // -08, +0530, +00
+}, d = {
+  ...c,
+  ...o
+}, s = {
+  // Calendar year (y)
+  y: "#",
+  // 44, 1, 1900, 2017, 9999
+  // Local week-numbering year (Y)
+  Y: "#",
+  // 44, 1, 1900, 2017, 9000
+  // Extended year (u)
+  u: ["-#", "#"],
+  // -43, 1, 1900, 2017, 9999, -999
+  // Day of year (D tokens)
+  D: "#"
+  // 1, 2, ..., 365, 366
+}, i = {
+  // Fraction of second (S tokens)
+  S: "#"
+  // 0, 1, ..., 9
+}, x = {
+  ...s,
+  ...i
+};
+function b(e) {
+  const a = e.replace(/(['"]).*?\1/g, ""), r = Object.keys(x).map((n) => `${n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}{1,4}`).join("|"), E = Object.keys(d).sort((n, t) => t.length - n.length).map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), M = `(${r}|${E})`, m = new RegExp(M, "g");
+  return a.match(m);
+}
+function Q(e) {
+  const a = b(e);
+  if (!a)
+    throw Error("Failed to tokenize format string.");
+  return a.some(u) && !a.some(p);
+}
+function p(e) {
+  return c[e] !== void 0 || A(e) && s[e[0]] !== void 0;
+}
+function u(e) {
+  return o[e] !== void 0 || A(e) && i[e[0]] !== void 0;
+}
+function A(e) {
+  return /^(\w)\1*$/.test(e);
+}
+export {
+  x as dynamicTokensMap,
+  Q as isTimeOnlyFormat,
+  A as isUnitRepetition,
+  d as staticTokensMap,
+  b as tokenizeFormat
+};

package/esm/utils/download.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Downloads the provided file.
+ *
+ * @param file - The File object to be downloaded.
+ */
+export declare function downloadFile(file: File): void;
+//# sourceMappingURL=download.d.ts.map

package/esm/utils/download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.d.ts","sourceRoot":"","sources":["../../src/utils/download.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAqB7C"}

package/esm/utils/download.js

@@ -0,0 +1,16 @@
+function r(o) {
+  const t = new FileReader();
+  t.onload = () => {
+    const a = o.type || "application/octet-stream", d = new Blob([t.result], { type: a }), e = Object.assign(document.createElement("a"), {
+      href: URL.createObjectURL(d),
+      download: o.name || "download"
+    });
+    document.body.appendChild(e), e.click(), setTimeout(() => {
+      var n;
+      URL.revokeObjectURL(e.href), (n = e.parentNode) == null || n.removeChild(e);
+    }, 100);
+  }, t.readAsArrayBuffer(o);
+}
+export {
+  r as downloadFile
+};