joopjs 2.0.0

package/dist/utilities/index.mjs

@@ -0,0 +1,1923 @@
+// src/utilities/common.utility.ts
+function removeTrailingSlash(url) {
+  return url?.endsWith("/") ? url.slice(0, -1) : url;
+}
+function objectToQueryString(obj) {
+  return Object.entries(obj).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+}
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function randomString(length, charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset[Math.floor(Math.random() * charset.length)];
+  }
+  return result;
+}
+function stringToHex(input) {
+  let result = "";
+  for (let i = 0; i < input.length; i++) {
+    result += input.charCodeAt(i).toString(16).slice(-4);
+  }
+  return result;
+}
+function bufferToHex(buffer) {
+  return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function flattenObject(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (isPlainObject(value)) {
+      Object.assign(result, flattenObject(value, fullKey));
+    } else {
+      result[fullKey] = String(value);
+    }
+  }
+  return result;
+}
+
+// src/utilities/device.utility.ts
+function getDeviceInfo() {
+  const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+  const platform = typeof navigator !== "undefined" ? navigator.platform ?? "" : "";
+  const language = typeof navigator !== "undefined" ? navigator.language ?? "en" : "en";
+  const isIOS = /iphone|ipad|ipod/i.test(ua);
+  const isAndroid = /android/i.test(ua);
+  const isMobile = isIOS || isAndroid || /mobi/i.test(ua);
+  return {
+    userAgent: ua,
+    platform,
+    isIOS,
+    isAndroid,
+    isMobile,
+    isDesktop: !isMobile,
+    language
+  };
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isSSR() {
+  return !isBrowser();
+}
+
+// src/utilities/sanitizer.utility.ts
+var SQL_KEYWORDS = /\b(SELECT|INSERT|UPDATE|DELETE|DROP|TRUNCATE|ALTER|EXEC|UNION|SCRIPT)\b/gi;
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function stripHtml(input) {
+  return input.replace(/<[^>]*>/g, "");
+}
+function sanitizeInput(input) {
+  return escapeHtml(input.trim());
+}
+function stripSqlKeywords(input) {
+  return input.replace(/['";\\]/g, "").replace(SQL_KEYWORDS, "");
+}
+function sanitizeFileName(name) {
+  return name.replace(/[^a-zA-Z0-9._\-]/g, "_").replace(/_{2,}/g, "_");
+}
+function isValidUrl(url) {
+  try {
+    const { protocol } = new URL(url);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isValidEmail(email) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(email);
+}
+function isValidPhone(phone) {
+  return /^\+?[\d\s\-()]{7,20}$/.test(phone);
+}
+function isAlphanumeric(value) {
+  return /^[a-zA-Z0-9]+$/.test(value);
+}
+function truncate(value, maxLength, suffix = "\u2026") {
+  return value.length > maxLength ? value.slice(0, maxLength - suffix.length) + suffix : value;
+}
+
+// src/utilities/connection.utility.ts
+function flattenObj(obj, prefix = "", result = {}) {
+  for (const key of Object.keys(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    const val = obj[key];
+    if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+      flattenObj(val, fullKey, result);
+    } else {
+      result[fullKey] = val == null ? "" : String(val);
+    }
+  }
+  return result;
+}
+function buildQueryString(params, encode = true) {
+  const flat = flattenObj(params);
+  return Object.entries(flat).filter(([, v]) => v !== "").map(([k, v]) => `${encode ? encodeURIComponent(k) : k}=${encode ? encodeURIComponent(v) : v}`).join("&");
+}
+function buildFormData(params, files) {
+  const flat = flattenObj(params);
+  const fd = new FormData();
+  for (const [k, v] of Object.entries(flat)) {
+    fd.append(k, v);
+  }
+  if (files) {
+    for (const { field, file, name } of files) {
+      if (name) {
+        fd.append(field, file, name);
+      } else {
+        fd.append(field, file);
+      }
+    }
+  }
+  return fd;
+}
+function urlEncode(params) {
+  return Object.entries(params).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+}
+function getRandomNum(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+// src/events/index.ts
+var JoopSubject = class {
+  _listeners = [];
+  subscribe(listener) {
+    this._listeners.push(listener);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== listener);
+    };
+  }
+  next(value) {
+    for (const listener of this._listeners) {
+      listener(value);
+    }
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopBehaviorSubject = class extends JoopSubject {
+  _value;
+  constructor(initialValue) {
+    super();
+    this._value = initialValue;
+  }
+  getValue() {
+    return this._value;
+  }
+  next(value) {
+    this._value = value;
+    super.next(value);
+  }
+  subscribe(listener) {
+    listener(this._value);
+    return super.subscribe(listener);
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopObservable = class {
+  constructor(_subscribeFn) {
+    this._subscribeFn = _subscribeFn;
+  }
+  _subscribeFn;
+  subscribe(listener) {
+    return this._subscribeFn(listener);
+  }
+  /** Returns the current value without subscribing (only meaningful for BehaviorSubject-backed observables). */
+  getOnce() {
+    let result;
+    const unsub = this.subscribe((v) => {
+      result = v;
+    });
+    unsub();
+    return result;
+  }
+};
+
+// src/utilities/clipboard.utility.ts
+var JoopClipboardService = class {
+  _events$ = new JoopSubject();
+  /** Copy text to clipboard. Falls back to execCommand for older browsers. */
+  async copy(text) {
+    try {
+      if (navigator?.clipboard?.writeText) {
+        await navigator.clipboard.writeText(text);
+        this._events$.next({ type: "copy", text });
+        return true;
+      }
+      return this._execCopy(text);
+    } catch {
+      return this._execCopy(text);
+    }
+  }
+  /** Read text from clipboard */
+  async paste() {
+    try {
+      if (navigator?.clipboard?.readText) {
+        const text = await navigator.clipboard.readText();
+        this._events$.next({ type: "paste", text });
+        return text;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /** Copy a DOM element's innerText */
+  async copyElement(elementOrId) {
+    const el = typeof elementOrId === "string" ? document.getElementById(elementOrId) : elementOrId;
+    return el ? this.copy(el.innerText ?? el.textContent ?? "") : false;
+  }
+  /** Observe copy/paste events */
+  events$() {
+    return this._events$.asObservable();
+  }
+  _execCopy(text) {
+    if (typeof document === "undefined") return false;
+    const ta = document.createElement("textarea");
+    ta.value = text;
+    ta.style.cssText = "position:fixed;top:-9999px;left:-9999px;opacity:0";
+    document.body.appendChild(ta);
+    ta.focus();
+    ta.select();
+    try {
+      const ok = document.execCommand("copy");
+      if (ok) this._events$.next({ type: "copy", text });
+      return ok;
+    } finally {
+      document.body.removeChild(ta);
+    }
+  }
+};
+var clipboard = new JoopClipboardService();
+
+// src/utilities/image.utility.ts
+var JoopImageService = class {
+  /** Compress and optionally resize an image file */
+  compress(file, options = {}) {
+    const { maxWidthOrHeight = 1920, quality = 0.8, outputType = "image/jpeg" } = options;
+    return new Promise((resolve, reject) => {
+      const url = URL.createObjectURL(file);
+      const img = new Image();
+      img.onload = () => {
+        URL.revokeObjectURL(url);
+        const canvas = document.createElement("canvas");
+        let { width, height } = img;
+        if (width > maxWidthOrHeight || height > maxWidthOrHeight) {
+          if (width > height) {
+            height = Math.round(height * maxWidthOrHeight / width);
+            width = maxWidthOrHeight;
+          } else {
+            width = Math.round(width * maxWidthOrHeight / height);
+            height = maxWidthOrHeight;
+          }
+        }
+        canvas.width = width;
+        canvas.height = height;
+        canvas.getContext("2d").drawImage(img, 0, 0, width, height);
+        canvas.toBlob((b) => b ? resolve(b) : reject(new Error("compression failed")), outputType, quality);
+      };
+      img.onerror = reject;
+      img.src = url;
+    });
+  }
+  /** Resize to exact dimensions */
+  resize(file, width, height, outputType = "image/jpeg") {
+    return new Promise((resolve, reject) => {
+      const url = URL.createObjectURL(file);
+      const img = new Image();
+      img.onload = () => {
+        URL.revokeObjectURL(url);
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        canvas.getContext("2d").drawImage(img, 0, 0, width, height);
+        canvas.toBlob((b) => b ? resolve(b) : reject(new Error("resize failed")), outputType, 0.9);
+      };
+      img.onerror = reject;
+      img.src = url;
+    });
+  }
+  /** Convert a blob to base64 data URL */
+  toBase64(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = reject;
+      reader.readAsDataURL(file);
+    });
+  }
+  /** Get image dimensions and metadata */
+  getInfo(file) {
+    return new Promise((resolve, reject) => {
+      const url = URL.createObjectURL(file);
+      const img = new Image();
+      img.onload = () => {
+        URL.revokeObjectURL(url);
+        resolve({
+          width: img.naturalWidth,
+          height: img.naturalHeight,
+          size: file.size,
+          type: file.type,
+          name: file instanceof File ? file.name : "",
+          aspectRatio: parseFloat((img.naturalWidth / img.naturalHeight).toFixed(4))
+        });
+      };
+      img.onerror = reject;
+      img.src = url;
+    });
+  }
+  /** Validate an image against size/type/dimension constraints */
+  async validate(file, options = {}) {
+    const errors = [];
+    if (options.maxSizeBytes && file.size > options.maxSizeBytes) {
+      errors.push(`File too large: ${(file.size / 1024).toFixed(1)} KB exceeds ${(options.maxSizeBytes / 1024).toFixed(1)} KB`);
+    }
+    if (options.allowedTypes && !options.allowedTypes.includes(file.type)) {
+      errors.push(`Invalid type: ${file.type}. Allowed: ${options.allowedTypes.join(", ")}`);
+    }
+    if (options.maxWidth || options.maxHeight || options.minWidth || options.minHeight) {
+      try {
+        const info = await this.getInfo(file);
+        if (options.maxWidth && info.width > options.maxWidth) errors.push(`Width ${info.width}px exceeds max ${options.maxWidth}px`);
+        if (options.maxHeight && info.height > options.maxHeight) errors.push(`Height ${info.height}px exceeds max ${options.maxHeight}px`);
+        if (options.minWidth && info.width < options.minWidth) errors.push(`Width ${info.width}px below min ${options.minWidth}px`);
+        if (options.minHeight && info.height < options.minHeight) errors.push(`Height ${info.height}px below min ${options.minHeight}px`);
+      } catch {
+        errors.push("Could not read image dimensions");
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /** Create thumbnail as data URL */
+  async thumbnail(file, size = 128) {
+    const thumb = await this.compress(file, { maxWidthOrHeight: size, quality: 0.7 });
+    return this.toBase64(thumb);
+  }
+};
+
+// src/utilities/date.utility.ts
+function isBusinessDay(date, holidays = [], weekend = [0, 6]) {
+  const dow = date.getDay();
+  if (weekend.includes(dow)) return false;
+  const iso = _toIso(date);
+  return !holidays.some((h) => _toIso(h) === iso);
+}
+function addBusinessDays(date, days, holidays = [], weekend = [0, 6]) {
+  const d = new Date(date);
+  let remaining = Math.abs(days);
+  const step = days >= 0 ? 1 : -1;
+  while (remaining > 0) {
+    d.setDate(d.getDate() + step);
+    if (isBusinessDay(d, holidays, weekend)) remaining--;
+  }
+  return d;
+}
+function getBusinessDaysBetween(start, end, holidays = [], weekend = [0, 6]) {
+  const s = new Date(Math.min(start.getTime(), end.getTime()));
+  const e = new Date(Math.max(start.getTime(), end.getTime()));
+  let count = 0;
+  const cur = new Date(s);
+  cur.setDate(cur.getDate() + 1);
+  while (cur <= e) {
+    if (isBusinessDay(cur, holidays, weekend)) count++;
+    cur.setDate(cur.getDate() + 1);
+  }
+  return count;
+}
+function daysBetween(a, b) {
+  return Math.round(Math.abs(b.getTime() - a.getTime()) / 864e5);
+}
+function isDateInRange(date, start, end) {
+  return date >= start && date <= end;
+}
+function parseDate(value) {
+  if (!value) return null;
+  const d = new Date(value);
+  return isNaN(d.getTime()) ? null : d;
+}
+function formatDate(date, format, locale = "en-US") {
+  const p = {
+    YYYY: String(date.getFullYear()),
+    MM: String(date.getMonth() + 1).padStart(2, "0"),
+    DD: String(date.getDate()).padStart(2, "0"),
+    HH: String(date.getHours()).padStart(2, "0"),
+    mm: String(date.getMinutes()).padStart(2, "0"),
+    ss: String(date.getSeconds()).padStart(2, "0"),
+    M: String(date.getMonth() + 1),
+    D: String(date.getDate()),
+    // locale-aware month name
+    MMM: date.toLocaleDateString(locale, { month: "short" }),
+    MMMM: date.toLocaleDateString(locale, { month: "long" })
+  };
+  return format.replace(/MMMM|MMM|YYYY|MM|DD|HH|mm|ss|M|D/g, (k) => p[k] ?? k);
+}
+var HIJRI_MONTHS = [
+  "Muharram",
+  "Safar",
+  "Rabi al-Awwal",
+  "Rabi al-Thani",
+  "Jumada al-Awwal",
+  "Jumada al-Thani",
+  "Rajab",
+  "Sha'ban",
+  "Ramadan",
+  "Shawwal",
+  "Dhu al-Qi'dah",
+  "Dhu al-Hijjah"
+];
+function toHijri(date) {
+  const jd = _toJulian(date.getFullYear(), date.getMonth() + 1, date.getDate());
+  let l = jd - 1948440 + 10632;
+  const n = Math.floor((l - 1) / 10631);
+  l = l - 10631 * n + 354;
+  const j = Math.floor((10985 - l) / 5316) * Math.floor(50 * l / 17719) + Math.floor(l / 5670) * Math.floor(43 * l / 15238);
+  l = l - Math.floor((30 - j) / 15) * Math.floor(17719 * j / 50) - Math.floor(j / 16) * Math.floor(15238 * j / 43) + 29;
+  const month = Math.floor(24 * l / 709);
+  const day = l - Math.floor(709 * month / 24);
+  const year = 30 * n + j - 30;
+  return { year, month, day, monthName: HIJRI_MONTHS[month - 1] ?? "" };
+}
+function fromHijri(year, month, day) {
+  const jd = Math.floor((11 * year + 3) / 30) + 354 * year + 30 * month - Math.floor((month - 1) / 2) + day + 1948440 - 385;
+  return _fromJulian(jd);
+}
+function formatHijri(date, includeMonthName = true) {
+  const d = String(date.day).padStart(2, "0");
+  const m = String(date.month).padStart(2, "0");
+  return includeMonthName ? `${d} ${date.monthName} ${date.year} AH` : `${d}/${m}/${date.year}`;
+}
+function timeAgo(date, locale = "en") {
+  const diff = Date.now() - date.getTime();
+  const abs = Math.abs(diff);
+  const future = diff < 0;
+  const pre = future ? "in " : "";
+  const suf = future ? "" : " ago";
+  if (abs < 6e4) return "just now";
+  if (abs < 36e5) return `${pre}${Math.floor(abs / 6e4)}m${suf}`;
+  if (abs < 864e5) return `${pre}${Math.floor(abs / 36e5)}h${suf}`;
+  if (abs < 2592e6) return `${pre}${Math.floor(abs / 864e5)}d${suf}`;
+  return formatDate(date, "DD MMM YYYY", locale);
+}
+function _toIso(date) {
+  return date.toISOString().slice(0, 10);
+}
+function _toJulian(y, m, d) {
+  if (m <= 2) {
+    y--;
+    m += 12;
+  }
+  const A = Math.floor(y / 100);
+  const B = 2 - A + Math.floor(A / 4);
+  return Math.floor(365.25 * (y + 4716)) + Math.floor(30.6001 * (m + 1)) + d + B - 1524;
+}
+function _fromJulian(jd) {
+  const z = Math.floor(jd + 0.5);
+  const a = Math.floor((z - 186721625e-2) / 36524.25);
+  const A = z + 1 + a - Math.floor(a / 4);
+  const B = A + 1524;
+  const C = Math.floor((B - 122.1) / 365.25);
+  const D = Math.floor(365.25 * C);
+  const E = Math.floor((B - D) / 30.6001);
+  const day = B - D - Math.floor(30.6001 * E);
+  const month = E < 14 ? E - 1 : E - 13;
+  const year = month > 2 ? C - 4716 : C - 4715;
+  return new Date(year, month - 1, day);
+}
+
+// src/utilities/qr.utility.ts
+var _GFe = new Uint8Array(512);
+var _GFl = new Uint8Array(256);
+(function() {
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    _GFe[i] = x;
+    _GFl[x] = i;
+    x = x << 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 512; i++) _GFe[i] = _GFe[i - 255];
+})();
+var _gm = (a, b) => a && b ? _GFe[(_GFl[a] + _GFl[b]) % 255] : 0;
+function _gen(n) {
+  let g = [1];
+  for (let i = 0; i < n; i++) {
+    const next = new Array(g.length + 1).fill(0);
+    for (let j = 0; j < g.length; j++) {
+      next[j] ^= g[j];
+      next[j + 1] ^= _gm(g[j], _GFe[i]);
+    }
+    g = next;
+  }
+  return g;
+}
+function _rsEnc(data, nec) {
+  const g = _gen(nec);
+  const msg = [...data, ...new Array(nec).fill(0)];
+  for (let i = 0; i < data.length; i++) {
+    const c = msg[i];
+    if (c) for (let j = 0; j < g.length; j++) msg[i + j] ^= _gm(g[j], c);
+  }
+  return msg.slice(data.length);
+}
+var VT = [
+  { aln: [], L: [7, [[1, 19]]], M: [10, [[1, 16]]], Q: [13, [[1, 13]]], H: [17, [[1, 9]]] },
+  { aln: [6, 18], L: [10, [[1, 34]]], M: [16, [[1, 28]]], Q: [22, [[1, 22]]], H: [28, [[1, 16]]] },
+  { aln: [6, 22], L: [15, [[1, 55]]], M: [26, [[1, 44]]], Q: [18, [[2, 17]]], H: [22, [[2, 13]]] },
+  { aln: [6, 26], L: [20, [[1, 80]]], M: [18, [[2, 32]]], Q: [26, [[2, 24]]], H: [16, [[4, 9]]] },
+  { aln: [6, 30], L: [26, [[1, 108]]], M: [24, [[2, 43]]], Q: [18, [[2, 15], [2, 16]]], H: [22, [[2, 11], [2, 12]]] },
+  { aln: [6, 34], L: [18, [[2, 68]]], M: [16, [[4, 27]]], Q: [24, [[4, 19]]], H: [28, [[4, 15]]] },
+  { aln: [6, 22, 38], L: [20, [[2, 78]]], M: [18, [[4, 31]]], Q: [18, [[2, 14], [4, 15]]], H: [26, [[4, 13], [1, 14]]] },
+  { aln: [6, 24, 42], L: [24, [[2, 97]]], M: [22, [[2, 38], [2, 39]]], Q: [22, [[4, 18], [2, 19]]], H: [26, [[4, 14], [2, 15]]] },
+  { aln: [6, 26, 46], L: [30, [[2, 116]]], M: [22, [[3, 36], [2, 37]]], Q: [20, [[4, 16], [4, 17]]], H: [24, [[4, 12], [4, 13]]] },
+  { aln: [6, 28, 50], L: [18, [[2, 68], [2, 69]]], M: [26, [[4, 43], [1, 44]]], Q: [24, [[6, 19], [2, 20]]], H: [28, [[6, 15], [2, 16]]] }
+];
+var ECI = { L: 1, M: 0, Q: 3, H: 2 };
+function _cap(v, ec) {
+  return VT[v - 1][ec][1].reduce((s, [c, d]) => s + c * d, 0);
+}
+function _bestV(len, ec) {
+  for (let v = 1; v <= 10; v++) if (_cap(v, ec) >= len + 3) return v;
+  throw new Error(`JoopQr: text too long (${len} bytes) for versions 1-10`);
+}
+function _encData(text, ver, ec) {
+  const bytes = new TextEncoder().encode(text);
+  const total = _cap(ver, ec);
+  const bits = [];
+  const push = (v, n) => {
+    for (let i = n - 1; i >= 0; i--) bits.push(v >> i & 1);
+  };
+  push(4, 4);
+  push(bytes.length, 8);
+  for (const b of bytes) push(b, 8);
+  push(0, Math.min(4, total * 8 - bits.length));
+  while (bits.length % 8) bits.push(0);
+  const cw = [];
+  for (let i = 0; i < bits.length; i += 8) {
+    let b = 0;
+    for (let j = 0; j < 8; j++) b = b << 1 | (bits[i + j] ?? 0);
+    cw.push(b);
+  }
+  const pad = [236, 17];
+  while (cw.length < total) cw.push(pad[cw.length % 2]);
+  return cw;
+}
+function _buildCW(data, ver, ec) {
+  const [ecpb, groups] = VT[ver - 1][ec];
+  const db = [], eb = [];
+  let di = 0;
+  for (const [cnt, dpb] of groups) for (let b = 0; b < cnt; b++) {
+    const bl = data.slice(di, di + dpb);
+    di += dpb;
+    db.push(bl);
+    eb.push(_rsEnc(bl, ecpb));
+  }
+  const r = [];
+  const md = Math.max(...db.map((b) => b.length));
+  for (let i = 0; i < md; i++) for (const b of db) if (i < b.length) r.push(b[i]);
+  for (let i = 0; i < ecpb; i++) for (const b of eb) r.push(b[i]);
+  return r;
+}
+function _mat(sz) {
+  return Array.from({ length: sz }, () => new Int8Array(sz).fill(-1));
+}
+function _finder(m, r, c) {
+  for (let dr = -1; dr <= 7; dr++) for (let dc = -1; dc <= 7; dc++) {
+    const row = r + dr, col = c + dc;
+    if (row < 0 || col < 0 || row >= m.length || col >= m.length) continue;
+    const inF = dr >= 0 && dr <= 6 && dc >= 0 && dc <= 6;
+    m[row][col] = inF ? dr === 0 || dr === 6 || dc === 0 || dc === 6 || dr >= 2 && dr <= 4 && dc >= 2 && dc <= 4 ? 1 : 0 : 0;
+  }
+}
+function _align(m, r, c) {
+  for (let dr = -2; dr <= 2; dr++) for (let dc = -2; dc <= 2; dc++) {
+    m[r + dr][c + dc] = Math.abs(dr) === 2 || Math.abs(dc) === 2 || dr === 0 && dc === 0 ? 1 : 0;
+  }
+}
+function _funcPat(m, ver) {
+  const sz = m.length;
+  _finder(m, 0, 0);
+  _finder(m, 0, sz - 7);
+  _finder(m, sz - 7, 0);
+  for (let i = 8; i < sz - 8; i++) {
+    if (m[6][i] === -1) m[6][i] = i % 2 ? 0 : 1;
+    if (m[i][6] === -1) m[i][6] = i % 2 ? 0 : 1;
+  }
+  const aln = VT[ver - 1].aln;
+  for (const r of aln) for (const c of aln) if (m[r][c] === -1) _align(m, r, c);
+  m[4 * ver + 9][8] = 1;
+  for (let i = 0; i <= 8; i++) {
+    if (m[8][i] === -1) m[8][i] = 0;
+    if (m[i][8] === -1) m[i][8] = 0;
+  }
+  for (let i = sz - 8; i < sz; i++) {
+    if (m[8][i] === -1) m[8][i] = 0;
+    if (m[i][8] === -1) m[i][8] = 0;
+  }
+}
+function _placeData(m, cw) {
+  const sz = m.length;
+  const bits = [];
+  for (const b of cw) for (let i = 7; i >= 0; i--) bits.push(b >> i & 1);
+  let bi = 0, up = true;
+  for (let col = sz - 1; col >= 1; col -= 2) {
+    if (col === 6) col--;
+    for (let ri = 0; ri < sz; ri++) {
+      const row = up ? sz - 1 - ri : ri;
+      for (let dc = 0; dc < 2; dc++) {
+        const c = col - dc;
+        if (m[row][c] === -1) m[row][c] = bi < bits.length ? bits[bi++] : 0;
+      }
+    }
+    up = !up;
+  }
+}
+var MFN = [
+  (r, c) => (r + c) % 2 === 0,
+  (r) => r % 2 === 0,
+  (_, c) => c % 3 === 0,
+  (r, c) => (r + c) % 3 === 0,
+  (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+  (r, c) => r * c % 2 + r * c % 3 === 0,
+  (r, c) => (r * c % 2 + r * c % 3) % 2 === 0,
+  (r, c) => ((r + c) % 2 + r * c % 3) % 2 === 0
+];
+function _mask(m, pat, isF) {
+  const sz = m.length;
+  const copy = m.map((r) => new Int8Array(r));
+  const fn = MFN[pat];
+  for (let r = 0; r < sz; r++) for (let c = 0; c < sz; c++) if (!isF[r][c] && copy[r][c] !== -1) {
+    if (fn(r, c)) copy[r][c] ^= 1;
+  }
+  return copy;
+}
+function _pen(m) {
+  const sz = m.length;
+  let p = 0;
+  for (let r = 0; r < sz; r++) for (const hor of [true, false]) {
+    let run = 1, prev = hor ? m[r][0] : m[0][r];
+    for (let i = 1; i < sz; i++) {
+      const cur = hor ? m[r][i] : m[i][r];
+      if (cur === prev) {
+        run++;
+        if (run === 5) p += 3;
+        else if (run > 5) p++;
+      } else {
+        run = 1;
+        prev = cur;
+      }
+    }
+  }
+  for (let r = 0; r < sz - 1; r++) for (let c = 0; c < sz - 1; c++) {
+    const v = m[r][c];
+    if (v === m[r][c + 1] && v === m[r + 1][c] && v === m[r + 1][c + 1]) p += 3;
+  }
+  let dark = 0;
+  for (let r = 0; r < sz; r++) for (let c = 0; c < sz; c++) if (m[r][c]) dark++;
+  p += Math.abs(Math.floor(dark / (sz * sz) * 20) - 10) * 10;
+  return p;
+}
+function _fmtBits(ec, mask) {
+  const data = ECI[ec] << 3 | mask;
+  let rem = data << 10;
+  for (let i = 14; i >= 10; i--) if (rem & 1 << i) rem ^= 1335 << i - 10;
+  return (data << 10 | rem) ^ 21522;
+}
+function _placeFmt(m, fmt) {
+  const sz = m.length;
+  const bits = [];
+  for (let i = 14; i >= 0; i--) bits.push(fmt >> i & 1);
+  let bi = 0;
+  for (let c = 0; c <= 5; c++) m[8][c] = bits[bi++];
+  m[8][7] = bits[bi++];
+  m[8][8] = bits[bi++];
+  m[7][8] = bits[bi++];
+  for (let r = 5; r >= 0; r--) m[r][8] = bits[bi++];
+  bi = 0;
+  for (let r = sz - 1; r >= sz - 7; r--) m[r][8] = bits[bi++];
+  m[8][sz - 8] = bits[bi++];
+  for (let c = sz - 7; c < sz; c++) m[8][c] = bits[bi++];
+}
+function _svg(m, o) {
+  const sz = m.length, tot = sz + 2 * o.margin, mod = o.size / tot;
+  let rects = "";
+  for (let r = 0; r < sz; r++) for (let c = 0; c < sz; c++) {
+    if (m[r][c] === 1) {
+      const x = ((c + o.margin) * mod).toFixed(2), y = ((r + o.margin) * mod).toFixed(2), s = (mod + 0.1).toFixed(2);
+      rects += `<rect x="${x}" y="${y}" width="${s}" height="${s}"/>`;
+    }
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${o.size} ${o.size}" shape-rendering="crispEdges"><rect width="${o.size}" height="${o.size}" fill="${o.background}"/><g fill="${o.foreground}">${rects}</g></svg>`;
+}
+function generateQr(text, options = {}) {
+  const ec = options.ecLevel ?? "M";
+  const opts = {
+    size: options.size ?? 300,
+    margin: options.margin ?? 4,
+    foreground: options.foreground ?? "#000000",
+    background: options.background ?? "#ffffff"
+  };
+  const bytes = new TextEncoder().encode(text);
+  const ver = _bestV(bytes.length, ec);
+  const sz = 4 * ver + 17;
+  const dataCW = _encData(text, ver, ec);
+  const allCW = _buildCW(dataCW, ver, ec);
+  const m = _mat(sz);
+  _funcPat(m, ver);
+  const isF = Array.from({ length: sz }, (_, r) => Array.from({ length: sz }, (_2, c) => m[r][c] !== -1));
+  _placeData(m, allCW);
+  let bm = 0, bp = Infinity;
+  for (let mp = 0; mp < 8; mp++) {
+    const masked = _mask(m, mp, isF);
+    _placeFmt(masked, _fmtBits(ec, mp));
+    const pen = _pen(masked);
+    if (pen < bp) {
+      bp = pen;
+      bm = mp;
+    }
+  }
+  const final = _mask(m, bm, isF);
+  _placeFmt(final, _fmtBits(ec, bm));
+  return _svg(final, opts);
+}
+function generateQrDataUrl(text, options = {}) {
+  const svg = generateQr(text, options);
+  return "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(svg)));
+}
+function generatePaymentQr(amount, currency, reference, options) {
+  const uri = `payment:${currency}:${amount}:${reference}`;
+  return generateQr(uri, options);
+}
+
+// src/utilities/barcode.utility.ts
+var C128_SYMBOLS = [
+  "11011001100",
+  "11001101100",
+  "11001100110",
+  "10010011000",
+  "10010001100",
+  "10001001100",
+  "10011001000",
+  "10011000100",
+  "10001100100",
+  "11001001000",
+  "11001000100",
+  "11000100100",
+  "10110011100",
+  "10011011100",
+  "10011001110",
+  "10111001100",
+  "10011101100",
+  "10011100110",
+  "11001110010",
+  "11001011100",
+  "11001001110",
+  "11011100100",
+  "11001110100",
+  "11101101110",
+  "11101001100",
+  "11100101100",
+  "11100100110",
+  "11101100100",
+  "11100110100",
+  "11100110010",
+  "11011011000",
+  "11011000110",
+  "11000110110",
+  "10100011000",
+  "10001011000",
+  "10001000110",
+  "10110001000",
+  "10001101000",
+  "10001100010",
+  "11010001000",
+  "11000101000",
+  "11000100010",
+  "10110111000",
+  "10110001110",
+  "10001101110",
+  "10111011000",
+  "10111000110",
+  "10001110110",
+  "11101110110",
+  "11010001110",
+  "11000101110",
+  "11011101000",
+  "11011100010",
+  "11011101110",
+  "11101011000",
+  "11101000110",
+  "11100010110",
+  "11101101000",
+  "11101100010",
+  "11100011010",
+  "11101111010",
+  "11001000010",
+  "11110001010",
+  "10100110000",
+  "10100001100",
+  "10010110000",
+  "10010000110",
+  "10000101100",
+  "10000100110",
+  "10110010000",
+  "10110000100",
+  "10011010000",
+  "10011000010",
+  "10000110100",
+  "10000110010",
+  "11000010010",
+  "11001010000",
+  "11110111010",
+  "11000010100",
+  "10001111010",
+  "10100111100",
+  "10010111100",
+  "10010011110",
+  "10111100100",
+  "10011110100",
+  "10011110010",
+  "11110100100",
+  "11110010100",
+  "11110010010",
+  "11011011110",
+  "11011110110",
+  "11110110110",
+  "10101111000",
+  "10100011110",
+  "10001011110",
+  "10111101000",
+  "10111100010",
+  "11110101000",
+  "11110100010",
+  "10111011110",
+  "10111101110",
+  "11101011110",
+  "11110101110",
+  "11010000100",
+  "11010010000",
+  "11010011100",
+  "11000111010"
+];
+var C128_START_B = "11010010000";
+var C128_STOP = "11000111010";
+function _code128Bars(text) {
+  const codes = [];
+  let checksum = 104;
+  for (let i = 0; i < text.length; i++) {
+    const v = text.charCodeAt(i) - 32;
+    if (v < 0 || v > 95) throw new Error(`Code128: unsupported char '${text[i]}'`);
+    codes.push(v);
+    checksum += v * (i + 1);
+  }
+  codes.push(checksum % 103);
+  return C128_START_B + codes.map((c) => C128_SYMBOLS[c]).join("") + C128_STOP + "11";
+}
+function generateCode128(text, opts = {}) {
+  const bars = _code128Bars(text);
+  const mw = opts.width ? Math.floor((opts.width - 2 * (opts.margin ?? 10)) / bars.length) : 2;
+  const margin = opts.margin ?? 10;
+  const barH = (opts.height ?? 80) - (opts.showText !== false ? (opts.fontSize ?? 12) + 4 : 0) - margin;
+  const totalW = bars.length * mw + margin * 2;
+  const totalH = opts.height ?? 80;
+  const fg = opts.foreground ?? "#000000";
+  const bg = opts.background ?? "#ffffff";
+  let rects = "";
+  for (let i = 0; i < bars.length; i++) {
+    if (bars[i] === "1") rects += `<rect x="${margin + i * mw}" y="${margin}" width="${mw}" height="${barH}" fill="${fg}"/>`;
+  }
+  const label = opts.showText !== false ? `<text x="${totalW / 2}" y="${totalH - 2}" text-anchor="middle" font-family="monospace" font-size="${opts.fontSize ?? 12}" fill="${fg}">${text}</text>` : "";
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}"><rect width="${totalW}" height="${totalH}" fill="${bg}"/>${rects}${label}</svg>`;
+}
+var EAN_L = ["0001101", "0011001", "0010011", "0111101", "0100011", "0110001", "0101111", "0111011", "0110111", "0001011"];
+var EAN_G = ["0100111", "0110011", "0011011", "0100001", "0011101", "0111001", "0000101", "0010001", "0001001", "0010111"];
+var EAN_R = ["1110010", "1100110", "1101100", "1000010", "1011100", "1001110", "1010000", "1000100", "1001000", "1110100"];
+var EAN_PARITY = ["LLLLLL", "LLGLGG", "LLGGLG", "LLGGGL", "LGLLGG", "LGGLLG", "LGGGLL", "LGLGLG", "LGLGGL", "LGGLGL"];
+function _ean13Bars(digits) {
+  if (!/^\d{13}$/.test(digits)) throw new Error("EAN-13: need exactly 13 digits");
+  const d = digits.split("").map(Number);
+  const parity = EAN_PARITY[d[0]];
+  let bars = "101";
+  for (let i = 0; i < 6; i++) bars += parity[i] === "G" ? EAN_G[d[i + 1]] : EAN_L[d[i + 1]];
+  bars += "01010";
+  for (let i = 7; i < 13; i++) bars += EAN_R[d[i]];
+  bars += "101";
+  return bars;
+}
+function validateEan13(digits) {
+  if (!/^\d{12,13}$/.test(digits)) return false;
+  const d = digits.slice(0, 12).split("").map(Number);
+  const check = (10 - d.reduce((s, v, i) => s + (i % 2 === 0 ? v : v * 3), 0) % 10) % 10;
+  return digits.length === 12 ? true : check === Number(digits[12]);
+}
+function generateEan13(digits, opts = {}) {
+  const bars = _ean13Bars(digits);
+  const mw = 2;
+  const margin = opts.margin ?? 10;
+  const barH = (opts.height ?? 70) - (opts.showText !== false ? (opts.fontSize ?? 12) + 4 : 0) - margin;
+  const totalW = bars.length * mw + margin * 2 + 8;
+  const totalH = opts.height ?? 70;
+  const fg = opts.foreground ?? "#000000";
+  const bg = opts.background ?? "#ffffff";
+  let rects = "";
+  const xOff = margin + 8;
+  for (let i = 0; i < bars.length; i++) {
+    if (bars[i] === "1") rects += `<rect x="${xOff + i * mw}" y="${margin}" width="${mw}" height="${barH}" fill="${fg}"/>`;
+  }
+  const label = opts.showText !== false ? `<text x="${margin}" y="${margin + barH - 2}" font-family="monospace" font-size="${opts.fontSize ?? 10}" fill="${fg}">${digits[0]}</text><text x="${totalW / 2}" y="${totalH - 2}" text-anchor="middle" font-family="monospace" font-size="${opts.fontSize ?? 10}" fill="${fg}">${digits.slice(1, 7)} ${digits.slice(7)}</text>` : "";
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}"><rect width="${totalW}" height="${totalH}" fill="${bg}"/>${rects}${label}</svg>`;
+}
+var C39_MAP = {
+  "0": "101001101101",
+  "1": "110100101011",
+  "2": "101100101011",
+  "3": "110110010101",
+  "4": "101001101011",
+  "5": "110100110101",
+  "6": "101100110101",
+  "7": "101001011011",
+  "8": "110100101101",
+  "9": "101100101101",
+  "A": "110101001011",
+  "B": "101101001011",
+  "C": "110110100101",
+  "D": "101011001011",
+  "E": "110101100101",
+  "F": "101101100101",
+  "G": "101010011011",
+  "H": "110101001101",
+  "I": "101101001101",
+  "J": "101011001101",
+  "K": "110101010011",
+  "L": "101101010011",
+  "M": "110110101001",
+  "N": "101011010011",
+  "O": "110101101001",
+  "P": "101101101001",
+  "Q": "101010110011",
+  "R": "110101011001",
+  "S": "101101011001",
+  "T": "101011011001",
+  "U": "110010101011",
+  "V": "100110101011",
+  "W": "110011010101",
+  "X": "100101101011",
+  "Y": "110010110101",
+  "Z": "100110110101",
+  "-": "100101011011",
+  ".": "110010101101",
+  " ": "100110101101",
+  "*": "100101101101"
+};
+function generateCode39(text, opts = {}) {
+  const upper = text.toUpperCase();
+  const barsStr = ["*", ...upper.split(""), "*"].map((c) => {
+    if (!C39_MAP[c]) throw new Error(`Code39: unsupported char '${c}'`);
+    return C39_MAP[c];
+  }).join("0");
+  const mw = 2;
+  const margin = opts.margin ?? 10;
+  const barH = (opts.height ?? 70) - (opts.showText !== false ? (opts.fontSize ?? 12) + 4 : 0) - margin;
+  const totalW = barsStr.length * mw + margin * 2;
+  const totalH = opts.height ?? 70;
+  const fg = opts.foreground ?? "#000000";
+  const bg = opts.background ?? "#ffffff";
+  let rects = "";
+  for (let i = 0; i < barsStr.length; i++) {
+    if (barsStr[i] === "1") rects += `<rect x="${margin + i * mw}" y="${margin}" width="${mw}" height="${barH}" fill="${fg}"/>`;
+  }
+  const label = opts.showText !== false ? `<text x="${totalW / 2}" y="${totalH - 2}" text-anchor="middle" font-family="monospace" font-size="${opts.fontSize ?? 12}" fill="${fg}">${text}</text>` : "";
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}"><rect width="${totalW}" height="${totalH}" fill="${bg}"/>${rects}${label}</svg>`;
+}
+function generateBarcodeDataUrl(svg) {
+  return `data:image/svg+xml;base64,${btoa(svg)}`;
+}
+
+// src/utilities/pdf.utility.ts
+var PT = { W: 595.28, H: 841.89 };
+var _PdfBuilder = class {
+  _objs = [];
+  _offsets = [];
+  _stream = "";
+  _pw;
+  _ph;
+  _fonts = /* @__PURE__ */ new Set();
+  constructor(w = PT.W, h = PT.H) {
+    this._pw = w;
+    this._ph = h;
+  }
+  _addObj(body) {
+    const id = this._objs.length + 1;
+    this._objs.push(body);
+    return id;
+  }
+  _y(y) {
+    return this._ph - y;
+  }
+  // flip Y axis
+  text(x, y, content, opts = {}) {
+    const font = opts.font ?? "Helvetica";
+    const size = opts.size ?? 10;
+    const [r, g, b] = opts.color ?? [0, 0, 0];
+    this._fonts.add(font);
+    const safe = content.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+    this._stream += `BT
+/${font.replace("-", "")} ${size} Tf
+${r} ${g} ${b} rg
+${x} ${this._y(y) - size} Td
+(${safe}) Tj
+ET
+`;
+    return this;
+  }
+  line(x1, y1, x2, y2, opts = {}) {
+    const [r, g, b] = opts.color ?? [0, 0, 0];
+    const w = opts.width ?? 0.5;
+    const dash = opts.dash ? `[${opts.dash[0]} ${opts.dash[1]}] 0 d
+` : "[] 0 d\n";
+    this._stream += `${r} ${g} ${b} RG
+${w} w
+${dash}${x1} ${this._y(y1)} m
+${x2} ${this._y(y2)} l
+S
+`;
+    return this;
+  }
+  rect(x, y, w, h, fill, stroke) {
+    if (fill) this._stream += `${fill[0]} ${fill[1]} ${fill[2]} rg
+${x} ${this._y(y) - h} ${w} ${h} re
+f
+`;
+    if (stroke) this._stream += `${stroke[0]} ${stroke[1]} ${stroke[2]} RG
+${x} ${this._y(y) - h} ${w} ${h} re
+S
+`;
+    return this;
+  }
+  table(x, y, cols, rows, opts = {}) {
+    const rh = opts.rowHeight ?? 18;
+    const fs = opts.fontSize ?? 9;
+    const hbg = opts.headerBg ?? [0.2, 0.4, 0.7];
+    const totalW = cols.reduce((s, c) => s + c.width, 0);
+    this.rect(x, y, totalW, rh, hbg);
+    let cx = x;
+    for (const col of cols) {
+      this.text(cx + 3, y + 4, col.header, { font: "Helvetica-Bold", size: fs, color: [1, 1, 1] });
+      cx += col.width;
+    }
+    y += rh;
+    for (let i = 0; i < rows.length; i++) {
+      if (i % 2 === 1) this.rect(x, y, totalW, rh, [0.95, 0.95, 0.95]);
+      cx = x;
+      for (const col of cols) {
+        const val = String(rows[i][col.key] ?? "");
+        const textX = col.align === "right" ? cx + col.width - 3 - val.length * fs * 0.5 : col.align === "center" ? cx + col.width / 2 - val.length * fs * 0.25 : cx + 3;
+        this.text(textX, y + 4, val, { size: fs });
+        cx += col.width;
+      }
+      this.line(x, y + rh, x + totalW, y + rh, { width: 0.3, color: [0.8, 0.8, 0.8] });
+      y += rh;
+    }
+    return y;
+  }
+  build() {
+    const fontNames = ["Helvetica", "HelveticaBold", "TimesRoman", "Courier"];
+    const fontObjs = [];
+    for (const fn of fontNames) {
+      const baseName = fn === "HelveticaBold" ? "Helvetica-Bold" : fn === "TimesRoman" ? "Times-Roman" : fn;
+      fontObjs.push(this._addObj(`<< /Type /Font /Subtype /Type1 /BaseFont /${baseName} /Encoding /WinAnsiEncoding >>`));
+    }
+    const fontDict = fontNames.map((n, i) => `/${n} ${fontObjs[i]} 0 R`).join("\n");
+    const resources = this._addObj(`<< /Font << ${fontDict} >> >>`);
+    const streamBytes = new TextEncoder().encode(this._stream);
+    const contentObj = this._addObj(`<< /Length ${streamBytes.length} >>
+stream
+${this._stream}endstream`);
+    const pageObj = this._addObj(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${this._pw} ${this._ph}] /Contents ${contentObj} 0 R /Resources ${resources} 0 R >>`);
+    const ordered = [
+      `<< /Type /Catalog /Pages 2 0 R >>`,
+      `<< /Type /Pages /Kids [${pageObj} 0 R] /Count 1 >>`,
+      ...this._objs.slice(2)
+    ];
+    let body = "%PDF-1.4\n";
+    const offsets = [];
+    for (let i = 0; i < ordered.length; i++) {
+      offsets.push(body.length);
+      body += `${i + 1} 0 obj
+${ordered[i]}
+endobj
+`;
+    }
+    const xrefOffset = body.length;
+    body += `xref
+0 ${ordered.length + 1}
+0000000000 65535 f 
+`;
+    for (const off of offsets) body += `${String(off).padStart(10, "0")} 00000 n 
+`;
+    body += `trailer
+<< /Size ${ordered.length + 1} /Root 1 0 R >>
+startxref
+${xrefOffset}
+%%EOF`;
+    return new TextEncoder().encode(body);
+  }
+};
+var JoopPdfService = class {
+  _opts;
+  constructor(opts = {}) {
+    this._opts = opts;
+  }
+  _builder() {
+    return new _PdfBuilder(this._opts.pageWidth ?? PT.W, this._opts.pageHeight ?? PT.H);
+  }
+  /** Generate a basic receipt PDF */
+  receipt(title, lines, footer) {
+    const m = this._opts.margin ?? 60;
+    const pw = this._opts.pageWidth ?? PT.W;
+    const doc = this._builder();
+    let y = m;
+    doc.text(m, y, title, { font: "Helvetica-Bold", size: 16 });
+    y += 30;
+    doc.line(m, y, pw - m, y);
+    y += 12;
+    for (const line of lines) {
+      const font = line.bold ? "Helvetica-Bold" : "Helvetica";
+      doc.text(m, y, line.label, { font, size: 10 });
+      doc.text(pw - m - line.value.length * 6, y, line.value, { font, size: 10 });
+      y += 16;
+    }
+    doc.line(m, y, pw - m, y);
+    y += 14;
+    if (footer) doc.text(m, y, footer, { size: 8, color: [0.5, 0.5, 0.5] });
+    return doc.build();
+  }
+  /** Generate a statement with a table */
+  statement(title, subtitle, columns, rows, summary) {
+    const m = this._opts.margin ?? 40;
+    const pw = this._opts.pageWidth ?? PT.W;
+    const doc = this._builder();
+    let y = m;
+    doc.text(m, y, title, { font: "Helvetica-Bold", size: 14 });
+    y += 20;
+    doc.text(m, y, subtitle, { size: 9, color: [0.4, 0.4, 0.4] });
+    y += 16;
+    doc.line(m, y, pw - m, y);
+    y += 12;
+    y = doc.table(m, y, columns, rows) + 10;
+    if (summary) {
+      for (const line of summary) {
+        const font = line.bold ? "Helvetica-Bold" : "Helvetica";
+        doc.text(m, y, line.label, { font, size: 10 });
+        doc.text(pw - m - line.value.length * 6, y, line.value, { font, size: 10 });
+        y += 16;
+      }
+    }
+    return doc.build();
+  }
+  /** Wrap raw bytes as a base64 data URL */
+  toDataUrl(bytes) {
+    let bin = "";
+    for (const b of bytes) bin += String.fromCharCode(b);
+    return `data:application/pdf;base64,${btoa(bin)}`;
+  }
+  /** Trigger browser download */
+  download(bytes, filename = "document.pdf") {
+    const blob = new Blob([new Uint8Array(bytes)], { type: "application/pdf" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+  /** Low-level builder for custom documents */
+  builder() {
+    return this._builder();
+  }
+};
+
+// src/utilities/notification.service.ts
+var JoopNotificationService = class {
+  _permission$ = new JoopBehaviorSubject(
+    typeof Notification !== "undefined" ? Notification.permission : "default"
+  );
+  _messageHandlers = [];
+  _swReg = null;
+  isSupported() {
+    return typeof Notification !== "undefined";
+  }
+  getPermission() {
+    return this._permission$.getValue();
+  }
+  permission$() {
+    return this._permission$.asObservable();
+  }
+  async requestPermission() {
+    if (!this.isSupported()) return "denied";
+    const result = await Notification.requestPermission();
+    this._permission$.next(result);
+    return result;
+  }
+  async show(title, options = {}) {
+    if (this._permission$.getValue() !== "granted") {
+      const p = await this.requestPermission();
+      if (p !== "granted") return null;
+    }
+    if (this._swReg) {
+      await this._swReg.showNotification(title, options);
+      return null;
+    }
+    return new Notification(title, options);
+  }
+  async setServiceWorker(reg) {
+    this._swReg = reg;
+  }
+  async subscribe(vapidPublicKey) {
+    if (!this._swReg) throw new Error("JoopNotification: ServiceWorkerRegistration required");
+    const key = _urlBase64ToUint8Array(vapidPublicKey);
+    return this._swReg.pushManager.subscribe({ userVisibleOnly: true, applicationServerKey: key });
+  }
+  async unsubscribe() {
+    if (!this._swReg) return false;
+    const sub = await this._swReg.pushManager.getSubscription();
+    if (!sub) return false;
+    return sub.unsubscribe();
+  }
+  async getSubscription() {
+    if (!this._swReg) return null;
+    return this._swReg.pushManager.getSubscription();
+  }
+  onMessage(handler) {
+    this._messageHandlers.push(handler);
+    navigator.serviceWorker?.addEventListener("message", handler);
+    return () => {
+      this._messageHandlers = this._messageHandlers.filter((h) => h !== handler);
+      navigator.serviceWorker?.removeEventListener("message", handler);
+    };
+  }
+  destroy() {
+    for (const h of this._messageHandlers) navigator.serviceWorker?.removeEventListener("message", h);
+    this._messageHandlers = [];
+  }
+};
+function _urlBase64ToUint8Array(base64String) {
+  const padding = "=".repeat((4 - base64String.length % 4) % 4);
+  const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(base64);
+  return new Uint8Array(Array.from(raw, (c) => c.charCodeAt(0)));
+}
+
+// src/utilities/geo.service.ts
+var JoopGeoService = class {
+  isSupported() {
+    return "geolocation" in navigator;
+  }
+  async getPosition(opts = {}) {
+    return new Promise((resolve, reject) => {
+      if (!this.isSupported()) {
+        reject(new Error("Geolocation not supported"));
+        return;
+      }
+      navigator.geolocation.getCurrentPosition(
+        (p) => resolve(this._map(p)),
+        (e) => reject(e),
+        opts
+      );
+    });
+  }
+  watchPosition(onSuccess, onError, opts = {}) {
+    return navigator.geolocation.watchPosition(
+      (p) => onSuccess(this._map(p)),
+      onError,
+      opts
+    );
+  }
+  clearWatch(id) {
+    navigator.geolocation.clearWatch(id);
+  }
+  async getPermissionState() {
+    if (!("permissions" in navigator)) return "prompt";
+    const status = await navigator.permissions.query({ name: "geolocation" });
+    return status.state;
+  }
+  /** Haversine distance in kilometers */
+  distance(from, to) {
+    const R = 6371;
+    const dLat = _rad(to.latitude - from.latitude);
+    const dLon = _rad(to.longitude - from.longitude);
+    const a = Math.sin(dLat / 2) ** 2 + Math.cos(_rad(from.latitude)) * Math.cos(_rad(to.latitude)) * Math.sin(dLon / 2) ** 2;
+    return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  }
+  isInRadius(point, center, radiusKm) {
+    return this.distance(point, center) <= radiusKm;
+  }
+  /** Compute compass bearing from `from` to `to` in degrees (0–360) */
+  bearing(from, to) {
+    const dLon = _rad(to.longitude - from.longitude);
+    const lat1 = _rad(from.latitude), lat2 = _rad(to.latitude);
+    const y = Math.sin(dLon) * Math.cos(lat2);
+    const x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
+    return (_deg(Math.atan2(y, x)) + 360) % 360;
+  }
+  formatCoords(lat, lon, format = "decimal") {
+    if (format === "decimal") return `${lat.toFixed(6)}, ${lon.toFixed(6)}`;
+    const fmt = (d, posLabel, negLabel) => {
+      const abs = Math.abs(d);
+      const deg = Math.floor(abs), min = Math.floor((abs - deg) * 60);
+      const sec = ((abs - deg - min / 60) * 3600).toFixed(2);
+      return `${deg}\xB0 ${min}' ${sec}" ${d >= 0 ? posLabel : negLabel}`;
+    };
+    return `${fmt(lat, "N", "S")}, ${fmt(lon, "E", "W")}`;
+  }
+  _map(p) {
+    return {
+      latitude: p.coords.latitude,
+      longitude: p.coords.longitude,
+      accuracy: p.coords.accuracy,
+      altitude: p.coords.altitude,
+      speed: p.coords.speed,
+      heading: p.coords.heading,
+      timestamp: p.timestamp
+    };
+  }
+};
+function _rad(d) {
+  return d * Math.PI / 180;
+}
+function _deg(r) {
+  return r * 180 / Math.PI;
+}
+
+// src/utilities/media.service.ts
+var JoopMediaRecorder = class {
+  _recorder;
+  _chunks = [];
+  constructor(stream, opts = {}) {
+    const mimeType = opts.mimeType ?? (MediaRecorder.isTypeSupported("video/webm") ? "video/webm" : "");
+    this._recorder = new MediaRecorder(stream, { mimeType, audioBitsPerSecond: opts.audioBitsPerSecond, videoBitsPerSecond: opts.videoBitsPerSecond });
+    this._recorder.ondataavailable = (e) => {
+      if (e.data.size > 0) this._chunks.push(e.data);
+    };
+  }
+  start(timeslice) {
+    this._recorder.start(timeslice);
+  }
+  stop() {
+    return new Promise((resolve) => {
+      this._recorder.onstop = () => {
+        const mimeType = this._recorder.mimeType || "video/webm";
+        resolve(new Blob(this._chunks, { type: mimeType }));
+      };
+      this._recorder.stop();
+    });
+  }
+  pause() {
+    this._recorder.pause();
+  }
+  resume() {
+    this._recorder.resume();
+  }
+  getState() {
+    return this._recorder.state;
+  }
+};
+var JoopMediaService = class {
+  isSupported() {
+    return "mediaDevices" in navigator;
+  }
+  async requestStream(constraints) {
+    if (!this.isSupported()) throw new Error("MediaDevices not supported");
+    return navigator.mediaDevices.getUserMedia(constraints);
+  }
+  async requestCamera(constraints = {}) {
+    return this.requestStream({ video: Object.keys(constraints).length ? constraints : true });
+  }
+  async requestMicrophone(constraints = {}) {
+    return this.requestStream({ audio: Object.keys(constraints).length ? constraints : true });
+  }
+  async requestScreenShare(withAudio = false) {
+    if (!("getDisplayMedia" in navigator.mediaDevices)) throw new Error("Screen capture not supported");
+    return navigator.mediaDevices.getDisplayMedia({ video: true, audio: withAudio });
+  }
+  stopStream(stream) {
+    stream.getTracks().forEach((t) => t.stop());
+  }
+  async capturePhoto(stream, quality = 0.92) {
+    const video = document.createElement("video");
+    video.srcObject = stream;
+    video.muted = true;
+    await video.play();
+    const canvas = document.createElement("canvas");
+    canvas.width = video.videoWidth;
+    canvas.height = video.videoHeight;
+    canvas.getContext("2d").drawImage(video, 0, 0);
+    return new Promise((resolve, reject) => canvas.toBlob((b) => b ? resolve(b) : reject(new Error("Capture failed")), "image/jpeg", quality));
+  }
+  createRecorder(stream, opts) {
+    return new JoopMediaRecorder(stream, opts);
+  }
+  async getDevices(kind) {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    return kind ? devices.filter((d) => d.kind === kind) : devices;
+  }
+  async checkPermission(kind) {
+    if (!("permissions" in navigator)) return "prompt";
+    const name = kind === "camera" ? "camera" : "microphone";
+    const status = await navigator.permissions.query({ name });
+    return status.state;
+  }
+  /** Attach a stream to a <video> element */
+  attachStream(stream, videoEl, muted = true) {
+    videoEl.srcObject = stream;
+    videoEl.muted = muted;
+    videoEl.play().catch(() => {
+    });
+  }
+};
+
+// src/encryption/crypto-utils.ts
+function _hex(buf) {
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function _hexToBytes(hex) {
+  return new Uint8Array(hex.match(/.{2}/g).map((h) => parseInt(h, 16)));
+}
+var JoopCryptoUtils = class {
+  // ── Hashing ──────────────────────────────────────────────────────────────
+  async sha256(data) {
+    const buf = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return _hex(await crypto.subtle.digest("SHA-256", buf));
+  }
+  async sha512(data) {
+    const buf = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return _hex(await crypto.subtle.digest("SHA-512", buf));
+  }
+  async sha1(data) {
+    const buf = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return _hex(await crypto.subtle.digest("SHA-1", buf));
+  }
+  // ── HMAC ─────────────────────────────────────────────────────────────────
+  async hmac(data, secret, algo = "SHA-256") {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      new TextEncoder().encode(secret),
+      { name: "HMAC", hash: algo },
+      false,
+      ["sign"]
+    );
+    return _hex(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(data)));
+  }
+  async hmacVerify(data, secret, signature, algo = "SHA-256") {
+    const expected = await this.hmac(data, secret, algo);
+    return this.timingSafeEqual(expected, signature);
+  }
+  // ── PBKDF2 ───────────────────────────────────────────────────────────────
+  async pbkdf2(password, salt, iterations = 1e5, keyLen = 32, hash = "SHA-256") {
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, ["deriveBits"]);
+    const bits = await crypto.subtle.deriveBits(
+      { name: "PBKDF2", salt: new TextEncoder().encode(salt), iterations, hash },
+      key,
+      keyLen * 8
+    );
+    return _hex(bits);
+  }
+  // ── Password hashing ──────────────────────────────────────────────────────
+  async hashPassword(password, salt, iterations = 1e5) {
+    const s = salt ?? this.generateSalt();
+    const hash = await this.pbkdf2(password, s, iterations);
+    return { hash, salt: s, iterations, keyLen: 32 };
+  }
+  async verifyPassword(password, record) {
+    const { hash } = await this.hashPassword(password, record.salt, record.iterations);
+    return this.timingSafeEqual(hash, record.hash);
+  }
+  // ── Utilities ──────────────────────────────────────────────────────────────
+  generateSalt(bytes = 32) {
+    return _hex(crypto.getRandomValues(new Uint8Array(bytes)).buffer);
+  }
+  randomBytes(length) {
+    return new Uint8Array(crypto.getRandomValues(new Uint8Array(length)));
+  }
+  randomHex(bytes = 16) {
+    return _hex(this.randomBytes(bytes).buffer);
+  }
+  uuid() {
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = _hex(bytes.buffer);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  /** Constant-time string comparison to prevent timing attacks */
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    return diff === 0;
+  }
+  hexToBytes(hex) {
+    return _hexToBytes(hex);
+  }
+  bytesToHex(bytes) {
+    return _hex(bytes.buffer);
+  }
+  base64ToHex(b64) {
+    return this.bytesToHex(new Uint8Array(Array.from(atob(b64), (c) => c.charCodeAt(0))));
+  }
+  hexToBase64(hex) {
+    return btoa(String.fromCharCode(..._hexToBytes(hex)));
+  }
+  /** Derive an AES-GCM key from a password via PBKDF2 */
+  async deriveKey(password, salt, iterations = 1e5) {
+    const base = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, ["deriveKey"]);
+    return crypto.subtle.deriveKey(
+      { name: "PBKDF2", salt: new TextEncoder().encode(salt), iterations, hash: "SHA-256" },
+      base,
+      { name: "AES-GCM", length: 256 },
+      false,
+      ["encrypt", "decrypt"]
+    );
+  }
+};
+
+// src/utilities/chart-data.utility.ts
+function _intervalMs(interval) {
+  const MS = { hour: 36e5, day: 864e5, week: 6048e5, month: 2592e6, year: 31536e6 };
+  return MS[interval];
+}
+function _bucketLabel(ts, interval) {
+  const d = new Date(ts);
+  if (interval === "hour") return `${d.toLocaleDateString()} ${d.getHours().toString().padStart(2, "0")}:00`;
+  if (interval === "day") return d.toLocaleDateString();
+  if (interval === "week") return `W${_isoWeek(d)} ${d.getFullYear()}`;
+  if (interval === "month") return `${d.toLocaleString("default", { month: "short" })} ${d.getFullYear()}`;
+  return String(d.getFullYear());
+}
+function _isoWeek(d) {
+  const jan4 = new Date(d.getFullYear(), 0, 4);
+  return Math.ceil(((d.getTime() - jan4.getTime()) / 864e5 + jan4.getDay() + 1) / 7);
+}
+function bucketByTime(data, interval, valueKey, dateKey = "date") {
+  if (!data.length) return [];
+  const ms = _intervalMs(interval);
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of data) {
+    const ts = new Date(row[dateKey]).getTime();
+    const key = Math.floor(ts / ms) * ms;
+    const b = buckets.get(key) ?? { sum: 0, count: 0 };
+    b.sum += Number(row[valueKey] ?? 0);
+    b.count++;
+    buckets.set(key, b);
+  }
+  return Array.from(buckets.entries()).sort(([a], [b]) => a - b).map(([key, b]) => ({
+    label: _bucketLabel(key, interval),
+    value: b.sum,
+    count: b.count,
+    start: key,
+    end: key + ms
+  }));
+}
+function rollingAverage(data, window2) {
+  return data.map((_, i) => {
+    const slice = data.slice(Math.max(0, i - window2 + 1), i + 1);
+    return slice.reduce((a, b) => a + b, 0) / slice.length;
+  });
+}
+function normalize(data, min, max) {
+  const mn = min ?? Math.min(...data);
+  const mx = max ?? Math.max(...data);
+  const range = mx - mn || 1;
+  return data.map((v) => (v - mn) / range);
+}
+function cumulative(data) {
+  let sum = 0;
+  return data.map((v) => sum += v);
+}
+function movingSum(data, window2) {
+  return data.map((_, i) => data.slice(Math.max(0, i - window2 + 1), i + 1).reduce((a, b) => a + b, 0));
+}
+function aggregateByCategory(data, categoryKey, valueKey) {
+  const map = /* @__PURE__ */ new Map();
+  for (const row of data) {
+    const cat = String(row[categoryKey] ?? "");
+    const val = Number(row[valueKey] ?? 0);
+    if (!map.has(cat)) map.set(cat, []);
+    map.get(cat).push(val);
+  }
+  return Array.from(map.entries()).map(([category, vals]) => ({
+    category,
+    total: vals.reduce((a, b) => a + b, 0),
+    count: vals.length,
+    average: vals.reduce((a, b) => a + b, 0) / vals.length,
+    min: Math.min(...vals),
+    max: Math.max(...vals)
+  }));
+}
+function percentChange(values) {
+  return values.map((v, i) => i === 0 ? 0 : (v - values[i - 1]) / (Math.abs(values[i - 1]) || 1) * 100);
+}
+function detectTrend(data, threshold = 0.05) {
+  if (data.length < 2) return "flat";
+  const n = data.length;
+  const xMean = (n - 1) / 2;
+  const yMean = data.reduce((a, b) => a + b, 0) / n;
+  let num = 0, den = 0;
+  data.forEach((y, x) => {
+    num += (x - xMean) * (y - yMean);
+    den += (x - xMean) ** 2;
+  });
+  const slope = den ? num / den : 0;
+  const relativeSlope = Math.abs(slope) / (Math.abs(yMean) || 1);
+  return relativeSlope < threshold ? "flat" : slope > 0 ? "up" : "down";
+}
+function sparklinePoints(data, width, height) {
+  if (!data.length) return "";
+  const mn = Math.min(...data), mx = Math.max(...data), range = mx - mn || 1;
+  return data.map((v, i) => {
+    const x = i / (data.length - 1 || 1) * width;
+    const y = height - (v - mn) / range * height;
+    return `${x.toFixed(2)},${y.toFixed(2)}`;
+  }).join(" ");
+}
+function sparklineSvg(data, width = 100, height = 30, color = "#2563eb") {
+  if (!data.length) return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}"/>`;
+  const pts = sparklinePoints(data, width, height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><polyline points="${pts}" fill="none" stroke="${color}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+}
+
+// src/utilities/watermark.service.ts
+var JoopWatermarkService = class {
+  _watermarkedElements = /* @__PURE__ */ new WeakMap();
+  /**
+   * Apply a visible tiled watermark overlay to an element.
+   */
+  apply(element, text, opts = {}) {
+    this.remove(element);
+    const { opacity = 0.08, fontSize = 16, color = "#000000", rotation = -30, repeat = true } = opts;
+    const overlay = document.createElement("div");
+    Object.assign(overlay.style, {
+      position: "absolute",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      pointerEvents: "none",
+      zIndex: "9999",
+      overflow: "hidden",
+      opacity: String(opacity)
+    });
+    if (repeat) {
+      const canvas = document.createElement("canvas");
+      canvas.width = 200;
+      canvas.height = 100;
+      const ctx = canvas.getContext("2d");
+      ctx.clearRect(0, 0, 200, 100);
+      ctx.save();
+      ctx.translate(100, 50);
+      ctx.rotate(rotation * Math.PI / 180);
+      ctx.font = `${fontSize}px sans-serif`;
+      ctx.fillStyle = color;
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      ctx.fillText(text, 0, 0);
+      ctx.restore();
+      overlay.style.backgroundImage = `url(${canvas.toDataURL()})`;
+      overlay.style.backgroundRepeat = "repeat";
+    } else {
+      overlay.style.display = "flex";
+      overlay.style.alignItems = "center";
+      overlay.style.justifyContent = "center";
+      const span = document.createElement("span");
+      span.textContent = text;
+      span.style.transform = `rotate(${rotation}deg)`;
+      span.style.fontSize = `${fontSize}px`;
+      span.style.color = color;
+      span.style.whiteSpace = "nowrap";
+      overlay.appendChild(span);
+    }
+    if (getComputedStyle(element).position === "static") element.style.position = "relative";
+    element.appendChild(overlay);
+    this._watermarkedElements.set(element, overlay);
+  }
+  remove(element) {
+    const overlay = this._watermarkedElements.get(element);
+    if (overlay && overlay.parentNode === element) element.removeChild(overlay);
+    this._watermarkedElements.delete(element);
+  }
+  /**
+   * Embed a payload invisibly into an ImageData using LSB steganography.
+   * Modifies the least significant bit of the R channel of each pixel.
+   */
+  embedInImage(imageData, payload) {
+    const bytes = new TextEncoder().encode(payload + "\0");
+    const bits = _toBits(bytes);
+    const data = new Uint8ClampedArray(imageData.data);
+    const lenBits = _uint32ToBits(bytes.length);
+    for (let i = 0; i < 32 && i < data.length / 4; i++) {
+      data[i * 4] = data[i * 4] & 254 | lenBits[i];
+    }
+    for (let i = 0; i < bits.length; i++) {
+      const pixelIdx = (i + 32) * 4;
+      if (pixelIdx >= data.length) break;
+      data[pixelIdx] = data[pixelIdx] & 254 | bits[i];
+    }
+    return new ImageData(data, imageData.width, imageData.height);
+  }
+  /**
+   * Extract a payload from an ImageData that was embedded with embedInImage.
+   * Returns null if no valid payload is found.
+   */
+  extractFromImage(imageData) {
+    const data = imageData.data;
+    const lenBits = [];
+    for (let i = 0; i < 32; i++) lenBits.push(data[i * 4] & 1);
+    const len = _bitsToUint32(lenBits);
+    if (len <= 0 || len > (data.length / 4 - 32) / 8) return null;
+    const totalBits = len * 8;
+    const bits = [];
+    for (let i = 0; i < totalBits; i++) {
+      const pixelIdx = (i + 32) * 4;
+      if (pixelIdx >= data.length) break;
+      bits.push(data[pixelIdx] & 1);
+    }
+    const bytes = _fromBits(bits);
+    try {
+      const text = new TextDecoder().decode(bytes);
+      const nullIdx = text.indexOf("\0");
+      return nullIdx >= 0 ? text.slice(0, nullIdx) : text;
+    } catch {
+      return null;
+    }
+  }
+  /** Apply invisible LSB watermark to a canvas element */
+  applyToCanvas(canvas, payload) {
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return;
+    const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const modified = this.embedInImage(imgData, payload);
+    ctx.putImageData(modified, 0, 0);
+  }
+};
+function _toBits(bytes) {
+  const bits = [];
+  for (const byte of bytes) for (let i = 7; i >= 0; i--) bits.push(byte >> i & 1);
+  return bits;
+}
+function _fromBits(bits) {
+  const bytes = new Uint8Array(Math.ceil(bits.length / 8));
+  for (let i = 0; i < bytes.length; i++) {
+    let val = 0;
+    for (let j = 0; j < 8 && i * 8 + j < bits.length; j++) val = val << 1 | bits[i * 8 + j];
+    bytes[i] = val;
+  }
+  return bytes;
+}
+function _uint32ToBits(n) {
+  const bits = [];
+  for (let i = 31; i >= 0; i--) bits.push(n >> i & 1);
+  return bits;
+}
+function _bitsToUint32(bits) {
+  let n = 0;
+  for (const b of bits) n = n << 1 | b;
+  return n >>> 0;
+}
+
+// src/utilities/qr-scanner.ts
+var JoopQrScanner = class {
+  _stream = null;
+  _video = null;
+  _canvas = null;
+  _ctx = null;
+  _timer = null;
+  _active = false;
+  _onResult = null;
+  _onError = null;
+  _cfg;
+  constructor(config) {
+    this._cfg = {
+      decoder: config.decoder,
+      facingMode: config.facingMode ?? "environment",
+      fps: config.fps ?? 10,
+      stopOnScan: config.stopOnScan ?? true,
+      width: config.width ?? 1280,
+      height: config.height ?? 720
+    };
+  }
+  onResult(fn) {
+    this._onResult = fn;
+    return this;
+  }
+  onError(fn) {
+    this._onError = fn;
+    return this;
+  }
+  async start(container) {
+    if (this._active) return;
+    if (!navigator.mediaDevices?.getUserMedia) throw new Error("Camera not available");
+    this._stream = await navigator.mediaDevices.getUserMedia({
+      video: {
+        facingMode: this._cfg.facingMode,
+        width: { ideal: this._cfg.width },
+        height: { ideal: this._cfg.height }
+      }
+    });
+    this._video = document.createElement("video");
+    this._video.setAttribute("playsinline", "true");
+    this._video.muted = true;
+    this._video.srcObject = this._stream;
+    if (container) {
+      Object.assign(this._video.style, { width: "100%", height: "100%", objectFit: "cover", display: "block" });
+      container.appendChild(this._video);
+    }
+    await new Promise((res) => {
+      this._video.onloadedmetadata = () => {
+        this._video.play();
+        res();
+      };
+    });
+    this._canvas = document.createElement("canvas");
+    this._ctx = this._canvas.getContext("2d");
+    this._active = true;
+    this._scheduleFrames();
+  }
+  stop() {
+    this._active = false;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    this._stream?.getTracks().forEach((t) => t.stop());
+    this._stream = null;
+    this._video?.remove();
+    this._video = null;
+  }
+  isActive() {
+    return this._active;
+  }
+  /** Scan a static image File / Blob instead of the camera. */
+  async scanFile(file) {
+    return new Promise((resolve) => {
+      const img = new Image();
+      const url = URL.createObjectURL(file);
+      img.onload = () => {
+        const canvas = document.createElement("canvas");
+        canvas.width = img.width;
+        canvas.height = img.height;
+        const ctx = canvas.getContext("2d");
+        ctx.drawImage(img, 0, 0);
+        const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        const text = this._cfg.decoder(data, canvas.width, canvas.height);
+        URL.revokeObjectURL(url);
+        resolve(text ? { text, timestamp: Date.now() } : null);
+      };
+      img.src = url;
+    });
+  }
+  _scheduleFrames() {
+    const interval = Math.round(1e3 / this._cfg.fps);
+    this._timer = setInterval(() => this._processFrame(), interval);
+  }
+  _processFrame() {
+    if (!this._active || !this._video || !this._canvas || !this._ctx) return;
+    if (this._video.readyState < 2) return;
+    this._canvas.width = this._video.videoWidth;
+    this._canvas.height = this._video.videoHeight;
+    this._ctx.drawImage(this._video, 0, 0);
+    try {
+      const imageData = this._ctx.getImageData(0, 0, this._canvas.width, this._canvas.height);
+      const text = this._cfg.decoder(imageData.data, this._canvas.width, this._canvas.height);
+      if (text) {
+        if (this._cfg.stopOnScan) this.stop();
+        this._onResult?.({ text, timestamp: Date.now() });
+      }
+    } catch (err) {
+      this._onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+};
+function generateTotpUri(options) {
+  const { secret, account, issuer, period = 30, digits = 6, algorithm = "SHA1" } = options;
+  const params = new URLSearchParams({
+    secret,
+    issuer,
+    algorithm,
+    digits: String(digits),
+    period: String(period)
+  });
+  return `otpauth://totp/${encodeURIComponent(issuer)}:${encodeURIComponent(account)}?${params}`;
+}
+
+export { JoopClipboardService, JoopCryptoUtils, JoopGeoService, JoopImageService, JoopMediaRecorder, JoopMediaService, JoopNotificationService, JoopPdfService, JoopQrScanner, JoopWatermarkService, addBusinessDays, aggregateByCategory, bucketByTime, bufferToHex, buildFormData, buildQueryString, clipboard, cumulative, daysBetween, deepClone, detectTrend, escapeHtml, flattenObj, flattenObject, formatDate, formatHijri, fromHijri, generateBarcodeDataUrl, generateCode128, generateCode39, generateEan13, generatePaymentQr, generateQr, generateQrDataUrl, generateTotpUri, getBusinessDaysBetween, getDeviceInfo, getRandomNum, isAlphanumeric, isBrowser, isBusinessDay, isDateInRange, isPlainObject, isSSR, isValidEmail, isValidPhone, isValidUrl, movingSum, normalize, objectToQueryString, parseDate, percentChange, randomString, removeTrailingSlash, rollingAverage, sanitizeFileName, sanitizeInput, sparklinePoints, sparklineSvg, stringToHex, stripHtml, stripSqlKeywords, timeAgo, toHijri, truncate, urlEncode, validateEan13 };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map