@lupinum/ginko 0.4.0 → 0.5.0

package/dist/shared/ginko.DY7RbCEw.mjs

@@ -0,0 +1,601 @@
+import { c as calendarOfCountry } from './ginko.D1PeQ3ds.mjs';
+import { t as todayIn, z as zonedDateTime } from './ginko.AprJymER.mjs';
+import { f, p as plainText } from './ginko.BNVC-g9n.mjs';
+import { m as minorDigits, c as collection, s as single } from './ginko.Dmgixfpf.mjs';
+
+const sourceOf = (o) => o.source ? { source: o.source } : {};
+
+function postalAddress(a, siteCountry) {
+  const country = a.country ?? siteCountry;
+  return { "@type": "PostalAddress", streetAddress: a.street, ...a.postalCode ? { postalCode: a.postalCode } : {}, addressLocality: a.city, ...country ? { addressCountry: country } : {} };
+}
+function offerPrice(m, siteCurrency) {
+  const currency = m.currency ?? siteCurrency;
+  if (!currency) throw new Error("JSON-LD: pass `currency` (the site\u2019s currency) for prices that carry none.");
+  const digits = minorDigits(currency);
+  return { price: (m.amount / 10 ** digits).toFixed(digits), priceCurrency: currency };
+}
+function offerJsonLd(m, siteCurrency, o = {}) {
+  const price = offerPrice(m, siteCurrency);
+  const vat = o.valueAddedTaxIncluded === void 0 ? {} : { valueAddedTaxIncluded: o.valueAddedTaxIncluded };
+  const specification = o.unitCode ? { "@type": "UnitPriceSpecification", ...price, ...vat, referenceQuantity: { "@type": "QuantitativeValue", value: 1, unitCode: o.unitCode } } : o.valueAddedTaxIncluded === void 0 ? void 0 : { "@type": "PriceSpecification", ...price, ...vat };
+  return { "@type": "Offer", ...price, ...specification ? { priceSpecification: specification } : {} };
+}
+
+const both = (de, en) => ({ de, en });
+const weekdays = [
+  { value: "mo", label: both("Montag", "Monday") },
+  { value: "tu", label: both("Dienstag", "Tuesday") },
+  { value: "we", label: both("Mittwoch", "Wednesday") },
+  { value: "th", label: both("Donnerstag", "Thursday") },
+  { value: "fr", label: both("Freitag", "Friday") },
+  { value: "sa", label: both("Samstag", "Saturday") },
+  { value: "su", label: both("Sonntag", "Sunday") }
+];
+const officeWeek = weekdays.map((d) => {
+  const closed = d.value === "sa" || d.value === "su";
+  return { _id: `wk${d.value}000000`, day: d.value, closed, ...closed ? {} : { from1: "09:00", to1: "17:00" } };
+});
+const neutral = {
+  hours: both("\xD6ffnungszeiten", "Opening hours"),
+  week: both("Wochenplan", "Weekly hours"),
+  day: both("Tag", "Day"),
+  closed: both("Ganzt\xE4gig geschlossen", "Closed all day"),
+  opens: both("\xD6ffnet um", "Opens at"),
+  closes: both("Schlie\xDFt um", "Closes at"),
+  opensAgain: both("\xD6ffnet wieder um", "Opens again at"),
+  opensAgainHint: both("Nur wenn du untertags eine Pause machst.", "Only if you close for a break during the day."),
+  closesAgain: both("Schlie\xDFt wieder um", "Closes again at"),
+  exceptions: both("Schlie\xDFtage und Ausnahmen", "Closures and exceptions"),
+  exception: both("Ausnahme", "Exception"),
+  dates: both("Zeitraum", "Dates"),
+  reason: both("Grund", "Reason"),
+  reasonHint: both("Kurz, z. B. \u201EUrlaub\u201C oder \u201EInventur\u201C. Steht so auf der Website.", "Keep it short, e.g. \u201CHoliday\u201D or \u201CStocktaking\u201D. Shown like this on the website."),
+  exceptionClosed: both("Geschlossen", "Closed"),
+  closedOn: both("Geschlossen am", "Closed on"),
+  closedOnHint: both("Ein einzelner Tag. F\xFCr mehrere Tage nimm \u201ESchlie\xDFtage und Ausnahmen\u201C.", "A single day. For several days, use \u201CClosures and exceptions\u201D."),
+  closedNote: both("Grund f\xFCr Besucher", "Reason for visitors"),
+  closedNoteHint: both("Steht auf der Website, z. B. \u201EWegen eines Wasserrohrbruchs\u201C.", "Shown on the website, e.g. \u201CBecause of a burst water pipe\u201D."),
+  noticeDays: both("Schlie\xDFungen ank\xFCndigen (Tage vorher)", "Announce closures (days ahead)"),
+  noticeDaysHint: both("So viele Tage vorher k\xFCndigt die Website eine Schlie\xDFung oder einen geschlossenen Feiertag an.", "How many days ahead the website announces a closure or a public holiday when you are closed."),
+  holidays: both("An Feiertagen", "On public holidays"),
+  holidaySunday: both("wie am Sonntag", "same as Sunday"),
+  holidayClosed: both("geschlossen", "closed"),
+  holidayNormal: both("normale Zeiten des Wochentags", "the weekday\u2019s usual hours"),
+  holidaysHint: both(
+    "Gilt f\xFCr alle gesetzlichen Feiertage. \u201EWie am Sonntag\u201C nimmt die Sonntagszeiten, die an dem Tag gelten. F\xFCr andere Zeiten an einem einzelnen Feiertag trag unter \u201ESchlie\xDFtage und Ausnahmen\u201C eine Ausnahme ein.",
+    "Applies to every public holiday. \u201CSame as Sunday\u201D uses the Sunday hours that apply on that day. For other hours on a single holiday, add an exception under \u201CClosures and exceptions\u201D."
+  ),
+  closedToday: both("Heute geschlossen", "Closed today"),
+  holidaySetting: both("\xD6ffnungszeiten an Feiertagen", "Opening hours on public holidays"),
+  plans: both("\xD6ffnungszeiten ab Datum", "Opening hours from a date"),
+  planName: both("Name", "Name"),
+  planFrom: both("Gilt ab", "Applies from"),
+  planTo: both("Gilt bis", "Applies until"),
+  yearly: both("Jedes Jahr wiederholen", "Repeat every year"),
+  planAdd: both("Neue \xD6ffnungszeiten ab \u2026", "New opening hours from \u2026"),
+  planEdit: both("\xD6ffnungszeiten ab Datum bearbeiten", "Edit hours from a date"),
+  planRemove: both("\xD6ffnungszeiten ab Datum entfernen", "Remove hours from a date")
+};
+const open = { field: "closed", not: true };
+function timeFields(t) {
+  return {
+    from1: f.time(t.opens, { optional: true, showWhen: open }),
+    to1: f.time(t.closes, { optional: true, showWhen: open }),
+    from2: f.time(t.opensAgain, { optional: true, showWhen: open, hint: t.opensAgainHint }),
+    to2: f.time(t.closesAgain, { optional: true, showWhen: open })
+  };
+}
+function weekField(t, week) {
+  return f.list(t.week, {
+    itemLabel: t.day,
+    fields: {
+      day: f.choice(t.day, { options: weekdays }),
+      closed: f.boolean(t.closed),
+      ...timeFields(t)
+    },
+    min: 7,
+    max: 7,
+    unique: "day",
+    default: week
+  });
+}
+function hoursBrick(t, week, opts) {
+  return single({
+    label: opts.label ?? t.hours,
+    ...sourceOf(opts),
+    // Today's hours on the Studio's Today page (closed, open from … to …, or due when nothing is entered for today),
+    // with the hour plans when the site names them.
+    status: { hours: opts.plans ? { plans: opts.plans } : true },
+    fields: {
+      week: weekField(t, week),
+      exceptions: f.list(t.exceptions, {
+        itemLabel: t.exception,
+        fields: {
+          when: f.daterange(t.dates),
+          reason: f.text(t.reason, { max: 140, hint: t.reasonHint }),
+          // A new exception is a closure unless the owner says otherwise.
+          closed: f.boolean(t.exceptionClosed, { default: true }),
+          // Special hours: "closed" off and times set, e.g. 24 December from 11:00 to 14:00.
+          ...timeFields(t)
+        },
+        max: 20,
+        default: []
+      }),
+      // Optional: "Clear" in the Studio clears it, and saving it empty lifts the closure.
+      closedOn: f.date(t.closedOn, { optional: true, hint: t.closedOnHint }),
+      closedNote: f.text(t.closedNote, { max: 140, optional: true, hint: t.closedNoteHint }),
+      holidayNoticeDays: f.number(t.noticeDays, { min: 0, max: 60, step: 1, default: 14, hint: t.noticeDaysHint }),
+      // Which holidays count is the site's `country` or `calendar` (code), so the hint says what the choice covers and
+      // where a single holiday gets other hours.
+      holidays: f.choice(t.holidays, {
+        options: [
+          { value: "sunday", label: t.holidaySunday },
+          { value: "closed", label: t.holidayClosed },
+          { value: "normal", label: t.holidayNormal }
+        ],
+        optional: true,
+        default: "sunday",
+        hint: t.holidaysHint
+      })
+    },
+    tasks: [
+      { id: "closedToday", label: t.closedToday, kind: "edit", fields: ["closedOn", "closedNote"], prefill: { closedOn: "@today" } },
+      // The lead time sits under the list, so the owner sees when visitors first read about a closure.
+      { id: "holiday", label: t.exceptions, kind: "edit", fields: ["exceptions", "holidayNoticeDays"] },
+      { id: "holidaySetting", label: t.holidaySetting, kind: "edit", fields: ["holidays"] }
+    ]
+  });
+}
+function hourPlansBrick(t, week, opts) {
+  return collection({
+    label: opts.label ?? t.plans,
+    ...sourceOf(opts),
+    fields: {
+      label: f.text(t.planName, { max: 80 }),
+      from: f.date(t.planFrom),
+      to: f.date(t.planTo, { optional: true }),
+      yearly: f.boolean(t.yearly, { default: false }),
+      week: weekField(t, week)
+    },
+    max: 12,
+    order: { field: "from", dir: "asc" },
+    tasks: [
+      { id: "add", label: t.planAdd, kind: "create" },
+      { id: "edit", label: t.planEdit, kind: "edit", pick: true, fields: ["label", "from", "to", "yearly", "week"] },
+      { id: "remove", label: t.planRemove, kind: "remove" }
+    ]
+  });
+}
+function hours(opts = {}) {
+  return hoursBrick(neutral, officeWeek, opts);
+}
+function hourPlans(opts = {}) {
+  return hourPlansBrick(neutral, officeWeek, opts);
+}
+
+const weekdayKeys = ["mo", "tu", "we", "th", "fr", "sa", "su"];
+function weekdayOf(date) {
+  const day = (/* @__PURE__ */ new Date(`${date}T12:00:00Z`)).getUTCDay();
+  return weekdayKeys[(day + 6) % 7];
+}
+function addDays(date, n) {
+  const d = /* @__PURE__ */ new Date(`${date}T12:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + n);
+  return d.toISOString().slice(0, 10);
+}
+
+function easter(year) {
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const g = Math.floor((8 * b + 13) / 25);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 19 * l) / 433);
+  const month = Math.floor((h + l - 7 * m + 90) / 25);
+  const day = (h + l - 7 * m + 114) % 31 + 1;
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+const byDate = (list) => list.sort((p, q) => p.date.localeCompare(q.date));
+function austrianHolidays(year) {
+  const y = String(year);
+  const easterSunday = easter(year);
+  return byDate([
+    { date: `${y}-01-01`, de: "Neujahr", en: "New Year\u2019s Day" },
+    { date: `${y}-01-06`, de: "Heilige Drei K\xF6nige", en: "Epiphany" },
+    { date: addDays(easterSunday, 1), de: "Ostermontag", en: "Easter Monday" },
+    { date: `${y}-05-01`, de: "Staatsfeiertag", en: "Labour Day" },
+    { date: addDays(easterSunday, 39), de: "Christi Himmelfahrt", en: "Ascension Day" },
+    { date: addDays(easterSunday, 50), de: "Pfingstmontag", en: "Whit Monday" },
+    { date: addDays(easterSunday, 60), de: "Fronleichnam", en: "Corpus Christi" },
+    { date: `${y}-08-15`, de: "Mari\xE4 Himmelfahrt", en: "Assumption Day" },
+    { date: `${y}-10-26`, de: "Nationalfeiertag", en: "Austrian National Day" },
+    { date: `${y}-11-01`, de: "Allerheiligen", en: "All Saints\u2019 Day" },
+    { date: `${y}-12-08`, de: "Mari\xE4 Empf\xE4ngnis", en: "Immaculate Conception" },
+    { date: `${y}-12-25`, de: "Christtag", en: "Christmas Day" },
+    { date: `${y}-12-26`, de: "Stefanitag", en: "St. Stephen\u2019s Day" }
+  ]);
+}
+function germanHolidays(year) {
+  const y = String(year);
+  const easterSunday = easter(year);
+  return byDate([
+    { date: `${y}-01-01`, de: "Neujahr", en: "New Year\u2019s Day" },
+    { date: addDays(easterSunday, -2), de: "Karfreitag", en: "Good Friday" },
+    { date: addDays(easterSunday, 1), de: "Ostermontag", en: "Easter Monday" },
+    { date: `${y}-05-01`, de: "Tag der Arbeit", en: "Labour Day" },
+    { date: addDays(easterSunday, 39), de: "Christi Himmelfahrt", en: "Ascension Day" },
+    { date: addDays(easterSunday, 50), de: "Pfingstmontag", en: "Whit Monday" },
+    { date: `${y}-10-03`, de: "Tag der Deutschen Einheit", en: "German Unity Day" },
+    { date: `${y}-12-25`, de: "1. Weihnachtstag", en: "Christmas Day" },
+    { date: `${y}-12-26`, de: "2. Weihnachtstag", en: "Boxing Day" }
+  ]);
+}
+const singaporeTable = {
+  2026: [
+    { date: "2026-02-17", de: "Chinesisches Neujahr", en: "Chinese New Year" },
+    { date: "2026-02-18", de: "Chinesisches Neujahr", en: "Chinese New Year" },
+    { date: "2026-03-21", de: "Hari Raya Puasa", en: "Hari Raya Puasa" },
+    { date: "2026-04-03", de: "Karfreitag", en: "Good Friday" },
+    { date: "2026-05-27", de: "Hari Raya Haji", en: "Hari Raya Haji" },
+    { date: "2026-05-31", de: "Vesak", en: "Vesak Day" },
+    { date: "2026-11-08", de: "Deepavali", en: "Deepavali" }
+  ],
+  2027: [
+    { date: "2027-02-06", de: "Chinesisches Neujahr", en: "Chinese New Year" },
+    { date: "2027-02-07", de: "Chinesisches Neujahr", en: "Chinese New Year" },
+    { date: "2027-03-10", de: "Hari Raya Puasa", en: "Hari Raya Puasa" },
+    { date: "2027-03-26", de: "Karfreitag", en: "Good Friday" },
+    { date: "2027-05-17", de: "Hari Raya Haji", en: "Hari Raya Haji" },
+    { date: "2027-05-20", de: "Vesak", en: "Vesak Day" },
+    { date: "2027-10-28", de: "Deepavali", en: "Deepavali" }
+  ]
+};
+function singaporeHolidays(year) {
+  const y = String(year);
+  const base = [
+    { date: `${y}-01-01`, de: "Neujahr", en: "New Year\u2019s Day" },
+    { date: `${y}-05-01`, de: "Tag der Arbeit", en: "Labour Day" },
+    { date: `${y}-08-09`, de: "Nationalfeiertag", en: "National Day" },
+    { date: `${y}-12-25`, de: "Weihnachten", en: "Christmas Day" },
+    ...singaporeTable[year] ?? []
+  ];
+  const out = [...base];
+  for (const h of base) {
+    if (weekdayOf(h.date) === "su") out.push({ date: addDays(h.date, 1), de: `${h.de} (Ersatztag)`, en: `${h.en} (observed)` });
+  }
+  return byDate(out);
+}
+const calendars = { AT: austrianHolidays, DE: germanHolidays, SG: singaporeHolidays, none: () => [] };
+function calendarOf(option) {
+  return typeof option === "function" ? option : calendars[option];
+}
+
+function spansOf(t) {
+  return [[t.from1, t.to1], [t.from2, t.to2]].filter((p) => !!p[0] && !!p[1]).map(([from, to]) => ({ from, to }));
+}
+function spansText(spans, and) {
+  return spans.map((s) => `${s.from}\u2013${s.to}`).join(` ${and} `);
+}
+function timesOf(day, and) {
+  if (!day || day.closed) return "";
+  return spansText(spansOf(day), and);
+}
+function holidayOn(date, calendar) {
+  return calendarOf(calendar)(Number(date.slice(0, 4))).find((h) => h.date === date);
+}
+function calendarIn(ctx) {
+  return ctx.calendar ?? (ctx.country ? calendarOfCountry(ctx.country) : void 0) ?? "none";
+}
+function planCovers(plan, date) {
+  if (date < plan.from) return false;
+  if (!plan.yearly) return !plan.to || date <= plan.to;
+  const md = date.slice(5);
+  const from = plan.from.slice(5);
+  if (!plan.to) return md >= from;
+  const to = plan.to.slice(5);
+  return from <= to ? md >= from && md <= to : md >= from || md <= to;
+}
+function planOn(plans, date) {
+  return (plans ?? []).filter((p) => planCovers(p, date)).sort((a, b) => b.from.localeCompare(a.from))[0];
+}
+function weekFor(ctx, date) {
+  const plan = planOn(ctx.plans, date);
+  return plan ? { week: plan.week, plan } : { week: ctx.hours.week };
+}
+function ruleOfDay(day, source) {
+  if (!day || day.closed) return { closed: true, times: [], source };
+  return { closed: false, times: spansOf(day), source };
+}
+function hoursOn(ctx, date) {
+  const { hours } = ctx;
+  if (hours.closedOn === date) return { closed: true, times: [], reason: hours.closedNote || void 0, source: "today", field: "closedNote" };
+  const covering = (hours.exceptions ?? []).filter((e) => e.when.from <= date && date <= e.when.to && (e.closed || spansOf(e).length > 0));
+  const exception = covering.find((e) => e.closed) ?? covering[0];
+  if (exception) {
+    const field = `exceptions.${exception._id}.reason`;
+    return exception.closed ? { closed: true, times: [], reason: exception.reason, source: "exception", field } : { closed: false, times: spansOf(exception), reason: exception.reason, source: "exception", field };
+  }
+  const { week, plan } = weekFor(ctx, date);
+  const holiday = holidayOn(date, calendarIn(ctx));
+  const setting = hours.holidays ?? "sunday";
+  if (holiday && setting !== "normal") {
+    const base = setting === "closed" ? void 0 : week.find((d) => d.day === "su");
+    return { ...ruleOfDay(base, "holiday"), holiday: { de: holiday.de, en: holiday.en } };
+  }
+  return ruleOfDay(week.find((d) => d.day === weekdayOf(date)), plan ? "plan" : "week");
+}
+function weekOf(ctx, monday) {
+  return Array.from({ length: 7 }, (_, i) => {
+    const date = addDays(monday, i);
+    return { date, weekday: weekdayOf(date), ...hoursOn(ctx, date) };
+  });
+}
+function todayState(ctx, today) {
+  const rule = hoursOn(ctx, today);
+  if (!rule.closed) return { kind: "open", times: rule.times, ...rule.source === "exception" ? { reason: rule.reason, field: rule.field } : {} };
+  if (rule.source === "today" || rule.source === "exception") return { kind: "closed", reason: rule.reason, field: rule.field ?? "" };
+  if (rule.holiday) return { kind: "holiday", holiday: rule.holiday };
+  return { kind: "restDay" };
+}
+function noticesOn(notices, ctx, today) {
+  if (todayState(ctx, today).kind !== "closed") return [...notices];
+  return notices.filter((n) => n.data.until !== today);
+}
+function upcomingHolidayClosures(ctx, today, days) {
+  const out = [];
+  for (let i = 1; i <= days; i++) {
+    const date = addDays(today, i);
+    const rule = hoursOn(ctx, date);
+    if (rule.source === "holiday" && rule.closed && rule.holiday && !ruleOfDay(weekFor(ctx, date).week.find((d) => d.day === weekdayOf(date)), "week").closed) {
+      out.push({ _id: `holiday-${date}`, when: { from: date, to: date }, closed: true, holiday: rule.holiday });
+    }
+  }
+  return out;
+}
+function closedOnClosure(hours, today) {
+  const day = hours.closedOn;
+  return day && day > today ? { _id: "closedOn", when: { from: day, to: day }, reason: hours.closedNote ?? "", closed: true, field: "closedNote" } : void 0;
+}
+function upcomingClosures(ctx, today, days) {
+  const until = addDays(today, days);
+  const { hours } = ctx;
+  const closures = (hours.exceptions ?? []).filter((e) => e.closed && e.when.from > today && e.when.from <= until).map((e) => ({ ...e, field: `exceptions.${e._id}.reason` }));
+  const closedOn = closedOnClosure(hours, today);
+  if (closedOn && closedOn.when.from <= until) closures.push(closedOn);
+  closures.push(...upcomingHolidayClosures(ctx, today, days));
+  return closures.sort((a, b) => a.when.from.localeCompare(b.when.from));
+}
+function endOf(plan, starts) {
+  if (!plan.to || !plan.yearly) return plan.to;
+  const year = Number(starts.slice(0, 4));
+  const md = plan.to.slice(5);
+  return `${md < plan.from.slice(5) ? year + 1 : year}-${md}`;
+}
+function upcomingPlans(plans, today, days) {
+  const until = addDays(today, days);
+  const out = [];
+  for (const plan of plans) {
+    let starts = plan.from;
+    if (plan.yearly) {
+      const year = Number(today.slice(0, 4));
+      const md = plan.from.slice(5);
+      starts = `${year}-${md}` > today ? `${year}-${md}` : `${year + 1}-${md}`;
+      if (plan.from > starts) starts = plan.from;
+    }
+    let ends = endOf(plan, starts);
+    if (ends) {
+      for (let day = ends, i = 0; day >= starts && i < 366; day = addDays(day, -1), i++) {
+        if (planOn(plans, day) === plan) {
+          ends = day;
+          break;
+        }
+      }
+    }
+    if (starts > today && starts <= until) out.push({ plan, starts, ...ends ? { ends } : {} });
+  }
+  return out.sort((a, b) => a.starts.localeCompare(b.starts));
+}
+const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const isText = (v) => typeof v === "string" ? v !== "" : isRecord(v) && Object.values(v).every((x) => typeof x === "string");
+function asHours(data) {
+  if (!isRecord(data) || !Array.isArray(data.week) || !data.week.every((d) => isRecord(d) && typeof d.day === "string")) return void 0;
+  if (data.exceptions !== void 0 && data.exceptions !== null && !(Array.isArray(data.exceptions) && data.exceptions.every((e) => isRecord(e) && isRecord(e.when)))) return void 0;
+  return { ...data, exceptions: data.exceptions ?? [] };
+}
+function hoursLine(data, ctx) {
+  const hours = asHours(data);
+  if (!hours) return { state: "unknown" };
+  const today = todayIn(ctx.timeZone, ctx.now);
+  if (ctx.holidays === void 0) {
+    const [none, at] = [lineOn(hours, today, ctx.plans, "none"), lineOn(hours, today, ctx.plans, "AT")];
+    if (JSON.stringify(none) === JSON.stringify(at)) return none;
+    return none.state === "unknown" ? none : at.state === "unknown" ? at : { state: "unknown", calendar: true };
+  }
+  const rule = hoursOn({ hours, plans: ctx.plans, calendar: ctx.holidays === "custom" ? "none" : ctx.holidays }, today);
+  const line = lineOf(rule, hours, today, ctx.plans);
+  if (ctx.holidays === "custom" && line.state !== "unknown" && rule.source !== "today" && rule.source !== "exception") return { state: "unknown", calendar: true };
+  return line;
+}
+function lineOn(hours, today, plans, calendar) {
+  return lineOf(hoursOn({ hours, plans, calendar }, today), hours, today, plans);
+}
+function lineOf(rule, hours, today, plans) {
+  if (rule.source === "week" || rule.source === "plan") {
+    if (!weekFor({ hours, plans }, today).week.some((d) => d.day === weekdayOf(today))) return { state: "unknown" };
+  }
+  if (rule.closed) {
+    if (rule.holiday) return { state: "closed", holiday: { de: rule.holiday.de, en: rule.holiday.en } };
+    return isText(rule.reason) ? { state: "closed", reason: rule.reason } : { state: "closed" };
+  }
+  const ranges = rule.times.filter((s) => TIME.test(s.from) && TIME.test(s.to)).map((s) => [s.from, s.to]);
+  return ranges.length ? { state: "open", ranges } : { state: "unknown" };
+}
+
+const noticeFields = () => ({
+  text: f.text(both("Text", "Text"), { max: 140 }),
+  until: f.date(both("Gilt bis", "Shown until"), {
+    optional: true,
+    hint: both("Leer lassen, wenn der Hinweis bleiben soll, bis du ihn entfernst.", "Leave empty to keep the notice until you remove it.")
+  })
+});
+function noticesBrick(opts, first) {
+  return collection({
+    label: opts.label ?? both("Hinweise", "Notices"),
+    ...sourceOf(opts),
+    fields: noticeFields(),
+    max: 5,
+    order: "manual",
+    visible: { mode: "until", field: "until", deleteExpired: true },
+    tasks: [
+      ...first,
+      { id: "add", label: both("Hinweis hinzuf\xFCgen", "Add a notice"), kind: "create" },
+      { id: "remove", label: both("Hinweis entfernen", "Remove a notice"), kind: "remove" }
+    ]
+  });
+}
+function notices(opts = {}) {
+  return noticesBrick(opts, []);
+}
+
+function eventsBrick(opts, booking, extra, afterBooking) {
+  const fields = {
+    title: f.text(both("Titel", "Title"), { max: 120 }),
+    slug: f.slug(both("Adresse", "Web address"), { from: "title" }),
+    when: f.daterange(both("Wann", "When")),
+    // The clock time of the first day. `when` stays the order and visibility field.
+    start: f.time(both("Beginn", "Starts at"), { optional: true }),
+    ...extra,
+    description: f.markdown(both("Beschreibung", "Description"), { profile: "basic", max: 5e3 }),
+    price: f.money(both("Preis", "Price"), { optional: true }),
+    booking: f.text(booking, { format: "url", optional: true }),
+    ...afterBooking ?? {},
+    image: f.image(both("Bild", "Image"), { optional: true }),
+    // The site shows "fully booked" instead of the booking link. Optional: a missing value means bookable.
+    soldOut: f.boolean(both("Ausgebucht", "Fully booked"), { optional: true })
+  };
+  const tasks = [
+    { id: "add", label: both("Veranstaltung hinzuf\xFCgen", "Add an event"), kind: "create" },
+    { id: "soldOut", label: both("Veranstaltung ausgebucht", "Event fully booked"), kind: "edit", pick: true, fields: ["soldOut"] },
+    { id: "remove", label: both("Veranstaltung entfernen", "Remove an event"), kind: "remove" }
+  ];
+  return collection({
+    label: opts.label ?? both("Veranstaltungen", "Events"),
+    ...sourceOf(opts),
+    fields,
+    max: 30,
+    order: { field: "when", dir: "asc" },
+    // `extra` keeps the fields generic, so the type cannot see that `when` is still the daterange.
+    visible: { mode: "until", field: "when" },
+    ...opts.route ? { route: opts.route } : {},
+    tasks
+  });
+}
+function events(opts) {
+  return eventsBrick(opts, both("Buchungs-Link", "Booking link"), {
+    // The clock time of the last day.
+    end: f.time(both("Ende", "Ends at"), { optional: true }),
+    location: f.text(both("Ort", "Location"), { max: 200, optional: true }),
+    online: f.text(both("Online-Link", "Online link"), { format: "url", optional: true })
+  }, {
+    // Ticket sales or bookings that close before the event: the site hides the booking link after this day.
+    bookingUntil: f.date(both("Buchbar bis", "Bookable until"), {
+      optional: true,
+      hint: both("Letzter Tag, an dem der Buchungs-Link erscheint. Leer: bis zur Veranstaltung.", "Last day the booking link shows. Empty: until the event.")
+    })
+  });
+}
+function sessionsBrick(opts, speakers) {
+  return collection({
+    label: opts.label ?? both("Programmpunkte", "Sessions"),
+    ...sourceOf(opts),
+    fields: {
+      event: f.ref(both("Veranstaltung", "Event"), { to: opts.events ?? "events" }),
+      date: f.date(both("Datum", "Date")),
+      from: f.time(both("Beginn", "Starts at")),
+      to: f.time(both("Ende", "Ends at"), { after: "from" }),
+      title: f.text(both("Titel", "Title"), { max: 120 }),
+      // One or two sentences: what the session is about and who it is for.
+      summary: f.text(both("Kurzbeschreibung", "Summary"), { max: 200, optional: true }),
+      room: f.text(both("Raum", "Room"), { max: 80, optional: true }),
+      speakers,
+      status: f.choice(both("Status", "Status"), {
+        options: [
+          { value: "open", label: both("Findet statt", "Open") },
+          { value: "soldOut", label: both("Ausgebucht", "Sold out") },
+          { value: "cancelled", label: both("Abgesagt", "Cancelled") }
+        ],
+        default: "open"
+      })
+    },
+    max: 300,
+    // Core orders by one field: sessions of one day share a date and come in no fixed order here (also in the Studio
+    // list). Pages sort with `sessionsInOrder` (date, then start time).
+    order: { field: "date", dir: "asc" },
+    visible: { mode: "until", field: "date" },
+    tasks: [
+      // The job during the event: a session moves, changes its room, fills up or is cancelled.
+      { id: "change", label: both("Programmpunkt \xE4ndern", "Change a session"), kind: "edit", pick: true, fields: ["from", "to", "room", "status"] },
+      { id: "soldOut", label: both("Ausgebucht", "Sold out"), kind: "edit", pick: true, fields: ["status"], prefill: { status: "soldOut" } }
+    ]
+  });
+}
+function sessions(opts = {}) {
+  return opts.people ? sessionsBrick(opts, speakerRefs(opts.people)) : sessionsBrick(opts, speakerText());
+}
+const speakerRefs = (people) => f.refs(both("Vortragende", "Speakers"), { to: people, max: 10, optional: true });
+const speakerText = () => f.text(both("Vortragende", "Speakers"), { max: 200, optional: true });
+function sessionsInOrder(items) {
+  return [...items].sort((a, b) => a.data.date.localeCompare(b.data.date) || a.data.from.localeCompare(b.data.from) || String(a.data.title ?? "").localeCompare(String(b.data.title ?? "")));
+}
+const SCHEDULED = "https://schema.org/EventScheduled";
+const SOLD_OUT = "https://schema.org/SoldOut";
+function attendanceOf(input) {
+  const mode = input.online ? input.location ? "Mixed" : "Online" : "Offline";
+  return `https://schema.org/${mode}EventAttendanceMode`;
+}
+function locationOf(input) {
+  const place = input.location ? { "@type": "Place", name: input.location.name, ...input.location.address ? { address: postalAddress(input.location.address, input.country) } : {} } : void 0;
+  const virtual = input.online ? { "@type": "VirtualLocation", url: input.online } : void 0;
+  return place && virtual ? [place, virtual] : place ?? virtual;
+}
+function subEvent(s, input) {
+  return {
+    "@type": "Event",
+    name: s.title,
+    startDate: zonedDateTime(s.date, s.from, input.timeZone),
+    endDate: zonedDateTime(s.date, s.to, input.timeZone),
+    eventStatus: s.status === "cancelled" ? "https://schema.org/EventCancelled" : SCHEDULED,
+    ...s.room ? { location: { "@type": "Place", name: s.room } } : {},
+    ...s.speakers?.length ? { performer: s.speakers.map((name) => ({ "@type": "Person", name })) } : {},
+    ...s.status === "soldOut" ? { offers: { "@type": "Offer", availability: SOLD_OUT } } : {}
+  };
+}
+function eventJsonLd(input) {
+  const description = input.description ? plainText(input.description) : "";
+  const offers = input.soldOut ? { "@type": "Offer", ...input.price ? offerPrice(input.price, input.currency) : {}, availability: SOLD_OUT } : input.price ? { "@type": "Offer", ...offerPrice(input.price, input.currency), ...input.booking ? { url: input.booking } : {} } : void 0;
+  const location = locationOf(input);
+  return {
+    "@context": "https://schema.org",
+    "@type": "Event",
+    name: input.title,
+    startDate: input.start ? zonedDateTime(input.when.from, input.start, input.timeZone) : input.when.from,
+    endDate: input.end ? zonedDateTime(input.when.to, input.end, input.timeZone) : input.when.to,
+    eventStatus: SCHEDULED,
+    eventAttendanceMode: attendanceOf(input),
+    ...location ? { location } : {},
+    url: input.url,
+    ...input.image ? { image: input.image } : {},
+    ...description ? { description } : {},
+    ...offers ? { offers } : {},
+    ...input.sessions?.length ? { subEvent: input.sessions.map((s) => subEvent(s, input)) } : {}
+  };
+}
+
+export { spansText as A, timesOf as B, todayState as C, upcomingClosures as D, upcomingHolidayClosures as E, upcomingPlans as F, weekOf as G, eventsBrick as H, hourPlansBrick as I, hoursBrick as J, noticesBrick as K, offerPrice as L, postalAddress as M, weekdays as N, addDays as a, weekdayOf as b, spansOf as c, weekdayKeys as d, both as e, austrianHolidays as f, calendarIn as g, hoursOn as h, calendarOf as i, closedOnClosure as j, eventJsonLd as k, events as l, germanHolidays as m, holidayOn as n, hourPlans as o, hours as p, hoursLine as q, notices as r, sourceOf as s, noticesOn as t, offerJsonLd as u, planOn as v, weekFor as w, sessions as x, sessionsInOrder as y, singaporeHolidays as z };