@remit/web-client 0.0.325 → 0.0.327

package/src/hooks/calendar/instance.ts

@@ -1,224 +0,0 @@
-/**
- * The API's shapes, as the calendar kit draws them.
- *
- * One place does the translating, so the grid, the strip and the reading pane
- * cannot disagree about what an occurrence is. Nothing here expands a
- * recurrence: the server returns instances, and this reads them.
- */
-import type {
-	RemitImapCalendarEventInstance,
-	RemitImapCalendarResponse,
-} from "@remit/api-http-client/types.gen.ts";
-import type {
-	CalendarColorId,
-	CalendarDescriptor,
-	CalendarEventData,
-	ZoneCertainty,
-} from "@remit/ui";
-import { isoOnClock } from "./window";
-
-/** The device's own clock, the only zone a browser can honestly draw in. */
-export const deviceTimeZone = (): string =>
-	Intl.DateTimeFormat().resolvedOptions().timeZone;
-
-/** A collection that names no zone of its own, spelled the way the API spells it. */
-export const UNZONED_CALENDAR = "";
-
-/**
- * The zone a write anchors an event in: the collection's, or where it names
- * none, the device's — a weekly 09:00 written from New York into an unzoned
- * calendar would otherwise be stored in UTC and meet at 10:00 once the clocks
- * change. UTC itself has no name the server takes as a TZID, so a device on it
- * sends nothing, which the server reads as UTC.
- */
-export function anchorZoneFor(collectionZone: string): string {
-	if (collectionZone !== UNZONED_CALENDAR) return collectionZone;
-	const device = deviceTimeZone();
-	return Intl.supportedValuesOf("timeZone").includes(device)
-		? device
-		: UNZONED_CALENDAR;
-}
-
-const COLORS: Record<string, CalendarColorId> = {
-	Cal1: "cal-1",
-	Cal2: "cal-2",
-	Cal3: "cal-3",
-	Cal4: "cal-4",
-	Cal5: "cal-5",
-	Cal6: "cal-6",
-};
-
-const ZONES: Record<string, ZoneCertainty> = {
-	Local: "local",
-	Explicit: "explicit",
-	Ambiguous: "ambiguous",
-};
-
-/**
- * The address of one occurrence, as a single string, because the grid selects
- * an event by one id. A series draws many occurrences from one resource, so the
- * resource id alone would key every Monday standup the same and select all of
- * them at once.
- */
-const OCCURRENCE_SEPARATOR = "#";
-
-export function calendarInstanceId(
-	calendarObjectId: string,
-	recurrenceId: string,
-): string {
-	return recurrenceId === ""
-		? calendarObjectId
-		: `${calendarObjectId}${OCCURRENCE_SEPARATOR}${recurrenceId}`;
-}
-
-export interface CalendarInstanceRef {
-	calendarObjectId: string;
-	/** `""` on a resource that does not recur. */
-	recurrenceId: string;
-}
-
-export function readCalendarInstanceId(id: string): CalendarInstanceRef {
-	const cut = id.indexOf(OCCURRENCE_SEPARATOR);
-	if (cut === -1) return { calendarObjectId: id, recurrenceId: "" };
-	return {
-		calendarObjectId: id.slice(0, cut),
-		recurrenceId: id.slice(cut + 1),
-	};
-}
-
-const nextOrFirst = (
-	events: readonly CalendarEventData[],
-	now: string,
-): CalendarEventData | undefined => {
-	const ordered = [...events].sort(
-		(a, b) => Date.parse(a.start) - Date.parse(b.start),
-	);
-	return (
-		ordered.find((event) => Date.parse(event.end) > Date.parse(now)) ??
-		ordered[0]
-	);
-};
-
-/**
- * The occurrence a series opens at when the address names only the series: the
- * next one still to finish, or the first in the window where none is left.
- */
-export function seriesOccurrenceOf(
-	events: readonly CalendarEventData[],
-	calendarObjectId: string,
-	now: string,
-): CalendarInstanceRef | undefined {
-	const picked = nextOrFirst(
-		events.filter((event) => {
-			const ref = readCalendarInstanceId(event.id);
-			return (
-				ref.calendarObjectId === calendarObjectId && ref.recurrenceId !== ""
-			);
-		}),
-		now,
-	);
-	return picked ? readCalendarInstanceId(picked.id) : undefined;
-}
-
-export interface CalendarJump extends CalendarInstanceRef {
-	calendarId: string;
-	/** On the clock the calendar is drawn in. */
-	date: string;
-}
-
-/**
- * Where a view has to move to show an event it does not hold: the day of its
- * next occurrence still to finish, or of its first where none is left.
- */
-export function calendarJumpOf(
-	instances: readonly RemitImapCalendarEventInstance[],
-	calendarObjectId: string,
-	now: string,
-	clockZone: string,
-): CalendarJump | undefined {
-	const picked = nextOrFirst(
-		instances
-			.filter(
-				(instance) =>
-					instance.calendarObjectId === calendarObjectId &&
-					isDrawnInstance(instance),
-			)
-			.map((instance) => toCalendarEventData(instance, "", clockZone)),
-		now,
-	);
-	if (!picked) return undefined;
-	return {
-		...readCalendarInstanceId(picked.id),
-		calendarId: picked.calendarId,
-		date: picked.start.slice(0, 10),
-	};
-}
-
-export function toCalendarDescriptor(
-	calendar: RemitImapCalendarResponse,
-): CalendarDescriptor {
-	return {
-		id: calendar.calendarId,
-		accountId: calendar.accountConfigId,
-		accountLabel: "",
-		name: calendar.displayName,
-		color: COLORS[calendar.color] ?? "cal-1",
-		...(calendar.source === "Subscribed"
-			? {
-					readOnly: true,
-					sync: calendar.subscriptionEnabled ? "live" : "paused",
-					syncError: calendar.subscriptionError,
-				}
-			: {}),
-	};
-}
-
-/**
- * One occurrence, drawn. `location`, `notes` and the guest list are projections
- * the listing does not carry — the reading pane fetches the resource itself for
- * those, and a grid chip has no room for them anyway.
- *
- * A timed occurrence is re-read on `clockZone`, the clock every surface draws
- * on. An all-day one is a civil date and keeps only its date: midnight with an
- * offset is an instant, and a device west of it reads that instant as the day
- * before.
- */
-export function toCalendarEventData(
-	instance: RemitImapCalendarEventInstance,
-	timeZone: string,
-	clockZone: string,
-): CalendarEventData {
-	return {
-		id: calendarInstanceId(instance.calendarObjectId, instance.recurrenceId),
-		calendarId: instance.calendarId,
-		title: instance.summary,
-		start: instance.allDay
-			? instance.start.slice(0, 10)
-			: isoOnClock(instance.start, clockZone),
-		end: instance.allDay
-			? instance.end.slice(0, 10)
-			: isoOnClock(instance.end, clockZone),
-		allDay: instance.allDay,
-		location: "",
-		notes: "",
-		attendees: [],
-		myRsvp: "accepted",
-		threadId: "",
-		threadSubject: "",
-		timeZone,
-		zoneCertainty: ZONES[instance.zoneCertainty] ?? "explicit",
-		recurrenceRule: instance.hasRecurrence ? "Repeats" : "",
-		seriesId: instance.hasRecurrence ? instance.icalUid : "",
-		seriesException: false,
-		status: instance.status === "Tentative" ? "tentative" : "confirmed",
-	};
-}
-
-/**
- * A cancelled occurrence is not a lighter shade of confirmed, and the kit has
- * no third state to draw it in, so it is left off the calendar entirely rather
- * than shown as an event that is still happening.
- */
-export const isDrawnInstance = (
-	instance: RemitImapCalendarEventInstance,
-): boolean => instance.status !== "Cancelled";

package/src/hooks/calendar/recurrence-rule.test.ts

@@ -1,134 +0,0 @@
-/**
- * Repeat rules, both ways.
- *
- * The picker only ever offers the sentences `repeatChoices` derives, so the
- * table has to cover exactly those and refuse everything else — a sentence
- * turned into a rule it does not mean is an event that repeats on days nobody
- * chose, and nothing on screen would say so.
- *
- * A rule written by something else — a native client, an invitation — must come
- * back unread rather than snapped to the nearest sentence.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { repeatChoices } from "@remit/ui";
-import { moveRule, rruleFromText, textFromRrule } from "./recurrence-rule";
-
-const DATE = "2026-06-10";
-const TIME = "09:15";
-
-describe("every rule the picker offers", () => {
-	it("becomes an RRULE, and reads back as the sentence it was picked from", () => {
-		for (const choice of repeatChoices(DATE, TIME)) {
-			const rule = rruleFromText(choice);
-			assert.ok(
-				rule !== undefined && rule !== "",
-				`no rule for the offered choice "${choice}"`,
-			);
-			assert.equal(textFromRrule(rule, TIME), choice);
-		}
-	});
-
-	it("says what each one means", () => {
-		assert.equal(rruleFromText("Every day, 09:15"), "FREQ=DAILY");
-		assert.equal(
-			rruleFromText("Every weekday, 09:15"),
-			"FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
-		);
-		assert.equal(
-			rruleFromText("Every week on Wednesday, 09:15"),
-			"FREQ=WEEKLY;BYDAY=WE",
-		);
-		assert.equal(
-			rruleFromText("Every month on the second Wednesday, 09:15"),
-			"FREQ=MONTHLY;BYDAY=2WE",
-		);
-		assert.equal(
-			rruleFromText("Every year on 10 June, 09:15"),
-			"FREQ=YEARLY;BYMONTH=6;BYMONTHDAY=10",
-		);
-	});
-
-	it("reads the last week of a month as the rule that means it", () => {
-		assert.equal(
-			rruleFromText("Every month on the last Friday"),
-			"FREQ=MONTHLY;BYDAY=-1FR",
-		);
-		assert.equal(
-			textFromRrule("FREQ=MONTHLY;BYDAY=-1FR", ""),
-			"Every month on the last Friday",
-		);
-	});
-});
-
-describe("no repeat", () => {
-	it("is the empty rule rather than a refusal", () => {
-		assert.equal(rruleFromText(""), "");
-	});
-});
-
-describe("a sentence this table does not cover", () => {
-	it("is refused rather than guessed at", () => {
-		assert.equal(rruleFromText("Every other Tuesday"), undefined);
-		assert.equal(rruleFromText("Every week on Caturday"), undefined);
-		assert.equal(rruleFromText("Repeats"), undefined);
-	});
-});
-
-describe("a rule written by something else", () => {
-	it("comes back unread rather than snapped to the nearest sentence", () => {
-		assert.equal(
-			textFromRrule("FREQ=WEEKLY;INTERVAL=2;BYDAY=TU", ""),
-			undefined,
-		);
-		assert.equal(textFromRrule("FREQ=DAILY;COUNT=10", ""), undefined);
-		assert.equal(
-			textFromRrule("FREQ=DAILY;UNTIL=20261231T000000Z", ""),
-			undefined,
-		);
-		assert.equal(textFromRrule("FREQ=HOURLY", ""), undefined);
-		assert.equal(textFromRrule("FREQ=WEEKLY", ""), undefined);
-	});
-});
-
-describe("a rule moved onto the day the event's own zone shows", () => {
-	it("shifts the weekdays of a weekly rule with the day", () => {
-		assert.equal(
-			moveRule("FREQ=WEEKLY;BYDAY=SU", "2026-06-14", "2026-06-15"),
-			"FREQ=WEEKLY;BYDAY=MO",
-		);
-		assert.equal(
-			moveRule("FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR", "2026-06-15", "2026-06-14"),
-			"FREQ=WEEKLY;BYDAY=SU,MO,TU,WE,TH",
-		);
-	});
-
-	it("reads a monthly position off the new date rather than shifting it", () => {
-		assert.equal(
-			moveRule("FREQ=MONTHLY;BYDAY=2WE", "2026-06-10", "2026-06-11"),
-			"FREQ=MONTHLY;BYDAY=2TH",
-		);
-		assert.equal(
-			moveRule("FREQ=MONTHLY;BYDAY=2WE", "2026-07-14", "2026-07-15"),
-			"FREQ=MONTHLY;BYDAY=3WE",
-		);
-	});
-
-	it("moves a yearly date, month and all", () => {
-		assert.equal(
-			moveRule(
-				"FREQ=YEARLY;BYMONTH=5;BYMONTHDAY=31",
-				"2026-05-31",
-				"2026-06-01",
-			),
-			"FREQ=YEARLY;BYMONTH=6;BYMONTHDAY=1",
-		);
-	});
-
-	it("leaves a rule alone on the same day", () => {
-		assert.equal(
-			moveRule("FREQ=WEEKLY;BYDAY=SU", "2026-06-14", "2026-06-14"),
-			"FREQ=WEEKLY;BYDAY=SU",
-		);
-	});
-});

package/src/hooks/calendar/recurrence-rule.ts

@@ -1,177 +0,0 @@
-/**
- * Repeat rules, between the sentence a person picks and the RRULE the API
- * stores.
- *
- * The kit's picker deals only in sentences — "Every weekday, 09:15" — and the
- * calendar API deals only in RFC 5545 rules. This is the single table read both
- * ways, so a rule this client wrote reads back as the sentence it was picked
- * from. A rule written by anything else, a native client or an invitation, is
- * not forced into one of these sentences: it comes back unread, and the surface
- * says the event repeats without claiming to know how.
- */
-
-const WEEKDAYS = [
-	"Sunday",
-	"Monday",
-	"Tuesday",
-	"Wednesday",
-	"Thursday",
-	"Friday",
-	"Saturday",
-];
-
-const BYDAY = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
-
-const MONTHS = [
-	"January",
-	"February",
-	"March",
-	"April",
-	"May",
-	"June",
-	"July",
-	"August",
-	"September",
-	"October",
-	"November",
-	"December",
-];
-
-const ORDINALS = ["first", "second", "third", "fourth", "last"];
-
-const ORDINAL_NUMBERS = [1, 2, 3, 4, -1];
-
-const WEEKDAY_SET = "MO,TU,WE,TH,FR";
-
-/** The clock the picker appends, stripped so the rule itself can be read. */
-const withoutClock = (text: string): string =>
-	text.replace(/,\s*\d{2}:\d{2}$/, "").trim();
-
-/**
- * The RRULE a picked sentence means, or `undefined` for a sentence this table
- * does not cover. A caller refuses the write rather than storing a rule it
- * guessed at.
- */
-export function rruleFromText(text: string): string | undefined {
-	const rule = withoutClock(text);
-	if (rule === "") return "";
-	if (rule === "Every day") return "FREQ=DAILY";
-	if (rule === "Every weekday") return `FREQ=WEEKLY;BYDAY=${WEEKDAY_SET}`;
-
-	const weekly = rule.match(/^Every week on (\w+)$/);
-	if (weekly) {
-		const day = WEEKDAYS.indexOf(weekly[1]);
-		return day === -1 ? undefined : `FREQ=WEEKLY;BYDAY=${BYDAY[day]}`;
-	}
-
-	const monthly = rule.match(/^Every month on the (\w+) (\w+)$/);
-	if (monthly) {
-		const ordinal = ORDINALS.indexOf(monthly[1]);
-		const day = WEEKDAYS.indexOf(monthly[2]);
-		if (ordinal === -1 || day === -1) return undefined;
-		return `FREQ=MONTHLY;BYDAY=${ORDINAL_NUMBERS[ordinal]}${BYDAY[day]}`;
-	}
-
-	const yearly = rule.match(/^Every year on (\d{1,2}) (\w+)$/);
-	if (yearly) {
-		const month = MONTHS.indexOf(yearly[2]);
-		if (month === -1) return undefined;
-		return `FREQ=YEARLY;BYMONTH=${month + 1};BYMONTHDAY=${Number(yearly[1])}`;
-	}
-
-	return undefined;
-}
-
-const clockSuffix = (startTime: string): string =>
-	startTime === "" ? "" : `, ${startTime}`;
-
-/** The sentence an RRULE was picked from, or `undefined` where it was not. */
-export function textFromRrule(
-	rule: string,
-	startTime: string,
-): string | undefined {
-	const parts = new Map(
-		rule
-			.split(";")
-			.map((part) => part.split("="))
-			.filter((pair): pair is [string, string] => pair.length === 2)
-			.map(([name, value]) => [name.toUpperCase(), value.toUpperCase()]),
-	);
-	const clock = clockSuffix(startTime);
-	const frequency = parts.get("FREQ");
-	const byDay = parts.get("BYDAY");
-
-	if (parts.has("INTERVAL") && parts.get("INTERVAL") !== "1") return undefined;
-	if (parts.has("UNTIL") || parts.has("COUNT")) return undefined;
-
-	if (frequency === "DAILY") return `Every day${clock}`;
-
-	if (frequency === "WEEKLY") {
-		if (byDay === undefined) return undefined;
-		if (byDay === WEEKDAY_SET) return `Every weekday${clock}`;
-		const day = BYDAY.indexOf(byDay);
-		return day === -1 ? undefined : `Every week on ${WEEKDAYS[day]}${clock}`;
-	}
-
-	if (frequency === "MONTHLY") {
-		const match = byDay?.match(/^(-?\d)([A-Z]{2})$/);
-		if (!match) return undefined;
-		const ordinal = ORDINAL_NUMBERS.indexOf(Number(match[1]));
-		const day = BYDAY.indexOf(match[2]);
-		if (ordinal === -1 || day === -1) return undefined;
-		return `Every month on the ${ORDINALS[ordinal]} ${WEEKDAYS[day]}${clock}`;
-	}
-
-	if (frequency === "YEARLY") {
-		const month = Number(parts.get("BYMONTH"));
-		const day = Number(parts.get("BYMONTHDAY"));
-		if (!month || !day || month > 12) return undefined;
-		return `Every year on ${day} ${MONTHS[month - 1]}${clock}`;
-	}
-
-	return undefined;
-}
-
-const dayNumber = (date: string): number =>
-	Date.parse(`${date}T00:00:00Z`) / 86_400_000;
-
-/**
- * A rule picked on one civil date, rewritten for the same moment read on
- * another. The picker offers rules off the day the device shows, and the
- * server expands them on the day the event's own zone shows; 21:00 on a New
- * York Sunday is a Tokyo Monday, so "every Sunday" has to be stored as BYDAY=MO
- * or the series lands on Saturday evenings. Weekdays shift with the day; a
- * monthly or yearly position is read off the new date itself, because the day
- * after the second Wednesday is not always the second Thursday.
- */
-export function moveRule(
-	rule: string,
-	fromDate: string,
-	toDate: string,
-): string {
-	const shift = dayNumber(toDate) - dayNumber(fromDate);
-	if (rule === "" || shift === 0 || Number.isNaN(shift)) return rule;
-	const [year, month, dayOfMonth] = toDate.split("-").map(Number);
-	const weekday = new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay();
-	const frequency = /FREQ=(\w+)/i.exec(rule)?.[1]?.toUpperCase();
-	return rule
-		.split(";")
-		.map((part) => {
-			const [name, value = ""] = part.split("=");
-			const key = name.toUpperCase();
-			if (key === "BYDAY" && frequency === "MONTHLY")
-				return `BYDAY=${ORDINAL_NUMBERS[Math.min(Math.floor((dayOfMonth - 1) / 7), 4)]}${BYDAY[weekday]}`;
-			if (key === "BYDAY")
-				return `BYDAY=${value
-					.split(",")
-					.map((code) => {
-						const index = BYDAY.indexOf(code.toUpperCase());
-						return index === -1 ? code : BYDAY[(index + shift + 7) % 7];
-					})
-					.join(",")}`;
-			if (key === "BYMONTH") return `BYMONTH=${month}`;
-			if (key === "BYMONTHDAY") return `BYMONTHDAY=${dayOfMonth}`;
-			return part;
-		})
-		.join(";");
-}

package/src/hooks/calendar/resource.test.ts

@@ -1,141 +0,0 @@
-/**
- * Reading three properties off a stored resource.
- *
- * RFC 5545 folds a long line by breaking it and indenting the remainder, so a
- * value read line-first stops halfway and looks like a shorter value rather
- * than a broken one — a rule truncated that way turns a weekly meeting into a
- * daily one on screen with nothing to say it happened.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	rruleFromIcalData,
-	storedAnchorZone,
-	textFromIcalData,
-} from "./resource";
-
-const ics = (...lines: string[]): string =>
-	[
-		"BEGIN:VCALENDAR",
-		"BEGIN:VEVENT",
-		...lines,
-		"END:VEVENT",
-		"END:VCALENDAR",
-	].join("\r\n");
-
-describe("the rule inside a resource", () => {
-	it("is read whole across a fold", () => {
-		assert.equal(
-			rruleFromIcalData(ics("RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,", " TH,FR")),
-			"FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
-		);
-	});
-
-	it("is empty where the event does not repeat", () => {
-		assert.equal(rruleFromIcalData(ics("SUMMARY:Roadmap review")), "");
-	});
-});
-
-describe("the text a listing does not carry", () => {
-	it("comes back unescaped", () => {
-		const text = textFromIcalData(
-			ics(
-				"LOCATION:Room Zuid\\, second floor",
-				"DESCRIPTION:Bring the numbers.\\nAnd the slides.",
-			),
-		);
-		assert.equal(text.location, "Room Zuid, second floor");
-		assert.equal(text.description, "Bring the numbers.\nAnd the slides.");
-	});
-
-	it("reads a property that carries parameters", () => {
-		assert.equal(
-			textFromIcalData(ics("DESCRIPTION;LANGUAGE=en:Plain text")).description,
-			"Plain text",
-		);
-	});
-
-	/**
-	 * A parameter value may be quoted precisely so it can hold a colon, which is
-	 * what a URI does. Splitting the line on its first colon hands back the tail
-	 * of that URI as though it were the property's own value.
-	 */
-	it("reads past a colon inside a quoted parameter", () => {
-		assert.equal(
-			textFromIcalData(ics('DESCRIPTION;ALTREP="cid:part1.0":Plain text'))
-				.description,
-			"Plain text",
-		);
-		assert.equal(
-			textFromIcalData(
-				ics('LOCATION;X-ADDRESS="https://maps.example/x:1":Room Zuid'),
-			).location,
-			"Room Zuid",
-		);
-	});
-
-	it("does not answer for a property whose name merely starts the same", () => {
-		assert.equal(textFromIcalData(ics("LOCATION-TYPE:room")).location, "");
-	});
-
-	it("takes the master's value rather than an override's", () => {
-		const overridden = [
-			"BEGIN:VCALENDAR",
-			"BEGIN:VEVENT",
-			"LOCATION:Room Zuid",
-			"END:VEVENT",
-			"BEGIN:VEVENT",
-			"RECURRENCE-ID:20260610T090000Z",
-			"LOCATION:Room Noord",
-			"END:VEVENT",
-			"END:VCALENDAR",
-		].join("\r\n");
-		assert.equal(textFromIcalData(overridden).location, "Room Zuid");
-	});
-
-	it("is empty where the resource says nothing", () => {
-		assert.deepEqual(textFromIcalData(ics("SUMMARY:Standup")), {
-			location: "",
-			description: "",
-		});
-	});
-});
-
-describe("the zone an edit writes an event back in", () => {
-	const vevent = (dtstart: string): string =>
-		`BEGIN:VEVENT\r\n${dtstart}\r\nEND:VEVENT`;
-
-	it("is the TZID the stored start names", () => {
-		assert.equal(
-			storedAnchorZone(
-				vevent("DTSTART;TZID=Asia/Tokyo:20340222T080000"),
-				"Europe/Amsterdam",
-			),
-			"Asia/Tokyo",
-		);
-	});
-
-	it("is UTC for a start stored as a UTC instant, whatever the calendar says", () => {
-		assert.equal(
-			storedAnchorZone(vevent("DTSTART:20260615T010000Z"), "Europe/Amsterdam"),
-			"",
-		);
-	});
-
-	it("is the calendar's zone for a floating start", () => {
-		assert.equal(
-			storedAnchorZone(vevent("DTSTART:20260615T010000"), "Europe/Amsterdam"),
-			"Europe/Amsterdam",
-		);
-	});
-
-	it("is the calendar's zone for a TZID nothing can resolve", () => {
-		assert.equal(
-			storedAnchorZone(
-				vevent("DTSTART;TZID=W. Europe Standard Time:20260615T010000"),
-				"Europe/Amsterdam",
-			),
-			"Europe/Amsterdam",
-		);
-	});
-});