@golemui/gui-lit 1.0.3 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golemui/gui-lit",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "license": "MIT",
   "type": "module",
   "main": "./index.umd.cjs",
@@ -22,11 +22,11 @@
     "*.md"
   ],
   "peerDependencies": {
-    "@golemui/lit": "1.0.3",
-    "@golemui/core": "1.0.3",
-    "@golemui/gui-components": "1.0.3",
-    "@golemui/gui-shared": "1.0.3",
-    "@golemui/gui-validators": "1.0.3",
+    "@golemui/lit": "1.1.0",
+    "@golemui/core": "1.1.0",
+    "@golemui/gui-components": "1.1.0",
+    "@golemui/gui-shared": "1.1.0",
+    "@golemui/gui-validators": "1.1.0",
     "@lit/context": "^1.1.6",
     "lit-html": "^3.3.1",
     "lit": "^3.3.1",

package/part-templates-Db871PS3.js

@@ -0,0 +1,677 @@
+import { html as D, nothing as N } from "lit";
+import { p as b, o as V, q as C, I as O, a as R, s as v, u as x, t as B } from "./date-Bj9mI3GU.js";
+import { live as H } from "lit/directives/live.js";
+import { repeat as T } from "lit-html/directives/repeat.js";
+const A = new Date(2025, 0, 15, 9, 5, 0);
+function K(n, t) {
+  if (t === "12" || t === "24") return t;
+  const { hourCycle: r } = new Intl.DateTimeFormat(n ?? "en", {
+    hour: "numeric"
+  }).resolvedOptions();
+  return r === "h11" || r === "h12" ? "12" : "24";
+}
+function ut(n, t) {
+  return new Intl.DateTimeFormat(n ?? "en", {
+    hour: "numeric",
+    minute: "numeric",
+    hourCycle: t === "12" ? "h12" : "h23"
+  }).formatToParts(A);
+}
+function ct(n, t) {
+  return new Intl.DateTimeFormat(n ?? "en", {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    hourCycle: t === "12" ? "h12" : "h23"
+  }).formatToParts(A);
+}
+function U(n) {
+  const t = new Intl.DateTimeFormat(n ?? "en", {
+    hour: "numeric",
+    hourCycle: "h12"
+  }), r = (e) => t.formatToParts(new Date(2025, 0, 15, e, 0, 0)).find((s) => s.type === "dayPeriod")?.value ?? "";
+  return { am: r(9) || "AM", pm: r(21) || "PM" };
+}
+function I(n) {
+  const t = n.getFullYear(), r = String(n.getMonth() + 1).padStart(2, "0"), e = String(n.getDate()).padStart(2, "0"), s = String(n.getHours()).padStart(2, "0"), i = String(n.getMinutes()).padStart(2, "0"), a = String(n.getSeconds()).padStart(2, "0");
+  return `${t}-${r}-${e}T${s}:${i}:${a}`;
+}
+function S(n) {
+  const t = String(n.getHours()).padStart(2, "0"), r = String(n.getMinutes()).padStart(2, "0"), e = String(n.getSeconds()).padStart(2, "0");
+  return `${t}:${r}:${e}`;
+}
+function P(n) {
+  const t = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$/.exec(n);
+  return t ? {
+    hours: Number(t[1]),
+    minutes: Number(t[2]),
+    seconds: Number(t[3] ?? 0)
+  } : null;
+}
+function l(n) {
+  const t = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2}))?)?$/.exec(n);
+  return t ? new Date(
+    Number(t[1]),
+    Number(t[2]) - 1,
+    Number(t[3]),
+    Number(t[4] ?? 0),
+    Number(t[5] ?? 0),
+    Number(t[6] ?? 0)
+  ) : new Date(n);
+}
+const lt = "No available times";
+function f(n, t) {
+  const r = (i) => i.length === 5 ? `${i}:00` : i, e = r(n), s = r(t);
+  return e < s ? -1 : e > s ? 1 : 0;
+}
+function dt(n, t) {
+  const r = P(n);
+  if (!r) return;
+  const e = r.hours * 60 + r.minutes + (t || 30);
+  if (!(e >= 1440))
+    return S(new Date(1970, 0, 1, Math.floor(e / 60), e % 60, 0));
+}
+function mt(n, t) {
+  if (!n?.length) return [];
+  const r = b(t).getDay();
+  return n.filter(
+    (e) => (e.date == null || e.date === t) && (e.weekdays == null || e.weekdays.includes(r))
+  ).map(({ start: e, end: s }) => ({ start: e, end: s }));
+}
+function q(n, t) {
+  return t?.length ? t.some(
+    (r) => f(n, r.start) >= 0 && f(n, r.end ?? r.start) <= 0
+  ) : !1;
+}
+function ht(n, t, r) {
+  if (!r?.length) return !1;
+  const e = t ?? n;
+  return r.some((s) => {
+    const i = s.end ?? s.start;
+    return f(n, i) <= 0 && f(s.start, e) <= 0;
+  });
+}
+function E(n) {
+  return n.length === 5 ? `${n}:00` : n;
+}
+function ft(n) {
+  if (!n.length) return [];
+  const t = n.map((e) => ({ start: E(e.start), end: E(e.end ?? e.start) })).sort((e, s) => f(e.start, s.start)), r = [];
+  for (const e of t) {
+    const s = r[r.length - 1];
+    s && f(e.start, s.end) <= 0 ? f(e.end, s.end) > 0 && (s.end = e.end) : r.push({ ...e });
+  }
+  return r;
+}
+function pt(n, t) {
+  return l(n).getTime() <= l(t).getTime() ? { start: n, end: t } : { start: t, end: n };
+}
+function gt(n) {
+  if (!n.length) return [];
+  const t = n.map((e) => ({
+    start: l(e.start).getTime(),
+    end: l(e.end ?? e.start).getTime()
+  })).sort((e, s) => e.start - s.start), r = [];
+  for (const e of t) {
+    const s = r[r.length - 1];
+    s && e.start <= s.end ? e.end > s.end && (s.end = e.end) : r.push({ start: e.start, end: e.end });
+  }
+  return r.map((e) => ({
+    start: I(new Date(e.start)),
+    end: I(new Date(e.end))
+  }));
+}
+function yt(n, t) {
+  if (!t?.length) return !1;
+  const r = l(n.start).getTime(), e = l(n.end ?? n.start).getTime();
+  return t.some((s) => {
+    const i = l(s.start).getTime(), a = l(s.end ?? s.start).getTime();
+    return r < a && i < e;
+  });
+}
+function St(n, t) {
+  if (!t?.length) return !1;
+  const r = l(`${n}T00:00:00`).getTime(), e = l(`${n}T23:59:59`).getTime();
+  return t.some((s) => {
+    const i = l(s.start).getTime(), a = l(s.end ?? s.start).getTime();
+    return i <= r && a >= e;
+  });
+}
+function Tt(n, t) {
+  if (!n?.length) return [];
+  const r = l(`${t}T00:00:00`).getTime(), e = l(`${t}T23:59:59`).getTime(), s = [];
+  for (const i of n) {
+    const a = l(i.start).getTime(), o = l(i.end ?? i.start).getTime();
+    if (o < r || a > e) continue;
+    const u = a <= r ? "00:00:00" : S(new Date(a)), c = o >= e ? "23:59:59" : S(new Date(o));
+    s.push({ start: u, end: c });
+  }
+  return s;
+}
+function Dt(n) {
+  const t = n.minuteStep || 30, r = P(n.minTime ?? "") ?? { hours: 0, minutes: 0, seconds: 0 }, e = S(new Date(1970, 0, 1, r.hours, r.minutes, r.seconds)), s = n.maxTime ?? "23:59:59", i = [];
+  for (let a = r.hours * 60 + r.minutes; a < 1440; a += t) {
+    const o = S(
+      new Date(1970, 0, 1, Math.floor(a / 60), a % 60, 0)
+    );
+    if (f(o, s) > 0) break;
+    f(o, e) < 0 || i.push({ value: o, disabled: q(o, n.disabledRanges) });
+  }
+  return i;
+}
+function Pt(n, t, r) {
+  const e = P(n);
+  return e ? new Intl.DateTimeFormat(t ?? "en", {
+    hour: "numeric",
+    minute: "numeric",
+    hourCycle: r === "12" ? "h12" : "h23"
+  }).format(new Date(2025, 0, 15, e.hours, e.minutes, e.seconds)) : n;
+}
+function _t(n, t, r) {
+  const e = l(n);
+  return isNaN(e.getTime()) ? n : new Intl.DateTimeFormat(t ?? "en", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: r === "12"
+  }).format(e);
+}
+function It(n, t, r, e) {
+  const s = l(n).getTime();
+  if (isNaN(s)) return null;
+  if (t) {
+    const i = l(t);
+    if (!isNaN(i.getTime()) && s < i.getTime())
+      return e?.minDateTimeMessage ?? V;
+  }
+  if (r) {
+    const i = l(r);
+    if (!isNaN(i.getTime()) && s > i.getTime())
+      return e?.maxDateTimeMessage ?? C;
+  }
+  return null;
+}
+function M(n, t) {
+  const r = n % 12;
+  return t === "pm" ? r + 12 : r;
+}
+function Y(n) {
+  const t = n >= 12 ? "pm" : "am";
+  return { hour12: n % 12 === 0 ? 12 : n % 12, period: t };
+}
+function W() {
+  return {
+    day: { type: "day", kind: "numeric", maxLength: 2, min: 1, max: 31, placeholder: "dd" },
+    month: { type: "month", kind: "numeric", maxLength: 2, min: 1, max: 12, placeholder: "mm" },
+    year: {
+      type: "year",
+      kind: "numeric",
+      maxLength: 4,
+      min: 1e3,
+      // TODO: Add a prop to set the default minimum year, like 1979 or 2000
+      max: 9999,
+      placeholder: "yyyy"
+    }
+  };
+}
+function z(n, t, r) {
+  return {
+    hour: n === "12" ? {
+      type: "hour",
+      kind: "numeric",
+      maxLength: 2,
+      min: 1,
+      max: 12,
+      placeholder: "hh"
+    } : {
+      type: "hour",
+      kind: "numeric",
+      maxLength: 2,
+      min: 0,
+      max: 23,
+      placeholder: "hh",
+      incrementFallback: 0
+    },
+    minute: {
+      type: "minute",
+      kind: "numeric",
+      maxLength: 2,
+      min: 0,
+      max: 59,
+      placeholder: "mm",
+      step: t,
+      incrementFallback: 0,
+      wrap: !0
+    },
+    dayPeriod: {
+      type: "dayPeriod",
+      kind: "dayPeriod",
+      maxLength: 8,
+      min: 0,
+      max: 0,
+      placeholder: r
+    }
+  };
+}
+function G(n, t, r) {
+  return n[t]?.[r] ?? "";
+}
+function L(n, t, r, e) {
+  return { ...n, [t]: { ...n[t], [r]: e } };
+}
+function j(n, t) {
+  return { ...n, [t]: {} };
+}
+function X(n, t, r) {
+  if (r !== "12") return n;
+  let e = n;
+  for (const s of t)
+    G(e, s, "dayPeriod") || (e = L(e, s, "dayPeriod", "am"));
+  return e;
+}
+function J(n, t) {
+  if (isNaN(t)) return { value: t };
+  if (!n) return { value: t };
+  const r = Math.max(n.min, Math.min(n.max, t));
+  return r === t ? { value: t } : {
+    value: r,
+    writeBack: r.toString().padStart(n.maxLength ?? 2, "0")
+  };
+}
+function p(n, t, r, e) {
+  const s = parseInt(n[r] ?? "", 10), { value: i, writeBack: a } = J(t[r], s);
+  return a !== void 0 && (e[r] = a), i;
+}
+function kt(n, t) {
+  const r = {}, e = p(n, t.descriptors, "year", r), s = p(n, t.descriptors, "month", r), i = p(n, t.descriptors, "day", r), a = !isNaN(e) && String(e).length === 4, o = !isNaN(s) && s > 0, u = !isNaN(i) && i > 0;
+  if (!(a && o && u))
+    return { result: { kind: "incomplete" }, writeBacks: r };
+  if (i > v(s, e))
+    return {
+      result: { kind: "invalid", message: t.invalidDateMessage ?? x },
+      writeBacks: r
+    };
+  const c = new Date(e, s - 1, i);
+  return { result: { kind: "valid", iso: B(c), instant: c }, writeBacks: r };
+}
+function $t(n, t) {
+  const r = t.hourFormat === "12", e = {}, s = p(n, t.descriptors, "hour", e), i = p(n, t.descriptors, "minute", e), a = n.dayPeriod ?? "";
+  if (isNaN(s) || isNaN(i)) return { result: { kind: "incomplete" }, writeBacks: e };
+  if (r && a !== "am" && a !== "pm")
+    return { result: { kind: "incomplete" }, writeBacks: e };
+  const o = r ? M(s, a) : s, u = new Date(1970, 0, 1, o, i, 0);
+  return { result: { kind: "valid", iso: S(u), instant: u }, writeBacks: e };
+}
+function Et(n, t) {
+  const r = t.hourFormat === "12", e = {}, s = p(n, t.descriptors, "year", e), i = p(n, t.descriptors, "month", e), a = p(n, t.descriptors, "day", e), o = p(n, t.descriptors, "hour", e), u = p(n, t.descriptors, "minute", e), c = n.dayPeriod ?? "", d = !isNaN(s) && String(s).length === 4, m = !isNaN(i) && i > 0, h = !isNaN(a) && a > 0, g = !isNaN(o), y = !isNaN(u);
+  if (!(d && m && h && g && y && (!r || c === "am" || c === "pm")))
+    return { result: { kind: "incomplete" }, writeBacks: e };
+  if (a > v(i, s))
+    return {
+      result: { kind: "invalid", message: t.invalidDateMessage ?? x },
+      writeBacks: e
+    };
+  const _ = r ? M(o, c) : o, $ = new Date(s, i - 1, a, _, u, 0);
+  return { result: { kind: "valid", iso: I($), instant: $ }, writeBacks: e };
+}
+function wt(n, t) {
+  return t.minTime && f(n, t.minTime) < 0 ? t.minTimeMessage ?? O : t.maxTime && f(n, t.maxTime) > 0 ? t.maxTimeMessage ?? R : null;
+}
+const Q = [
+  "Backspace",
+  "Tab",
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Delete",
+  "Enter"
+];
+function F(n) {
+  return /^[0-9]$/.test(n);
+}
+function Z(n, t) {
+  return Q.includes(n.key) || n.ctrlKey || n.metaKey || t ? !1 : !F(n.key);
+}
+function tt(n, t, r) {
+  const e = n?.step ?? 1, s = n?.incrementFallback ?? 1, i = r === "up" ? e : -e, a = parseInt(t, 10);
+  let o;
+  if (isNaN(a))
+    o = s;
+  else if (o = a + i, n?.wrap) {
+    const u = n.max - n.min + 1;
+    o = ((o - n.min) % u + u) % u + n.min;
+  } else n && (o = Math.max(n.min, Math.min(n.max, o)));
+  return o.toString().padStart(n?.maxLength ?? 2, "0");
+}
+const w = /* @__PURE__ */ new Map();
+function Nt(n, t, r, e = !1) {
+  const s = r || 1, i = `${n ?? ""}|${t ?? ""}|${s}|${e ? "dt" : "t"}`, a = w.get(i);
+  if (a) return a;
+  const o = K(n, t), u = U(n), c = z(o, s, u.am), d = e ? { ...W(), ...c } : c, m = { effectiveHourFormat: o, dayPeriodLabels: u, descriptors: d };
+  return w.set(i, m), m;
+}
+class bt {
+  constructor(t, r) {
+    this._values = {}, this._hasSurfacedInputError = !1, this.getPartDisplay = (e, s) => {
+      const i = this.getPart(e, s);
+      if (s === "dayPeriod" && (i === "am" || i === "pm")) {
+        const a = this.options.getDayPeriodLabels?.();
+        if (a) return a[i];
+      }
+      return i;
+    }, this.handleKeyDown = (e, s, i) => {
+      e.key === "Enter" && this.options.onEnter && (e.preventDefault(), e.target instanceof HTMLInputElement && this.setPart(s, i, e.target.value.replace(/[^0-9]/g, ""))), Z(e, this.options.isReadonly()) && e.preventDefault();
+    }, this.handleDayPeriodKeyDown = (e) => {
+      (e.key === "ArrowUp" || e.key === "ArrowDown") && e.preventDefault(), e.key === "Enter" && e.preventDefault();
+    }, this.handleFocus = (e) => {
+      this.host.dispatchEvent(new CustomEvent("focus", { detail: e }));
+    }, this.handleKeyUp = (e, s, i) => {
+      if (this.options.isReadonly()) return;
+      const a = window.getComputedStyle(this.host).direction === "rtl", o = e.target, u = o, c = this.getGroupInputs(s), d = c.indexOf(o), m = this.options.getDescriptor(i);
+      switch (o instanceof HTMLInputElement && u.value.length === u.maxLength && F(e.key) && (d === c.length - 1 ? this.autoAdvanceFromGroupEnd(s) : c[d + 1].focus()), e.key) {
+        case "Enter": {
+          this.options.onEnter?.(e, s);
+          break;
+        }
+        case "ArrowUp":
+        case "ArrowDown": {
+          if (m?.kind === "dayPeriod") {
+            this.toggleDayPeriod(s, i);
+            break;
+          }
+          const h = tt(
+            m,
+            u.value,
+            e.key === "ArrowUp" ? "up" : "down"
+          );
+          this.setPart(s, i, h), this.selectPart(o), this.options.commitGroup(s);
+          break;
+        }
+        case "ArrowLeft":
+        case "ArrowRight": {
+          const h = [...c].sort(
+            (k, _) => k.getBoundingClientRect().left - _.getBoundingClientRect().left
+          ), g = h.indexOf(o), y = e.key === "ArrowRight" ? g + 1 : g - 1;
+          y >= 0 && y < h.length ? (h[y].focus(), this.selectPart(h[y])) : this.navigatePastGroupEdge(e.key, s, a);
+          break;
+        }
+      }
+    }, this.handleChange = (e, s, i) => {
+      if (e.stopImmediatePropagation(), this.options.isReadonly() || this.options.getDescriptor(i)?.kind === "dayPeriod") return;
+      const u = e.target.value.replace(/[^0-9]/g, "");
+      this.setPart(s, i, u), this.options.commitGroup(s);
+    }, this.handleBlur = (e, s, i) => {
+      const a = this.options.getDescriptor(i);
+      if (a?.kind !== "dayPeriod") {
+        const o = e.target, u = parseInt(o.value, 10);
+        !isNaN(u) && (u > 0 || a?.min === 0) ? o.value = u.toString().padStart(a?.maxLength ?? 2, "0") : this.options.onEmptyPartBlur();
+      }
+      this.host.dispatchEvent(new CustomEvent("blur"));
+    }, this.toggleDayPeriod = (e, s) => {
+      if (this.options.isReadonly() || this.options.isDisabled()) return;
+      const i = this.getPart(e, s);
+      this.setPart(e, s, i === "am" ? "pm" : "am"), this.options.commitGroup(e);
+    }, this.host = t, this.options = r, t.addController(this);
+  }
+  hostConnected() {
+  }
+  get values() {
+    return this._values;
+  }
+  getPart(t, r) {
+    return G(this._values, t, r);
+  }
+  setPart(t, r, e) {
+    this._values = L(this._values, t, r, e), this.host.requestUpdate();
+  }
+  clearGroup(t) {
+    this._values = j(this._values, t), this.host.requestUpdate();
+  }
+  /** Writes clamp corrections back into the state. */
+  applyWriteBacks(t, r) {
+    for (const [e, s] of Object.entries(r))
+      s !== void 0 && this.setPart(t, e, s);
+  }
+  /**
+   * Seeds each group's day-period toggle to 'am' when the effective format is
+   * 12h (the twins' seedDayPeriods). Requests an update only when something
+   * was actually seeded, matching the conditional setPartValue calls.
+   *
+   * @param {readonly string[]} [groups] - The groups to seed; defaults to all.
+   */
+  seedDayPeriods(t = this.options.groups) {
+    this.seedWith(t, this.options.getHourFormat?.() ?? "24");
+  }
+  seedWith(t, r) {
+    const e = X(this._values, t, r);
+    e !== this._values && (this._values = e, this.host.requestUpdate());
+  }
+  /**
+   * Seeds a group's parts from an ISO value; a null/empty value clears the
+   * group (re-seeding its day period for time-aware shapes) and an
+   * unparseable one leaves the state untouched.
+   *
+   * @param {string} group - The group to seed.
+   * @param {string | null} iso - The ISO value, or null/'' to clear.
+   * @param {GroupSeedShape} shape - Which parts the value carries.
+   * @param {HourFormat} [hourFormat] - The effective hour format; defaults to
+   *   the `getHourFormat` option (then '24').
+   */
+  setGroupFromISO(t, r, e, s) {
+    const i = s ?? this.options.getHourFormat?.() ?? "24";
+    if (!r) {
+      this.clearGroup(t), e !== "date" && this.seedWith([t], i);
+      return;
+    }
+    if (e === "date") {
+      const o = b(r);
+      if (isNaN(o.getTime())) return;
+      this.setPart(t, "year", String(o.getFullYear()).padStart(4, "0")), this.setPart(t, "month", String(o.getMonth() + 1).padStart(2, "0")), this.setPart(t, "day", String(o.getDate()).padStart(2, "0"));
+      return;
+    }
+    if (e === "time") {
+      let o = P(r);
+      if (!o) {
+        const u = l(r);
+        if (isNaN(u.getTime())) return;
+        o = { hours: u.getHours(), minutes: u.getMinutes(), seconds: u.getSeconds() };
+      }
+      this.writeTimeParts(t, o.hours, o.minutes, i);
+      return;
+    }
+    const a = l(r);
+    isNaN(a.getTime()) || (this.setPart(t, "day", String(a.getDate()).padStart(2, "0")), this.setPart(t, "month", String(a.getMonth() + 1).padStart(2, "0")), this.setPart(t, "year", String(a.getFullYear()).padStart(4, "0")), this.writeTimeParts(t, a.getHours(), a.getMinutes(), i));
+  }
+  writeTimeParts(t, r, e, s) {
+    if (s === "12") {
+      const { hour12: i, period: a } = Y(r);
+      this.setPart(t, "hour", i.toString().padStart(2, "0")), this.setPart(t, "dayPeriod", a);
+    } else
+      this.setPart(t, "hour", r.toString().padStart(2, "0"));
+    this.setPart(t, "minute", e.toString().padStart(2, "0"));
+  }
+  /**
+   * Focusable part elements of a group in DOM order. Numeric parts are
+   * inputs; dayPeriod parts are toggle buttons.
+   */
+  getGroupInputs(t) {
+    return this.options.groups.length > 1 ? Array.from(this.host.querySelectorAll(`[data-group="${t}"]`)) : Array.from(this.host.querySelectorAll(`.${this.options.blockClass}__part`));
+  }
+  /** Selects an input's text; a no-op for non-input parts (the toggle button). */
+  selectPart(t) {
+    t instanceof HTMLInputElement && t.select();
+  }
+  focusFirst(t) {
+    requestAnimationFrame(() => {
+      this.getGroupInputs(t)[0]?.focus();
+    });
+  }
+  /**
+   * Auto-advance past the last input of a group, or into the next
+   * group's first input, if it has more than one group (like ranged inputs).
+   */
+  autoAdvanceFromGroupEnd(t) {
+    const r = this.options.groups;
+    if (r.length > 1) {
+      const e = r[r.indexOf(t) + 1];
+      e !== void 0 && this.getGroupInputs(e)[0]?.focus();
+      return;
+    }
+    this.getGroupInputs(t)[0]?.focus();
+  }
+  /**
+   * ArrowLeft/ArrowRight past a group's visual edge.
+   */
+  navigatePastGroupEdge(t, r, e) {
+    const s = this.options.groups;
+    if (s.length <= 1) return;
+    const i = s[0], a = s[s.length - 1];
+    if (t === "ArrowLeft") {
+      const o = e ? a : i;
+      if (r !== o) {
+        const u = this.getGroupInputs(o), c = u[u.length - 1];
+        c && (c.focus(), this.selectPart(c));
+      }
+    } else {
+      const o = e ? i : a;
+      if (r !== o) {
+        const u = this.getGroupInputs(o);
+        u[0] && (u[0].focus(), this.selectPart(u[0]));
+      }
+    }
+  }
+  /** Whether an inputError has been surfaced and not yet cleared. */
+  get hasSurfacedInputError() {
+    return this._hasSurfacedInputError;
+  }
+  /**
+   * Surfaces an inputError through `onInputErrorSurfaced` and remembers it so
+   * it can later be cleared.
+   */
+  surfaceInputError(t) {
+    this._hasSurfacedInputError = !0, this.options.onInputErrorSurfaced?.(t);
+  }
+  /**
+   * Clears a previously-surfaced inputError by echoing the given (unchanged)
+   * value through `onSurfacedErrorCleared`; a no-op when nothing is surfaced.
+   */
+  clearSurfacedInputError(t) {
+    this._hasSurfacedInputError && (this._hasSurfacedInputError = !1, this.options.onSurfacedErrorCleared?.(t));
+  }
+  resetSurfacedInputError() {
+    this._hasSurfacedInputError = !1;
+  }
+}
+const et = (n, t) => D`<span class="${t}__separator">${n.value}</span>`;
+function vt(n, t, r) {
+  const e = t.formatParts, s = t.groups.length > 1, i = (d) => s ? `${n}-${d.type}` : d.type, a = (d, m) => {
+    if (d.type === "literal")
+      return et(d, t.blockClass);
+    const h = t.getDescriptor(d.type);
+    if (!h) return "";
+    const g = n === t.groups[0] && m === 0 ? 0 : -1;
+    return nt(n, h, g, t, r);
+  }, o = (d) => d.type === "hour" || d.type === "minute" || d.type === "second", u = e.findIndex(o);
+  if (u === -1)
+    return T(e, i, a);
+  let c = e.length - 1;
+  for (; !o(e[c]); ) c--;
+  return D`
+    ${T(e.slice(0, u), i, a)}
+    <div class="gui-parts__time-cluster ${t.blockClass}__time-cluster" dir="ltr">
+      ${T(e.slice(u, c + 1), i, (d, m) => a(d, u + m))}
+    </div>
+    ${T(e.slice(c + 1), i, (d, m) => a(d, c + 1 + m))}
+  `;
+}
+function nt(n, t, r, e, s) {
+  const i = e.blockClass, a = t.type;
+  if (t.kind === "dayPeriod")
+    return rt(n, t, r, e, s);
+  const o = a === "year" ? `gui-parts__year ${i}__year` : "";
+  return D`
+    <div class="gui-parts__touch-target ${i}__touch-target">
+      <input
+        type="text"
+        inputmode="numeric"
+        class="gui-parts__part ${i}__part ${o}"
+        data-type=${a}
+        data-group=${e.groups.length > 1 ? n : N}
+        maxlength=${t.maxLength}
+        placeholder=${t.placeholder}
+        tabindex=${r}
+        ?required=${e.required}
+        ?disabled=${e.disabled}
+        ?readonly=${e.partsReadonly}
+        autocomplete="off"
+        .value=${H(e.getDisplayValue(n, a))}
+        @keydown=${(u) => s.handleKeyDown(u, n, a)}
+        @keyup=${(u) => s.handleKeyUp(u, n, a)}
+        @focus=${s.handleFocus}
+        @blur=${(u) => s.handleBlur(u, n, a)}
+        @change=${(u) => s.handleChange(u, n, a)}
+      />
+      <div class="gui-parts__visual-underline ${i}__visual-underline"></div>
+    </div>
+  `;
+}
+function rt(n, t, r, e, s) {
+  const i = e.blockClass, a = t.type;
+  return D`
+    <div class="gui-parts__touch-target ${i}__touch-target">
+      <button
+        type="button"
+        class="gui-parts__part gui-parts__dayperiod ${i}__part ${i}__dayperiod"
+        data-type=${a}
+        data-group=${e.groups.length > 1 ? n : N}
+        tabindex=${r}
+        ?disabled=${e.disabled}
+        aria-label=${e.dayPeriodAriaLabel ?? "AM/PM"}
+        @click=${() => s.toggleDayPeriod(n, a)}
+        @keydown=${s.handleDayPeriodKeyDown}
+        @keyup=${(o) => s.handleKeyUp(o, n, a)}
+        @focus=${s.handleFocus}
+        @blur=${(o) => s.handleBlur(o, n, a)}
+      >
+        ${e.getDisplayValue(n, a)}
+      </button>
+      <div class="gui-parts__visual-underline ${i}__visual-underline"></div>
+    </div>
+  `;
+}
+export {
+  Dt as A,
+  bt as G,
+  lt as N,
+  ct as a,
+  Et as b,
+  yt as c,
+  It as d,
+  K as e,
+  _t as f,
+  Nt as g,
+  q as h,
+  St as i,
+  Tt as j,
+  dt as k,
+  Pt as l,
+  gt as m,
+  W as n,
+  pt as o,
+  l as p,
+  kt as q,
+  vt as r,
+  f as s,
+  ht as t,
+  ut as u,
+  $t as v,
+  wt as w,
+  ft as x,
+  mt as y,
+  S as z
+};