@enigmax/primitives 0.16.0 → 0.18.0

package/dist/chunk-53DQY6LP.js

@@ -1,1164 +0,0 @@
-// src/core/marquee.ts
-var DEFAULT_DECAY = 0.12;
-var DRAG_THRESHOLD = 6;
-var STILL_MS = 90;
-var MAX_DT = 0.05;
-var VELOCITY_SMOOTHING = 0.6;
-var TOUCH_HOVER_SUPPRESS_MS = 1e3;
-var IDLE_EPSILON = 0.01;
-var DEFAULTS = {
-  speed: 60,
-  reverse: false,
-  vertical: false,
-  draggable: true,
-  hover: "off",
-  decay: DEFAULT_DECAY,
-  manageStyles: true,
-  copies: "clone"
-};
-var MAX_COPIES = 24;
-function createMarquee(lane, track, options = {}) {
-  let opts = { ...DEFAULTS, ...options };
-  let period = 0;
-  let copyCount = Math.max(2, track.children.length);
-  let offset = 0;
-  let velocity = 0;
-  let running = false;
-  let paused = false;
-  let destroyed = false;
-  let frame = 0;
-  let lastTime = 0;
-  let dragging = false;
-  let pointerId = null;
-  let lastPointer = 0;
-  let startPointer = 0;
-  let lastMoveTime = 0;
-  let maxTravel = 0;
-  let hovering = false;
-  let lastTouchAt = 0;
-  const motionQuery = typeof window.matchMedia === "function" ? window.matchMedia("(prefers-reduced-motion: reduce)") : null;
-  let reducedMotion = motionQuery?.matches ?? false;
-  function hoverTarget(cruise) {
-    const hover = opts.hover ?? "off";
-    if (hover === "off") return cruise;
-    if (hover === "pause") return 0;
-    if (typeof hover === "number") return cruise * hover;
-    return (cruise < 0 ? -1 : 1) * Math.abs(hover.speed);
-  }
-  function target() {
-    if (reducedMotion || paused) return 0;
-    const cruise = opts.reverse ? -opts.speed : opts.speed;
-    return hovering ? hoverTarget(cruise) : cruise;
-  }
-  function axisSize(element) {
-    return opts.vertical ? element.offsetHeight : element.offsetWidth;
-  }
-  function axisStart(element) {
-    return opts.vertical ? element.offsetTop : element.offsetLeft;
-  }
-  function applyStyles() {
-    if (!opts.manageStyles) return;
-    lane.style.overflow = "hidden";
-    lane.style.touchAction = opts.vertical ? "pan-x" : "pan-y";
-    lane.style.userSelect = "none";
-    lane.style.webkitUserSelect = "none";
-    track.style.willChange = "transform";
-  }
-  function render() {
-    const x = opts.vertical ? 0 : -offset;
-    const y = opts.vertical ? -offset : 0;
-    track.style.transform = `translate3d(${x}px, ${y}px, 0)`;
-  }
-  function readPeriod() {
-    const first = track.children[0];
-    const second = track.children[1];
-    if (!first) return 0;
-    if (second) {
-      const step = axisStart(second) - axisStart(first);
-      if (step > 0) return step;
-    }
-    return axisSize(first);
-  }
-  function requiredCopies(measured) {
-    if (measured <= 0) return 2;
-    return Math.min(MAX_COPIES, Math.max(2, Math.ceil(axisSize(lane) / measured) + 1));
-  }
-  function syncClones(count) {
-    const source = track.children[0];
-    if (!source) return;
-    while (track.children.length > count) track.removeChild(track.lastElementChild);
-    while (track.children.length < count) {
-      const clone = source.cloneNode(true);
-      clone.setAttribute("aria-hidden", "true");
-      clone.dataset.enigmaMarqueeCopy = String(track.children.length);
-      track.appendChild(clone);
-    }
-  }
-  function measure() {
-    if (destroyed) return;
-    const cloning = opts.copies === "clone";
-    if (cloning && track.children.length < 2) syncClones(2);
-    let measured = readPeriod();
-    let needed = requiredCopies(measured);
-    if (cloning && track.children.length !== needed) {
-      syncClones(needed);
-      measured = readPeriod();
-      needed = requiredCopies(measured);
-    }
-    const changed = measured !== period || needed !== copyCount;
-    period = measured;
-    if (needed !== copyCount) {
-      copyCount = needed;
-      opts.onCopyCountChange?.(needed);
-    }
-    if (period > 0) offset = wrap(offset);
-    render();
-    if (changed) opts.onMeasure?.(period, copyCount);
-    start();
-  }
-  function wrap(value) {
-    if (period <= 0) return value;
-    return (value % period + period) % period;
-  }
-  function tick(now) {
-    frame = 0;
-    if (destroyed) return;
-    const dt = Math.min((now - lastTime) / 1e3, MAX_DT);
-    lastTime = now;
-    if (!dragging) {
-      velocity += (target() - velocity) * (1 - Math.pow(opts.decay, dt));
-      offset = wrap(offset + velocity * dt);
-    }
-    render();
-    const idle = !dragging && Math.abs(velocity) < IDLE_EPSILON && Math.abs(target()) < IDLE_EPSILON;
-    if (idle) {
-      velocity = 0;
-      running = false;
-      return;
-    }
-    frame = requestAnimationFrame(tick);
-  }
-  function start() {
-    if (destroyed || running) return;
-    running = true;
-    lastTime = performance.now();
-    frame = requestAnimationFrame(tick);
-  }
-  function pointerDelta(event) {
-    return opts.vertical ? event.clientY : event.clientX;
-  }
-  function onPointerDown(event) {
-    if (event.pointerType !== "mouse") noteTouch();
-    if (!opts.draggable || event.button > 0 || pointerId !== null) return;
-    pointerId = event.pointerId;
-    dragging = true;
-    lastPointer = pointerDelta(event);
-    startPointer = lastPointer;
-    lastMoveTime = event.timeStamp;
-    maxTravel = 0;
-    lane.dataset.dragging = "true";
-    window.addEventListener("pointermove", onPointerMove);
-    window.addEventListener("pointerup", onPointerUp);
-    window.addEventListener("pointercancel", onPointerUp);
-    start();
-  }
-  function onPointerMove(event) {
-    if (event.pointerId !== pointerId) return;
-    const position = pointerDelta(event);
-    const delta = position - lastPointer;
-    lastPointer = position;
-    const dt = Math.max((event.timeStamp - lastMoveTime) / 1e3, 1e-3);
-    lastMoveTime = event.timeStamp;
-    maxTravel = Math.max(maxTravel, Math.abs(position - startPointer));
-    offset = wrap(offset - delta);
-    const instant = -delta / dt;
-    velocity = velocity * VELOCITY_SMOOTHING + instant * (1 - VELOCITY_SMOOTHING);
-  }
-  function onPointerUp(event) {
-    if (event.pointerId !== pointerId) return;
-    pointerId = null;
-    dragging = false;
-    delete lane.dataset.dragging;
-    window.removeEventListener("pointermove", onPointerMove);
-    window.removeEventListener("pointerup", onPointerUp);
-    window.removeEventListener("pointercancel", onPointerUp);
-    if (event.timeStamp - lastMoveTime > STILL_MS) velocity = 0;
-    start();
-  }
-  function onClickCapture(event) {
-    if (maxTravel <= DRAG_THRESHOLD) return;
-    event.preventDefault();
-    event.stopPropagation();
-  }
-  function onClick(event) {
-    if (maxTravel > DRAG_THRESHOLD) return;
-    opts.onItemClick?.(event);
-  }
-  function onPointerEnter(event) {
-    if (event.pointerType !== "mouse") {
-      noteTouch();
-      return;
-    }
-    if (Date.now() - lastTouchAt < TOUCH_HOVER_SUPPRESS_MS) return;
-    hovering = true;
-    lane.dataset.hovering = "true";
-    start();
-  }
-  function onPointerLeave() {
-    hovering = false;
-    delete lane.dataset.hovering;
-    start();
-  }
-  function noteTouch() {
-    lastTouchAt = Date.now();
-    if (!hovering) return;
-    hovering = false;
-    delete lane.dataset.hovering;
-    start();
-  }
-  function onMotionChange(event) {
-    reducedMotion = event.matches;
-    lane.dataset.reducedMotion = String(reducedMotion);
-    start();
-  }
-  const resizeObserver = typeof ResizeObserver === "function" ? new ResizeObserver(() => measure()) : null;
-  function init() {
-    applyStyles();
-    lane.dataset.enigmaMarquee = "";
-    lane.dataset.reducedMotion = String(reducedMotion);
-    track.dataset.enigmaMarqueeTrack = "";
-    for (const child of Array.from(track.children)) {
-      child.dataset.enigmaMarqueeCopy ??= "0";
-    }
-    lane.addEventListener("pointerdown", onPointerDown);
-    lane.addEventListener("pointerenter", onPointerEnter);
-    lane.addEventListener("pointerleave", onPointerLeave);
-    lane.addEventListener("touchstart", noteTouch, { passive: true });
-    lane.addEventListener("click", onClickCapture, true);
-    lane.addEventListener("click", onClick);
-    motionQuery?.addEventListener("change", onMotionChange);
-    resizeObserver?.observe(lane);
-    const first = track.children[0];
-    if (first) resizeObserver?.observe(first);
-    measure();
-    void document.fonts?.ready.then(() => measure());
-    remeasureOnImageLoad();
-  }
-  function remeasureOnImageLoad() {
-    for (const image of track.querySelectorAll("img")) {
-      if (image.complete) continue;
-      const done = () => {
-        image.removeEventListener("load", done);
-        image.removeEventListener("error", done);
-        if (!destroyed) measure();
-      };
-      image.addEventListener("load", done);
-      image.addEventListener("error", done);
-    }
-  }
-  init();
-  return {
-    get offset() {
-      return offset;
-    },
-    get period() {
-      return period;
-    },
-    get copyCount() {
-      return copyCount;
-    },
-    get dragging() {
-      return dragging;
-    },
-    get reducedMotion() {
-      return reducedMotion;
-    },
-    update(next) {
-      const styleKeys = next.vertical !== void 0 || next.manageStyles !== void 0;
-      opts = { ...opts, ...next };
-      if (styleKeys) applyStyles();
-      measure();
-    },
-    measure,
-    pause() {
-      paused = true;
-      start();
-    },
-    resume() {
-      paused = false;
-      start();
-    },
-    destroy() {
-      destroyed = true;
-      if (frame) cancelAnimationFrame(frame);
-      resizeObserver?.disconnect();
-      motionQuery?.removeEventListener("change", onMotionChange);
-      lane.removeEventListener("pointerdown", onPointerDown);
-      lane.removeEventListener("pointerenter", onPointerEnter);
-      lane.removeEventListener("pointerleave", onPointerLeave);
-      lane.removeEventListener("touchstart", noteTouch);
-      lane.removeEventListener("click", onClickCapture, true);
-      lane.removeEventListener("click", onClick);
-      window.removeEventListener("pointermove", onPointerMove);
-      window.removeEventListener("pointerup", onPointerUp);
-      window.removeEventListener("pointercancel", onPointerUp);
-    }
-  };
-}
-
-// src/core/input.ts
-var INPUT_ICON_PATHS = {
-  eye: ["M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7-10-7-10-7Z", "M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z"],
-  eyeOff: [
-    "M10.6 5.2A9.8 9.8 0 0 1 12 5c6.5 0 10 7 10 7a17.6 17.6 0 0 1-3.2 4.2M6.2 6.2A17.7 17.7 0 0 0 2 12s3.5 7 10 7a9.6 9.6 0 0 0 4.2-.9",
-    "m2 2 20 20",
-    "M9.9 9.9a3 3 0 0 0 4.2 4.2"
-  ],
-  generate: ["m12 3 1.9 4.6L18.5 9.5 13.9 11.4 12 16l-1.9-4.6L5.5 9.5l4.6-1.9Z", "M19 15l.8 2.2 2.2.8-2.2.8-.8 2.2-.8-2.2-2.2-.8 2.2-.8Z"]
-};
-function iconMarkup(paths) {
-  const body = paths.map((path) => `<path d="${path}"/>`).join("");
-  return `<svg viewBox="0 0 24 24" width="1em" height="1em" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${body}</svg>`;
-}
-var EYE = iconMarkup(INPUT_ICON_PATHS.eye);
-var EYE_OFF = iconMarkup(INPUT_ICON_PATHS.eyeOff);
-function resolve(value, state) {
-  return typeof value === "function" ? value(state) : value;
-}
-function paint(target, icon) {
-  if (typeof icon === "string") target.innerHTML = icon;
-  else {
-    target.replaceChildren(icon);
-  }
-}
-function createInput(input, options = {}) {
-  let opts = { ...options };
-  let revealed = false;
-  let destroyed = false;
-  let restoreTimer = null;
-  const owned = !opts.container;
-  const container = opts.container ?? document.createElement("span");
-  const buttons = /* @__PURE__ */ new Map();
-  function state() {
-    return { input, revealed, locked: input.disabled || input.readOnly };
-  }
-  function revealConfig() {
-    return typeof opts.reveal === "object" ? opts.reveal : {};
-  }
-  function revealAction() {
-    const config = revealConfig();
-    return {
-      name: "reveal",
-      label: (current) => current.revealed ? config.hideLabel ?? "Hide password" : config.showLabel ?? "Show password",
-      icon: (current) => current.revealed ? config.hideIcon ?? EYE_OFF : config.showIcon ?? EYE,
-      pressed: (current) => current.revealed,
-      onSelect: () => setRevealed(!revealed)
-    };
-  }
-  function isPasswordField() {
-    return input.type === "password" || revealed && input.dataset.enigmaInputReveal === "on";
-  }
-  function activeActions() {
-    const custom = opts.actions ?? [];
-    const wantsReveal = opts.reveal !== false && isPasswordField();
-    const builtIn = wantsReveal && !custom.some((action) => action.name === "reveal") ? [revealAction()] : [];
-    return [...builtIn, ...custom];
-  }
-  function setRevealed(next) {
-    if (!isPasswordField() && next) return;
-    const selection = readSelection();
-    revealed = next;
-    input.type = next ? "text" : "password";
-    input.dataset.enigmaInputReveal = next ? "on" : "off";
-    render();
-    if (selection) {
-      applySelection(selection);
-      if (restoreTimer !== null) clearTimeout(restoreTimer);
-      restoreTimer = setTimeout(() => {
-        restoreTimer = null;
-        if (!destroyed && document.activeElement === input) applySelection(selection);
-      }, 0);
-    }
-    opts.onRevealChange?.(next);
-  }
-  function readSelection() {
-    if (document.activeElement !== input) return null;
-    try {
-      const { selectionStart, selectionEnd } = input;
-      return selectionStart === null || selectionEnd === null ? null : [selectionStart, selectionEnd];
-    } catch {
-      return null;
-    }
-  }
-  function applySelection(selection) {
-    try {
-      input.setSelectionRange(selection[0], selection[1]);
-    } catch {
-    }
-  }
-  function render() {
-    if (destroyed) return;
-    const selection = readSelection();
-    const current = state();
-    const actions = activeActions();
-    const seen = /* @__PURE__ */ new Set();
-    for (const action of actions) {
-      seen.add(action.name);
-      const visible = action.visible ? action.visible(current) : true;
-      let button = buttons.get(action.name);
-      if (!button) {
-        button = document.createElement("button");
-        button.type = "button";
-        button.dataset.enigmaInputAction = action.name;
-        buttons.set(action.name, button);
-        container.append(button);
-      }
-      if (!visible) {
-        button.remove();
-        buttons.delete(action.name);
-        continue;
-      }
-      if (!button.isConnected) container.append(button);
-      const label = resolve(action.label, current);
-      button.setAttribute("aria-label", label);
-      button.title = label;
-      button.disabled = current.locked;
-      if (action.pressed) button.setAttribute("aria-pressed", String(action.pressed(current)));
-      else button.removeAttribute("aria-pressed");
-      paint(button, resolve(action.icon, current));
-    }
-    for (const [name, button] of [...buttons]) {
-      if (seen.has(name)) continue;
-      button.remove();
-      buttons.delete(name);
-    }
-    container.hidden = buttons.size === 0;
-    if (selection) {
-      try {
-        input.setSelectionRange(selection[0], selection[1]);
-      } catch {
-      }
-    }
-  }
-  function onMouseDown(event) {
-    if (!event.target?.closest("[data-enigma-input-action]")) return;
-    event.preventDefault();
-  }
-  function onClick(event) {
-    const target = event.target?.closest("[data-enigma-input-action]");
-    if (!target) return;
-    const action = activeActions().find((candidate) => candidate.name === target.dataset.enigmaInputAction);
-    if (!action) return;
-    event.preventDefault();
-    action.onSelect(state());
-  }
-  const observer = typeof MutationObserver === "function" ? new MutationObserver(() => {
-    if (!isPasswordField() && revealed) revealed = false;
-    render();
-  }) : null;
-  function mount() {
-    input.dataset.enigmaInput = "";
-    container.dataset.enigmaInputActions = "";
-    container.dataset.position = opts.position ?? "end";
-    if (owned && !container.isConnected) {
-      if ((opts.position ?? "end") === "start") input.before(container);
-      else input.after(container);
-    }
-    container.addEventListener("mousedown", onMouseDown);
-    container.addEventListener("click", onClick);
-    observer?.observe(input, { attributes: true, attributeFilter: ["type", "disabled", "readonly"] });
-    render();
-  }
-  mount();
-  return {
-    get revealed() {
-      return revealed;
-    },
-    reveal(next) {
-      setRevealed(next ?? !revealed);
-    },
-    refresh: render,
-    update(next) {
-      const moved = next.position !== void 0 && next.position !== opts.position;
-      opts = { ...opts, ...next };
-      if (moved && owned) {
-        container.dataset.position = opts.position ?? "end";
-        if (opts.position === "start") input.before(container);
-        else input.after(container);
-      }
-      render();
-    },
-    destroy() {
-      destroyed = true;
-      if (restoreTimer !== null) clearTimeout(restoreTimer);
-      observer?.disconnect();
-      container.removeEventListener("mousedown", onMouseDown);
-      container.removeEventListener("click", onClick);
-      for (const button of buttons.values()) button.remove();
-      buttons.clear();
-      if (owned) container.remove();
-      delete input.dataset.enigmaInput;
-      delete input.dataset.enigmaInputReveal;
-      if (revealed) input.type = "password";
-    }
-  };
-}
-
-// src/core/button.ts
-var TICK_MS = 100;
-function store(cooldown) {
-  if (!cooldown.key || typeof window === "undefined") return null;
-  try {
-    const target = cooldown.storage === "local" ? window.localStorage : window.sessionStorage;
-    const probe = "__enigma_probe__";
-    target.setItem(probe, "1");
-    target.removeItem(probe);
-    return target;
-  } catch {
-    return null;
-  }
-}
-function normalize(cooldown) {
-  if (cooldown == null) return null;
-  return typeof cooldown === "number" ? { ms: cooldown } : cooldown;
-}
-function isTyping(target) {
-  const element = target;
-  if (!element) return false;
-  const tag = element.tagName;
-  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || element.isContentEditable === true;
-}
-function createButton(options = {}) {
-  let opts = { ...options };
-  let loading = Boolean(opts.loading);
-  let readyAt = 0;
-  let timer = null;
-  let destroyed = false;
-  const listeners = /* @__PURE__ */ new Set();
-  const storageKey = () => {
-    const cooldown = normalize(opts.cooldown);
-    return cooldown?.key ? `enigma:cooldown:${cooldown.key}` : null;
-  };
-  function restore() {
-    const cooldown = normalize(opts.cooldown);
-    if (!cooldown) return;
-    const target = store(cooldown);
-    const key = storageKey();
-    if (!target || !key) return;
-    const saved = Number(target.getItem(key));
-    if (Number.isFinite(saved) && saved > Date.now()) readyAt = saved;
-  }
-  function remaining() {
-    return Math.max(0, readyAt - Date.now());
-  }
-  function snapshot() {
-    const disabled = Boolean(opts.disabled);
-    const cooldown = remaining();
-    return {
-      element: opts.href ? "a" : "button",
-      available: !disabled && !loading && cooldown === 0,
-      loading,
-      disabled,
-      cooldown,
-      shortcut: opts.shortcut ?? null
-    };
-  }
-  function emit() {
-    const state = snapshot();
-    opts.onChange?.(state);
-    for (const listener of listeners) listener(state);
-  }
-  function stopTicking() {
-    if (timer === null) return;
-    clearInterval(timer);
-    timer = null;
-  }
-  function startTicking() {
-    if (timer !== null || remaining() === 0) return;
-    timer = setInterval(() => {
-      if (remaining() > 0) {
-        emit();
-        return;
-      }
-      stopTicking();
-      emit();
-    }, TICK_MS);
-  }
-  function beginCooldown() {
-    const cooldown = normalize(opts.cooldown);
-    if (!cooldown || cooldown.ms <= 0) return;
-    readyAt = Date.now() + cooldown.ms;
-    const target = store(cooldown);
-    const key = storageKey();
-    if (target && key) {
-      try {
-        target.setItem(key, String(readyAt));
-      } catch {
-      }
-    }
-    startTicking();
-  }
-  async function press(event) {
-    if (destroyed || !snapshot().available) return;
-    const result = opts.onPress?.(event);
-    if (result instanceof Promise) {
-      loading = true;
-      emit();
-      try {
-        await result;
-      } finally {
-        loading = false;
-        beginCooldown();
-        emit();
-      }
-      return;
-    }
-    beginCooldown();
-    emit();
-  }
-  function onKeyDown(event) {
-    if (!opts.shortcut || isTyping(event.target)) return;
-    if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey) return;
-    if (event.key.toLowerCase() !== opts.shortcut.toLowerCase()) return;
-    if (!snapshot().available) return;
-    event.preventDefault();
-    void press(event);
-  }
-  if (typeof window !== "undefined") {
-    restore();
-    startTicking();
-    window.addEventListener("keydown", onKeyDown);
-  }
-  return {
-    get state() {
-      return snapshot();
-    },
-    press,
-    update(next) {
-      const hadCooldown = JSON.stringify(normalize(opts.cooldown));
-      opts = { ...opts, ...next };
-      if (next.loading !== void 0) loading = Boolean(next.loading);
-      if (JSON.stringify(normalize(opts.cooldown)) !== hadCooldown) restore();
-      emit();
-    },
-    reset() {
-      readyAt = 0;
-      stopTicking();
-      const cooldown = normalize(opts.cooldown);
-      const key = storageKey();
-      if (cooldown && key) store(cooldown)?.removeItem(key);
-      emit();
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    destroy() {
-      destroyed = true;
-      stopTicking();
-      listeners.clear();
-      if (typeof window !== "undefined") window.removeEventListener("keydown", onKeyDown);
-    }
-  };
-}
-
-// src/core/password.ts
-var LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
-var UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-var DIGITS = "0123456789";
-var SYMBOLS = "!@#$%^&*()-_=+[]{};:,.?";
-var AMBIGUOUS = "Il1O0";
-function randomIndex(bound) {
-  const random = globalThis.crypto?.getRandomValues?.bind(globalThis.crypto);
-  if (!random) {
-    throw new Error("Generating a password needs crypto.getRandomValues, which browsers only expose over HTTPS (or on localhost).");
-  }
-  const limit = Math.floor(2 ** 32 / bound) * bound;
-  const buffer = new Uint32Array(1);
-  let value;
-  do {
-    random(buffer);
-    value = buffer[0];
-  } while (value >= limit);
-  return value % bound;
-}
-function pick(alphabet) {
-  return alphabet[randomIndex(alphabet.length)];
-}
-function classes(options) {
-  const { lowercase = true, uppercase = true, digits = true, symbols = true, excludeAmbiguous = false, exclude = "" } = options;
-  const banned = /* @__PURE__ */ new Set([...excludeAmbiguous ? AMBIGUOUS : "", ...exclude]);
-  const clean = (source) => [...source].filter((character) => !banned.has(character)).join("");
-  return [
-    lowercase ? clean(LOWERCASE) : "",
-    uppercase ? clean(UPPERCASE) : "",
-    digits ? clean(DIGITS) : "",
-    symbols ? clean(SYMBOLS) : ""
-  ].filter(Boolean);
-}
-function shuffle(characters) {
-  for (let index = characters.length - 1; index > 0; index--) {
-    const swap = randomIndex(index + 1);
-    [characters[index], characters[swap]] = [characters[swap], characters[index]];
-  }
-  return characters;
-}
-function generatePassword(options = {}) {
-  const { length = 20, requireEachClass = true } = options;
-  const pools = classes(options);
-  if (!pools.length) throw new Error("generatePassword: every character class was excluded.");
-  if (length < 1) throw new Error("generatePassword: length must be at least 1.");
-  if (requireEachClass && length < pools.length) {
-    throw new Error(`generatePassword: length ${length} cannot hold one character from each of the ${pools.length} classes requested.`);
-  }
-  const everything = pools.join("");
-  const required = requireEachClass ? pools.map(pick) : [];
-  const rest = Array.from({ length: length - required.length }, () => pick(everything));
-  return shuffle([...required, ...rest]).join("");
-}
-var COMMON = /* @__PURE__ */ new Set([
-  "password",
-  "passwd",
-  "123456",
-  "12345678",
-  "123456789",
-  "1234567890",
-  "qwerty",
-  "qwertyuiop",
-  "abc123",
-  "111111",
-  "123123",
-  "admin",
-  "letmein",
-  "welcome",
-  "monkey",
-  "dragon",
-  "sunshine",
-  "iloveyou",
-  "princess",
-  "football",
-  "baseball",
-  "master",
-  "shadow",
-  "superman",
-  "batman",
-  "trustno1",
-  "hello",
-  "freedom",
-  "whatever",
-  "starwars",
-  "changeme",
-  "secret",
-  "login",
-  "root",
-  "toor",
-  "test",
-  "guest",
-  "azerty",
-  "1q2w3e4r",
-  "zaq12wsx"
-]);
-var SEQUENCES = ["abcdefghijklmnopqrstuvwxyz", "0123456789", "qwertyuiop", "asdfghjkl", "zxcvbnm"];
-function poolSize(password) {
-  let size = 0;
-  if (/[a-z]/.test(password)) size += 26;
-  if (/[A-Z]/.test(password)) size += 26;
-  if (/\d/.test(password)) size += 10;
-  if (/[^\w\s]|_/.test(password)) size += SYMBOLS.length;
-  if (/\s/.test(password)) size += 1;
-  return size || 1;
-}
-function longestRun(password) {
-  let longest = 1, run = 1;
-  for (let index = 1; index < password.length; index++) {
-    run = password[index] === password[index - 1] ? run + 1 : 1;
-    longest = Math.max(longest, run);
-  }
-  return longest;
-}
-function longestSequence(password) {
-  const lower = password.toLowerCase();
-  let longest = 0;
-  for (const line of SEQUENCES) {
-    const reversed = [...line].reverse().join("");
-    for (const source of [line, reversed]) {
-      for (let start = 0; start < source.length; start++) {
-        for (let end = source.length; end > start + longest; end--) {
-          if (lower.includes(source.slice(start, end))) {
-            longest = Math.max(longest, end - start);
-            break;
-          }
-        }
-      }
-    }
-  }
-  return longest;
-}
-function core(password) {
-  return password.toLowerCase().replace(/^[^a-z]+/, "").replace(/[^a-z]+$/, "").replace(/[0!@$]/g, (character) => ({ "0": "o", "!": "i", "@": "a", "$": "s" })[character] ?? character);
-}
-function estimatePasswordStrength(password, options = {}) {
-  if (!password) return { score: 0, bits: 0, warnings: [], empty: true };
-  const warnings = [];
-  let bits = password.length * Math.log2(poolSize(password));
-  const stripped = core(password);
-  if (COMMON.has(password.toLowerCase()) || COMMON.has(stripped)) {
-    bits = Math.min(bits, 8);
-    warnings.push("This is one of the most common passwords there is.");
-  }
-  for (const input of options.userInputs ?? []) {
-    const needle = input.trim().toLowerCase();
-    if (needle.length < 4 || !password.toLowerCase().includes(needle)) continue;
-    bits = Math.min(bits, 16);
-    warnings.push("It contains something you already typed on this form.");
-    break;
-  }
-  const run = longestRun(password);
-  if (run >= 3) {
-    bits -= (run - 2) * Math.log2(poolSize(password));
-    warnings.push("A character repeats several times in a row.");
-  }
-  const sequence = longestSequence(password);
-  if (sequence >= 4) {
-    bits -= sequence * Math.log2(poolSize(password)) * 0.75;
-    warnings.push("Part of it runs straight along the keyboard or the alphabet.");
-  }
-  if (password.length < 8) warnings.push("Short passwords fall to a brute force whatever they contain.");
-  bits = Math.max(0, Math.round(bits));
-  const score = bits < 28 ? 0 : bits < 40 ? 1 : bits < 60 ? 2 : bits < 80 ? 3 : 4;
-  return { score, bits, warnings, empty: false };
-}
-
-// src/core/notifications.ts
-var DEFAULT_MAX = 4;
-var DEFAULT_DURATION = 5e3;
-function createNotifications(options = {}) {
-  const view = typeof document === "undefined" ? null : document;
-  const max = options.max ?? DEFAULT_MAX;
-  const defaultDuration = options.duration ?? DEFAULT_DURATION;
-  const sticky = /* @__PURE__ */ new Set([...options.stickyTones ?? ["error"], "loading"]);
-  let items = [];
-  let paused = false;
-  let sequence = 0;
-  const listeners = /* @__PURE__ */ new Set();
-  const timers = /* @__PURE__ */ new Map();
-  function emit() {
-    const snapshot = Object.freeze([...items]);
-    for (const listener of listeners) listener(snapshot);
-  }
-  function clearTimer(id) {
-    const timer = timers.get(id);
-    if (timer?.handle) clearTimeout(timer.handle);
-    timers.delete(id);
-  }
-  function startTimer(id, remaining) {
-    if (!Number.isFinite(remaining) || remaining <= 0) return;
-    const handle = paused ? null : setTimeout(() => dismiss(id), remaining);
-    timers.set(id, { handle, remaining, startedAt: Date.now() });
-  }
-  function dismiss(id) {
-    const next = items.filter((item) => item.id !== id);
-    if (next.length === items.length) return;
-    items = next;
-    clearTimer(id);
-    emit();
-  }
-  function notify(input) {
-    const tone = input.tone ?? "info";
-    const duration = input.duration ?? (sticky.has(tone) ? Infinity : defaultDuration);
-    const existing = input.key ? items.find((item) => item.key === input.key) : void 0;
-    const id = existing?.id ?? `n${++sequence}`;
-    const notification = {
-      id,
-      key: input.key,
-      title: input.title,
-      body: input.body,
-      tone,
-      duration,
-      action: input.action,
-      data: input.data,
-      createdAt: Date.now()
-    };
-    items = existing ? items.map((item) => item.id === id ? notification : item) : [...items, notification];
-    if (items.length > max) {
-      const evictable = items.find((item) => Number.isFinite(item.duration) && item.id !== id);
-      if (evictable) {
-        items = items.filter((item) => item.id !== evictable.id);
-        clearTimer(evictable.id);
-      } else {
-        items = items.slice(items.length - max);
-      }
-    }
-    clearTimer(id);
-    startTimer(id, duration);
-    emit();
-    return id;
-  }
-  const onVisibility = () => {
-    if (!view) return;
-    if (view.hidden) instance.pause();
-    else instance.resume();
-  };
-  function update(id, patch) {
-    const current = items.find((item) => item.id === id);
-    if (!current) return;
-    const tone = patch.tone ?? current.tone;
-    const duration = patch.duration ?? (patch.tone ? sticky.has(tone) ? Infinity : defaultDuration : current.duration);
-    items = items.map((item) => item.id === id ? { ...current, ...patch, tone, duration } : item);
-    clearTimer(id);
-    startTimer(id, duration);
-    emit();
-  }
-  function resolveMessage(message, value) {
-    const resolved = typeof message === "function" ? message(value) : message;
-    return typeof resolved === "string" ? { title: resolved } : resolved;
-  }
-  async function promise(work, messages) {
-    const start = typeof messages.loading === "string" ? { title: messages.loading } : messages.loading;
-    const key = start.key ?? `p${++sequence}`;
-    notify({ ...start, key, tone: "loading" });
-    try {
-      const value = await work;
-      notify({ ...resolveMessage(messages.success, value), key, tone: "success" });
-      return value;
-    } catch (error) {
-      notify({ ...resolveMessage(messages.error, error), key, tone: "error" });
-      throw error;
-    }
-  }
-  const instance = {
-    get items() {
-      return Object.freeze([...items]);
-    },
-    notify,
-    update,
-    promise,
-    dismiss,
-    dismissAll() {
-      for (const item of items) clearTimer(item.id);
-      items = [];
-      emit();
-    },
-    pause() {
-      if (paused) return;
-      paused = true;
-      for (const [id, timer] of timers) {
-        if (!timer.handle) continue;
-        clearTimeout(timer.handle);
-        timers.set(id, {
-          handle: null,
-          remaining: Math.max(timer.remaining - (Date.now() - timer.startedAt), 0),
-          startedAt: Date.now()
-        });
-      }
-    },
-    resume() {
-      if (!paused) return;
-      paused = false;
-      for (const [id, timer] of [...timers]) {
-        clearTimer(id);
-        startTimer(id, timer.remaining);
-      }
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    destroy() {
-      for (const item of items) clearTimer(item.id);
-      items = [];
-      listeners.clear();
-      view?.removeEventListener("visibilitychange", onVisibility);
-    }
-  };
-  view?.addEventListener("visibilitychange", onVisibility);
-  return instance;
-}
-
-// src/core/network.ts
-var SERVER_NETWORK_STATE = {
-  online: true,
-  downlink: null,
-  downlinkMax: null,
-  effectiveType: null,
-  rtt: null,
-  saveData: null,
-  type: null,
-  recovered: false,
-  slow: false
-};
-function connection() {
-  if (typeof navigator === "undefined") return null;
-  const nav = navigator;
-  return nav.connection ?? nav.mozConnection ?? nav.webkitConnection ?? null;
-}
-function shallowEqual(left, right) {
-  for (const key of Object.keys(left)) {
-    if (left[key] !== right[key]) return false;
-  }
-  return true;
-}
-function createNetworkMonitor() {
-  if (typeof window === "undefined") {
-    return {
-      get state() {
-        return SERVER_NETWORK_STATE;
-      },
-      subscribe() {
-        return () => {
-        };
-      },
-      destroy() {
-      }
-    };
-  }
-  const listeners = /* @__PURE__ */ new Set();
-  let hasBeenOffline = false;
-  let state = read();
-  function read() {
-    const link2 = connection();
-    const online = navigator.onLine;
-    const effectiveType = link2?.effectiveType ?? null;
-    const saveData = link2?.saveData ?? null;
-    return {
-      online,
-      downlink: link2?.downlink ?? null,
-      downlinkMax: link2?.downlinkMax ?? null,
-      effectiveType,
-      rtt: link2?.rtt ?? null,
-      saveData,
-      type: link2?.type ?? null,
-      recovered: online && hasBeenOffline,
-      slow: saveData === true || effectiveType === "2g" || effectiveType === "slow-2g"
-    };
-  }
-  function update() {
-    if (!navigator.onLine) hasBeenOffline = true;
-    const next = read();
-    if (shallowEqual(state, next)) return;
-    state = next;
-    for (const listener of listeners) listener(state);
-  }
-  const link = connection();
-  window.addEventListener("online", update, { passive: true });
-  window.addEventListener("offline", update, { passive: true });
-  link?.addEventListener("change", update, { passive: true });
-  return {
-    get state() {
-      return state;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    destroy() {
-      listeners.clear();
-      window.removeEventListener("online", update);
-      window.removeEventListener("offline", update);
-      link?.removeEventListener("change", update);
-    }
-  };
-}
-
-// src/core/relative-time.ts
-var ZONED = /([zZ]|[+-]\d{2}:?\d{2})$/;
-var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
-var HAS_TIME = /\d{2}:\d{2}/;
-var DURATION = /^([+-])?P(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
-var SECOND = 1e3;
-var MINUTE = 60 * SECOND;
-var HOUR = 60 * MINUTE;
-var DAY = 24 * HOUR;
-var WEEK = 7 * DAY;
-var MONTH = 30 * DAY;
-var YEAR = 365 * DAY;
-function ensureZone(text) {
-  const trimmed = text.trim();
-  if (!trimmed || DATE_ONLY.test(trimmed) || ZONED.test(trimmed)) return trimmed;
-  const iso = trimmed.replace(" ", "T");
-  return HAS_TIME.test(iso) ? `${iso}Z` : iso;
-}
-function normalizeDate(value) {
-  if (value == null) return null;
-  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
-  if (typeof value === "number") return Number.isFinite(value) ? new Date(value) : null;
-  const date = new Date(ensureZone(value));
-  return Number.isNaN(date.getTime()) ? null : date;
-}
-function parseDuration(value) {
-  const match = DURATION.exec(value.trim());
-  if (!match) return 0;
-  const [, sign, years, months, weeks, days, hours, minutes, seconds] = match;
-  const n = (part) => part ? Number(part) : 0;
-  const total = n(years) * YEAR + n(months) * MONTH + n(weeks) * WEEK + n(days) * DAY + n(hours) * HOUR + n(minutes) * MINUTE + n(seconds) * SECOND;
-  return sign === "-" ? -total : total;
-}
-function dateTimeOptions(options) {
-  const { second, minute, hour, weekday, day, month, year, timeZone, timeZoneName } = options;
-  const parts = { timeZone, timeZoneName, second, minute, hour, weekday, day, month, year };
-  for (const key of Object.keys(parts)) {
-    if (parts[key] === void 0) delete parts[key];
-  }
-  return parts;
-}
-function format(date, locale, options) {
-  try {
-    return new Intl.DateTimeFormat(locale, options).format(date);
-  } catch {
-    return date.toISOString();
-  }
-}
-function relativeTimeView(value, options = {}, now = /* @__PURE__ */ new Date()) {
-  const date = normalizeDate(value);
-  if (!date) return { date: null, iso: "", label: "", exact: "", beyondThreshold: false, absoluteOnly: false };
-  const { locale, threshold = "P30D", prefix = "on", numericBeyondThreshold = false } = options;
-  const age = Math.abs(date.getTime() - now.getTime());
-  const beyondThreshold = age > parseDuration(threshold);
-  const absoluteOnly = numericBeyondThreshold && beyondThreshold;
-  const parts = absoluteOnly ? { day: "numeric", month: "numeric", year: "numeric", timeZone: options.timeZone } : { day: "numeric", month: "short", year: "numeric", ...dateTimeOptions(options) };
-  const label = format(date, locale, parts);
-  return {
-    date,
-    iso: date.toISOString(),
-    label: !absoluteOnly && prefix ? `${prefix} ${label}` : label,
-    exact: format(date, locale, { dateStyle: "full", timeStyle: "long", timeZone: options.timeZone }),
-    beyondThreshold,
-    absoluteOnly
-  };
-}
-function relativeTimeAttributes(view, options = {}) {
-  const attributes = {
-    datetime: view.iso,
-    format: options.format,
-    tense: options.tense,
-    precision: options.precision,
-    threshold: options.threshold,
-    prefix: options.prefix,
-    "format-style": options.formatStyle,
-    second: options.second,
-    minute: options.minute,
-    hour: options.hour,
-    weekday: options.weekday,
-    day: options.day,
-    month: options.month,
-    year: options.year,
-    lang: options.locale,
-    "time-zone": options.timeZone,
-    "time-zone-name": options.timeZoneName,
-    // Boolean attributes are read by presence: "false" would still be true.
-    "no-title": options.noTitle ? "" : void 0
-  };
-  const out = {};
-  for (const [key, value] of Object.entries(attributes)) {
-    if (value !== void 0) out[key] = value;
-  }
-  return out;
-}
-
-export { INPUT_ICON_PATHS, SERVER_NETWORK_STATE, createButton, createInput, createMarquee, createNetworkMonitor, createNotifications, ensureZone, estimatePasswordStrength, generatePassword, iconMarkup, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView };