@nomideusz/svelte-calendar 1.7.1 → 1.8.2

package/README.md

@@ -585,6 +585,7 @@ The calendar reads its events through an adapter. Which one:
 | `createMemoryAdapter(events)` | The events are already in the page (a fixed list, your own state). Writes stay in memory. See [Quick Start](#quick-start). |
 | [`createRecurringAdapter(rules)`](#recurring-schedules) | The schedule repeats by rule: class timetables, office hours. Read-only. |
 | [`createRestAdapter(options)`](#rest-adapter) | The events live behind your own HTTP API, which also stores creates and moves. |
+| [`createIcsAdapter(source)`](#icalendar-ics) | The events come from Google Calendar, Apple Calendar, Outlook or any other calendar app: an imported `.ics` file or a subscription URL. Read-only. |
 | [`createJmapAdapter(client, options)`](#jmap-adapter) | The events are in a JMAP Calendars server (Fastmail, Stalwart, Cyrus). Read-only. |
 | [`createMappedAdapter(records, options)`](#mapped-adapter) | You have records from another system with their own field names: map the fields instead of writing an adapter. |
 | [`createCompositeAdapter(adapters)`](#composite-adapter) | One calendar shows several sources, e.g. a recurring timetable plus one-off events. |
@@ -640,6 +641,67 @@ const adapter = createJmapAdapter(client, {
 
 Read-only. Expands recurrences server-side and handles all-day events, ISO-duration ends and per-calendar colors (pass `calendars: [{ id, name, color }]`, or a function returning them).
 
+### iCalendar (.ics)
+
+Every calendar app speaks iCalendar: Google Calendar, Apple Calendar / iCloud, Outlook / Microsoft 365, Thunderbird, Proton, Fastmail, Nextcloud. One adapter reads all of them, from a file or a feed:
+
+```svelte
+<script>
+  import { Calendar, createIcsAdapter } from '@nomideusz/svelte-calendar';
+
+  let adapter = $state(createIcsAdapter(''));
+  async function importFile(e) {
+    const file = e.currentTarget.files?.[0];
+    if (file) adapter = createIcsAdapter(await file.text());
+  }
+</script>
+
+<input type="file" accept=".ics,.ical,.ifb,text/calendar" onchange={importFile} />
+<Calendar {adapter} />
+```
+
+A subscription URL loads on the first fetch (`webcal://` reads as `https://`); `refreshInterval` refetches once the copy is older than that many ms:
+
+```ts
+// Google: Settings → your calendar → "Secret address in iCal format"
+// Outlook: Settings → Calendar → Shared calendars → Publish → ICS link
+// iCloud: share the calendar as "Public Calendar" → webcal:// link
+const adapter = createIcsAdapter({ url: '/api/calendar-feed', refreshInterval: 15 * 60_000 });
+```
+
+Google, Outlook and iCloud send no CORS headers, so a browser can't fetch their feeds directly: serve them through a route of your own (the feed URL is a secret, so keep it on the server anyway):
+
+```ts
+// src/routes/api/calendar-feed/+server.ts
+export const GET = async ({ fetch }) => new Response(await (await fetch(FEED_URL)).text(), {
+  headers: { 'content-type': 'text/calendar; charset=utf-8' },
+});
+```
+
+- Recurrence is expanded per viewed range: `RRULE` (daily, weekly, monthly, yearly; `INTERVAL`, `COUNT`, `UNTIL`, `BYDAY` with ordinals like `-1FR`, `BYMONTHDAY`, `BYMONTH`, `BYSETPOS`, `WKST`), `RDATE`, `EXDATE`, and moved or edited occurrences (`RECURRENCE-ID`).
+- Times keep their zone: UTC, IANA `TZID`s, and the `VTIMEZONE` blocks Outlook writes under Windows zone names. Floating times read in the calendar's `X-WR-TIMEZONE`, else the browser's. All-day dates are local midnights, end exclusive.
+- `SUMMARY` → `title`, `LOCATION` → `location`, `STATUS` → `status`, the first of `CATEGORIES` → `category`, `COLOR` → `color`, `UID` → `externalId`, `DESCRIPTION` / `URL` → `data.description` / `data.url`. Events without a colour take `options.color`, else the calendar's own (`X-APPLE-CALENDAR-COLOR`).
+- Read-only: each occurrence carries `data.readOnly`, and a write throws `CalendarReadOnlyError`, so in a composite a drag reaches `oneventmove`.
+- The source may also be a function returning the text: `createIcsAdapter(() => loadIt())`.
+
+To use the events outside an adapter (copy an import into your own store), parse once and expand any range:
+
+```ts
+import { parseIcs } from '@nomideusz/svelte-calendar';
+
+const cal = parseIcs(text);           // { name, color, events(range) }
+const imported = cal.events({ start, end });
+```
+
+**Export.** `toIcs(events, { name })` writes an `.ics` file that Google, Apple and Outlook import, or subscribe to when you serve it from a URL. For a single event, `googleCalendarUrl(event)` and `outlookCalendarUrl(event, { work })` (personal outlook.live.com, or Microsoft 365) open the app's "add event" page:
+
+```ts
+import { toIcs, googleCalendarUrl, outlookCalendarUrl } from '@nomideusz/svelte-calendar';
+
+const file = new Blob([toIcs(events, { name: 'Studio' })], { type: 'text/calendar' });
+const href = URL.createObjectURL(file);   // <a {href} download="studio.ics">
+```
+
 ### Mapped Adapter
 
 Wrap any static array of external records (class schedules, appointments, timetables) without writing a custom adapter. Supply a declarative field mapping (or a `mapEvent` function for full control) and the adapter handles parsing, colors, tags and status:

package/dist/adapters/ics.d.ts

@@ -0,0 +1,60 @@
+import type { TimelineEvent } from '../core/types.js';
+import type { CalendarAdapter, DateRange } from './types.js';
+export interface IcsCalendar {
+    /** The calendar's name (X-WR-CALNAME / NAME), when the file has one */
+    name?: string;
+    /** The calendar's colour (X-APPLE-CALENDAR-COLOR / COLOR), when the file has one */
+    color?: string;
+    /** Every event overlapping `range`, recurrences expanded */
+    events(range: DateRange): TimelineEvent[];
+}
+/**
+ * Parse an iCalendar text (.ics, .ical, .ifb; a .vcs reads as far as its
+ * events go). Recurring events are expanded per range by `events(range)`.
+ * A malformed line or event is skipped, never thrown.
+ */
+export declare function parseIcs(input: string): IcsCalendar;
+export type IcsSource = string | {
+    /** An https:// or webcal:// feed URL (Google's "secret address in iCal format", Outlook's published ICS, an iCloud public calendar) */
+    url: string;
+    /** Your own fetch — e.g. one that adds headers or goes through your server */
+    fetch?: typeof fetch;
+    /** Refetch on the next load once the copy is older than this many ms (default: never) */
+    refreshInterval?: number;
+} | (() => Promise<string>);
+export interface IcsAdapterOptions {
+    /** Colour for events that name none (default: the calendar's own colour, else ink) */
+    color?: string;
+}
+/**
+ * A read-only CalendarAdapter over iCalendar data: a file's text, a feed URL,
+ * or a function that loads the text. Each occurrence carries `data.readOnly`,
+ * and a write throws CalendarReadOnlyError, so a composite hands a drag to
+ * `oneventmove`.
+ *
+ * Feeds from Google, Outlook and iCloud send no CORS headers: in a browser,
+ * fetch them through your own server route.
+ */
+export declare function createIcsAdapter(source: IcsSource, options?: IcsAdapterOptions): CalendarAdapter;
+export interface ToIcsOptions {
+    /** Calendar name (X-WR-CALNAME), shown by Google, Apple and Outlook */
+    name?: string;
+    /** PRODID (default: -//nomideusz//svelte-calendar//EN) */
+    prodId?: string;
+}
+/**
+ * Write events as an iCalendar file that Google Calendar, Apple Calendar and
+ * Outlook import (or subscribe to, served from a URL). Times go out in UTC;
+ * all-day events as dates. UID is `externalId ?? id`. A string
+ * `data.description` / `data.url` becomes DESCRIPTION / URL.
+ */
+export declare function toIcs(events: TimelineEvent[], options?: ToIcsOptions): string;
+/** An "add to Google Calendar" link for one event. */
+export declare function googleCalendarUrl(ev: TimelineEvent): string;
+/**
+ * An "add to Outlook" link for one event: outlook.live.com (personal), or
+ * `work: true` for outlook.office.com (Microsoft 365).
+ */
+export declare function outlookCalendarUrl(ev: TimelineEvent, options?: {
+    work?: boolean;
+}): string;

package/dist/adapters/ics.js

@@ -0,0 +1,682 @@
+/**
+ * iCalendar (.ics, RFC 5545) — read and write the format every calendar app
+ * speaks: Google Calendar, Apple Calendar / iCloud, Outlook / Microsoft 365,
+ * Thunderbird, Proton, Fastmail, Nextcloud. A file import, a subscription URL
+ * ("secret address in iCal format", "publish calendar", webcal://) and an
+ * export are all this one format.
+ *
+ * Usage:
+ *   import { createIcsAdapter, parseIcs, toIcs } from '@nomideusz/svelte-calendar';
+ *
+ *   const adapter = createIcsAdapter(await file.text());          // a dropped .ics file
+ *   const feed = createIcsAdapter({ url: '/api/google-feed' });     // a subscription
+ *   const download = toIcs(events, { name: 'Studio' });             // back out
+ *
+ * Recurrence: RRULE (DAILY, WEEKLY, MONTHLY, YEARLY with INTERVAL, COUNT,
+ * UNTIL, BYDAY incl. ordinals, BYMONTHDAY, BYMONTH, BYSETPOS, WKST), RDATE,
+ * EXDATE and RECURRENCE-ID overrides. Times: UTC, floating, IANA TZIDs and
+ * the VTIMEZONE blocks Outlook writes under Windows zone names.
+ */
+import { getTimezoneOffset } from 'date-fns-tz';
+import { CalendarReadOnlyError, EventNotFoundError } from './errors.js';
+/** One content line: NAME;PARAM=a;PARAM="b:c":value */
+function parseLine(line) {
+    let i = 0;
+    while (i < line.length && line[i] !== ';' && line[i] !== ':')
+        i++;
+    const name = line.slice(0, i).toUpperCase();
+    const params = {};
+    while (line[i] === ';') {
+        const eq = line.indexOf('=', i);
+        if (eq < 0)
+            return null;
+        const key = line.slice(i + 1, eq).toUpperCase();
+        let val = '';
+        let quoted = false;
+        for (i = eq + 1; i < line.length; i++) {
+            const ch = line[i];
+            if (ch === '"')
+                quoted = !quoted;
+            else if (!quoted && (ch === ';' || ch === ':'))
+                break;
+            else
+                val += ch;
+        }
+        params[key] = val;
+    }
+    if (line[i] !== ':')
+        return null;
+    return { name, params, value: line.slice(i + 1) };
+}
+function parseComponents(text) {
+    const root = { name: 'ROOT', props: [], children: [] };
+    const stack = [root];
+    // Unfold: a line starting with a space or tab continues the previous one.
+    const lines = text.replace(/\r\n?/g, '\n').replace(/\n[ \t]/g, '').split('\n');
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        const prop = parseLine(line);
+        if (!prop)
+            continue;
+        const top = stack[stack.length - 1];
+        if (prop.name === 'BEGIN') {
+            const child = { name: prop.value.trim().toUpperCase(), props: [], children: [] };
+            top.children.push(child);
+            stack.push(child);
+        }
+        else if (prop.name === 'END') {
+            if (stack.length > 1)
+                stack.pop();
+        }
+        else {
+            top.props.push(prop);
+        }
+    }
+    return root;
+}
+const prop = (c, name) => c.props.find((p) => p.name === name);
+const props = (c, name) => c.props.filter((p) => p.name === name);
+function unescapeText(v) {
+    return v.replace(/\\([\\;,nN])/g, (_, ch) => (ch === 'n' || ch === 'N' ? '\n' : ch));
+}
+const text = (c, name) => {
+    const p = prop(c, name);
+    return p ? unescapeText(p.value) : undefined;
+};
+// ── Time ────────────────────────────────────────────────
+// A "wall" is a wall-clock time stored as UTC milliseconds: its UTC getters
+// read the local fields. Day math on walls is plain DAY steps, DST-free; a
+// wall only becomes an instant through its zone.
+const DAY = 86_400_000;
+const UTC_ZONE = (wall) => wall;
+/** A floating time: the browser's own wall clock. */
+const LOCAL_ZONE = (wall) => {
+    const d = new Date(wall);
+    return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds()).getTime();
+};
+function ianaZone(tz) {
+    if (Number.isNaN(getTimezoneOffset(tz, new Date(0))))
+        return undefined;
+    return (wall) => {
+        // Two passes: the offset at the guessed instant settles DST edges.
+        const guess = wall - getTimezoneOffset(tz, new Date(wall));
+        return wall - getTimezoneOffset(tz, new Date(guess));
+    };
+}
+/** "20261026" or "20261026T090000" (Z dropped) → wall */
+function parseWall(v) {
+    const m = /^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})?)?/.exec(v.trim());
+    if (!m)
+        return undefined;
+    return Date.UTC(+m[1], +m[2] - 1, +m[3], +(m[4] ?? 0), +(m[5] ?? 0), +(m[6] ?? 0));
+}
+/** "-PT15M", "P1DT2H", "P1W" → ms */
+function parseDuration(v) {
+    const m = /^([+-])?P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(v.trim());
+    if (!m)
+        return undefined;
+    const ms = (+(m[2] ?? 0) * 7 + +(m[3] ?? 0)) * DAY + (+(m[4] ?? 0) * 3600 + +(m[5] ?? 0) * 60 + +(m[6] ?? 0)) * 1000;
+    return m[1] === '-' ? -ms : ms;
+}
+// ── Recurrence ──────────────────────────────────────────
+const WEEKDAYS = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+function parseRule(v, zoneOf) {
+    const parts = {};
+    for (const kv of v.split(';')) {
+        const [k, val] = kv.split('=');
+        if (k && val)
+            parts[k.toUpperCase()] = val.toUpperCase();
+    }
+    const freq = parts.FREQ;
+    // ponytail: HOURLY/MINUTELY/SECONDLY and BYHOUR/BYMINUTE/BYYEARDAY/BYWEEKNO are
+    // not expanded (calendar apps don't write them); such an event shows its DTSTART only.
+    if (freq !== 'DAILY' && freq !== 'WEEKLY' && freq !== 'MONTHLY' && freq !== 'YEARLY')
+        return undefined;
+    const nums = (s) => s?.split(',').map(Number).filter((n) => Number.isInteger(n) && n !== 0);
+    let until;
+    if (parts.UNTIL) {
+        const wall = parseWall(parts.UNTIL);
+        if (wall != null)
+            until = { wall, date: !parts.UNTIL.includes('T'), zone: parts.UNTIL.endsWith('Z') ? UTC_ZONE : zoneOf() };
+    }
+    return {
+        freq,
+        interval: Math.max(1, Number(parts.INTERVAL) || 1),
+        count: parts.COUNT ? Number(parts.COUNT) : undefined,
+        until,
+        byDay: parts.BYDAY?.split(',').flatMap((s) => {
+            const m = /^([+-]?\d+)?([A-Z]{2})$/.exec(s);
+            const wd = m ? WEEKDAYS.indexOf(m[2]) : -1;
+            return m && wd >= 0 ? [{ n: Number(m[1] ?? 0), wd }] : [];
+        }),
+        byMonthDay: nums(parts.BYMONTHDAY),
+        byMonth: nums(parts.BYMONTH)?.map((m) => m - 1),
+        bySetPos: nums(parts.BYSETPOS),
+        wkst: Math.max(0, WEEKDAYS.indexOf(parts.WKST ?? 'MO')),
+    };
+}
+const daysInMonth = (y, m) => new Date(Date.UTC(y, m + 1, 0)).getUTCDate();
+const weekday = (wall) => new Date(wall).getUTCDay();
+/** Day offsets in a span of `len` days from `start` matching BYDAY (ordinals count within the span). */
+function pickWeekdays(start, len, byDay) {
+    const out = [];
+    for (const { n, wd } of byDay) {
+        const all = [];
+        for (let d = (wd - weekday(start) + 7) % 7; d < len; d += 7)
+            all.push(d);
+        if (!n)
+            out.push(...all);
+        else {
+            const pick = n > 0 ? all[n - 1] : all[all.length + n];
+            if (pick != null)
+                out.push(pick);
+        }
+    }
+    return out;
+}
+/** Days (walls at midnight) of month y/m the rule selects; `dtDay` when it names none. */
+function monthDays(y, m, r, dtDay) {
+    const len = daysInMonth(y, m);
+    const start = Date.UTC(y, m, 1);
+    let days;
+    if (r.byMonthDay?.length) {
+        days = r.byMonthDay.map((d) => (d < 0 ? len + d + 1 : d)).filter((d) => d >= 1 && d <= len).map((d) => d - 1);
+    }
+    if (r.byDay?.length) {
+        const picked = pickWeekdays(start, len, r.byDay);
+        days = days ? days.filter((d) => picked.includes(d)) : picked;
+    }
+    // RFC 5545: a date that doesn't exist (31 Feb) is skipped, not clamped.
+    days ??= dtDay <= len ? [dtDay - 1] : [];
+    return days.map((d) => start + d * DAY);
+}
+/**
+ * Occurrence walls of a rule, in order, from DTSTART (always the first) until
+ * the rule ends or a period starts after `to`. `from` lets a rule without
+ * COUNT skip the periods that end before it.
+ */
+function* expandRule(dt, r, from, to) {
+    const tod = ((dt % DAY) + DAY) % DAY;
+    const dtDate = new Date(dt - tod);
+    const dtY = dtDate.getUTCFullYear();
+    const dtM = dtDate.getUTCMonth();
+    const dtD = dtDate.getUTCDate();
+    let emitted = 0;
+    const limit = r.count ?? Infinity;
+    yield dt;
+    if (++emitted >= limit)
+        return;
+    const inMonth = (w) => !r.byMonth?.length || r.byMonth.includes(new Date(w).getUTCMonth());
+    for (let p = 0;; p += r.interval) {
+        let periodStart;
+        let days;
+        switch (r.freq) {
+            case 'DAILY': {
+                periodStart = dt - tod + p * DAY;
+                if (r.count == null && periodStart < from - DAY) {
+                    p += Math.floor((from - DAY - periodStart) / DAY / r.interval) * r.interval;
+                    periodStart = dt - tod + p * DAY;
+                }
+                const d = new Date(periodStart);
+                const ok = inMonth(periodStart) &&
+                    (!r.byDay?.length || r.byDay.some((b) => b.wd === d.getUTCDay())) &&
+                    (!r.byMonthDay?.length ||
+                        r.byMonthDay.some((md) => (md < 0 ? daysInMonth(d.getUTCFullYear(), d.getUTCMonth()) + md + 1 : md) === d.getUTCDate()));
+                days = ok ? [periodStart] : [];
+                break;
+            }
+            case 'WEEKLY': {
+                const week0 = dt - tod - ((weekday(dt) - r.wkst + 7) % 7) * DAY;
+                periodStart = week0 + p * 7 * DAY;
+                if (r.count == null && periodStart < from - 7 * DAY) {
+                    p += Math.floor((from - 7 * DAY - periodStart) / (7 * DAY) / r.interval) * r.interval;
+                    periodStart = week0 + p * 7 * DAY;
+                }
+                const wds = r.byDay?.length ? r.byDay.map((b) => b.wd) : [weekday(dt)];
+                days = wds.map((wd) => periodStart + ((wd - r.wkst + 7) % 7) * DAY).filter(inMonth);
+                break;
+            }
+            case 'MONTHLY': {
+                const y = dtY + Math.floor((dtM + p) / 12);
+                const m = (dtM + p) % 12;
+                periodStart = Date.UTC(y, m, 1);
+                days = r.byMonth?.length && !r.byMonth.includes(m) ? [] : monthDays(y, m, r, dtD);
+                break;
+            }
+            case 'YEARLY': {
+                const y = dtY + p;
+                periodStart = Date.UTC(y, 0, 1);
+                if (r.byDay?.length && !r.byMonth?.length && !r.byMonthDay?.length) {
+                    // BYDAY alone ranges over the whole year (20MO = 20th Monday).
+                    const len = (Date.UTC(y + 1, 0, 1) - periodStart) / DAY;
+                    days = pickWeekdays(periodStart, len, r.byDay).map((d) => periodStart + d * DAY);
+                }
+                else {
+                    const months = r.byMonth?.length ? r.byMonth : r.byMonthDay?.length ? [...Array(12).keys()] : [dtM];
+                    days = months.flatMap((m) => monthDays(y, m, r, dtD));
+                }
+                break;
+            }
+        }
+        if (periodStart > to)
+            return;
+        if (r.until && periodStart > r.until.wall + DAY)
+            return;
+        let walls = [...new Set(days)].sort((a, b) => a - b).map((d) => d + tod);
+        if (r.bySetPos?.length) {
+            const all = walls;
+            walls = r.bySetPos.map((i) => all[i > 0 ? i - 1 : all.length + i]).filter((w) => w != null).sort((a, b) => a - b);
+        }
+        for (const w of walls) {
+            if (w <= dt)
+                continue;
+            yield w;
+            if (++emitted >= limit)
+                return;
+        }
+    }
+}
+// ── VTIMEZONE ───────────────────────────────────────────
+const parseOffset = (v) => {
+    const m = /^([+-])(\d{2})(\d{2})(\d{2})?$/.exec(v.trim());
+    return m ? (m[1] === '-' ? -1 : 1) * ((+m[2] * 60 + +m[3]) * 60 + +(m[4] ?? 0)) * 1000 : 0;
+};
+/** A zone built from a VTIMEZONE's STANDARD/DAYLIGHT onsets (Outlook's Windows-named zones). */
+function vtimezoneZone(tz) {
+    const parts = tz.children.flatMap((c) => {
+        const start = parseWall(prop(c, 'DTSTART')?.value ?? '');
+        const to = prop(c, 'TZOFFSETTO');
+        if (start == null || !to)
+            return [];
+        const rrule = prop(c, 'RRULE');
+        return [{
+                start,
+                to: parseOffset(to.value),
+                from: parseOffset(prop(c, 'TZOFFSETFROM')?.value ?? to.value),
+                rule: rrule ? parseRule(rrule.value, () => UTC_ZONE) : undefined,
+                rdates: props(c, 'RDATE').flatMap((p) => p.value.split(',')).map(parseWall).filter((w) => w != null),
+            }];
+    });
+    if (!parts.length)
+        return undefined;
+    const byYear = new Map();
+    const onsets = (year) => {
+        let list = byYear.get(year);
+        if (!list) {
+            const from = Date.UTC(year - 1, 0, 1);
+            const to = Date.UTC(year + 1, 0, 1);
+            list = [];
+            for (const part of parts) {
+                const walls = part.rule ? expandRule(part.start, part.rule, from, to) : [part.start];
+                for (const at of walls)
+                    if (at >= from && at < to)
+                        list.push({ at, to: part.to });
+                for (const at of part.rdates)
+                    if (at >= from && at < to)
+                        list.push({ at, to: part.to });
+            }
+            list.sort((a, b) => a.at - b.at);
+            byYear.set(year, list);
+        }
+        return list;
+    };
+    const first = parts.reduce((a, b) => (b.start < a.start ? b : a));
+    return (wall) => {
+        const list = onsets(new Date(wall).getUTCFullYear());
+        let offset = first.from;
+        for (const o of list)
+            if (o.at <= wall)
+                offset = o.to;
+        return wall - offset;
+    };
+}
+const instant = (t) => t.zone(t.wall);
+/** An all-day date is midnight in the browser's zone; a time is its instant. */
+const toDate = (t) => new Date(t.date ? LOCAL_ZONE(t.wall) : instant(t));
+/** UNTIL is inclusive; a date UNTIL keeps that whole day. */
+function pastUntil(t, until) {
+    if (!until)
+        return false;
+    if (until.date)
+        return t.wall >= until.wall + DAY;
+    return t.date ? t.wall > until.wall : instant(t) > instant(until);
+}
+const STATUS = { CANCELLED: 'cancelled', TENTATIVE: 'tentative', CONFIRMED: 'confirmed' };
+/**
+ * Parse an iCalendar text (.ics, .ical, .ifb; a .vcs reads as far as its
+ * events go). Recurring events are expanded per range by `events(range)`.
+ * A malformed line or event is skipped, never thrown.
+ */
+export function parseIcs(input) {
+    const root = parseComponents(input);
+    const cal = root.children.find((c) => c.name === 'VCALENDAR') ?? root;
+    const zones = new Map();
+    for (const tz of cal.children.filter((c) => c.name === 'VTIMEZONE')) {
+        const id = prop(tz, 'TZID')?.value;
+        const zone = id ? vtimezoneZone(tz) : undefined;
+        if (id && zone)
+            zones.set(id, zone);
+    }
+    // Floating times read in the calendar's own zone when it names one (Google does).
+    const calTz = prop(cal, 'X-WR-TIMEZONE')?.value;
+    const floating = (calTz && ianaZone(calTz)) || LOCAL_ZONE;
+    const zoneOf = (tzid) => {
+        if (!tzid)
+            return floating;
+        const id = tzid.replace(/^\//, '');
+        return ianaZone(id) ?? zones.get(tzid) ?? floating;
+    };
+    const timeOf = (p) => {
+        if (!p)
+            return undefined;
+        const wall = parseWall(p.value);
+        if (wall == null)
+            return undefined;
+        return {
+            wall,
+            date: p.params.VALUE === 'DATE' || !p.value.includes('T'),
+            zone: p.value.trim().endsWith('Z') ? UTC_ZONE : zoneOf(p.params.TZID),
+        };
+    };
+    const timesOf = (ps) => ps.flatMap((p) => p.value.split(',').map((value) => timeOf({ ...p, value }))).filter((t) => !!t);
+    const defs = [];
+    for (const ve of cal.children.filter((c) => c.name === 'VEVENT')) {
+        const start = timeOf(prop(ve, 'DTSTART'));
+        if (!start)
+            continue;
+        const end = timeOf(prop(ve, 'DTEND'));
+        const dur = prop(ve, 'DURATION');
+        let duration = end
+            ? start.date ? end.wall - start.wall : instant(end) - instant(start)
+            : dur ? (parseDuration(dur.value) ?? 0) : start.date ? DAY : 0;
+        if (duration < 0)
+            duration = 0;
+        const rrule = prop(ve, 'RRULE');
+        const recurrenceId = timeOf(prop(ve, 'RECURRENCE-ID'));
+        const status = prop(ve, 'STATUS')?.value.trim().toUpperCase();
+        const data = { readOnly: true };
+        const description = text(ve, 'DESCRIPTION');
+        if (description)
+            data.description = description;
+        const url = prop(ve, 'URL')?.value.trim();
+        if (url)
+            data.url = url;
+        defs.push({
+            uid: prop(ve, 'UID')?.value.trim() || `ics-${defs.length}`,
+            start,
+            duration,
+            rule: rrule ? parseRule(rrule.value, zoneOf) : undefined,
+            rdates: timesOf(props(ve, 'RDATE')),
+            exdates: new Set(timesOf(props(ve, 'EXDATE')).map(instant)),
+            recurrence: recurrenceId,
+            title: text(ve, 'SUMMARY')?.trim() || '(No title)',
+            location: text(ve, 'LOCATION')?.trim() || undefined,
+            status: status ? STATUS[status] : undefined,
+            category: text(ve, 'CATEGORIES')?.split(',')[0]?.trim() || undefined,
+            color: prop(ve, 'COLOR')?.value.trim() || undefined,
+            data,
+        });
+    }
+    // RECURRENCE-ID rows replace one occurrence of their master.
+    const overrides = new Map();
+    for (const d of defs) {
+        if (!d.recurrence)
+            continue;
+        let m = overrides.get(d.uid);
+        if (!m)
+            overrides.set(d.uid, (m = new Map()));
+        m.set(instant(d.recurrence), d);
+    }
+    const masters = defs.filter((d) => !d.recurrence);
+    const mastered = new Set(masters.map((d) => d.uid));
+    // An override whose master isn't in the file still stands alone.
+    const orphans = defs.filter((d) => d.recurrence && !mastered.has(d.uid));
+    const calColor = prop(cal, 'X-APPLE-CALENDAR-COLOR')?.value.trim() || prop(cal, 'COLOR')?.value.trim() || undefined;
+    const toEvent = (d, start, id) => {
+        const s = toDate(start);
+        const e = start.date
+            ? toDate({ ...start, wall: start.wall + d.duration })
+            : new Date(s.getTime() + d.duration);
+        const ev = { id, title: d.title, start: s, end: e, externalId: d.uid, data: { ...d.data } };
+        if (start.date)
+            ev.allDay = true;
+        if (d.location)
+            ev.location = d.location;
+        if (d.status)
+            ev.status = d.status;
+        if (d.category)
+            ev.category = d.category;
+        if (d.color)
+            ev.color = d.color;
+        return ev;
+    };
+    const key = (t) => new Date(t.wall).toISOString().replace(/[-:]|\.\d+Z$/g, '').replace(t.date ? /T.*$/ : /$/, '');
+    return {
+        name: text(cal, 'X-WR-CALNAME') ?? text(cal, 'NAME'),
+        color: calColor,
+        events(range) {
+            const out = [];
+            const lo = range.start.getTime();
+            const hi = range.end.getTime();
+            const push = (ev) => {
+                const s = ev.start.getTime();
+                const e = Math.max(ev.end.getTime(), s + 1); // a zero-length event still sits at its time
+                if (s < hi && e > lo)
+                    out.push(ev);
+            };
+            for (const d of masters) {
+                if (!d.rule && !d.rdates.length) {
+                    push(toEvent(d, d.start, d.uid));
+                    continue;
+                }
+                const own = overrides.get(d.uid);
+                const seen = new Set();
+                const occurrence = (t) => {
+                    const at = instant(t);
+                    if (seen.has(at) || d.exdates.has(at))
+                        return;
+                    seen.add(at);
+                    const id = `${d.uid}--${key(t)}`;
+                    const over = own?.get(at);
+                    push(over ? toEvent(over, over.start, id) : toEvent(d, t, id));
+                };
+                // Walls run ±14 h from instants, and an occurrence can start a
+                // duration before the range: widen by both, trim in push().
+                const from = lo - d.duration - 2 * DAY + (d.start.wall - instant(d.start));
+                const to = hi + 2 * DAY + (d.start.wall - instant(d.start));
+                if (d.rule) {
+                    for (const wall of expandRule(d.start.wall, d.rule, from, to)) {
+                        const t = { ...d.start, wall };
+                        if (wall > to || pastUntil(t, d.rule.until))
+                            break;
+                        if (wall >= from)
+                            occurrence(t);
+                    }
+                }
+                else {
+                    occurrence(d.start);
+                }
+                for (const t of d.rdates)
+                    occurrence(t);
+                // An override moved into the range from an occurrence outside it.
+                for (const over of own?.values() ?? []) {
+                    const at = instant(over.recurrence);
+                    if (seen.has(at) || d.exdates.has(at))
+                        continue;
+                    push(toEvent(over, over.start, `${d.uid}--${key(over.recurrence)}`));
+                }
+            }
+            for (const d of orphans)
+                push(toEvent(d, d.start, `${d.uid}--${key(d.recurrence)}`));
+            return out;
+        },
+    };
+}
+/**
+ * A read-only CalendarAdapter over iCalendar data: a file's text, a feed URL,
+ * or a function that loads the text. Each occurrence carries `data.readOnly`,
+ * and a write throws CalendarReadOnlyError, so a composite hands a drag to
+ * `oneventmove`.
+ *
+ * Feeds from Google, Outlook and iCloud send no CORS headers: in a browser,
+ * fetch them through your own server route.
+ */
+export function createIcsAdapter(source, options = {}) {
+    let parsed = typeof source === 'string' ? parseIcs(source) : undefined;
+    let loading;
+    let loadedAt = 0;
+    // Ids this adapter has handed out: a write to one is refused as read-only,
+    // any other id is "not mine" (a composite asks its next child).
+    const known = new Set();
+    const load = () => {
+        if (typeof source === 'string')
+            return Promise.resolve(parsed);
+        const stale = typeof source === 'object' && source.refreshInterval != null && Date.now() - loadedAt > source.refreshInterval;
+        if (!loading || (stale && parsed)) {
+            loadedAt = Date.now();
+            const request = typeof source === 'function'
+                ? source()
+                : (source.fetch ?? fetch)(source.url.replace(/^webcal:/i, 'https:')).then((r) => {
+                    if (!r.ok)
+                        throw new Error(`ICS feed ${source.url}: HTTP ${r.status}`);
+                    return r.text();
+                });
+            loading = request.then((t) => (parsed = parseIcs(t)), (e) => {
+                loading = undefined; // the next load tries again
+                throw e;
+            });
+        }
+        return parsed && !stale ? Promise.resolve(parsed) : loading;
+    };
+    const paint = (events, cal) => {
+        const color = options.color ?? cal.color;
+        for (const e of events)
+            known.add(e.id);
+        return color ? events.map((e) => (e.color ? e : { ...e, color })) : events;
+    };
+    return {
+        fetchEventsSync(range) {
+            return parsed && typeof source === 'string' ? paint(parsed.events(range), parsed) : undefined;
+        },
+        async fetchEvents(range) {
+            const cal = await load();
+            return paint(cal.events(range), cal);
+        },
+        async updateEvent(id) {
+            if (!known.has(id))
+                throw new EventNotFoundError(id);
+            throw new CalendarReadOnlyError(`read-only: ${id} comes from an iCalendar source`);
+        },
+    };
+}
+// ── Export ──────────────────────────────────────────────
+function escapeText(v) {
+    return v.replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\r?\n/g, '\\n');
+}
+/** Fold a content line at 75 octets (RFC 5545 §3.1), never inside a character. */
+function fold(line) {
+    const out = [];
+    let cur = '';
+    let bytes = 0;
+    for (const ch of line) {
+        const cp = ch.codePointAt(0);
+        const n = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
+        if (bytes + n > (out.length ? 74 : 75)) {
+            out.push(cur);
+            cur = '';
+            bytes = 0;
+        }
+        cur += ch;
+        bytes += n;
+    }
+    out.push(cur);
+    return out.join('\r\n ');
+}
+const pad = (n) => String(n).padStart(2, '0');
+const utcStamp = (d) => d.toISOString().replace(/[-:]|\.\d+/g, '');
+const localDate = (d) => `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`;
+/**
+ * Write events as an iCalendar file that Google Calendar, Apple Calendar and
+ * Outlook import (or subscribe to, served from a URL). Times go out in UTC;
+ * all-day events as dates. UID is `externalId ?? id`. A string
+ * `data.description` / `data.url` becomes DESCRIPTION / URL.
+ */
+export function toIcs(events, options = {}) {
+    const stamp = utcStamp(new Date());
+    const lines = [
+        'BEGIN:VCALENDAR',
+        'VERSION:2.0',
+        `PRODID:${options.prodId ?? '-//nomideusz//svelte-calendar//EN'}`,
+        'CALSCALE:GREGORIAN',
+        'METHOD:PUBLISH',
+    ];
+    if (options.name)
+        lines.push(`X-WR-CALNAME:${escapeText(options.name)}`);
+    for (const ev of events) {
+        lines.push('BEGIN:VEVENT', `UID:${escapeText(ev.externalId ?? ev.id)}`, `DTSTAMP:${stamp}`);
+        if (ev.allDay) {
+            // An all-day end is exclusive: a one-day event ends the next midnight.
+            const end = ev.end > ev.start ? ev.end : new Date(ev.start.getFullYear(), ev.start.getMonth(), ev.start.getDate() + 1);
+            const endDay = end.getHours() || end.getMinutes() ? new Date(end.getFullYear(), end.getMonth(), end.getDate() + 1) : end;
+            lines.push(`DTSTART;VALUE=DATE:${localDate(ev.start)}`, `DTEND;VALUE=DATE:${localDate(endDay)}`);
+        }
+        else {
+            lines.push(`DTSTART:${utcStamp(ev.start)}`, `DTEND:${utcStamp(ev.end)}`);
+        }
+        lines.push(`SUMMARY:${escapeText(ev.title)}`);
+        if (ev.location)
+            lines.push(`LOCATION:${escapeText(ev.location)}`);
+        const description = ev.data?.description ?? ev.subtitle;
+        if (typeof description === 'string' && description)
+            lines.push(`DESCRIPTION:${escapeText(description)}`);
+        if (typeof ev.data?.url === 'string')
+            lines.push(`URL:${ev.data.url}`);
+        if (ev.category)
+            lines.push(`CATEGORIES:${escapeText(ev.category)}`);
+        if (ev.status === 'cancelled' || ev.status === 'tentative')
+            lines.push(`STATUS:${ev.status.toUpperCase()}`);
+        lines.push('END:VEVENT');
+    }
+    lines.push('END:VCALENDAR');
+    return lines.map(fold).join('\r\n') + '\r\n';
+}
+// ── One-event links ─────────────────────────────────────
+const detailsOf = (ev) => {
+    const d = ev.data?.description ?? ev.subtitle;
+    return typeof d === 'string' ? d : '';
+};
+/** An "add to Google Calendar" link for one event. */
+export function googleCalendarUrl(ev) {
+    const dates = ev.allDay
+        ? `${localDate(ev.start)}/${localDate(ev.end > ev.start ? ev.end : new Date(ev.start.getFullYear(), ev.start.getMonth(), ev.start.getDate() + 1))}`
+        : `${utcStamp(ev.start)}/${utcStamp(ev.end)}`;
+    const q = new URLSearchParams({ action: 'TEMPLATE', text: ev.title, dates });
+    if (ev.location)
+        q.set('location', ev.location);
+    const details = detailsOf(ev);
+    if (details)
+        q.set('details', details);
+    return `https://calendar.google.com/calendar/render?${q}`;
+}
+/**
+ * An "add to Outlook" link for one event: outlook.live.com (personal), or
+ * `work: true` for outlook.office.com (Microsoft 365).
+ */
+export function outlookCalendarUrl(ev, options = {}) {
+    const iso = (d) => (ev.allDay ? `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` : d.toISOString());
+    const q = new URLSearchParams({
+        path: '/calendar/action/compose',
+        rru: 'addevent',
+        subject: ev.title,
+        startdt: iso(ev.start),
+        enddt: iso(ev.end),
+        allday: String(!!ev.allDay),
+    });
+    if (ev.location)
+        q.set('location', ev.location);
+    const details = detailsOf(ev);
+    if (details)
+        q.set('body', details);
+    return `https://${options.work ? 'outlook.office.com' : 'outlook.live.com'}/calendar/0/deeplink/compose?${q}`;
+}

package/dist/adapters/index.d.ts

@@ -12,4 +12,6 @@ export { withInitialEvents } from './seeded.js';
 export type { CompositeAdapterOptions } from './composite.js';
 export { createJmapAdapter } from './jmap.js';
 export type { JmapClient, JmapCalendarAdapterOptions } from './jmap.js';
+export { createIcsAdapter, parseIcs, toIcs, googleCalendarUrl, outlookCalendarUrl } from './ics.js';
+export type { IcsCalendar, IcsSource, IcsAdapterOptions, ToIcsOptions } from './ics.js';
 export { CalendarReadOnlyError, EventNotFoundError, isReadOnlyError, isNotFoundError } from './errors.js';

package/dist/adapters/index.js

@@ -5,4 +5,5 @@ export { createMappedAdapter } from './mapped.js';
 export { createCompositeAdapter } from './composite.js';
 export { withInitialEvents } from './seeded.js';
 export { createJmapAdapter } from './jmap.js';
+export { createIcsAdapter, parseIcs, toIcs, googleCalendarUrl, outlookCalendarUrl } from './ics.js';
 export { CalendarReadOnlyError, EventNotFoundError, isReadOnlyError, isNotFoundError } from './errors.js';

package/dist/index.d.ts

@@ -8,8 +8,9 @@ export type { CalendarContext } from './views/shared/context.svelte.js';
 export { createEventStore, createViewState, createSelection, createDragState, } from './engine/index.js';
 export type { EventStore, ViewState, ViewStateOptions, CalendarViewId, BuiltInViewId, ViewMode, Selection as CalendarSelection, DragState, DragMode, DragPayload, } from './engine/index.js';
 export { createMemoryAdapter, createRestAdapter, createRecurringAdapter, createMappedAdapter, createCompositeAdapter, createJmapAdapter, withInitialEvents } from './adapters/index.js';
+export { createIcsAdapter, parseIcs, toIcs, googleCalendarUrl, outlookCalendarUrl } from './adapters/index.js';
 export { CalendarReadOnlyError, EventNotFoundError, isReadOnlyError, isNotFoundError } from './adapters/index.js';
-export type { CalendarAdapter, WritableCalendarAdapter, DateRange, MemoryAdapterOptions, RestAdapterOptions, RecurringEvent, RecurringAdapterOptions, FieldMapping, MappedAdapterOptions, MutationHandler, CompositeAdapterOptions, JmapClient, JmapCalendarAdapterOptions, } from './adapters/index.js';
+export type { CalendarAdapter, WritableCalendarAdapter, DateRange, MemoryAdapterOptions, RestAdapterOptions, RecurringEvent, RecurringAdapterOptions, FieldMapping, MappedAdapterOptions, MutationHandler, CompositeAdapterOptions, JmapClient, JmapCalendarAdapterOptions, IcsCalendar, IcsSource, IcsAdapterOptions, ToIcsOptions, } from './adapters/index.js';
 export { createClock, sod, startOfWeek, addDaysMs, diffDays, fmtH, fmtHParts, fmtTime, fmtDuration, weekdayShort, weekdayLong, monthShort, monthLong, dateShort, dateWithWeekday, fmtDay, fmtWeekRange, setDefaultLocale, getDefaultLocale, is24HourLocale, defaultLabels, setLabels, resetLabels, getLabels, toZonedTime, fromZonedTime, nowInZone, formatInTimeZone, generatePalette, extractAccent, VIVID_PALETTE, isMultiDay, isAllDay, segmentForDay, } from './core/index.js';
 export type { Clock, TimelineEvent, BlockedSlot, DaySegment, CalendarLabels, EventStatus, } from './core/index.js';
 export { auto, neutral, midnight, presets } from './theme/index.js';

package/dist/index.js

@@ -11,6 +11,7 @@ export { useCalendarContext } from './views/shared/context.svelte.js';
 export { createEventStore, createViewState, createSelection, createDragState, } from './engine/index.js';
 // ─── Adapters ───────────────────────────────────────────
 export { createMemoryAdapter, createRestAdapter, createRecurringAdapter, createMappedAdapter, createCompositeAdapter, createJmapAdapter, withInitialEvents } from './adapters/index.js';
+export { createIcsAdapter, parseIcs, toIcs, googleCalendarUrl, outlookCalendarUrl } from './adapters/index.js';
 export { CalendarReadOnlyError, EventNotFoundError, isReadOnlyError, isNotFoundError } from './adapters/index.js';
 // ─── Core: clock, time, locale, types ───────────────────
 export { createClock, sod, startOfWeek, addDaysMs, diffDays, fmtH, fmtHParts, fmtTime, fmtDuration, weekdayShort, weekdayLong, monthShort, monthLong, dateShort, dateWithWeekday, fmtDay, fmtWeekRange, setDefaultLocale, getDefaultLocale, is24HourLocale, defaultLabels, setLabels, resetLabels, getLabels, toZonedTime, fromZonedTime, nowInZone, formatInTimeZone, generatePalette, extractAccent, VIVID_PALETTE, isMultiDay, isAllDay, segmentForDay, } from './core/index.js';

package/dist/text-fit.d.ts

@@ -50,10 +50,14 @@ export declare function fontOf(el: Element): string;
  * that does not come from its own text (block, or a flex item with min-width: 0).
  */
 export declare function fitLabel(candidates: readonly string[], lines?: number): Attachment<HTMLElement>;
+/** The badness of the loosest line but the last, were `lines` justified at `width`. */
+export declare function looseness(lines: readonly string[], font: string, width: number): number;
 export declare function breakLines(text: string, font: string, width: number): string[];
 /**
  * `<p {@attach typeset(text)}>` — sets the paragraph as justified Knuth-Plass
  * lines, one block span per line, re-done on resize and after webfonts load.
+ * A paragraph that cannot be justified without gaps (`TOLERANCE`) goes back to
+ * the browser as plain text, set however the element sets it (ragged).
  * Progressive: the server-rendered text is what crawlers and no-JS get; if the
  * browser's own measure disagrees with ours (a line overflows), the plain
  * text goes back and the browser breaks it. Pass the text, not the DOM — the

package/dist/text-fit.js

@@ -96,6 +96,23 @@ export function fitLabel(candidates, lines = 1) {
 // (10 + badness)² plus 50² for ending inside a word, plus 10000 when the line
 // above did too. ponytail: no fitness classes, no shrink; O(n·k).
 const SHY = '­';
+const badness = (slackPx, spaces, space) => {
+    const r = slackPx / (Math.max(spaces, 1) * space * 0.5);
+    return Math.min(10000, 100 * r * r * r);
+};
+// TeX's default \tolerance. A narrow column (a phone) sometimes has no set of
+// breaks that keeps every space under ~1.6× its width; justified, those lines
+// read as holes, so typeset leaves that paragraph to the browser, ragged.
+const TOLERANCE = 200;
+/** The badness of the loosest line but the last, were `lines` justified at `width`. */
+export function looseness(lines, font, width) {
+    const measure = (s) => measureNaturalWidth(prepareWithSegments(s, font));
+    const space = measure('a a') - measure('aa');
+    let worst = 0;
+    for (const l of lines.slice(0, -1))
+        worst = Math.max(worst, badness(width - measure(l), l.split(' ').length - 1, space));
+    return worst;
+}
 export function breakLines(text, font, width) {
     const measure = (s) => measureNaturalWidth(prepareWithSegments(s, font));
     const boxes = [];
@@ -119,10 +136,6 @@ export function breakLines(text, font, width) {
     const bw = boxes.map(measure);
     const space = measure('a a') - measure('aa');
     const hyphen = measure('-');
-    const badness = (slackPx, spaces) => {
-        const r = slackPx / (Math.max(spaces, 1) * space * 0.5);
-        return Math.min(10000, 100 * r * r * r);
-    };
     // best[h][k]: cheapest way to set boxes[0..k) with a break after, h = 1 when
     // that last line ended inside a word; prev[h][k]: [start of that line, its h].
     const best = [new Array(n + 1).fill(Infinity), new Array(n + 1).fill(Infinity)];
@@ -144,7 +157,7 @@ export function breakLines(text, font, width) {
                         break;
                     continue; // only the hyphen overflows — try the next box
                 }
-                const b = last ? 0 : badness(width - lineW, spaces);
+                const b = last ? 0 : badness(width - lineW, spaces, space);
                 const cost = last ? 0 : (10 + b) ** 2 + (h ? 50 ** 2 : 0) + (h && ph ? 10000 : 0);
                 if (best[ph][i] + cost < best[h][j + 1]) {
                     best[h][j + 1] = best[ph][i] + cost;
@@ -177,6 +190,8 @@ export function breakLines(text, font, width) {
 /**
  * `<p {@attach typeset(text)}>` — sets the paragraph as justified Knuth-Plass
  * lines, one block span per line, re-done on resize and after webfonts load.
+ * A paragraph that cannot be justified without gaps (`TOLERANCE`) goes back to
+ * the browser as plain text, set however the element sets it (ragged).
  * Progressive: the server-rendered text is what crawlers and no-JS get; if the
  * browser's own measure disagrees with ours (a line overflows), the plain
  * text goes back and the browser breaks it. Pass the text, not the DOM — the
@@ -194,19 +209,33 @@ export function typeset(text) {
         // hole in the paragraph. Set as nowrap, a misfit is plain overflow, which
         // is measurable: re-break a touch narrower, and only then hand the text
         // back to the browser.
+        // The lines are for the eye: their break hyphens ("co-" / "dzienne") are
+        // hidden from assistive tech, which reads the text whole from a visually
+        // hidden copy. Each line keeps the space it broke at (a trailing space
+        // is dropped at a nowrap line's end), so find and copy see words.
+        const whole = document.createElement('span');
+        whole.textContent = text;
+        whole.style.cssText =
+            'position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap';
         const set = (w) => {
             const lines = breakLines(text, font, w);
-            el.replaceChildren(...lines.map((l, i) => {
+            if (looseness(lines, font, w) > TOLERANCE) {
+                el.textContent = text;
+                return true;
+            }
+            const spans = lines.map((l, i) => {
                 const s = document.createElement('span');
+                s.setAttribute('aria-hidden', 'true');
                 s.style.display = 'block';
                 s.style.whiteSpace = 'nowrap';
                 s.style.hyphens = 'manual';
                 s.style.textAlign = 'justify';
                 s.style.textAlignLast = i === lines.length - 1 ? 'auto' : 'justify';
-                s.textContent = l;
+                s.textContent = i < lines.length - 1 && !l.endsWith('-') ? l + ' ' : l;
                 return s;
-            }));
-            for (const s of el.children)
+            });
+            el.replaceChildren(whole, ...spans);
+            for (const s of spans)
                 if (s.scrollWidth > s.clientWidth + 1)
                     return false;
             return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomideusz/svelte-calendar",
-  "version": "1.7.1",
+  "version": "1.8.2",
   "description": "A themeable Svelte 5 calendar: day, week, scrolling-week and month views, agenda lists, touch-first mobile layouts, drag-and-drop, timezones, a headless API and an embeddable web component.",
   "type": "module",
   "sideEffects": [

package/widget/widget.js

@@ -21056,5 +21056,15 @@ createHTML: (html) => {
 			return props;
 		}
 	};
-	if (!customElements.get("day-calendar")) customElements.define("day-calendar", DayCalendarElement);
+	if (!customElements.get("day-calendar")) {
+		customElements.define("day-calendar", DayCalendarElement);
+		const registry = customElements;
+		for (const el of document.querySelectorAll("day-calendar")) {
+			if (el instanceof DayCalendarElement) continue;
+			try {
+				registry.initialize?.(el);
+			} catch {}
+			customElements.upgrade(el);
+		}
+	}
 })();