@remit/ui 0.0.112 → 0.0.114

package/src/index.ts

@@ -30,6 +30,7 @@ export {
 	type Density,
 	INTELLIGENCE_MIN_WIDTH,
 	isBriefCategory,
+	isThreadCategory,
 	type MessageListKeyboard,
 	type MessageListSelection,
 	type NarrowView,
@@ -57,6 +58,14 @@ export {
 	AttachmentList,
 	type AttachmentListProps,
 } from "./components/attachment-list.js";
+export {
+	AttendeeList,
+	type AttendeeListProps,
+	AttendeeRow,
+	type AttendeeRowProps,
+	RsvpBadge,
+	type RsvpBadgeProps,
+} from "./components/attendee-row.js";
 export { AuthCard, type AuthCardProps } from "./components/auth-card.js";
 export {
 	AuthFooter,
@@ -111,6 +120,35 @@ export {
 	type ButtonLinkProps,
 	type ButtonProps,
 } from "./components/button.js";
+export {
+	CalendarEventChip,
+	type CalendarEventChipProps,
+} from "./components/calendar-event-chip.js";
+export {
+	CalendarList,
+	type CalendarListProps,
+} from "./components/calendar-list.js";
+export {
+	CalendarDateNav,
+	type CalendarDateNavProps,
+	CalendarViewSwitch,
+	type CalendarViewSwitchProps,
+	type SegmentOption,
+	segmentClassName,
+} from "./components/calendar-toolbar.js";
+export {
+	type CalendarAttendee,
+	type CalendarColorId,
+	type CalendarDescriptor,
+	type CalendarEventData,
+	type CalendarViewId,
+	calendarColorIds,
+	type EventDraft,
+	type EventSuggestion,
+	type RecurrenceScope,
+	type RsvpState,
+	type ZoneCertainty,
+} from "./components/calendar-types.js";
 export {
 	Card,
 	CardBody,
@@ -165,6 +203,12 @@ export {
 	ConfirmDialog,
 	type ConfirmDialogProps,
 } from "./components/confirm-dialog.js";
+export {
+	CustomRecurrenceDialog,
+	type CustomRecurrenceDialogProps,
+	CustomRecurrenceEditor,
+	type CustomRecurrenceEditorProps,
+} from "./components/custom-recurrence.js";
 export {
 	DangerZoneSection,
 	type DangerZoneSectionProps,
@@ -175,6 +219,36 @@ export {
 	type DialogBackdropProps,
 } from "./components/dialog-backdrop.js";
 export type { EmailFrameVariant } from "./components/email-frame-css.js";
+export {
+	EventDetail,
+	type EventDetailProps,
+} from "./components/event-detail.js";
+export {
+	EventCalendarField,
+	EventEditor,
+	type EventEditorLayout,
+	type EventEditorProps,
+	EventField,
+	type EventFieldProps,
+	EventGuestsField,
+	EventLocationField,
+	EventNotesField,
+	EventRepeatField,
+	EventTitleField,
+	EventWhenField,
+} from "./components/event-editor.js";
+export {
+	EventEditorPane,
+	type EventEditorPaneProps,
+} from "./components/event-editor-pane.js";
+export {
+	EventQuickEntry,
+	type EventQuickEntryProps,
+} from "./components/event-quick-entry.js";
+export {
+	EventSuggestionCard,
+	type EventSuggestionCardProps,
+} from "./components/event-suggestion-card.js";
 export {
 	FieldLabel,
 	type FieldLabelProps,
@@ -244,6 +318,12 @@ export {
 	type FilterSheetSource,
 	FilterToggle,
 } from "./components/filter-sheet.js";
+export {
+	FlowScreen,
+	type FlowScreenProps,
+	FlowStepRail,
+	type FlowStepRailProps,
+} from "./components/flow-screen.js";
 export {
 	FolderManageActions,
 	type FolderManageActionsProps,
@@ -447,6 +527,10 @@ export {
 	ReadingPaneEmpty,
 	type ReadingPaneEmptyProps,
 } from "./components/reading-pane-empty.js";
+export {
+	RecurrenceScopePrompt,
+	type RecurrenceScopePromptProps,
+} from "./components/recurrence-scope-prompt.js";
 export {
 	RefreshButton,
 	type RefreshButtonProps,
@@ -564,6 +648,8 @@ export {
 export {
 	FolderStepBody,
 	type FolderStepProps,
+	FooterNav,
+	type FooterNavProps,
 	MatchStepBody,
 	type MatchStepProps,
 	NameStepBody,
@@ -698,6 +784,10 @@ export {
 	setBriefCategoryInQuery,
 	toggleBriefFilterInQuery,
 } from "./lib/brief-filter-query.js";
+export {
+	type CalendarColorClasses,
+	calendarColorClasses,
+} from "./lib/calendar-color.js";
 export {
 	buildCidResolver,
 	type CidResolvableBodyPart,
@@ -730,6 +820,11 @@ export {
 	sanitizeInlineStyle,
 	sanitizeStyleElementCss,
 } from "./lib/email-sanitizer.js";
+export {
+	addMinutesToClock,
+	type PhraseParse,
+	parseEventPhrase,
+} from "./lib/event-phrase.js";
 export {
 	collapseFolderTree,
 	filterFolderTree,
@@ -786,6 +881,23 @@ export {
 	normalizeSubject,
 	sharedSubjectFragment,
 } from "./lib/property-prefill.js";
+export {
+	type CustomRecurrence,
+	dayOfMonthLabel,
+	defaultCustomRecurrence,
+	defaultEndDate,
+	endDateLabel,
+	formatCustomRecurrence,
+	type MonthlyMode,
+	NO_REPEAT,
+	ordinalWeekdayLabel,
+	type RecurrenceEnd,
+	type RecurrenceUnit,
+	readCustomRecurrence,
+	repeatChoices,
+	WEEKDAY_INITIALS,
+	weekdayName,
+} from "./lib/recurrence.js";
 export {
 	LIST_ROW_ATTRIBUTE,
 	LIST_ROW_SELECTOR,

package/src/lib/calendar-color.ts

@@ -0,0 +1,71 @@
+import type { CalendarColorId } from "../components/calendar-types.js";
+
+/**
+ * A calendar's hue is data, so the utility names cannot be built by
+ * interpolation — Tailwind only sees class strings it can read in source.
+ * Every calendar colour therefore names its utilities once, here, and every
+ * calendar surface reads them from this table.
+ */
+export interface CalendarColorClasses {
+	/** Solid fill: the swatch, the dot, the left rail of a chip. */
+	solid: string;
+	/** Tinted fill for the body of a chip or a day cell. */
+	soft: string;
+	/** Text and icons that sit on `soft`, or on a plain surface. */
+	text: string;
+	/** Hairline in the calendar's own hue. */
+	border: string;
+	/** Border on the leading edge only — the rail a timed chip carries. */
+	rail: string;
+}
+
+const table: Record<CalendarColorId, CalendarColorClasses> = {
+	"cal-1": {
+		solid: "bg-cal-1",
+		soft: "bg-cal-1-soft",
+		text: "text-cal-1",
+		border: "border-cal-1",
+		rail: "border-l-cal-1",
+	},
+	"cal-2": {
+		solid: "bg-cal-2",
+		soft: "bg-cal-2-soft",
+		text: "text-cal-2",
+		border: "border-cal-2",
+		rail: "border-l-cal-2",
+	},
+	"cal-3": {
+		solid: "bg-cal-3",
+		soft: "bg-cal-3-soft",
+		text: "text-cal-3",
+		border: "border-cal-3",
+		rail: "border-l-cal-3",
+	},
+	"cal-4": {
+		solid: "bg-cal-4",
+		soft: "bg-cal-4-soft",
+		text: "text-cal-4",
+		border: "border-cal-4",
+		rail: "border-l-cal-4",
+	},
+	"cal-5": {
+		solid: "bg-cal-5",
+		soft: "bg-cal-5-soft",
+		text: "text-cal-5",
+		border: "border-cal-5",
+		rail: "border-l-cal-5",
+	},
+	"cal-6": {
+		solid: "bg-cal-6",
+		soft: "bg-cal-6-soft",
+		text: "text-cal-6",
+		border: "border-cal-6",
+		rail: "border-l-cal-6",
+	},
+};
+
+export function calendarColorClasses(
+	color: CalendarColorId,
+): CalendarColorClasses {
+	return table[color];
+}

package/src/lib/event-phrase.test.ts

@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { addMinutesToClock, parseEventPhrase } from "./event-phrase.js";
+
+/** Wednesday 10 June 2026, 09:30 local — the fixtures' fixed "now". */
+const NOW = new Date(2026, 5, 10, 9, 30);
+
+describe("parseEventPhrase", () => {
+	it("reads a title, a guest, a weekday and a time", () => {
+		const parse = parseEventPhrase("lunch with Jane friday 1pm", NOW);
+		assert.equal(parse.title, "lunch");
+		assert.deepEqual(parse.attendees, ["Jane"]);
+		assert.equal(parse.date, "2026-06-12");
+		assert.equal(parse.startTime, "13:00");
+		assert.equal(parse.dateText, "friday");
+		assert.equal(parse.startTimeText, "1pm");
+	});
+
+	it("assumes an hour when no length is given, and says so", () => {
+		const parse = parseEventPhrase("standup tomorrow 9:30", NOW);
+		assert.equal(parse.date, "2026-06-11");
+		assert.equal(parse.startTime, "09:30");
+		assert.equal(parse.durationMinutes, 60);
+		assert.deepEqual(parse.assumptions, ["No length given — using an hour"]);
+	});
+
+	it("reads an explicit length instead of assuming one", () => {
+		const parse = parseEventPhrase("dentist next tuesday 15:00 for 45m", NOW);
+		assert.equal(parse.title, "dentist");
+		assert.equal(parse.date, "2026-06-23");
+		assert.equal(parse.durationMinutes, 45);
+		assert.deepEqual(parse.assumptions, []);
+	});
+
+	it("splits several guests", () => {
+		const parse = parseEventPhrase("coffee with Marcus and Dana thu 8am", NOW);
+		assert.equal(parse.title, "coffee");
+		assert.deepEqual(parse.attendees, ["Marcus", "Dana"]);
+		assert.equal(parse.date, "2026-06-11");
+		assert.equal(parse.startTime, "08:00");
+	});
+
+	it("reports a missing time rather than inventing one", () => {
+		const parse = parseEventPhrase("design review monday", NOW);
+		assert.equal(parse.startTime, "");
+		assert.deepEqual(parse.unresolved, ["No time given"]);
+	});
+
+	it("reports the day it fell back to", () => {
+		const parse = parseEventPhrase("call the plumber 3pm", NOW);
+		assert.equal(parse.date, "2026-06-10");
+		assert.deepEqual(parse.assumptions[0], "No day given — using today");
+	});
+
+	it("reads a named hour", () => {
+		const parse = parseEventPhrase("sandwich noon", NOW);
+		assert.equal(parse.startTime, "12:00");
+		assert.equal(parse.title, "sandwich");
+	});
+
+	it("has nothing to report on an empty phrase but the gaps", () => {
+		const parse = parseEventPhrase("", NOW);
+		assert.deepEqual(parse.unresolved, ["No title yet", "No time given"]);
+	});
+
+	it("keeps the same weekday when it is today", () => {
+		const parse = parseEventPhrase("retro wednesday 4pm", NOW);
+		assert.equal(parse.date, "2026-06-10");
+	});
+
+	it("reads hours as well as minutes", () => {
+		const parse = parseEventPhrase("workshop friday 10am 2h", NOW);
+		assert.equal(parse.durationMinutes, 120);
+	});
+});
+
+describe("addMinutesToClock", () => {
+	it("advances a clock", () => {
+		assert.equal(addMinutesToClock("13:00", 90), "14:30");
+	});
+
+	it("wraps past midnight", () => {
+		assert.equal(addMinutesToClock("23:30", 60), "00:30");
+	});
+
+	it("returns nothing for no clock", () => {
+		assert.equal(addMinutesToClock("", 60), "");
+	});
+});

package/src/lib/event-phrase.ts

@@ -0,0 +1,228 @@
+/**
+ * A deliberately small natural-language reader for the quick-entry field.
+ *
+ * It handles the phrasings a person actually types at a calendar — a title, a
+ * day, a time, a length, and who is coming — and it reports what it consumed
+ * for each one. The point is not coverage; it is that the machine's reading is
+ * on screen, attributed to the words it came from, before anything is
+ * committed. Whatever it could not settle comes back in `unresolved`, and
+ * whatever it filled in for you comes back in `assumptions`. Both are meant to
+ * be rendered, not swallowed.
+ */
+
+export interface PhraseParse {
+	/** What is left after the day, time, length and guests are taken out. */
+	title: string;
+	/** `YYYY-MM-DD`, empty when the phrase named no day. */
+	date: string;
+	/** The words the day was read from, e.g. "friday". */
+	dateText: string;
+	/** `HH:MM` on a 24-hour clock, empty when the phrase named no time. */
+	startTime: string;
+	startTimeText: string;
+	/** Minutes; 0 when the phrase named no length. */
+	durationMinutes: number;
+	durationText: string;
+	attendees: string[];
+	attendeesText: string;
+	/** Things the phrase never said, in the words the UI should show. */
+	unresolved: string[];
+	/** Defaults applied on the reader's own authority. */
+	assumptions: string[];
+}
+
+const WEEKDAYS: Record<string, number> = {
+	sun: 0,
+	sunday: 0,
+	mon: 1,
+	monday: 1,
+	tue: 2,
+	tues: 2,
+	tuesday: 2,
+	wed: 3,
+	weds: 3,
+	wednesday: 3,
+	thu: 4,
+	thur: 4,
+	thurs: 4,
+	thursday: 4,
+	fri: 5,
+	friday: 5,
+	sat: 6,
+	saturday: 6,
+};
+
+const WEEKDAY_ALTERNATION = Object.keys(WEEKDAYS)
+	.sort((a, b) => b.length - a.length)
+	.join("|");
+
+const DURATION_RE =
+	/\b(?:for\s+)?(\d+(?:[.,]\d+)?)\s*(hours|hour|hrs|hr|h|minutes|minute|mins|min|m)\b/i;
+const CLOCK_RE =
+	/\b(\d{1,2})(?:[:.](\d{2}))?\s*(am|pm)\b|\b(\d{1,2}):(\d{2})\b/i;
+const NOON_RE = /\b(noon|midday|midnight)\b/i;
+const RELATIVE_DAY_RE = /\b(today|tonight|tomorrow)\b/i;
+const NEXT_WEEKDAY_RE = new RegExp(
+	`\\bnext\\s+(${WEEKDAY_ALTERNATION})\\b`,
+	"i",
+);
+const WEEKDAY_RE = new RegExp(`\\b(?:on\\s+)?(${WEEKDAY_ALTERNATION})\\b`, "i");
+const WITH_RE = /\bwith\s+(.+)$/i;
+
+function pad(n: number): string {
+	return String(n).padStart(2, "0");
+}
+
+function isoDate(d: Date): string {
+	return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+function addDays(d: Date, days: number): Date {
+	const next = new Date(d);
+	next.setDate(next.getDate() + days);
+	return next;
+}
+
+/** The soonest day with this weekday, today included. */
+function comingWeekday(now: Date, weekday: number): Date {
+	return addDays(now, (weekday - now.getDay() + 7) % 7);
+}
+
+function minutesFrom(amount: number, unit: string): number {
+	const isHours = /^h/i.test(unit);
+	return Math.round(isHours ? amount * 60 : amount);
+}
+
+function cut(source: string, match: RegExpMatchArray): string {
+	const at = match.index ?? 0;
+	return `${source.slice(0, at)} ${source.slice(at + match[0].length)}`;
+}
+
+function tidy(text: string): string {
+	return text
+		.replace(/\s+/g, " ")
+		.replace(/^[\s,;–-]+|[\s,;–-]+$/g, "")
+		.replace(/\s+(on|at|with|for|from)$/i, "")
+		.trim();
+}
+
+function splitNames(clause: string): string[] {
+	return clause
+		.split(/\s*(?:,|\band\b|&)\s*/i)
+		.map((name) => tidy(name))
+		.filter((name) => name.length > 0);
+}
+
+function readClock(match: RegExpMatchArray): string {
+	if (match[3]) {
+		const meridiem = match[3].toLowerCase();
+		const hour12 = Number(match[1]) % 12;
+		const hour = meridiem === "pm" ? hour12 + 12 : hour12;
+		return `${pad(hour)}:${pad(Number(match[2] ?? 0))}`;
+	}
+	return `${pad(Number(match[4]))}:${pad(Number(match[5]))}`;
+}
+
+/**
+ * Reads `phrase` against `now`. `now` is a parameter rather than a call to the
+ * clock so the same phrase always gives the same answer in a story and a test.
+ */
+export function parseEventPhrase(phrase: string, now: Date): PhraseParse {
+	let rest = ` ${phrase} `;
+	const unresolved: string[] = [];
+	const assumptions: string[] = [];
+
+	let durationMinutes = 0;
+	let durationText = "";
+	const duration = rest.match(DURATION_RE);
+	if (duration) {
+		durationMinutes = minutesFrom(
+			Number(duration[1].replace(",", ".")),
+			duration[2],
+		);
+		durationText = duration[0].trim();
+		rest = cut(rest, duration);
+	}
+
+	let startTime = "";
+	let startTimeText = "";
+	const named = rest.match(NOON_RE);
+	const clock = rest.match(CLOCK_RE);
+	if (named) {
+		const word = named[1].toLowerCase();
+		startTime = word === "midnight" ? "00:00" : "12:00";
+		startTimeText = named[0].trim();
+		rest = cut(rest, named);
+	} else if (clock) {
+		startTime = readClock(clock);
+		startTimeText = clock[0].trim();
+		rest = cut(rest, clock);
+	}
+
+	let date = "";
+	let dateText = "";
+	const relative = rest.match(RELATIVE_DAY_RE);
+	const nextWeekday = rest.match(NEXT_WEEKDAY_RE);
+	const weekday = rest.match(WEEKDAY_RE);
+	if (relative) {
+		const word = relative[1].toLowerCase();
+		date = isoDate(word === "tomorrow" ? addDays(now, 1) : now);
+		dateText = relative[0].trim();
+		rest = cut(rest, relative);
+	} else if (nextWeekday) {
+		date = isoDate(
+			addDays(comingWeekday(now, WEEKDAYS[nextWeekday[1].toLowerCase()]), 7),
+		);
+		dateText = nextWeekday[0].trim();
+		rest = cut(rest, nextWeekday);
+	} else if (weekday) {
+		date = isoDate(comingWeekday(now, WEEKDAYS[weekday[1].toLowerCase()]));
+		dateText = weekday[0].trim();
+		rest = cut(rest, weekday);
+	}
+
+	let attendees: string[] = [];
+	let attendeesText = "";
+	const guests = tidy(rest).match(WITH_RE);
+	if (guests) {
+		attendees = splitNames(guests[1]);
+		attendeesText = guests[0].trim();
+		rest = tidy(rest).slice(0, guests.index ?? 0);
+	}
+
+	const title = tidy(rest);
+
+	if (title === "") unresolved.push("No title yet");
+	if (date === "") {
+		date = isoDate(now);
+		assumptions.push("No day given — using today");
+	}
+	if (startTime === "") {
+		unresolved.push("No time given");
+	} else if (durationMinutes === 0) {
+		durationMinutes = 60;
+		assumptions.push("No length given — using an hour");
+	}
+
+	return {
+		title,
+		date,
+		dateText,
+		startTime,
+		startTimeText,
+		durationMinutes,
+		durationText,
+		attendees,
+		attendeesText,
+		unresolved,
+		assumptions,
+	};
+}
+
+/** `13:00` + 90 → `14:30`. Empty in, empty out. */
+export function addMinutesToClock(clock: string, minutes: number): string {
+	if (clock === "") return "";
+	const [hours, mins] = clock.split(":").map(Number);
+	const total = (hours * 60 + mins + minutes) % 1440;
+	return `${pad(Math.floor(total / 60))}:${pad(total % 60)}`;
+}

package/src/lib/recurrence.test.ts

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	type CustomRecurrence,
+	dayOfMonthLabel,
+	defaultCustomRecurrence,
+	defaultEndDate,
+	formatCustomRecurrence,
+	ordinalWeekdayLabel,
+	readCustomRecurrence,
+	repeatChoices,
+} from "./recurrence.js";
+
+/** Thursday 11 June 2026. */
+const DATE = "2026-06-11";
+
+const rule = (patch: Partial<CustomRecurrence> = {}): CustomRecurrence => ({
+	...defaultCustomRecurrence(DATE),
+	...patch,
+});
+
+describe("repeatChoices", () => {
+	it("derives the monthly choice from the date's own weekday", () => {
+		assert.ok(
+			repeatChoices(DATE, "").includes("Every month on the second Thursday"),
+		);
+	});
+
+	it("appends the hour when there is one", () => {
+		assert.ok(repeatChoices(DATE, "09:15").includes("Every day, 09:15"));
+	});
+
+	it("offers weekdays only when the date is one", () => {
+		assert.ok(!repeatChoices("2026-06-13", "").includes("Every weekday"));
+	});
+});
+
+describe("defaultCustomRecurrence", () => {
+	it("starts on the event's own weekday", () => {
+		assert.deepEqual(defaultCustomRecurrence(DATE).weekdays, [4]);
+	});
+
+	it("survives a date it cannot read", () => {
+		assert.deepEqual(defaultCustomRecurrence("").weekdays, []);
+	});
+});
+
+describe("formatCustomRecurrence", () => {
+	it("reads a rule in words, never as an RRULE", () => {
+		const text = formatCustomRecurrence(
+			rule({
+				interval: 2,
+				weekdays: [1, 4],
+				ends: { kind: "onDate", date: "2026-10-03" },
+			}),
+			DATE,
+			"",
+		);
+		assert.equal(text, "Every 2 weeks on Monday and Thursday, until 3 October");
+	});
+
+	it("drops the interval when it is one", () => {
+		assert.equal(
+			formatCustomRecurrence(rule({ weekdays: [4] }), DATE, ""),
+			"Every week on Thursday",
+		);
+	});
+
+	it("counts an ending that is counted", () => {
+		assert.equal(
+			formatCustomRecurrence(
+				rule({ unit: "day", ends: { kind: "afterCount", count: 13 } }),
+				DATE,
+				"",
+			),
+			"Every day, 13 times",
+		);
+	});
+
+	it("says which of the two monthly readings is meant", () => {
+		assert.equal(
+			formatCustomRecurrence(rule({ unit: "month" }), DATE, ""),
+			"Every month on day 11",
+		);
+		assert.equal(
+			formatCustomRecurrence(
+				rule({ unit: "month", monthlyMode: "weekdayOfMonth" }),
+				DATE,
+				"",
+			),
+			"Every month on the second Thursday",
+		);
+	});
+
+	it("carries the hour", () => {
+		assert.equal(
+			formatCustomRecurrence(rule({ unit: "year" }), DATE, "09:15"),
+			"Every year on 11 June, 09:15",
+		);
+	});
+});
+
+describe("readCustomRecurrence", () => {
+	for (const seed of [
+		rule({ interval: 2, weekdays: [1, 4] }),
+		rule({ interval: 3, unit: "day" }),
+		rule({ unit: "month", monthlyMode: "weekdayOfMonth" }),
+		rule({ unit: "year" }),
+		rule({ weekdays: [0, 2, 6], ends: { kind: "afterCount", count: 13 } }),
+		rule({ ends: { kind: "onDate", date: "2026-10-03" } }),
+	])
+		it(`reopens on "${formatCustomRecurrence(seed, DATE, "")}"`, () => {
+			const text = formatCustomRecurrence(seed, DATE, "09:15");
+			const read = readCustomRecurrence(text, DATE);
+			assert.ok(read);
+			assert.equal(formatCustomRecurrence(read, DATE, "09:15"), text);
+		});
+
+	it("declines a sentence it did not write", () => {
+		assert.equal(readCustomRecurrence("Every weekday, 09:15", DATE), undefined);
+		assert.equal(
+			readCustomRecurrence("whenever Jane is free", DATE),
+			undefined,
+		);
+		assert.equal(
+			readCustomRecurrence("Every week on Blursday", DATE),
+			undefined,
+		);
+	});
+});
+
+describe("labels", () => {
+	it("offers an end date a year out", () => {
+		assert.equal(defaultEndDate(DATE), "2027-06-11");
+	});
+
+	it("names the two readings of the same day", () => {
+		assert.equal(dayOfMonthLabel(DATE), "day 11");
+		assert.equal(ordinalWeekdayLabel(DATE), "the second Thursday");
+	});
+});