better-supabase 0.14.0 → 0.15.0

package/dist/calendar-T3Vdpq7E.js

@@ -1,952 +0,0 @@
-import { n as dbError } from "./errors-03ysrOt4.js";
-import { t as temporal } from "./temporal-required-B8qQHYbI.js";
-import { t as AsyncResult } from "./result-B3m7xtRY.js";
-import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, b as oneOf, k as recordsOf, o as blockCall } from "./block-helpers-CiKtrb6g.js";
-import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
-import { i as extraOf, n as blockFields, t as allWithFields } from "./block-fields-DBSJSeaO.js";
-import { t as expandRule } from "./rrule-xDm2znty.js";
-//#region src/blocks/calendar/availability.ts
-const CALENDAR_EVENT_KINDS = [
-	"event",
-	"out_of_office",
-	"focus_time"
-];
-const CALENDAR_TRANSPARENCIES = ["opaque", "transparent"];
-const WEEKDAYS = /* @__PURE__ */ new Set([
-	1,
-	2,
-	3,
-	4,
-	5,
-	6,
-	7
-]);
-function rangesOf(value, label) {
-	return recordsOf(value, label).map((row) => ({
-		from: requiredInstant(row["startsAt"], `${label}.startsAt`),
-		until: requiredInstant(row["endsAt"], `${label}.endsAt`)
-	}));
-}
-/** A `calendar_free_busy` result. */
-function freeBusyOf(value) {
-	return recordsOf(value, "calendar_free_busy").map((row) => {
-		const tz = optionalText(row["tz"]);
-		const hours = row["workingHours"] === null || row["workingHours"] === void 0 ? void 0 : rangesOf(row["workingHours"], "workingHours");
-		return {
-			userId: textOf(row["userId"]),
-			busy: rangesOf(row["busy"], "busy"),
-			outOfOffice: rangesOf(row["outOfOffice"], "outOfOffice"),
-			focusTime: rangesOf(row["focusTime"], "focusTime"),
-			...hours === void 0 ? {} : { workingHours: hours },
-			...tz === void 0 ? {} : { tz }
-		};
-	});
-}
-/** A `list_calendar_working_hours` result. */
-function workingHoursOf(value) {
-	return recordsOf(value, "list_calendar_working_hours").map((row) => ({
-		userId: textOf(row["userId"]),
-		tz: optionalText(row["tz"]) ?? "UTC",
-		hours: recordsOf(row["hours"], "hours").flatMap((hour) => {
-			const weekday = Number(hour["weekday"]);
-			if (!WEEKDAYS.has(weekday)) return [];
-			return [{
-				weekday,
-				start: textOf(hour["start"]),
-				end: textOf(hour["end"])
-			}];
-		})
-	}));
-}
-const ms = (instant) => instant.epochMilliseconds;
-/** Sorted, merged ranges. */
-function merge(ranges) {
-	const sorted = ranges.filter((range) => ms(range.until) > ms(range.from)).toSorted((a, b) => ms(a.from) - ms(b.from));
-	const merged = [];
-	for (const range of sorted) {
-		const last = merged.at(-1);
-		if (last !== void 0 && ms(range.from) <= ms(last.until)) {
-			if (ms(range.until) > ms(last.until)) merged[merged.length - 1] = {
-				from: last.from,
-				until: range.until
-			};
-		} else merged.push(range);
-	}
-	return merged;
-}
-/** `ranges` minus `cut`, both merged. */
-function subtract(ranges, cut) {
-	const result = [];
-	for (const range of ranges) {
-		let from = range.from;
-		for (const block of cut) {
-			if (ms(block.until) <= ms(from) || ms(block.from) >= ms(range.until)) continue;
-			if (ms(block.from) > ms(from)) result.push({
-				from,
-				until: block.from
-			});
-			if (ms(block.until) > ms(from)) from = block.until;
-		}
-		if (ms(from) < ms(range.until)) result.push({
-			from,
-			until: range.until
-		});
-	}
-	return result;
-}
-/** Where two merged range lists overlap. */
-function intersect(a, b) {
-	const result = [];
-	for (const left of a) for (const right of b) {
-		const from = ms(left.from) > ms(right.from) ? left.from : right.from;
-		const until = ms(left.until) < ms(right.until) ? left.until : right.until;
-		if (ms(until) > ms(from)) result.push({
-			from,
-			until
-		});
-	}
-	return merge(result);
-}
-/**
-* The ranges in `range` when every member in `freeBusy` is free, for a "find a
-* time" view or a scheduling suggestion.
-*/
-function commonFreeTime(freeBusy, range, options = {}) {
-	let free = [{
-		from: range.from,
-		until: range.until
-	}];
-	for (const member of freeBusy) {
-		free = subtract(free, merge(member.busy));
-		if (options.workingHours !== false && member.workingHours !== void 0) free = intersect(free, merge(member.workingHours));
-	}
-	const minimum = options.minimum?.total({ unit: "milliseconds" }) ?? 0;
-	return free.filter((slot) => ms(slot.until) - ms(slot.from) >= Math.max(minimum, 1));
-}
-//#endregion
-//#region src/blocks/calendar/ics.ts
-const ROLES$1 = {
-	CHAIR: "chair",
-	"REQ-PARTICIPANT": "required",
-	"OPT-PARTICIPANT": "optional",
-	"NON-PARTICIPANT": "non-participant"
-};
-const RESPONSES$1 = {
-	"NEEDS-ACTION": "needs-action",
-	ACCEPTED: "accepted",
-	DECLINED: "declined",
-	TENTATIVE: "tentative"
-};
-const STATUSES$1 = [
-	"confirmed",
-	"tentative",
-	"cancelled"
-];
-const DATE = /^(\d{4})(\d{2})(\d{2})$/;
-const DATE_TIME = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z?)$/;
-/** Splits a content line at the first `:` and its `;` that are outside quotes. */
-function contentLine(line) {
-	const parts = [];
-	let quoted = false;
-	let start = 0;
-	for (let index = 0; index < line.length; index += 1) {
-		const char = line[index];
-		if (char === "\"") quoted = !quoted;
-		else if (!quoted && char === ";") {
-			parts.push(line.slice(start, index));
-			start = index + 1;
-		} else if (!quoted && char === ":") {
-			parts.push(line.slice(start, index));
-			const [name = "", ...rest] = parts;
-			const params = {};
-			for (const param of rest) {
-				const equals = param.indexOf("=");
-				if (equals < 1) continue;
-				params[param.slice(0, equals).toUpperCase()] = param.slice(equals + 1).replaceAll("\"", "");
-			}
-			return {
-				name: name.toUpperCase(),
-				params,
-				value: line.slice(index + 1)
-			};
-		}
-	}
-}
-/** RFC 5545 TEXT: `\n`, `\,`, `\;` and `\\`. */
-function unescapeText(value) {
-	return value.replaceAll(/\\([nN,;\\])/g, (_, char) => char === "n" || char === "N" ? "\n" : char);
-}
-function escapeText(value) {
-	return value.replaceAll("\\", "\\\\").replaceAll(";", "\\;").replaceAll(",", "\\,").replaceAll(/\r?\n/g, "\\n");
-}
-function zoneOr(zone, fallback) {
-	if (zone === void 0) return fallback;
-	try {
-		temporal().Now.zonedDateTimeISO(zone);
-		return zone;
-	} catch {
-		return fallback;
-	}
-}
-function dateValue(value, params, fallback) {
-	const time = temporal();
-	const tz = zoneOr(params["TZID"], fallback);
-	const date = DATE.exec(value);
-	if (date !== null || params["VALUE"] === "DATE") {
-		if (date === null) return;
-		return {
-			instant: time.PlainDate.from({
-				year: Number(date[1]),
-				month: Number(date[2]),
-				day: Number(date[3])
-			}).toZonedDateTime({ timeZone: tz }).toInstant(),
-			allDay: true,
-			tz
-		};
-	}
-	const match = DATE_TIME.exec(value);
-	if (match === null) return;
-	const fields = {
-		year: Number(match[1]),
-		month: Number(match[2]),
-		day: Number(match[3]),
-		hour: Number(match[4]),
-		minute: Number(match[5]),
-		second: Number(match[6])
-	};
-	if (match[7] === "Z") return {
-		instant: time.ZonedDateTime.from({
-			...fields,
-			timeZone: "UTC"
-		}).toInstant(),
-		allDay: false,
-		tz
-	};
-	return {
-		instant: time.ZonedDateTime.from({
-			...fields,
-			timeZone: tz
-		}).toInstant(),
-		allDay: false,
-		tz
-	};
-}
-function attendeeOf$1(line) {
-	const email = line.value.replace(/^mailto:/i, "").trim().toLowerCase();
-	if (email === "") return;
-	const name = line.params["CN"];
-	return {
-		email,
-		...name === void 0 ? {} : { name },
-		role: ROLES$1[(line.params["ROLE"] ?? "").toUpperCase()] ?? "required",
-		response: RESPONSES$1[(line.params["PARTSTAT"] ?? "").toUpperCase()] ?? "needs-action"
-	};
-}
-/** One `VEVENT`'s lines as an event, or `undefined` without UID or DTSTART. */
-function eventOf(lines, fallback) {
-	const time = temporal();
-	let uid;
-	let start;
-	let end;
-	let duration;
-	let title = "";
-	let description;
-	let location;
-	let status = "confirmed";
-	let transparent = false;
-	let rrule;
-	let originalStart;
-	const exdates = [];
-	const attendees = [];
-	for (const line of lines) switch (line.name) {
-		case "UID":
-			uid = line.value.trim();
-			break;
-		case "DTSTART":
-			start = dateValue(line.value, line.params, fallback);
-			break;
-		case "DTEND":
-			end = dateValue(line.value, line.params, fallback);
-			break;
-		case "DURATION":
-			try {
-				duration = time.Duration.from(line.value.trim());
-			} catch {
-				duration = void 0;
-			}
-			break;
-		case "SUMMARY":
-			title = unescapeText(line.value);
-			break;
-		case "DESCRIPTION":
-			description = unescapeText(line.value);
-			break;
-		case "LOCATION":
-			location = unescapeText(line.value);
-			break;
-		case "STATUS": {
-			const value = line.value.trim().toLowerCase();
-			status = STATUSES$1.find((item) => item === value) ?? "confirmed";
-			break;
-		}
-		case "TRANSP":
-			transparent = line.value.trim().toUpperCase() === "TRANSPARENT";
-			break;
-		case "RRULE":
-			rrule = line.value.trim();
-			break;
-		case "EXDATE":
-			for (const value of line.value.split(",")) {
-				const date = dateValue(value.trim(), line.params, fallback);
-				if (date !== void 0) exdates.push(date.instant);
-			}
-			break;
-		case "RECURRENCE-ID":
-			originalStart = dateValue(line.value, line.params, fallback)?.instant;
-			break;
-		case "ATTENDEE": {
-			const attendee = attendeeOf$1(line);
-			if (attendee !== void 0) attendees.push(attendee);
-			break;
-		}
-	}
-	if (uid === void 0 || uid === "" || start === void 0) return;
-	const zoned = start.instant.toZonedDateTimeISO(start.tz);
-	const endsAt = end?.instant ?? (duration === void 0 ? start.allDay ? zoned.add({ days: 1 }).toInstant() : start.instant : zoned.add(duration).toInstant());
-	return {
-		uid,
-		title,
-		...description === void 0 ? {} : { description },
-		...location === void 0 ? {} : { location },
-		startsAt: start.instant,
-		endsAt,
-		allDay: start.allDay,
-		tz: start.tz,
-		status,
-		...rrule === void 0 ? {} : { rrule },
-		exdates,
-		...originalStart === void 0 ? {} : { originalStart },
-		attendees,
-		...transparent ? { transparency: "transparent" } : {}
-	};
-}
-/**
-* Reads an iCalendar file (RFC 5545): unfolds lines, unescapes TEXT values and
-* reads each `VEVENT`'s times, recurrence (`RRULE`, `EXDATE`, `RECURRENCE-ID`)
-* and attendees. Times in a zone Temporal does not know, floating times and
-* dates use `X-WR-TIMEZONE`, else UTC.
-*/
-function parseIcs(text) {
-	const lines = text.replaceAll(/\r?\n[ \t]/g, "").split(/\r?\n/).flatMap((raw) => {
-		const line = contentLine(raw);
-		return line === void 0 ? [] : [line];
-	});
-	let name;
-	let tz = "UTC";
-	for (const line of lines) {
-		if (line.name === "X-WR-CALNAME") name = unescapeText(line.value);
-		if (line.name === "X-WR-TIMEZONE") tz = zoneOr(line.value.trim(), "UTC");
-	}
-	const events = [];
-	let skipped = 0;
-	let current;
-	let depth = 0;
-	for (const line of lines) if (line.name === "BEGIN" && line.value.toUpperCase() === "VEVENT") {
-		current = [];
-		depth = 0;
-	} else if (current !== void 0 && line.name === "BEGIN") depth += 1;
-	else if (current !== void 0 && line.name === "END") {
-		if (depth > 0) depth -= 1;
-		else if (line.value.toUpperCase() === "VEVENT") {
-			const event = eventOf(current, tz);
-			if (event === void 0) skipped += 1;
-			else events.push(event);
-			current = void 0;
-		}
-	} else if (current !== void 0 && depth === 0) current.push(line);
-	return {
-		...name === void 0 ? {} : { name },
-		tz,
-		events,
-		skipped
-	};
-}
-const pad = (value, size = 2) => String(value).padStart(size, "0");
-function compact(zoned) {
-	return `${pad(zoned.year, 4)}${pad(zoned.month)}${pad(zoned.day)}T${pad(zoned.hour)}${pad(zoned.minute)}${pad(zoned.second)}`;
-}
-function utc(instant) {
-	return `${compact(instant.toZonedDateTimeISO("UTC"))}Z`;
-}
-function day(instant, tz) {
-	const date = instant.toZonedDateTimeISO(tz);
-	return `${pad(date.year, 4)}${pad(date.month)}${pad(date.day)}`;
-}
-/** A property whose value is a date or date-time in the event's zone. */
-function timeProperty(name, instant, event) {
-	if (event.allDay) return `${name};VALUE=DATE:${day(instant, event.tz)}`;
-	if (event.tz === "UTC") return `${name}:${utc(instant)}`;
-	return `${name};TZID=${event.tz}:${compact(instant.toZonedDateTimeISO(event.tz))}`;
-}
-function offset(nanoseconds) {
-	const minutes = Math.round(nanoseconds / 6e10);
-	const sign = minutes < 0 ? "-" : "+";
-	const abs = Math.abs(minutes);
-	return `${sign}${pad(Math.floor(abs / 60))}${pad(abs % 60)}`;
-}
-/**
-* A `VTIMEZONE` with one observance per transition between `from` and `until`,
-* from Temporal's zone data, so `TZID` references resolve without an external
-* database.
-*/
-function vtimezone(tz, from, until) {
-	let zoned = from.toZonedDateTimeISO(tz);
-	const lines = [
-		"BEGIN:VTIMEZONE",
-		`TZID:${tz}`,
-		"BEGIN:STANDARD",
-		`DTSTART:${compact(zoned.toPlainDateTime())}`,
-		`TZOFFSETFROM:${offset(zoned.offsetNanoseconds)}`,
-		`TZOFFSETTO:${offset(zoned.offsetNanoseconds)}`,
-		"END:STANDARD"
-	];
-	for (let count = 0; count < 80; count += 1) {
-		const next = zoned.getTimeZoneTransition("next");
-		if (next === null || temporal().Instant.compare(next.toInstant(), until) > 0) break;
-		const before = zoned.offsetNanoseconds;
-		const after = next.offsetNanoseconds;
-		const kind = after > before ? "DAYLIGHT" : "STANDARD";
-		const onset = next.toInstant().toZonedDateTimeISO("UTC").add({ nanoseconds: before }).toPlainDateTime();
-		lines.push(`BEGIN:${kind}`, `DTSTART:${compact(onset)}`, `TZOFFSETFROM:${offset(before)}`, `TZOFFSETTO:${offset(after)}`, `END:${kind}`);
-		zoned = next;
-	}
-	lines.push("END:VTIMEZONE");
-	return lines;
-}
-/** Folds a content line to 75 octets, never inside a UTF-8 sequence. */
-function fold(line) {
-	const encoder = new TextEncoder();
-	if (encoder.encode(line).length <= 75) return line;
-	const parts = [];
-	let current = "";
-	let size = 0;
-	for (const char of line) {
-		const bytes = encoder.encode(char).length;
-		const limit = parts.length === 0 ? 75 : 74;
-		if (size + bytes > limit) {
-			parts.push(current);
-			current = "";
-			size = 0;
-		}
-		current += char;
-		size += bytes;
-	}
-	parts.push(current);
-	return parts.join("\r\n ");
-}
-const ROLE_OUT = {
-	chair: "CHAIR",
-	required: "REQ-PARTICIPANT",
-	optional: "OPT-PARTICIPANT",
-	"non-participant": "NON-PARTICIPANT"
-};
-function paramValue(value) {
-	const clean = value.replaceAll("\"", "");
-	return /[:;,]/.test(clean) ? `"${clean}"` : clean;
-}
-function eventLines(event, stamp) {
-	const lines = [
-		"BEGIN:VEVENT",
-		`UID:${event.uid}`,
-		`DTSTAMP:${utc(event.updatedAt ?? stamp)}`,
-		timeProperty("DTSTART", event.startsAt, event),
-		timeProperty("DTEND", event.endsAt, event)
-	];
-	if (event.originalStart !== void 0) lines.push(timeProperty("RECURRENCE-ID", event.originalStart, event));
-	if (event.rrule !== void 0) lines.push(`RRULE:${event.rrule}`);
-	for (const exdate of event.exdates) lines.push(timeProperty("EXDATE", exdate, event));
-	lines.push(`SUMMARY:${escapeText(event.title)}`);
-	if (event.description !== void 0) lines.push(`DESCRIPTION:${escapeText(event.description)}`);
-	if (event.location !== void 0) lines.push(`LOCATION:${escapeText(event.location)}`);
-	lines.push(`STATUS:${event.status.toUpperCase()}`);
-	if (event.transparency === "transparent") lines.push("TRANSP:TRANSPARENT");
-	for (const attendee of event.attendees ?? []) {
-		const cn = attendee.name === void 0 ? "" : `;CN=${paramValue(attendee.name)}`;
-		lines.push(`ATTENDEE${cn};ROLE=${ROLE_OUT[attendee.role]};PARTSTAT=${attendee.response.toUpperCase()}:mailto:${attendee.email}`);
-	}
-	lines.push("END:VEVENT");
-	return lines;
-}
-/**
-* Writes events as an iCalendar file (RFC 5545): CRLF line ends, lines folded
-* at 75 octets, escaped TEXT, and a `VTIMEZONE` for every zone a timed event
-* uses, so recurrence keeps its wall-clock time across DST.
-*/
-function toIcs(events, options = {}) {
-	const time = temporal();
-	const stamp = options.now ?? time.Now.instant();
-	const zones = /* @__PURE__ */ new Map();
-	for (const event of events) {
-		if (event.allDay || event.tz === "UTC") continue;
-		const from = event.startsAt.subtract({ hours: 24 });
-		const until = event.rrule === void 0 ? event.endsAt.add({ hours: 24 }) : event.startsAt.add({ hours: 26352 });
-		const known = zones.get(event.tz);
-		zones.set(event.tz, {
-			from: known === void 0 || time.Instant.compare(from, known.from) < 0 ? from : known.from,
-			until: known === void 0 || time.Instant.compare(until, known.until) > 0 ? until : known.until
-		});
-	}
-	const lines = [
-		"BEGIN:VCALENDAR",
-		"VERSION:2.0",
-		`PRODID:${options.prodId ?? "-//better-supabase//calendar//EN"}`,
-		"CALSCALE:GREGORIAN"
-	];
-	if (options.name !== void 0) lines.push(`X-WR-CALNAME:${escapeText(options.name)}`);
-	if (options.tz !== void 0) lines.push(`X-WR-TIMEZONE:${options.tz}`);
-	for (const [tz, range] of zones) lines.push(...vtimezone(tz, range.from, range.until));
-	for (const event of events) lines.push(...eventLines(event, stamp));
-	lines.push("END:VCALENDAR");
-	return `${lines.map(fold).join("\r\n")}\r\n`;
-}
-//#endregion
-//#region src/blocks/calendar/occurrences.ts
-const keyOf = (id, start) => `${id}::${start.toString()}`;
-function overlaps(start, end, range) {
-	const time = temporal();
-	return time.Instant.compare(start, range.until) < 0 && (time.Instant.compare(end, range.from) > 0 || time.Instant.compare(start, end) === 0 && time.Instant.compare(start, range.from) >= 0);
-}
-/**
-* Expands events into the occurrences that overlap `[from, until)`. Series
-* expand with the reminders block's `expandRule` in their own zone, so a weekly
-* 09:00 meeting stays at 09:00 across DST. `EXDATE`s drop occurrences, and
-* overrides replace the occurrence they name, also when they move it out of the
-* range.
-*/
-function expandOccurrences(events, range, options = {}) {
-	const time = temporal();
-	const keep = (event) => options.includeCancelled === true || event.status !== "cancelled";
-	const series = /* @__PURE__ */ new Map();
-	const overrides = /* @__PURE__ */ new Map();
-	for (const event of events) if (event.recurrenceId !== void 0 && event.originalStart !== void 0) overrides.set(keyOf(event.recurrenceId, event.originalStart), event);
-	else if (event.rrule !== void 0) series.set(event.id, event);
-	const found = [];
-	for (const event of events) {
-		if (event.recurrenceId !== void 0) {
-			const master = series.get(event.recurrenceId);
-			if (event.originalStart !== void 0 && keep(event) && overlaps(event.startsAt, event.endsAt, range)) found.push({
-				key: keyOf(event.recurrenceId, event.originalStart),
-				event,
-				...master === void 0 ? {} : { series: master },
-				start: event.startsAt,
-				end: event.endsAt,
-				originalStart: event.originalStart,
-				allDay: event.allDay,
-				recurring: true
-			});
-			continue;
-		}
-		if (event.rrule === void 0) {
-			if (keep(event) && overlaps(event.startsAt, event.endsAt, range)) found.push({
-				key: keyOf(event.id, event.startsAt),
-				event,
-				start: event.startsAt,
-				end: event.endsAt,
-				originalStart: event.startsAt,
-				allDay: event.allDay,
-				recurring: false
-			});
-			continue;
-		}
-		if (!keep(event)) continue;
-		const zoned = event.startsAt.toZonedDateTimeISO(event.tz);
-		const length = zoned.until(event.endsAt.toZonedDateTimeISO(event.tz), { largestUnit: event.allDay ? "days" : "hours" });
-		const reach = event.endsAt.since(event.startsAt).add({ hours: 25 });
-		const skipped = new Set(event.exdates.map((date) => date.epochMilliseconds));
-		for (const when of expandRule({
-			dtstart: zoned,
-			rrule: event.rrule,
-			window: {
-				from: range.from.subtract(reach),
-				until: range.until
-			}
-		})) {
-			const start = when.toInstant();
-			if (skipped.has(start.epochMilliseconds)) continue;
-			if (overrides.has(keyOf(event.id, start))) continue;
-			const end = when.add(length).toInstant();
-			if (!overlaps(start, end, range)) continue;
-			found.push({
-				key: keyOf(event.id, start),
-				event,
-				series: event,
-				start,
-				end,
-				originalStart: start,
-				allDay: event.allDay,
-				recurring: true
-			});
-		}
-	}
-	return found.toSorted((a, b) => time.Instant.compare(a.start, b.start) || a.key.localeCompare(b.key));
-}
-function ruleParts(rrule) {
-	const parts = /* @__PURE__ */ new Map();
-	for (const part of rrule.replace(/^RRULE:/i, "").split(";")) {
-		const [key, value] = part.split("=");
-		if (key !== void 0 && key !== "" && value !== void 0) parts.set(key.toUpperCase(), value);
-	}
-	return parts;
-}
-const joinRule = (parts) => [...parts].map(([key, value]) => `${key}=${value}`).join(";");
-/**
-* Splits a series for "this and following": the first rule ends one second
-* before `at` (RFC 5545 forbids `COUNT` with `UNTIL`, so it drops `COUNT`), and
-* the second keeps the occurrences that are left.
-*/
-function splitRule(rrule, dtstart, at) {
-	const parts = ruleParts(rrule);
-	if (temporal().Instant.compare(at, dtstart.toInstant()) <= 0) throw new RangeError("splitRule: at must come after the first occurrence");
-	const before = new Map(parts);
-	before.delete("COUNT");
-	const until = at.subtract({ seconds: 1 }).toZonedDateTimeISO("UTC");
-	before.set("UNTIL", `${String(until.year).padStart(4, "0")}${String(until.month).padStart(2, "0")}${String(until.day).padStart(2, "0")}T${String(until.hour).padStart(2, "0")}${String(until.minute).padStart(2, "0")}${String(until.second).padStart(2, "0")}Z`);
-	const after = new Map(parts);
-	const count = parts.get("COUNT");
-	if (count !== void 0) {
-		const used = expandRule({
-			dtstart,
-			rrule,
-			window: {
-				from: dtstart.toInstant(),
-				until: at
-			},
-			limit: Number(count)
-		}).length;
-		const left = Number(count) - used;
-		if (left <= 0) throw new RangeError("splitRule: the series has no occurrence at or after at");
-		after.set("COUNT", String(left));
-	}
-	return {
-		before: joinRule(before),
-		after: joinRule(after)
-	};
-}
-//#endregion
-//#region src/blocks/calendar/calendar.ts
-const ROLES = [
-	"chair",
-	"required",
-	"optional",
-	"non-participant"
-];
-const RESPONSES = [
-	"needs-action",
-	"accepted",
-	"declined",
-	"tentative"
-];
-const STATUSES = [
-	"confirmed",
-	"tentative",
-	"cancelled"
-];
-function attendeeOf(value) {
-	const name = optionalText(value["name"]);
-	const userId = optionalText(value["userId"]);
-	return {
-		email: textOf(value["email"]),
-		...name === void 0 ? {} : { name },
-		...userId === void 0 ? {} : { userId },
-		role: oneOf(value["role"], ROLES, "required"),
-		response: oneOf(value["response"], RESPONSES, "needs-action")
-	};
-}
-/** A `list_calendar_events` or `calendar_feed` row as an event. */
-function calendarEventOf(value) {
-	const row = recordOf(value, "calendar event");
-	const text = (key) => {
-		const found = optionalText(row[key]);
-		return found === void 0 ? {} : { [key]: found };
-	};
-	const originalStart = optionalInstant(row["originalStart"]);
-	const updatedAt = optionalInstant(row["updatedAt"]);
-	const exdates = Array.isArray(row["exdates"]) ? row["exdates"] : [];
-	return {
-		id: textOf(row["id"]),
-		calendarId: textOf(row["calendarId"]),
-		uid: textOf(row["uid"]),
-		title: optionalText(row["title"]) ?? "",
-		...text("description"),
-		...text("location"),
-		startsAt: requiredInstant(row["startsAt"], "startsAt"),
-		endsAt: requiredInstant(row["endsAt"], "endsAt"),
-		allDay: row["allDay"] === true,
-		tz: optionalText(row["tz"]) ?? "UTC",
-		status: oneOf(row["status"], STATUSES, "confirmed"),
-		...text("rrule"),
-		exdates: exdates.map((date) => requiredInstant(date, "exdate")),
-		...text("recurrenceId"),
-		...originalStart === void 0 ? {} : { originalStart },
-		...text("subjectType"),
-		...text("subjectId"),
-		...text("color"),
-		...row["kind"] === void 0 ? {} : { kind: oneOf(row["kind"], CALENDAR_EVENT_KINDS, "event") },
-		...row["transparency"] === void 0 ? {} : { transparency: oneOf(row["transparency"], CALENDAR_TRANSPARENCIES, "opaque") },
-		...typeof row["autoDecline"] === "boolean" ? { autoDecline: row["autoDecline"] } : {},
-		attendees: recordsOf(row["attendees"], "attendees").map(attendeeOf),
-		...updatedAt === void 0 ? {} : { updatedAt }
-	};
-}
-/** The jsonb `save_calendar_event` takes. */
-function itemOf(input) {
-	const item = {};
-	for (const [key, value] of Object.entries(input)) {
-		if (value === void 0) continue;
-		if (key === "exdates" && Array.isArray(value)) item[key] = value.map(String);
-		else if (key === "startsAt" || key === "endsAt" || key === "originalStart") item[key] = String(value);
-		else item[key] = value;
-	}
-	return item;
-}
-/** An imported event as the jsonb `import_calendar_events` takes. */
-function importItem(event) {
-	return itemOf({
-		uid: event.uid,
-		title: event.title,
-		description: event.description ?? null,
-		location: event.location ?? null,
-		startsAt: event.startsAt,
-		endsAt: event.endsAt,
-		allDay: event.allDay,
-		tz: event.tz,
-		status: event.status,
-		rrule: event.rrule ?? null,
-		exdates: event.exdates,
-		...event.originalStart === void 0 ? {} : { originalStart: event.originalStart },
-		...event.transparency === void 0 ? {} : { transparency: event.transparency }
-	});
-}
-/** The fields of a series that an override or a new series starts from. */
-function copyOf(event) {
-	return {
-		title: event.title,
-		...event.description === void 0 ? {} : { description: event.description },
-		...event.location === void 0 ? {} : { location: event.location },
-		allDay: event.allDay,
-		tz: event.tz,
-		status: event.status,
-		...event.subjectType === void 0 ? {} : { subjectType: event.subjectType },
-		...event.subjectId === void 0 ? {} : { subjectId: event.subjectId },
-		...event.color === void 0 ? {} : { color: event.color },
-		...event.kind === void 0 ? {} : { kind: event.kind },
-		...event.transparency === void 0 ? {} : { transparency: event.transparency },
-		...event.autoDecline === void 0 ? {} : { autoDecline: event.autoDecline }
-	};
-}
-const INFINITE = {
-	from: "-infinity",
-	until: "infinity"
-};
-/** The keys of an event write the block types itself. */
-const EVENT_INPUT = /* @__PURE__ */ new Set([
-	"id",
-	"title",
-	"description",
-	"location",
-	"startsAt",
-	"endsAt",
-	"allDay",
-	"tz",
-	"status",
-	"rrule",
-	"exdates",
-	"subjectType",
-	"subjectId",
-	"color",
-	"kind",
-	"transparency",
-	"autoDecline",
-	"uid",
-	"recurrenceId",
-	"originalStart"
-]);
-function createCalendar(options) {
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const fields = blockFields(options.fields, "event fields");
-	/** The item a write sends, with its extra fields validated. */
-	const checked = (input) => AsyncResult.from(() => fields.write(extraOf(input, EVENT_INPUT))).map((extra) => ({
-		...extra,
-		...itemOf(input)
-	}));
-	const saved = (value) => {
-		const row = recordOf(value, "save_calendar_event");
-		return {
-			id: textOf(row["id"]),
-			uid: textOf(row["uid"]),
-			created: row["created"] === true
-		};
-	};
-	const save = (calendarId, input) => checked(input).andThen((item) => call("save_calendar_event", {
-		calendar_id: calendarId,
-		item
-	}, saved));
-	const list = (calendarIds, range) => call("list_calendar_events", {
-		calendar_ids: [...calendarIds],
-		range_start: range.from.toString(),
-		range_end: range.until.toString()
-	}, (value) => recordsOf(value, "list_calendar_events").map((raw) => [raw, calendarEventOf(raw)])).andThen((rows) => allWithFields(fields, rows));
-	return withBlockHooks({
-		createCalendar: (organizationId, name, extra = {}) => call("create_calendar", {
-			tenant: organizationId,
-			name,
-			tz: extra.tz ?? "UTC",
-			owner_type: extra.ownerType ?? null,
-			owner_id: extra.ownerId ?? null
-		}, (value) => ({ id: textOf(recordOf(value, "create_calendar")["id"]) })),
-		deleteCalendar: (id) => call("delete_calendar", { calendar_id: id }, (value) => value === true),
-		listCalendars: (organizationId) => call("list_calendars", { tenant: organizationId }, (value) => recordsOf(value, "list_calendars").map((row) => {
-			const extra = {};
-			for (const key of [
-				"color",
-				"ownerType",
-				"ownerId"
-			]) {
-				const found = optionalText(row[key]);
-				if (found !== void 0) extra[key] = found;
-			}
-			return {
-				id: textOf(row["id"]),
-				name: textOf(row["name"]),
-				tz: optionalText(row["tz"]) ?? "UTC",
-				...extra
-			};
-		})),
-		save,
-		delete: (eventId) => call("delete_calendar_event", { event_id: eventId }, (value) => value === true),
-		events: list,
-		occurrences: (calendarIds, range, occurrenceOptions) => list(calendarIds, range).map((events) => expandOccurrences(events, range, occurrenceOptions)),
-		editOccurrence: (occurrence, changes) => {
-			const series = occurrence.series;
-			if (!occurrence.recurring || series === void 0) return save(occurrence.event.calendarId, {
-				...changes,
-				id: occurrence.event.id
-			});
-			if (occurrence.event.recurrenceId !== void 0) return save(occurrence.event.calendarId, {
-				...changes,
-				id: occurrence.event.id
-			});
-			return save(series.calendarId, {
-				...copyOf(series),
-				startsAt: occurrence.start,
-				endsAt: occurrence.end,
-				...changes,
-				rrule: null,
-				exdates: [],
-				recurrenceId: series.id,
-				originalStart: occurrence.originalStart
-			});
-		},
-		editFollowing: (occurrence, changes) => {
-			const series = occurrence.series;
-			if (!occurrence.recurring || series?.rrule === void 0) return save(occurrence.event.calendarId, {
-				...changes,
-				id: occurrence.event.id
-			}).map(({ id }) => ({ id }));
-			if (occurrence.originalStart.equals(series.startsAt)) return save(series.calendarId, {
-				...changes,
-				id: series.id
-			}).map(({ id }) => ({ id }));
-			let rules;
-			try {
-				rules = splitRule(series.rrule, series.startsAt.toZonedDateTimeISO(series.tz), occurrence.originalStart);
-			} catch (cause) {
-				return AsyncResult.err(dbError("invalid_input", cause instanceof Error ? cause.message : String(cause), { hint: "CALENDAR_SPLIT_INVALID" }));
-			}
-			const length = series.endsAt.since(series.startsAt);
-			return checked({
-				...copyOf(series),
-				startsAt: occurrence.originalStart,
-				endsAt: occurrence.originalStart.add(length),
-				rrule: rules.after,
-				...changes
-			}).andThen((item) => call("split_calendar_event", {
-				event_id: series.id,
-				split_at: occurrence.originalStart.toString(),
-				before_rrule: rules.before,
-				item
-			}, (value) => ({ id: textOf(recordOf(value, "split_calendar_event")["id"]) })));
-		},
-		cancelOccurrence: (occurrence) => {
-			const series = occurrence.series;
-			if (!occurrence.recurring || series === void 0) return call("delete_calendar_event", { event_id: occurrence.event.id }, (value) => value === true);
-			return call("cancel_calendar_occurrence", {
-				event_id: series.id,
-				original_start: occurrence.originalStart.toString()
-			}, (value) => value === true);
-		},
-		setAttendee: (eventId, attendee) => call("set_calendar_attendee", {
-			event_id: eventId,
-			email: attendee.email,
-			name: attendee.name ?? null,
-			user_id: attendee.userId ?? null,
-			role: attendee.role ?? "required"
-		}, (value) => value === true),
-		removeAttendee: (eventId, email) => call("remove_calendar_attendee", {
-			event_id: eventId,
-			email
-		}, (value) => value === true),
-		respond: (eventId, response) => call("respond_calendar_event", {
-			event_id: eventId,
-			response
-		}, (value) => value === true),
-		importIcs: (calendarId, text) => {
-			const parsed = parseIcs(text);
-			return call("import_calendar_events", {
-				calendar_id: calendarId,
-				source: { events: parsed.events.map(importItem) }
-			}, (value) => {
-				const row = recordOf(value, "import_calendar_events");
-				return {
-					created: Number(row["created"] ?? 0),
-					updated: Number(row["updated"] ?? 0),
-					skipped: Number(row["skipped"] ?? 0) + parsed.skipped
-				};
-			});
-		},
-		exportIcs: (calendar, range) => list([calendar.id], range ?? INFINITE).map((events) => toIcs(events, {
-			name: calendar.name,
-			tz: calendar.tz
-		})),
-		feed: (token) => call("calendar_feed", { token }, (value) => {
-			if (value === null || value === void 0) return null;
-			const row = recordOf(value, "calendar_feed");
-			const info = recordOf(row["calendar"], "calendar_feed");
-			return toIcs(recordsOf(row["events"], "calendar_feed").map(calendarEventOf), {
-				name: textOf(info["name"]),
-				tz: optionalText(info["tz"]) ?? "UTC"
-			});
-		}),
-		setWorkingHours: (organizationId, input) => call("set_calendar_working_hours", {
-			tenant: organizationId,
-			user_id: input.userId ?? null,
-			tz: input.tz,
-			hours: input.hours.map((hour) => ({ ...hour }))
-		}, (value) => Number(value ?? 0)),
-		workingHours: (organizationId, userIds) => call("list_calendar_working_hours", {
-			tenant: organizationId,
-			user_ids: userIds === void 0 ? null : [...userIds]
-		}, workingHoursOf),
-		freeBusy: (organizationId, userIds, range) => call("calendar_free_busy", {
-			tenant: organizationId,
-			user_ids: [...userIds],
-			range_start: range.from.toString(),
-			range_end: range.until.toString()
-		}, freeBusyOf)
-	}, options.hooks, {
-		block: "calendar",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-//#endregion
-export { parseIcs as a, freeBusyOf as c, splitRule as i, workingHoursOf as l, createCalendar as n, toIcs as o, expandOccurrences as r, commonFreeTime as s, calendarEventOf as t };