donebear 0.3.6 → 0.3.7

package/dist/cli.mjs

@@ -14,10 +14,12 @@ import { styleText } from "node:util";
 import jmespath from "jmespath";
 import { stringify } from "yaml";
 import { createServer } from "node:http";
-import rrule from "rrule";
 import { fileURLToPath } from "node:url";
 import Database from "better-sqlite3";
 import { createInterface } from "node:readline";
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+//#endregion
 //#region src/jwt.ts
 const parseJwtBase64Url = (input) => {
 	const normalized = input.replaceAll("-", "+").replaceAll("_", "/");
@@ -415,6 +417,118 @@ const parseCliDateOnlyToEpoch = (value, fieldLabel) => {
 };
 const dateOnlyEpochFromLocalDate = (now = /* @__PURE__ */ new Date()) => Date.UTC(now.getFullYear(), now.getMonth(), now.getDate());
 //#endregion
+//#region src/output.ts
+const writeLine = (stream, message) => {
+	stream.write(`${message}\n`);
+};
+const colorize = (context, format, message) => {
+	if (!context.color) return message;
+	return styleText(format, message);
+};
+const writeJson = (value) => {
+	writeLine(process.stdout, JSON.stringify(value, null, 2));
+};
+const writeYaml = (value) => {
+	process.stdout.write(stringify(value));
+};
+const writeInfo = (context, message) => {
+	writeLine(process.stdout, colorize(context, "cyan", message));
+};
+const writeSuccess = (context, message) => {
+	writeLine(process.stdout, colorize(context, "green", message));
+};
+const writeWarning = (context, message) => {
+	writeLine(process.stderr, colorize(context, "yellow", message));
+};
+const writeError = (context, message) => {
+	writeLine(process.stderr, colorize(context, "red", message));
+};
+const writeDebug = (context, message) => {
+	if (!context.debug) return;
+	writeLine(process.stderr, colorize(context, "gray", `[debug] ${message}`));
+};
+const writeTotal = (context, count) => {
+	writeLine(process.stdout, colorize(context, "cyan", String(count)));
+};
+const escapeCsvField = (value) => {
+	if (value.includes(",") || value.includes("\"") || value.includes("\n")) return `"${value.replaceAll("\"", "\"\"")}"`;
+	return value;
+};
+const writeCsv = (headers, rows) => {
+	writeLine(process.stdout, headers.map(escapeCsvField).join(","));
+	for (const row of rows) writeLine(process.stdout, row.map(escapeCsvField).join(","));
+};
+const writeTsv = (headers, rows) => {
+	writeLine(process.stdout, headers.join("	"));
+	for (const row of rows) writeLine(process.stdout, row.join("	"));
+};
+/**
+* Write structured data to stdout, applying --jq filter and --limit if set.
+* Use this for all JSON/YAML/structured output from commands.
+*/
+const writeOutput = (context, data) => {
+	let result = data;
+	if (context.jq) try {
+		result = jmespath.search(result, context.jq);
+	} catch (error) {
+		throw new CliError(`Invalid --jq expression: ${error instanceof Error ? error.message : String(error)}`, EXIT_CODES.VALIDATION);
+	}
+	if (context.limit !== null && Array.isArray(result)) result = result.slice(0, context.limit);
+	switch (context.format) {
+		case "yaml":
+			writeYaml(result);
+			break;
+		case "json":
+			writeJson(result);
+			break;
+		default:
+			writeJson(result);
+			break;
+	}
+	if (context.copy) copyToClipboard(JSON.stringify(result, null, 2));
+};
+/**
+* Handles --total, --format csv, --format tsv, --format yaml output.
+* Returns true if the format was handled; caller renders text mode if false.
+*/
+const writeFormattedRows = (context, totalCount, headers, rows) => {
+	if (context.total) {
+		writeTotal(context, totalCount);
+		return true;
+	}
+	if (context.format === "yaml") {
+		const objects = rows.map((row) => Object.fromEntries(headers.map((h, i) => [h, row[i]])));
+		writeYaml(objects);
+		if (context.copy) copyToClipboard(stringify(objects));
+		return true;
+	}
+	if (context.format === "csv") {
+		writeCsv(headers, rows);
+		if (context.copy) copyToClipboard([headers.join(","), ...rows.map((r) => r.join(","))].join("\n"));
+		return true;
+	}
+	if (context.format === "tsv") {
+		writeTsv(headers, rows);
+		if (context.copy) copyToClipboard([headers.join("	"), ...rows.map((r) => r.join("	"))].join("\n"));
+		return true;
+	}
+	return false;
+};
+const copyToClipboard = (text) => {
+	try {
+		if (process.platform === "darwin") execSync("pbcopy", { input: text });
+		else if (process.platform === "win32") execSync("clip", { input: text });
+		else try {
+			execSync("xclip -selection clipboard", { input: text });
+		} catch {
+			execSync("xsel --clipboard --input", { input: text });
+		}
+		return true;
+	} catch {
+		return false;
+	}
+};
+//#endregion
 //#region src/manage-api.ts
 const TASK_FIELDS = `
   id
@@ -910,6 +1024,19 @@ const loadChecklistItemsByTask = async (context, options) => {
 	return results;
 };
 const mutateModel = async (context, options) => {
+	if (context.dryRun) {
+		writeWarning(context, "dry run: mutation skipped");
+		writeOutput(context, {
+			dryRun: true,
+			transactions: options.request.transactions.map((tx) => ({
+				action: tx.action,
+				modelId: tx.modelId,
+				modelName: tx.modelName,
+				payload: tx.payload
+			}))
+		});
+		return;
+	}
 	const response = await requestJson(context, `${options.baseUrl}/sync/mutate`, {
 		body: options.request,
 		method: "POST",
@@ -1019,118 +1146,6 @@ const requireUserId = (resolvedToken) => {
 	return userId;
 };
 //#endregion
-//#region src/output.ts
-const writeLine = (stream, message) => {
-	stream.write(`${message}\n`);
-};
-const colorize = (context, format, message) => {
-	if (!context.color) return message;
-	return styleText(format, message);
-};
-const writeJson = (value) => {
-	writeLine(process.stdout, JSON.stringify(value, null, 2));
-};
-const writeYaml = (value) => {
-	process.stdout.write(stringify(value));
-};
-const writeInfo = (context, message) => {
-	writeLine(process.stdout, colorize(context, "cyan", message));
-};
-const writeSuccess = (context, message) => {
-	writeLine(process.stdout, colorize(context, "green", message));
-};
-const writeWarning = (context, message) => {
-	writeLine(process.stderr, colorize(context, "yellow", message));
-};
-const writeError = (context, message) => {
-	writeLine(process.stderr, colorize(context, "red", message));
-};
-const writeDebug = (context, message) => {
-	if (!context.debug) return;
-	writeLine(process.stderr, colorize(context, "gray", `[debug] ${message}`));
-};
-const writeTotal = (context, count) => {
-	writeLine(process.stdout, colorize(context, "cyan", String(count)));
-};
-const escapeCsvField = (value) => {
-	if (value.includes(",") || value.includes("\"") || value.includes("\n")) return `"${value.replaceAll("\"", "\"\"")}"`;
-	return value;
-};
-const writeCsv = (headers, rows) => {
-	writeLine(process.stdout, headers.map(escapeCsvField).join(","));
-	for (const row of rows) writeLine(process.stdout, row.map(escapeCsvField).join(","));
-};
-const writeTsv = (headers, rows) => {
-	writeLine(process.stdout, headers.join("	"));
-	for (const row of rows) writeLine(process.stdout, row.join("	"));
-};
-/**
-* Write structured data to stdout, applying --jq filter and --limit if set.
-* Use this for all JSON/YAML/structured output from commands.
-*/
-const writeOutput = (context, data) => {
-	let result = data;
-	if (context.jq) try {
-		result = jmespath.search(result, context.jq);
-	} catch (error) {
-		throw new CliError(`Invalid --jq expression: ${error instanceof Error ? error.message : String(error)}`, EXIT_CODES.VALIDATION);
-	}
-	if (context.limit !== null && Array.isArray(result)) result = result.slice(0, context.limit);
-	switch (context.format) {
-		case "yaml":
-			writeYaml(result);
-			break;
-		case "json":
-			writeJson(result);
-			break;
-		default:
-			writeJson(result);
-			break;
-	}
-	if (context.copy) copyToClipboard(JSON.stringify(result, null, 2));
-};
-/**
-* Handles --total, --format csv, --format tsv, --format yaml output.
-* Returns true if the format was handled; caller renders text mode if false.
-*/
-const writeFormattedRows = (context, totalCount, headers, rows) => {
-	if (context.total) {
-		writeTotal(context, totalCount);
-		return true;
-	}
-	if (context.format === "yaml") {
-		const objects = rows.map((row) => Object.fromEntries(headers.map((h, i) => [h, row[i]])));
-		writeYaml(objects);
-		if (context.copy) copyToClipboard(stringify(objects));
-		return true;
-	}
-	if (context.format === "csv") {
-		writeCsv(headers, rows);
-		if (context.copy) copyToClipboard([headers.join(","), ...rows.map((r) => r.join(","))].join("\n"));
-		return true;
-	}
-	if (context.format === "tsv") {
-		writeTsv(headers, rows);
-		if (context.copy) copyToClipboard([headers.join("	"), ...rows.map((r) => r.join("	"))].join("\n"));
-		return true;
-	}
-	return false;
-};
-const copyToClipboard = (text) => {
-	try {
-		if (process.platform === "darwin") execSync("pbcopy", { input: text });
-		else if (process.platform === "win32") execSync("clip", { input: text });
-		else try {
-			execSync("xclip -selection clipboard", { input: text });
-		} catch {
-			execSync("xsel --clipboard --input", { input: text });
-		}
-		return true;
-	} catch {
-		return false;
-	}
-};
-//#endregion
 //#region src/options.ts
 const parseOutputFormat = (value) => {
 	switch (value?.trim().toLowerCase()) {
@@ -2212,8 +2227,8 @@ const createUuidV5 = (name, namespace) => {
 	const namespaceBytes = uuidToBytes(namespace);
 	const hash = createHash("sha1").update(namespaceBytes).update(Buffer.from(name, "utf8")).digest();
 	const bytes = Uint8Array.from(hash.subarray(0, 16));
-	const versionByte = bytes[6];
-	const variantByte = bytes[8];
+	const versionByte = bytes.at(6);
+	const variantByte = bytes.at(8);
 	if (typeof versionByte !== "number" || typeof variantByte !== "number") throw new TypeError("Failed to generate a deterministic UUID.");
 	bytes[6] = versionByte & 15 | 80;
 	bytes[8] = variantByte & 63 | 128;
@@ -2233,36 +2248,2792 @@ const createTeamProjectId = (params) => createCompositeSyncId("TeamProject", [
 ]);
 //#endregion
 //#region src/import/things-values.ts
-const PACKED_DATE_MULTIPLIER = 128;
-const PACKED_DATE_DAY_MASK = 31;
-const PACKED_DATE_MONTH_MASK = 15;
-const PACKED_DATE_MONTH_SHIFT = 5;
-const PACKED_DATE_YEAR_SHIFT = 9;
-const THINGS_REMINDER_HOUR_SCALE = 67108864;
-const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
-const isValidPackedDate = (parts) => isValidDateOnlyParts(parts);
-const formatFloatingDate = (parts) => {
-	const formatted = parts ? formatDateOnlyParts(parts) : null;
-	return formatted ? `${formatted.replaceAll("-", "")}T000000` : null;
-};
-const dateOnlyEpochToLocalMidnightInstant = (epochMs) => {
-	const parts = epochToDateOnlyParts(epochMs);
-	if (!parts) return null;
-	return new Date(parts.year, parts.month - 1, parts.day).getTime();
-};
-const decodeThingsPackedDateParts = (value) => {
-	if (!isFiniteNumber(value)) return null;
-	const integer = Math.trunc(value);
-	if (integer <= 0 || integer % PACKED_DATE_MULTIPLIER !== 0) return null;
-	const packed = integer / PACKED_DATE_MULTIPLIER;
-	const parts = {
-		day: packed & PACKED_DATE_DAY_MASK,
-		month: packed >> PACKED_DATE_MONTH_SHIFT & PACKED_DATE_MONTH_MASK,
-		year: packed >> PACKED_DATE_YEAR_SHIFT
-	};
-	return isValidPackedDate(parts) ? parts : null;
-};
-const decodeThingsPackedDate = (value) => {
+var import_rrule = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function webpackUniversalModuleDefinition(root, factory) {
+		if (typeof exports === "object" && typeof module === "object") module.exports = factory();
+		else if (typeof define === "function" && define.amd) define([], factory);
+		else if (typeof exports === "object") exports["rrule"] = factory();
+		else root["rrule"] = factory();
+	})(typeof self !== "undefined" ? self : exports, () => {
+		return (() => {
+			"use strict";
+			var __webpack_require__ = {};
+			__webpack_require__.d = (exports$1, definition) => {
+				for (var key in definition) if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports$1, key)) Object.defineProperty(exports$1, key, {
+					enumerable: true,
+					get: definition[key]
+				});
+			};
+			__webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+			__webpack_require__.r = (exports$2) => {
+				if (typeof Symbol !== "undefined" && Symbol.toStringTag) Object.defineProperty(exports$2, Symbol.toStringTag, { value: "Module" });
+				Object.defineProperty(exports$2, "__esModule", { value: true });
+			};
+			var __webpack_exports__ = {};
+			__webpack_require__.r(__webpack_exports__);
+			__webpack_require__.d(__webpack_exports__, {
+				"ALL_WEEKDAYS": () => ALL_WEEKDAYS,
+				"Frequency": () => Frequency,
+				"RRule": () => RRule,
+				"RRuleSet": () => RRuleSet,
+				"Weekday": () => Weekday,
+				"datetime": () => datetime,
+				"rrulestr": () => rrulestr
+			});
+			var ALL_WEEKDAYS = [
+				"MO",
+				"TU",
+				"WE",
+				"TH",
+				"FR",
+				"SA",
+				"SU"
+			];
+			var Weekday = function() {
+				function Weekday(weekday, n) {
+					if (n === 0) throw new Error("Can't create weekday with n == 0");
+					this.weekday = weekday;
+					this.n = n;
+				}
+				Weekday.fromStr = function(str) {
+					return new Weekday(ALL_WEEKDAYS.indexOf(str));
+				};
+				Weekday.prototype.nth = function(n) {
+					return this.n === n ? this : new Weekday(this.weekday, n);
+				};
+				Weekday.prototype.equals = function(other) {
+					return this.weekday === other.weekday && this.n === other.n;
+				};
+				Weekday.prototype.toString = function() {
+					var s = ALL_WEEKDAYS[this.weekday];
+					if (this.n) s = (this.n > 0 ? "+" : "") + String(this.n) + s;
+					return s;
+				};
+				Weekday.prototype.getJsWeekday = function() {
+					return this.weekday === 6 ? 0 : this.weekday + 1;
+				};
+				return Weekday;
+			}();
+			var isPresent = function(value) {
+				return value !== null && value !== void 0;
+			};
+			var isNumber = function(value) {
+				return typeof value === "number";
+			};
+			var isWeekdayStr = function(value) {
+				return typeof value === "string" && ALL_WEEKDAYS.includes(value);
+			};
+			var isArray = Array.isArray;
+			/**
+			* Simplified version of python's range()
+			*/
+			var range = function(start, end) {
+				if (end === void 0) end = start;
+				if (arguments.length === 1) {
+					end = start;
+					start = 0;
+				}
+				var rang = [];
+				for (var i = start; i < end; i++) rang.push(i);
+				return rang;
+			};
+			var repeat = function(value, times) {
+				var i = 0;
+				var array = [];
+				if (isArray(value)) for (; i < times; i++) array[i] = [].concat(value);
+				else for (; i < times; i++) array[i] = value;
+				return array;
+			};
+			var toArray = function(item) {
+				if (isArray(item)) return item;
+				return [item];
+			};
+			function padStart(item, targetLength, padString) {
+				if (padString === void 0) padString = " ";
+				var str = String(item);
+				targetLength = targetLength >> 0;
+				if (str.length > targetLength) return String(str);
+				targetLength = targetLength - str.length;
+				if (targetLength > padString.length) padString += repeat(padString, targetLength / padString.length);
+				return padString.slice(0, targetLength) + String(str);
+			}
+			/**
+			* Python like split
+			*/
+			var split = function(str, sep, num) {
+				var splits = str.split(sep);
+				return num ? splits.slice(0, num).concat([splits.slice(num).join(sep)]) : splits;
+			};
+			/**
+			* closure/goog/math/math.js:modulo
+			* Copyright 2006 The Closure Library Authors.
+			* The % operator in JavaScript returns the remainder of a / b, but differs from
+			* some other languages in that the result will have the same sign as the
+			* dividend. For example, -1 % 8 == -1, whereas in some other languages
+			* (such as Python) the result would be 7. This function emulates the more
+			* correct modulo behavior, which is useful for certain applications such as
+			* calculating an offset index in a circular list.
+			*
+			* @param {number} a The dividend.
+			* @param {number} b The divisor.
+			* @return {number} a % b where the result is between 0 and b (either 0 <= x < b
+			* or b < x <= 0, depending on the sign of b).
+			*/
+			var pymod = function(a, b) {
+				var r = a % b;
+				return r * b < 0 ? r + b : r;
+			};
+			/**
+			* @see: <http://docs.python.org/library/functions.html#divmod>
+			*/
+			var divmod = function(a, b) {
+				return {
+					div: Math.floor(a / b),
+					mod: pymod(a, b)
+				};
+			};
+			var empty = function(obj) {
+				return !isPresent(obj) || obj.length === 0;
+			};
+			/**
+			* Python-like boolean
+			*
+			* @return {Boolean} value of an object/primitive, taking into account
+			* the fact that in Python an empty list's/tuple's
+			* boolean value is False, whereas in JS it's true
+			*/
+			var notEmpty = function(obj) {
+				return !empty(obj);
+			};
+			/**
+			* Return true if a value is in an array
+			*/
+			var includes = function(arr, val) {
+				return notEmpty(arr) && arr.indexOf(val) !== -1;
+			};
+			var datetime = function(y, m, d, h, i, s) {
+				if (h === void 0) h = 0;
+				if (i === void 0) i = 0;
+				if (s === void 0) s = 0;
+				return new Date(Date.UTC(y, m - 1, d, h, i, s));
+			};
+			/**
+			* General date-related utilities.
+			* Also handles several incompatibilities between JavaScript and Python
+			*
+			*/
+			var MONTH_DAYS = [
+				31,
+				28,
+				31,
+				30,
+				31,
+				30,
+				31,
+				31,
+				30,
+				31,
+				30,
+				31
+			];
+			/**
+			* Number of milliseconds of one day
+			*/
+			var ONE_DAY = 1e3 * 60 * 60 * 24;
+			/**
+			* @see: <http://docs.python.org/library/datetime.html#datetime.MAXYEAR>
+			*/
+			var MAXYEAR = 9999;
+			/**
+			* Python uses 1-Jan-1 as the base for calculating ordinals but we don't
+			* want to confuse the JS engine with milliseconds > Number.MAX_NUMBER,
+			* therefore we use 1-Jan-1970 instead
+			*/
+			var ORDINAL_BASE = datetime(1970, 1, 1);
+			/**
+			* Python: MO-SU: 0 - 6
+			* JS: SU-SAT 0 - 6
+			*/
+			var PY_WEEKDAYS = [
+				6,
+				0,
+				1,
+				2,
+				3,
+				4,
+				5
+			];
+			var isLeapYear = function(year) {
+				return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+			};
+			var isDate = function(value) {
+				return value instanceof Date;
+			};
+			var isValidDate = function(value) {
+				return isDate(value) && !isNaN(value.getTime());
+			};
+			/**
+			* @see: <http://www.mcfedries.com/JavaScript/DaysBetween.asp>
+			*/
+			var daysBetween = function(date1, date2) {
+				var differencems = date1.getTime() - date2.getTime();
+				return Math.round(differencems / ONE_DAY);
+			};
+			/**
+			* @see: <http://docs.python.org/library/datetime.html#datetime.date.toordinal>
+			*/
+			var toOrdinal = function(date) {
+				return daysBetween(date, ORDINAL_BASE);
+			};
+			/**
+			* @see - <http://docs.python.org/library/datetime.html#datetime.date.fromordinal>
+			*/
+			var fromOrdinal = function(ordinal) {
+				return new Date(ORDINAL_BASE.getTime() + ordinal * ONE_DAY);
+			};
+			var getMonthDays = function(date) {
+				var month = date.getUTCMonth();
+				return month === 1 && isLeapYear(date.getUTCFullYear()) ? 29 : MONTH_DAYS[month];
+			};
+			/**
+			* @return {Number} python-like weekday
+			*/
+			var getWeekday = function(date) {
+				return PY_WEEKDAYS[date.getUTCDay()];
+			};
+			/**
+			* @see: <http://docs.python.org/library/calendar.html#calendar.monthrange>
+			*/
+			var monthRange = function(year, month) {
+				var date = datetime(year, month + 1, 1);
+				return [getWeekday(date), getMonthDays(date)];
+			};
+			/**
+			* @see: <http://docs.python.org/library/datetime.html#datetime.datetime.combine>
+			*/
+			var combine = function(date, time) {
+				time = time || date;
+				return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds()));
+			};
+			var dateutil_clone = function(date) {
+				return new Date(date.getTime());
+			};
+			var cloneDates = function(dates) {
+				var clones = [];
+				for (var i = 0; i < dates.length; i++) clones.push(dateutil_clone(dates[i]));
+				return clones;
+			};
+			/**
+			* Sorts an array of Date or Time objects
+			*/
+			var sort = function(dates) {
+				dates.sort(function(a, b) {
+					return a.getTime() - b.getTime();
+				});
+			};
+			var timeToUntilString = function(time, utc) {
+				if (utc === void 0) utc = true;
+				var date = new Date(time);
+				return [
+					padStart(date.getUTCFullYear().toString(), 4, "0"),
+					padStart(date.getUTCMonth() + 1, 2, "0"),
+					padStart(date.getUTCDate(), 2, "0"),
+					"T",
+					padStart(date.getUTCHours(), 2, "0"),
+					padStart(date.getUTCMinutes(), 2, "0"),
+					padStart(date.getUTCSeconds(), 2, "0"),
+					utc ? "Z" : ""
+				].join("");
+			};
+			var untilStringToDate = function(until) {
+				var bits = /^(\d{4})(\d{2})(\d{2})(T(\d{2})(\d{2})(\d{2})Z?)?$/.exec(until);
+				if (!bits) throw new Error("Invalid UNTIL value: ".concat(until));
+				return new Date(Date.UTC(parseInt(bits[1], 10), parseInt(bits[2], 10) - 1, parseInt(bits[3], 10), parseInt(bits[5], 10) || 0, parseInt(bits[6], 10) || 0, parseInt(bits[7], 10) || 0));
+			};
+			var dateTZtoISO8601 = function(date, timeZone) {
+				return date.toLocaleString("sv-SE", { timeZone }).replace(" ", "T") + "Z";
+			};
+			var dateInTimeZone = function(date, timeZone) {
+				var localTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+				var dateInLocalTZ = new Date(dateTZtoISO8601(date, localTimeZone));
+				var tzOffset = new Date(dateTZtoISO8601(date, timeZone !== null && timeZone !== void 0 ? timeZone : "UTC")).getTime() - dateInLocalTZ.getTime();
+				return new Date(date.getTime() - tzOffset);
+			};
+			const iterresult = function() {
+				function IterResult(method, args) {
+					this.minDate = null;
+					this.maxDate = null;
+					this._result = [];
+					this.total = 0;
+					this.method = method;
+					this.args = args;
+					if (method === "between") {
+						this.maxDate = args.inc ? args.before : /* @__PURE__ */ new Date(args.before.getTime() - 1);
+						this.minDate = args.inc ? args.after : new Date(args.after.getTime() + 1);
+					} else if (method === "before") this.maxDate = args.inc ? args.dt : /* @__PURE__ */ new Date(args.dt.getTime() - 1);
+					else if (method === "after") this.minDate = args.inc ? args.dt : new Date(args.dt.getTime() + 1);
+				}
+				/**
+				* Possibly adds a date into the result.
+				*
+				* @param {Date} date - the date isn't necessarly added to the result
+				* list (if it is too late/too early)
+				* @return {Boolean} true if it makes sense to continue the iteration
+				* false if we're done.
+				*/
+				IterResult.prototype.accept = function(date) {
+					++this.total;
+					var tooEarly = this.minDate && date < this.minDate;
+					var tooLate = this.maxDate && date > this.maxDate;
+					if (this.method === "between") {
+						if (tooEarly) return true;
+						if (tooLate) return false;
+					} else if (this.method === "before") {
+						if (tooLate) return false;
+					} else if (this.method === "after") {
+						if (tooEarly) return true;
+						this.add(date);
+						return false;
+					}
+					return this.add(date);
+				};
+				/**
+				*
+				* @param {Date} date that is part of the result.
+				* @return {Boolean} whether we are interested in more values.
+				*/
+				IterResult.prototype.add = function(date) {
+					this._result.push(date);
+					return true;
+				};
+				/**
+				* 'before' and 'after' return only one date, whereas 'all'
+				* and 'between' an array.
+				*
+				* @return {Date,Array?}
+				*/
+				IterResult.prototype.getValue = function() {
+					var res = this._result;
+					switch (this.method) {
+						case "all":
+						case "between": return res;
+						default: return res.length ? res[res.length - 1] : null;
+					}
+				};
+				IterResult.prototype.clone = function() {
+					return new IterResult(this.method, this.args);
+				};
+				return IterResult;
+			}();
+			/******************************************************************************
+			Copyright (c) Microsoft Corporation.
+			
+			Permission to use, copy, modify, and/or distribute this software for any
+			purpose with or without fee is hereby granted.
+			
+			THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+			REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+			AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+			INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+			LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+			OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+			PERFORMANCE OF THIS SOFTWARE.
+			***************************************************************************** */
+			var extendStatics = function(d, b) {
+				extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+					d.__proto__ = b;
+				} || function(d, b) {
+					for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+				};
+				return extendStatics(d, b);
+			};
+			function __extends(d, b) {
+				if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+				extendStatics(d, b);
+				function __() {
+					this.constructor = d;
+				}
+				d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+			}
+			var __assign = function() {
+				__assign = Object.assign || function __assign(t) {
+					for (var s, i = 1, n = arguments.length; i < n; i++) {
+						s = arguments[i];
+						for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+					}
+					return t;
+				};
+				return __assign.apply(this, arguments);
+			};
+			Object.create;
+			function __spreadArray(to, from, pack) {
+				if (pack || arguments.length === 2) {
+					for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
+						if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+						ar[i] = from[i];
+					}
+				}
+				return to.concat(ar || Array.prototype.slice.call(from));
+			}
+			function __await(v) {
+				return this instanceof __await ? (this.v = v, this) : new __await(v);
+			}
+			Object.create;
+			const callbackiterresult = function(_super) {
+				__extends(CallbackIterResult, _super);
+				function CallbackIterResult(method, args, iterator) {
+					var _this = _super.call(this, method, args) || this;
+					_this.iterator = iterator;
+					return _this;
+				}
+				CallbackIterResult.prototype.add = function(date) {
+					if (this.iterator(date, this._result.length)) {
+						this._result.push(date);
+						return true;
+					}
+					return false;
+				};
+				return CallbackIterResult;
+			}(iterresult);
+			const i18n = {
+				dayNames: [
+					"Sunday",
+					"Monday",
+					"Tuesday",
+					"Wednesday",
+					"Thursday",
+					"Friday",
+					"Saturday"
+				],
+				monthNames: [
+					"January",
+					"February",
+					"March",
+					"April",
+					"May",
+					"June",
+					"July",
+					"August",
+					"September",
+					"October",
+					"November",
+					"December"
+				],
+				tokens: {
+					SKIP: /^[ \r\n\t]+|^\.$/,
+					number: /^[1-9][0-9]*/,
+					numberAsText: /^(one|two|three)/i,
+					every: /^every/i,
+					"day(s)": /^days?/i,
+					"weekday(s)": /^weekdays?/i,
+					"week(s)": /^weeks?/i,
+					"hour(s)": /^hours?/i,
+					"minute(s)": /^minutes?/i,
+					"month(s)": /^months?/i,
+					"year(s)": /^years?/i,
+					on: /^(on|in)/i,
+					at: /^(at)/i,
+					the: /^the/i,
+					first: /^first/i,
+					second: /^second/i,
+					third: /^third/i,
+					nth: /^([1-9][0-9]*)(\.|th|nd|rd|st)/i,
+					last: /^last/i,
+					for: /^for/i,
+					"time(s)": /^times?/i,
+					until: /^(un)?til/i,
+					monday: /^mo(n(day)?)?/i,
+					tuesday: /^tu(e(s(day)?)?)?/i,
+					wednesday: /^we(d(n(esday)?)?)?/i,
+					thursday: /^th(u(r(sday)?)?)?/i,
+					friday: /^fr(i(day)?)?/i,
+					saturday: /^sa(t(urday)?)?/i,
+					sunday: /^su(n(day)?)?/i,
+					january: /^jan(uary)?/i,
+					february: /^feb(ruary)?/i,
+					march: /^mar(ch)?/i,
+					april: /^apr(il)?/i,
+					may: /^may/i,
+					june: /^june?/i,
+					july: /^july?/i,
+					august: /^aug(ust)?/i,
+					september: /^sep(t(ember)?)?/i,
+					october: /^oct(ober)?/i,
+					november: /^nov(ember)?/i,
+					december: /^dec(ember)?/i,
+					comma: /^(,\s*|(and|or)\s*)+/i
+				}
+			};
+			/**
+			* Return true if a value is in an array
+			*/
+			var contains = function(arr, val) {
+				return arr.indexOf(val) !== -1;
+			};
+			var defaultGetText = function(id) {
+				return id.toString();
+			};
+			var defaultDateFormatter = function(year, month, day) {
+				return "".concat(month, " ").concat(day, ", ").concat(year);
+			};
+			const totext = function() {
+				function ToText(rrule, gettext, language, dateFormatter) {
+					if (gettext === void 0) gettext = defaultGetText;
+					if (language === void 0) language = i18n;
+					if (dateFormatter === void 0) dateFormatter = defaultDateFormatter;
+					this.text = [];
+					this.language = language || i18n;
+					this.gettext = gettext;
+					this.dateFormatter = dateFormatter;
+					this.rrule = rrule;
+					this.options = rrule.options;
+					this.origOptions = rrule.origOptions;
+					if (this.origOptions.bymonthday) {
+						var bymonthday = [].concat(this.options.bymonthday);
+						var bynmonthday = [].concat(this.options.bynmonthday);
+						bymonthday.sort(function(a, b) {
+							return a - b;
+						});
+						bynmonthday.sort(function(a, b) {
+							return b - a;
+						});
+						this.bymonthday = bymonthday.concat(bynmonthday);
+						if (!this.bymonthday.length) this.bymonthday = null;
+					}
+					if (isPresent(this.origOptions.byweekday)) {
+						var byweekday = !isArray(this.origOptions.byweekday) ? [this.origOptions.byweekday] : this.origOptions.byweekday;
+						var days = String(byweekday);
+						this.byweekday = {
+							allWeeks: byweekday.filter(function(weekday) {
+								return !weekday.n;
+							}),
+							someWeeks: byweekday.filter(function(weekday) {
+								return Boolean(weekday.n);
+							}),
+							isWeekdays: days.indexOf("MO") !== -1 && days.indexOf("TU") !== -1 && days.indexOf("WE") !== -1 && days.indexOf("TH") !== -1 && days.indexOf("FR") !== -1 && days.indexOf("SA") === -1 && days.indexOf("SU") === -1,
+							isEveryDay: days.indexOf("MO") !== -1 && days.indexOf("TU") !== -1 && days.indexOf("WE") !== -1 && days.indexOf("TH") !== -1 && days.indexOf("FR") !== -1 && days.indexOf("SA") !== -1 && days.indexOf("SU") !== -1
+						};
+						var sortWeekDays = function(a, b) {
+							return a.weekday - b.weekday;
+						};
+						this.byweekday.allWeeks.sort(sortWeekDays);
+						this.byweekday.someWeeks.sort(sortWeekDays);
+						if (!this.byweekday.allWeeks.length) this.byweekday.allWeeks = null;
+						if (!this.byweekday.someWeeks.length) this.byweekday.someWeeks = null;
+					} else this.byweekday = null;
+				}
+				/**
+				* Test whether the rrule can be fully converted to text.
+				*
+				* @param {RRule} rrule
+				* @return {Boolean}
+				*/
+				ToText.isFullyConvertible = function(rrule) {
+					var canConvert = true;
+					if (!(rrule.options.freq in ToText.IMPLEMENTED)) return false;
+					if (rrule.origOptions.until && rrule.origOptions.count) return false;
+					for (var key in rrule.origOptions) {
+						if (contains([
+							"dtstart",
+							"tzid",
+							"wkst",
+							"freq"
+						], key)) return true;
+						if (!contains(ToText.IMPLEMENTED[rrule.options.freq], key)) return false;
+					}
+					return canConvert;
+				};
+				ToText.prototype.isFullyConvertible = function() {
+					return ToText.isFullyConvertible(this.rrule);
+				};
+				/**
+				* Perform the conversion. Only some of the frequencies are supported.
+				* If some of the rrule's options aren't supported, they'll
+				* be omitted from the output an "(~ approximate)" will be appended.
+				*
+				* @return {*}
+				*/
+				ToText.prototype.toString = function() {
+					var gettext = this.gettext;
+					if (!(this.options.freq in ToText.IMPLEMENTED)) return gettext("RRule error: Unable to fully convert this rrule to text");
+					this.text = [gettext("every")];
+					this[RRule.FREQUENCIES[this.options.freq]]();
+					if (this.options.until) {
+						this.add(gettext("until"));
+						var until = this.options.until;
+						this.add(this.dateFormatter(until.getUTCFullYear(), this.language.monthNames[until.getUTCMonth()], until.getUTCDate()));
+					} else if (this.options.count) this.add(gettext("for")).add(this.options.count.toString()).add(this.plural(this.options.count) ? gettext("times") : gettext("time"));
+					if (!this.isFullyConvertible()) this.add(gettext("(~ approximate)"));
+					return this.text.join("");
+				};
+				ToText.prototype.HOURLY = function() {
+					var gettext = this.gettext;
+					if (this.options.interval !== 1) this.add(this.options.interval.toString());
+					this.add(this.plural(this.options.interval) ? gettext("hours") : gettext("hour"));
+				};
+				ToText.prototype.MINUTELY = function() {
+					var gettext = this.gettext;
+					if (this.options.interval !== 1) this.add(this.options.interval.toString());
+					this.add(this.plural(this.options.interval) ? gettext("minutes") : gettext("minute"));
+				};
+				ToText.prototype.DAILY = function() {
+					var gettext = this.gettext;
+					if (this.options.interval !== 1) this.add(this.options.interval.toString());
+					if (this.byweekday && this.byweekday.isWeekdays) this.add(this.plural(this.options.interval) ? gettext("weekdays") : gettext("weekday"));
+					else this.add(this.plural(this.options.interval) ? gettext("days") : gettext("day"));
+					if (this.origOptions.bymonth) {
+						this.add(gettext("in"));
+						this._bymonth();
+					}
+					if (this.bymonthday) this._bymonthday();
+					else if (this.byweekday) this._byweekday();
+					else if (this.origOptions.byhour) this._byhour();
+				};
+				ToText.prototype.WEEKLY = function() {
+					var gettext = this.gettext;
+					if (this.options.interval !== 1) this.add(this.options.interval.toString()).add(this.plural(this.options.interval) ? gettext("weeks") : gettext("week"));
+					if (this.byweekday && this.byweekday.isWeekdays) if (this.options.interval === 1) this.add(this.plural(this.options.interval) ? gettext("weekdays") : gettext("weekday"));
+					else this.add(gettext("on")).add(gettext("weekdays"));
+					else if (this.byweekday && this.byweekday.isEveryDay) this.add(this.plural(this.options.interval) ? gettext("days") : gettext("day"));
+					else {
+						if (this.options.interval === 1) this.add(gettext("week"));
+						if (this.origOptions.bymonth) {
+							this.add(gettext("in"));
+							this._bymonth();
+						}
+						if (this.bymonthday) this._bymonthday();
+						else if (this.byweekday) this._byweekday();
+						if (this.origOptions.byhour) this._byhour();
+					}
+				};
+				ToText.prototype.MONTHLY = function() {
+					var gettext = this.gettext;
+					if (this.origOptions.bymonth) {
+						if (this.options.interval !== 1) {
+							this.add(this.options.interval.toString()).add(gettext("months"));
+							if (this.plural(this.options.interval)) this.add(gettext("in"));
+						}
+						this._bymonth();
+					} else {
+						if (this.options.interval !== 1) this.add(this.options.interval.toString());
+						this.add(this.plural(this.options.interval) ? gettext("months") : gettext("month"));
+					}
+					if (this.bymonthday) this._bymonthday();
+					else if (this.byweekday && this.byweekday.isWeekdays) this.add(gettext("on")).add(gettext("weekdays"));
+					else if (this.byweekday) this._byweekday();
+				};
+				ToText.prototype.YEARLY = function() {
+					var gettext = this.gettext;
+					if (this.origOptions.bymonth) {
+						if (this.options.interval !== 1) {
+							this.add(this.options.interval.toString());
+							this.add(gettext("years"));
+						}
+						this._bymonth();
+					} else {
+						if (this.options.interval !== 1) this.add(this.options.interval.toString());
+						this.add(this.plural(this.options.interval) ? gettext("years") : gettext("year"));
+					}
+					if (this.bymonthday) this._bymonthday();
+					else if (this.byweekday) this._byweekday();
+					if (this.options.byyearday) this.add(gettext("on the")).add(this.list(this.options.byyearday, this.nth, gettext("and"))).add(gettext("day"));
+					if (this.options.byweekno) this.add(gettext("in")).add(this.plural(this.options.byweekno.length) ? gettext("weeks") : gettext("week")).add(this.list(this.options.byweekno, void 0, gettext("and")));
+				};
+				ToText.prototype._bymonthday = function() {
+					var gettext = this.gettext;
+					if (this.byweekday && this.byweekday.allWeeks) this.add(gettext("on")).add(this.list(this.byweekday.allWeeks, this.weekdaytext, gettext("or"))).add(gettext("the")).add(this.list(this.bymonthday, this.nth, gettext("or")));
+					else this.add(gettext("on the")).add(this.list(this.bymonthday, this.nth, gettext("and")));
+				};
+				ToText.prototype._byweekday = function() {
+					var gettext = this.gettext;
+					if (this.byweekday.allWeeks && !this.byweekday.isWeekdays) this.add(gettext("on")).add(this.list(this.byweekday.allWeeks, this.weekdaytext));
+					if (this.byweekday.someWeeks) {
+						if (this.byweekday.allWeeks) this.add(gettext("and"));
+						this.add(gettext("on the")).add(this.list(this.byweekday.someWeeks, this.weekdaytext, gettext("and")));
+					}
+				};
+				ToText.prototype._byhour = function() {
+					var gettext = this.gettext;
+					this.add(gettext("at")).add(this.list(this.origOptions.byhour, void 0, gettext("and")));
+				};
+				ToText.prototype._bymonth = function() {
+					this.add(this.list(this.options.bymonth, this.monthtext, this.gettext("and")));
+				};
+				ToText.prototype.nth = function(n) {
+					n = parseInt(n.toString(), 10);
+					var nth;
+					var gettext = this.gettext;
+					if (n === -1) return gettext("last");
+					var npos = Math.abs(n);
+					switch (npos) {
+						case 1:
+						case 21:
+						case 31:
+							nth = npos + gettext("st");
+							break;
+						case 2:
+						case 22:
+							nth = npos + gettext("nd");
+							break;
+						case 3:
+						case 23:
+							nth = npos + gettext("rd");
+							break;
+						default: nth = npos + gettext("th");
+					}
+					return n < 0 ? nth + " " + gettext("last") : nth;
+				};
+				ToText.prototype.monthtext = function(m) {
+					return this.language.monthNames[m - 1];
+				};
+				ToText.prototype.weekdaytext = function(wday) {
+					var weekday = isNumber(wday) ? (wday + 1) % 7 : wday.getJsWeekday();
+					return (wday.n ? this.nth(wday.n) + " " : "") + this.language.dayNames[weekday];
+				};
+				ToText.prototype.plural = function(n) {
+					return n % 100 !== 1;
+				};
+				ToText.prototype.add = function(s) {
+					this.text.push(" ");
+					this.text.push(s);
+					return this;
+				};
+				ToText.prototype.list = function(arr, callback, finalDelim, delim) {
+					var _this = this;
+					if (delim === void 0) delim = ",";
+					if (!isArray(arr)) arr = [arr];
+					var delimJoin = function(array, delimiter, finalDelimiter) {
+						var list = "";
+						for (var i = 0; i < array.length; i++) {
+							if (i !== 0) if (i === array.length - 1) list += " " + finalDelimiter + " ";
+							else list += delimiter + " ";
+							list += array[i];
+						}
+						return list;
+					};
+					callback = callback || function(o) {
+						return o.toString();
+					};
+					var realCallback = function(arg) {
+						return callback && callback.call(_this, arg);
+					};
+					if (finalDelim) return delimJoin(arr.map(realCallback), delim, finalDelim);
+					else return arr.map(realCallback).join(delim + " ");
+				};
+				return ToText;
+			}();
+			var Parser = function() {
+				function Parser(rules) {
+					this.done = true;
+					this.rules = rules;
+				}
+				Parser.prototype.start = function(text) {
+					this.text = text;
+					this.done = false;
+					return this.nextSymbol();
+				};
+				Parser.prototype.isDone = function() {
+					return this.done && this.symbol === null;
+				};
+				Parser.prototype.nextSymbol = function() {
+					var best;
+					var bestSymbol;
+					this.symbol = null;
+					this.value = null;
+					do {
+						if (this.done) return false;
+						var rule = void 0;
+						best = null;
+						for (var name_1 in this.rules) {
+							rule = this.rules[name_1];
+							var match = rule.exec(this.text);
+							if (match) {
+								if (best === null || match[0].length > best[0].length) {
+									best = match;
+									bestSymbol = name_1;
+								}
+							}
+						}
+						if (best != null) {
+							this.text = this.text.substr(best[0].length);
+							if (this.text === "") this.done = true;
+						}
+						if (best == null) {
+							this.done = true;
+							this.symbol = null;
+							this.value = null;
+							return;
+						}
+					} while (bestSymbol === "SKIP");
+					this.symbol = bestSymbol;
+					this.value = best;
+					return true;
+				};
+				Parser.prototype.accept = function(name) {
+					if (this.symbol === name) {
+						if (this.value) {
+							var v = this.value;
+							this.nextSymbol();
+							return v;
+						}
+						this.nextSymbol();
+						return true;
+					}
+					return false;
+				};
+				Parser.prototype.acceptNumber = function() {
+					return this.accept("number");
+				};
+				Parser.prototype.expect = function(name) {
+					if (this.accept(name)) return true;
+					throw new Error("expected " + name + " but found " + this.symbol);
+				};
+				return Parser;
+			}();
+			function parseText(text, language) {
+				if (language === void 0) language = i18n;
+				var options = {};
+				var ttr = new Parser(language.tokens);
+				if (!ttr.start(text)) return null;
+				S();
+				return options;
+				function S() {
+					ttr.expect("every");
+					var n = ttr.acceptNumber();
+					if (n) options.interval = parseInt(n[0], 10);
+					if (ttr.isDone()) throw new Error("Unexpected end");
+					switch (ttr.symbol) {
+						case "day(s)":
+							options.freq = RRule.DAILY;
+							if (ttr.nextSymbol()) {
+								AT();
+								F();
+							}
+							break;
+						case "weekday(s)":
+							options.freq = RRule.WEEKLY;
+							options.byweekday = [
+								RRule.MO,
+								RRule.TU,
+								RRule.WE,
+								RRule.TH,
+								RRule.FR
+							];
+							ttr.nextSymbol();
+							AT();
+							F();
+							break;
+						case "week(s)":
+							options.freq = RRule.WEEKLY;
+							if (ttr.nextSymbol()) {
+								ON();
+								AT();
+								F();
+							}
+							break;
+						case "hour(s)":
+							options.freq = RRule.HOURLY;
+							if (ttr.nextSymbol()) {
+								ON();
+								F();
+							}
+							break;
+						case "minute(s)":
+							options.freq = RRule.MINUTELY;
+							if (ttr.nextSymbol()) {
+								ON();
+								F();
+							}
+							break;
+						case "month(s)":
+							options.freq = RRule.MONTHLY;
+							if (ttr.nextSymbol()) {
+								ON();
+								F();
+							}
+							break;
+						case "year(s)":
+							options.freq = RRule.YEARLY;
+							if (ttr.nextSymbol()) {
+								ON();
+								F();
+							}
+							break;
+						case "monday":
+						case "tuesday":
+						case "wednesday":
+						case "thursday":
+						case "friday":
+						case "saturday":
+						case "sunday":
+							options.freq = RRule.WEEKLY;
+							options.byweekday = [RRule[ttr.symbol.substr(0, 2).toUpperCase()]];
+							if (!ttr.nextSymbol()) return;
+							while (ttr.accept("comma")) {
+								if (ttr.isDone()) throw new Error("Unexpected end");
+								var wkd = decodeWKD();
+								if (!wkd) throw new Error("Unexpected symbol " + ttr.symbol + ", expected weekday");
+								options.byweekday.push(RRule[wkd]);
+								ttr.nextSymbol();
+							}
+							AT();
+							MDAYs();
+							F();
+							break;
+						case "january":
+						case "february":
+						case "march":
+						case "april":
+						case "may":
+						case "june":
+						case "july":
+						case "august":
+						case "september":
+						case "october":
+						case "november":
+						case "december":
+							options.freq = RRule.YEARLY;
+							options.bymonth = [decodeM()];
+							if (!ttr.nextSymbol()) return;
+							while (ttr.accept("comma")) {
+								if (ttr.isDone()) throw new Error("Unexpected end");
+								var m = decodeM();
+								if (!m) throw new Error("Unexpected symbol " + ttr.symbol + ", expected month");
+								options.bymonth.push(m);
+								ttr.nextSymbol();
+							}
+							ON();
+							F();
+							break;
+						default: throw new Error("Unknown symbol");
+					}
+				}
+				function ON() {
+					var on = ttr.accept("on");
+					var the = ttr.accept("the");
+					if (!(on || the)) return;
+					do {
+						var nth = decodeNTH();
+						var wkd = decodeWKD();
+						var m = decodeM();
+						if (nth) if (wkd) {
+							ttr.nextSymbol();
+							if (!options.byweekday) options.byweekday = [];
+							options.byweekday.push(RRule[wkd].nth(nth));
+						} else {
+							if (!options.bymonthday) options.bymonthday = [];
+							options.bymonthday.push(nth);
+							ttr.accept("day(s)");
+						}
+						else if (wkd) {
+							ttr.nextSymbol();
+							if (!options.byweekday) options.byweekday = [];
+							options.byweekday.push(RRule[wkd]);
+						} else if (ttr.symbol === "weekday(s)") {
+							ttr.nextSymbol();
+							if (!options.byweekday) options.byweekday = [
+								RRule.MO,
+								RRule.TU,
+								RRule.WE,
+								RRule.TH,
+								RRule.FR
+							];
+						} else if (ttr.symbol === "week(s)") {
+							ttr.nextSymbol();
+							var n = ttr.acceptNumber();
+							if (!n) throw new Error("Unexpected symbol " + ttr.symbol + ", expected week number");
+							options.byweekno = [parseInt(n[0], 10)];
+							while (ttr.accept("comma")) {
+								n = ttr.acceptNumber();
+								if (!n) throw new Error("Unexpected symbol " + ttr.symbol + "; expected monthday");
+								options.byweekno.push(parseInt(n[0], 10));
+							}
+						} else if (m) {
+							ttr.nextSymbol();
+							if (!options.bymonth) options.bymonth = [];
+							options.bymonth.push(m);
+						} else return;
+					} while (ttr.accept("comma") || ttr.accept("the") || ttr.accept("on"));
+				}
+				function AT() {
+					if (!ttr.accept("at")) return;
+					do {
+						var n = ttr.acceptNumber();
+						if (!n) throw new Error("Unexpected symbol " + ttr.symbol + ", expected hour");
+						options.byhour = [parseInt(n[0], 10)];
+						while (ttr.accept("comma")) {
+							n = ttr.acceptNumber();
+							if (!n) throw new Error("Unexpected symbol " + ttr.symbol + "; expected hour");
+							options.byhour.push(parseInt(n[0], 10));
+						}
+					} while (ttr.accept("comma") || ttr.accept("at"));
+				}
+				function decodeM() {
+					switch (ttr.symbol) {
+						case "january": return 1;
+						case "february": return 2;
+						case "march": return 3;
+						case "april": return 4;
+						case "may": return 5;
+						case "june": return 6;
+						case "july": return 7;
+						case "august": return 8;
+						case "september": return 9;
+						case "october": return 10;
+						case "november": return 11;
+						case "december": return 12;
+						default: return false;
+					}
+				}
+				function decodeWKD() {
+					switch (ttr.symbol) {
+						case "monday":
+						case "tuesday":
+						case "wednesday":
+						case "thursday":
+						case "friday":
+						case "saturday":
+						case "sunday": return ttr.symbol.substr(0, 2).toUpperCase();
+						default: return false;
+					}
+				}
+				function decodeNTH() {
+					switch (ttr.symbol) {
+						case "last":
+							ttr.nextSymbol();
+							return -1;
+						case "first":
+							ttr.nextSymbol();
+							return 1;
+						case "second":
+							ttr.nextSymbol();
+							return ttr.accept("last") ? -2 : 2;
+						case "third":
+							ttr.nextSymbol();
+							return ttr.accept("last") ? -3 : 3;
+						case "nth":
+							var v = parseInt(ttr.value[1], 10);
+							if (v < -366 || v > 366) throw new Error("Nth out of range: " + v);
+							ttr.nextSymbol();
+							return ttr.accept("last") ? -v : v;
+						default: return false;
+					}
+				}
+				function MDAYs() {
+					ttr.accept("on");
+					ttr.accept("the");
+					var nth = decodeNTH();
+					if (!nth) return;
+					options.bymonthday = [nth];
+					ttr.nextSymbol();
+					while (ttr.accept("comma")) {
+						nth = decodeNTH();
+						if (!nth) throw new Error("Unexpected symbol " + ttr.symbol + "; expected monthday");
+						options.bymonthday.push(nth);
+						ttr.nextSymbol();
+					}
+				}
+				function F() {
+					if (ttr.symbol === "until") {
+						var date = Date.parse(ttr.text);
+						if (!date) throw new Error("Cannot parse until date:" + ttr.text);
+						options.until = new Date(date);
+					} else if (ttr.accept("for")) {
+						options.count = parseInt(ttr.value[0], 10);
+						ttr.expect("number");
+					}
+				}
+			}
+			var Frequency;
+			(function(Frequency) {
+				Frequency[Frequency["YEARLY"] = 0] = "YEARLY";
+				Frequency[Frequency["MONTHLY"] = 1] = "MONTHLY";
+				Frequency[Frequency["WEEKLY"] = 2] = "WEEKLY";
+				Frequency[Frequency["DAILY"] = 3] = "DAILY";
+				Frequency[Frequency["HOURLY"] = 4] = "HOURLY";
+				Frequency[Frequency["MINUTELY"] = 5] = "MINUTELY";
+				Frequency[Frequency["SECONDLY"] = 6] = "SECONDLY";
+			})(Frequency || (Frequency = {}));
+			function freqIsDailyOrGreater(freq) {
+				return freq < Frequency.HOURLY;
+			}
+			/**
+			*
+			* Implementation of RRule.fromText() and RRule::toText().
+			*
+			*
+			* On the client side, this file needs to be included
+			* when those functions are used.
+			*
+			*/
+			/**
+			* Will be able to convert some of the below described rules from
+			* text format to a rule object.
+			*
+			*
+			* RULES
+			*
+			* Every ([n])
+			* day(s)
+			* | [weekday], ..., (and) [weekday]
+			* | weekday(s)
+			* | week(s)
+			* | month(s)
+			* | [month], ..., (and) [month]
+			* | year(s)
+			*
+			*
+			* Plus 0, 1, or multiple of these:
+			*
+			* on [weekday], ..., (or) [weekday] the [monthday], [monthday], ... (or) [monthday]
+			*
+			* on [weekday], ..., (and) [weekday]
+			*
+			* on the [monthday], [monthday], ... (and) [monthday] (day of the month)
+			*
+			* on the [nth-weekday], ..., (and) [nth-weekday] (of the month/year)
+			*
+			*
+			* Plus 0 or 1 of these:
+			*
+			* for [n] time(s)
+			*
+			* until [date]
+			*
+			* Plus (.)
+			*
+			*
+			* Definitely no supported for parsing:
+			*
+			* (for year):
+			* in week(s) [n], ..., (and) [n]
+			*
+			* on the [yearday], ..., (and) [n] day of the year
+			* on day [yearday], ..., (and) [n]
+			*
+			*
+			* NON-TERMINALS
+			*
+			* [n]: 1, 2 ..., one, two, three ..
+			* [month]: January, February, March, April, May, ... December
+			* [weekday]: Monday, ... Sunday
+			* [nth-weekday]: first [weekday], 2nd [weekday], ... last [weekday], ...
+			* [monthday]: first, 1., 2., 1st, 2nd, second, ... 31st, last day, 2nd last day, ..
+			* [date]:
+			* - [month] (0-31(,) ([year])),
+			* - (the) 0-31.(1-12.([year])),
+			* - (the) 0-31/(1-12/([year])),
+			* - [weekday]
+			*
+			* [year]: 0000, 0001, ... 01, 02, ..
+			*
+			* Definitely not supported for parsing:
+			*
+			* [yearday]: first, 1., 2., 1st, 2nd, second, ... 366th, last day, 2nd last day, ..
+			*
+			* @param {String} text
+			* @return {Object, Boolean} the rule, or null.
+			*/
+			var fromText = function(text, language) {
+				if (language === void 0) language = i18n;
+				return new RRule(parseText(text, language) || void 0);
+			};
+			var common = [
+				"count",
+				"until",
+				"interval",
+				"byweekday",
+				"bymonthday",
+				"bymonth"
+			];
+			totext.IMPLEMENTED = [];
+			totext.IMPLEMENTED[Frequency.HOURLY] = common;
+			totext.IMPLEMENTED[Frequency.MINUTELY] = common;
+			totext.IMPLEMENTED[Frequency.DAILY] = ["byhour"].concat(common);
+			totext.IMPLEMENTED[Frequency.WEEKLY] = common;
+			totext.IMPLEMENTED[Frequency.MONTHLY] = common;
+			totext.IMPLEMENTED[Frequency.YEARLY] = ["byweekno", "byyearday"].concat(common);
+			var toText = function(rrule, gettext, language, dateFormatter) {
+				return new totext(rrule, gettext, language, dateFormatter).toString();
+			};
+			var isFullyConvertible = totext.isFullyConvertible;
+			var Time = function() {
+				function Time(hour, minute, second, millisecond) {
+					this.hour = hour;
+					this.minute = minute;
+					this.second = second;
+					this.millisecond = millisecond || 0;
+				}
+				Time.prototype.getHours = function() {
+					return this.hour;
+				};
+				Time.prototype.getMinutes = function() {
+					return this.minute;
+				};
+				Time.prototype.getSeconds = function() {
+					return this.second;
+				};
+				Time.prototype.getMilliseconds = function() {
+					return this.millisecond;
+				};
+				Time.prototype.getTime = function() {
+					return (this.hour * 60 * 60 + this.minute * 60 + this.second) * 1e3 + this.millisecond;
+				};
+				return Time;
+			}();
+			var DateTime = function(_super) {
+				__extends(DateTime, _super);
+				function DateTime(year, month, day, hour, minute, second, millisecond) {
+					var _this = _super.call(this, hour, minute, second, millisecond) || this;
+					_this.year = year;
+					_this.month = month;
+					_this.day = day;
+					return _this;
+				}
+				DateTime.fromDate = function(date) {
+					return new this(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.valueOf() % 1e3);
+				};
+				DateTime.prototype.getWeekday = function() {
+					return getWeekday(new Date(this.getTime()));
+				};
+				DateTime.prototype.getTime = function() {
+					return new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond)).getTime();
+				};
+				DateTime.prototype.getDay = function() {
+					return this.day;
+				};
+				DateTime.prototype.getMonth = function() {
+					return this.month;
+				};
+				DateTime.prototype.getYear = function() {
+					return this.year;
+				};
+				DateTime.prototype.addYears = function(years) {
+					this.year += years;
+				};
+				DateTime.prototype.addMonths = function(months) {
+					this.month += months;
+					if (this.month > 12) {
+						var yearDiv = Math.floor(this.month / 12);
+						this.month = pymod(this.month, 12);
+						this.year += yearDiv;
+						if (this.month === 0) {
+							this.month = 12;
+							--this.year;
+						}
+					}
+				};
+				DateTime.prototype.addWeekly = function(days, wkst) {
+					if (wkst > this.getWeekday()) this.day += -(this.getWeekday() + 1 + (6 - wkst)) + days * 7;
+					else this.day += -(this.getWeekday() - wkst) + days * 7;
+					this.fixDay();
+				};
+				DateTime.prototype.addDaily = function(days) {
+					this.day += days;
+					this.fixDay();
+				};
+				DateTime.prototype.addHours = function(hours, filtered, byhour) {
+					if (filtered) this.hour += Math.floor((23 - this.hour) / hours) * hours;
+					for (;;) {
+						this.hour += hours;
+						var _a = divmod(this.hour, 24), dayDiv = _a.div, hourMod = _a.mod;
+						if (dayDiv) {
+							this.hour = hourMod;
+							this.addDaily(dayDiv);
+						}
+						if (empty(byhour) || includes(byhour, this.hour)) break;
+					}
+				};
+				DateTime.prototype.addMinutes = function(minutes, filtered, byhour, byminute) {
+					if (filtered) this.minute += Math.floor((1439 - (this.hour * 60 + this.minute)) / minutes) * minutes;
+					for (;;) {
+						this.minute += minutes;
+						var _a = divmod(this.minute, 60), hourDiv = _a.div, minuteMod = _a.mod;
+						if (hourDiv) {
+							this.minute = minuteMod;
+							this.addHours(hourDiv, false, byhour);
+						}
+						if ((empty(byhour) || includes(byhour, this.hour)) && (empty(byminute) || includes(byminute, this.minute))) break;
+					}
+				};
+				DateTime.prototype.addSeconds = function(seconds, filtered, byhour, byminute, bysecond) {
+					if (filtered) this.second += Math.floor((86399 - (this.hour * 3600 + this.minute * 60 + this.second)) / seconds) * seconds;
+					for (;;) {
+						this.second += seconds;
+						var _a = divmod(this.second, 60), minuteDiv = _a.div, secondMod = _a.mod;
+						if (minuteDiv) {
+							this.second = secondMod;
+							this.addMinutes(minuteDiv, false, byhour, byminute);
+						}
+						if ((empty(byhour) || includes(byhour, this.hour)) && (empty(byminute) || includes(byminute, this.minute)) && (empty(bysecond) || includes(bysecond, this.second))) break;
+					}
+				};
+				DateTime.prototype.fixDay = function() {
+					if (this.day <= 28) return;
+					var daysinmonth = monthRange(this.year, this.month - 1)[1];
+					if (this.day <= daysinmonth) return;
+					while (this.day > daysinmonth) {
+						this.day -= daysinmonth;
+						++this.month;
+						if (this.month === 13) {
+							this.month = 1;
+							++this.year;
+							if (this.year > MAXYEAR) return;
+						}
+						daysinmonth = monthRange(this.year, this.month - 1)[1];
+					}
+				};
+				DateTime.prototype.add = function(options, filtered) {
+					var freq = options.freq, interval = options.interval, wkst = options.wkst, byhour = options.byhour, byminute = options.byminute, bysecond = options.bysecond;
+					switch (freq) {
+						case Frequency.YEARLY: return this.addYears(interval);
+						case Frequency.MONTHLY: return this.addMonths(interval);
+						case Frequency.WEEKLY: return this.addWeekly(interval, wkst);
+						case Frequency.DAILY: return this.addDaily(interval);
+						case Frequency.HOURLY: return this.addHours(interval, filtered, byhour);
+						case Frequency.MINUTELY: return this.addMinutes(interval, filtered, byhour, byminute);
+						case Frequency.SECONDLY: return this.addSeconds(interval, filtered, byhour, byminute, bysecond);
+					}
+				};
+				return DateTime;
+			}(Time);
+			function initializeOptions(options) {
+				var invalid = [];
+				var keys = Object.keys(options);
+				for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+					var key = keys_1[_i];
+					if (!includes(defaultKeys, key)) invalid.push(key);
+					if (isDate(options[key]) && !isValidDate(options[key])) invalid.push(key);
+				}
+				if (invalid.length) throw new Error("Invalid options: " + invalid.join(", "));
+				return __assign({}, options);
+			}
+			function parseOptions(options) {
+				var opts = __assign(__assign({}, DEFAULT_OPTIONS), initializeOptions(options));
+				if (isPresent(opts.byeaster)) opts.freq = RRule.YEARLY;
+				if (!(isPresent(opts.freq) && RRule.FREQUENCIES[opts.freq])) throw new Error("Invalid frequency: ".concat(opts.freq, " ").concat(options.freq));
+				if (!opts.dtstart) opts.dtstart = new Date((/* @__PURE__ */ new Date()).setMilliseconds(0));
+				if (!isPresent(opts.wkst)) opts.wkst = RRule.MO.weekday;
+				else if (isNumber(opts.wkst)) {} else opts.wkst = opts.wkst.weekday;
+				if (isPresent(opts.bysetpos)) {
+					if (isNumber(opts.bysetpos)) opts.bysetpos = [opts.bysetpos];
+					for (var i = 0; i < opts.bysetpos.length; i++) {
+						var v = opts.bysetpos[i];
+						if (v === 0 || !(v >= -366 && v <= 366)) throw new Error("bysetpos must be between 1 and 366, or between -366 and -1");
+					}
+				}
+				if (!(Boolean(opts.byweekno) || notEmpty(opts.byweekno) || notEmpty(opts.byyearday) || Boolean(opts.bymonthday) || notEmpty(opts.bymonthday) || isPresent(opts.byweekday) || isPresent(opts.byeaster))) switch (opts.freq) {
+					case RRule.YEARLY:
+						if (!opts.bymonth) opts.bymonth = opts.dtstart.getUTCMonth() + 1;
+						opts.bymonthday = opts.dtstart.getUTCDate();
+						break;
+					case RRule.MONTHLY:
+						opts.bymonthday = opts.dtstart.getUTCDate();
+						break;
+					case RRule.WEEKLY:
+						opts.byweekday = [getWeekday(opts.dtstart)];
+						break;
+				}
+				if (isPresent(opts.bymonth) && !isArray(opts.bymonth)) opts.bymonth = [opts.bymonth];
+				if (isPresent(opts.byyearday) && !isArray(opts.byyearday) && isNumber(opts.byyearday)) opts.byyearday = [opts.byyearday];
+				if (!isPresent(opts.bymonthday)) {
+					opts.bymonthday = [];
+					opts.bynmonthday = [];
+				} else if (isArray(opts.bymonthday)) {
+					var bymonthday = [];
+					var bynmonthday = [];
+					for (var i = 0; i < opts.bymonthday.length; i++) {
+						var v = opts.bymonthday[i];
+						if (v > 0) bymonthday.push(v);
+						else if (v < 0) bynmonthday.push(v);
+					}
+					opts.bymonthday = bymonthday;
+					opts.bynmonthday = bynmonthday;
+				} else if (opts.bymonthday < 0) {
+					opts.bynmonthday = [opts.bymonthday];
+					opts.bymonthday = [];
+				} else {
+					opts.bynmonthday = [];
+					opts.bymonthday = [opts.bymonthday];
+				}
+				if (isPresent(opts.byweekno) && !isArray(opts.byweekno)) opts.byweekno = [opts.byweekno];
+				if (!isPresent(opts.byweekday)) opts.bynweekday = null;
+				else if (isNumber(opts.byweekday)) {
+					opts.byweekday = [opts.byweekday];
+					opts.bynweekday = null;
+				} else if (isWeekdayStr(opts.byweekday)) {
+					opts.byweekday = [Weekday.fromStr(opts.byweekday).weekday];
+					opts.bynweekday = null;
+				} else if (opts.byweekday instanceof Weekday) if (!opts.byweekday.n || opts.freq > RRule.MONTHLY) {
+					opts.byweekday = [opts.byweekday.weekday];
+					opts.bynweekday = null;
+				} else {
+					opts.bynweekday = [[opts.byweekday.weekday, opts.byweekday.n]];
+					opts.byweekday = null;
+				}
+				else {
+					var byweekday = [];
+					var bynweekday = [];
+					for (var i = 0; i < opts.byweekday.length; i++) {
+						var wday = opts.byweekday[i];
+						if (isNumber(wday)) {
+							byweekday.push(wday);
+							continue;
+						} else if (isWeekdayStr(wday)) {
+							byweekday.push(Weekday.fromStr(wday).weekday);
+							continue;
+						}
+						if (!wday.n || opts.freq > RRule.MONTHLY) byweekday.push(wday.weekday);
+						else bynweekday.push([wday.weekday, wday.n]);
+					}
+					opts.byweekday = notEmpty(byweekday) ? byweekday : null;
+					opts.bynweekday = notEmpty(bynweekday) ? bynweekday : null;
+				}
+				if (!isPresent(opts.byhour)) opts.byhour = opts.freq < RRule.HOURLY ? [opts.dtstart.getUTCHours()] : null;
+				else if (isNumber(opts.byhour)) opts.byhour = [opts.byhour];
+				if (!isPresent(opts.byminute)) opts.byminute = opts.freq < RRule.MINUTELY ? [opts.dtstart.getUTCMinutes()] : null;
+				else if (isNumber(opts.byminute)) opts.byminute = [opts.byminute];
+				if (!isPresent(opts.bysecond)) opts.bysecond = opts.freq < RRule.SECONDLY ? [opts.dtstart.getUTCSeconds()] : null;
+				else if (isNumber(opts.bysecond)) opts.bysecond = [opts.bysecond];
+				return { parsedOptions: opts };
+			}
+			function buildTimeset(opts) {
+				var millisecondModulo = opts.dtstart.getTime() % 1e3;
+				if (!freqIsDailyOrGreater(opts.freq)) return [];
+				var timeset = [];
+				opts.byhour.forEach(function(hour) {
+					opts.byminute.forEach(function(minute) {
+						opts.bysecond.forEach(function(second) {
+							timeset.push(new Time(hour, minute, second, millisecondModulo));
+						});
+					});
+				});
+				return timeset;
+			}
+			function parseString(rfcString) {
+				var options = rfcString.split("\n").map(parseLine).filter(function(x) {
+					return x !== null;
+				});
+				return __assign(__assign({}, options[0]), options[1]);
+			}
+			function parseDtstart(line) {
+				var options = {};
+				var dtstartWithZone = /DTSTART(?:;TZID=([^:=]+?))?(?::|=)([^;\s]+)/i.exec(line);
+				if (!dtstartWithZone) return options;
+				var tzid = dtstartWithZone[1], dtstart = dtstartWithZone[2];
+				if (tzid) options.tzid = tzid;
+				options.dtstart = untilStringToDate(dtstart);
+				return options;
+			}
+			function parseLine(rfcString) {
+				rfcString = rfcString.replace(/^\s+|\s+$/, "");
+				if (!rfcString.length) return null;
+				var header = /^([A-Z]+?)[:;]/.exec(rfcString.toUpperCase());
+				if (!header) return parseRrule(rfcString);
+				var key = header[1];
+				switch (key.toUpperCase()) {
+					case "RRULE":
+					case "EXRULE": return parseRrule(rfcString);
+					case "DTSTART": return parseDtstart(rfcString);
+					default: throw new Error("Unsupported RFC prop ".concat(key, " in ").concat(rfcString));
+				}
+			}
+			function parseRrule(line) {
+				var options = parseDtstart(line.replace(/^RRULE:/i, ""));
+				line.replace(/^(?:RRULE|EXRULE):/i, "").split(";").forEach(function(attr) {
+					var _a = attr.split("="), key = _a[0], value = _a[1];
+					switch (key.toUpperCase()) {
+						case "FREQ":
+							options.freq = Frequency[value.toUpperCase()];
+							break;
+						case "WKST":
+							options.wkst = Days[value.toUpperCase()];
+							break;
+						case "COUNT":
+						case "INTERVAL":
+						case "BYSETPOS":
+						case "BYMONTH":
+						case "BYMONTHDAY":
+						case "BYYEARDAY":
+						case "BYWEEKNO":
+						case "BYHOUR":
+						case "BYMINUTE":
+						case "BYSECOND":
+							var num = parseNumber(value);
+							var optionKey = key.toLowerCase();
+							options[optionKey] = num;
+							break;
+						case "BYWEEKDAY":
+						case "BYDAY":
+							options.byweekday = parseWeekday(value);
+							break;
+						case "DTSTART":
+						case "TZID":
+							var dtstart = parseDtstart(line);
+							options.tzid = dtstart.tzid;
+							options.dtstart = dtstart.dtstart;
+							break;
+						case "UNTIL":
+							options.until = untilStringToDate(value);
+							break;
+						case "BYEASTER":
+							options.byeaster = Number(value);
+							break;
+						default: throw new Error("Unknown RRULE property '" + key + "'");
+					}
+				});
+				return options;
+			}
+			function parseNumber(value) {
+				if (value.indexOf(",") !== -1) return value.split(",").map(parseIndividualNumber);
+				return parseIndividualNumber(value);
+			}
+			function parseIndividualNumber(value) {
+				if (/^[+-]?\d+$/.test(value)) return Number(value);
+				return value;
+			}
+			function parseWeekday(value) {
+				return value.split(",").map(function(day) {
+					if (day.length === 2) return Days[day];
+					var parts = day.match(/^([+-]?\d{1,2})([A-Z]{2})$/);
+					if (!parts || parts.length < 3) throw new SyntaxError("Invalid weekday string: ".concat(day));
+					var n = Number(parts[1]);
+					var wday = Days[parts[2]].weekday;
+					return new Weekday(wday, n);
+				});
+			}
+			var DateWithZone = function() {
+				function DateWithZone(date, tzid) {
+					if (isNaN(date.getTime())) throw new RangeError("Invalid date passed to DateWithZone");
+					this.date = date;
+					this.tzid = tzid;
+				}
+				Object.defineProperty(DateWithZone.prototype, "isUTC", {
+					get: function() {
+						return !this.tzid || this.tzid.toUpperCase() === "UTC";
+					},
+					enumerable: false,
+					configurable: true
+				});
+				DateWithZone.prototype.toString = function() {
+					var datestr = timeToUntilString(this.date.getTime(), this.isUTC);
+					if (!this.isUTC) return ";TZID=".concat(this.tzid, ":").concat(datestr);
+					return ":".concat(datestr);
+				};
+				DateWithZone.prototype.getTime = function() {
+					return this.date.getTime();
+				};
+				DateWithZone.prototype.rezonedDate = function() {
+					if (this.isUTC) return this.date;
+					return dateInTimeZone(this.date, this.tzid);
+				};
+				return DateWithZone;
+			}();
+			function optionsToString(options) {
+				var rrule = [];
+				var dtstart = "";
+				var keys = Object.keys(options);
+				var defaultKeys = Object.keys(DEFAULT_OPTIONS);
+				for (var i = 0; i < keys.length; i++) {
+					if (keys[i] === "tzid") continue;
+					if (!includes(defaultKeys, keys[i])) continue;
+					var key = keys[i].toUpperCase();
+					var value = options[keys[i]];
+					var outValue = "";
+					if (!isPresent(value) || isArray(value) && !value.length) continue;
+					switch (key) {
+						case "FREQ":
+							outValue = RRule.FREQUENCIES[options.freq];
+							break;
+						case "WKST":
+							if (isNumber(value)) outValue = new Weekday(value).toString();
+							else outValue = value.toString();
+							break;
+						case "BYWEEKDAY":
+							key = "BYDAY";
+							outValue = toArray(value).map(function(wday) {
+								if (wday instanceof Weekday) return wday;
+								if (isArray(wday)) return new Weekday(wday[0], wday[1]);
+								return new Weekday(wday);
+							}).toString();
+							break;
+						case "DTSTART":
+							dtstart = buildDtstart(value, options.tzid);
+							break;
+						case "UNTIL":
+							outValue = timeToUntilString(value, !options.tzid);
+							break;
+						default: if (isArray(value)) {
+							var strValues = [];
+							for (var j = 0; j < value.length; j++) strValues[j] = String(value[j]);
+							outValue = strValues.toString();
+						} else outValue = String(value);
+					}
+					if (outValue) rrule.push([key, outValue]);
+				}
+				var rules = rrule.map(function(_a) {
+					var key = _a[0], value = _a[1];
+					return "".concat(key, "=").concat(value.toString());
+				}).join(";");
+				var ruleString = "";
+				if (rules !== "") ruleString = "RRULE:".concat(rules);
+				return [dtstart, ruleString].filter(function(x) {
+					return !!x;
+				}).join("\n");
+			}
+			function buildDtstart(dtstart, tzid) {
+				if (!dtstart) return "";
+				return "DTSTART" + new DateWithZone(new Date(dtstart), tzid).toString();
+			}
+			function argsMatch(left, right) {
+				if (Array.isArray(left)) {
+					if (!Array.isArray(right)) return false;
+					if (left.length !== right.length) return false;
+					return left.every(function(date, i) {
+						return date.getTime() === right[i].getTime();
+					});
+				}
+				if (left instanceof Date) return right instanceof Date && left.getTime() === right.getTime();
+				return left === right;
+			}
+			var Cache = function() {
+				function Cache() {
+					this.all = false;
+					this.before = [];
+					this.after = [];
+					this.between = [];
+				}
+				/**
+				* @param {String} what - all/before/after/between
+				* @param {Array,Date} value - an array of dates, one date, or null
+				* @param {Object?} args - _iter arguments
+				*/
+				Cache.prototype._cacheAdd = function(what, value, args) {
+					if (value) value = value instanceof Date ? dateutil_clone(value) : cloneDates(value);
+					if (what === "all") this.all = value;
+					else {
+						args._value = value;
+						this[what].push(args);
+					}
+				};
+				/**
+				* @return false - not in the cache
+				* @return null  - cached, but zero occurrences (before/after)
+				* @return Date  - cached (before/after)
+				* @return []    - cached, but zero occurrences (all/between)
+				* @return [Date1, DateN] - cached (all/between)
+				*/
+				Cache.prototype._cacheGet = function(what, args) {
+					var cached = false;
+					var argsKeys = args ? Object.keys(args) : [];
+					var findCacheDiff = function(item) {
+						for (var i = 0; i < argsKeys.length; i++) {
+							var key = argsKeys[i];
+							if (!argsMatch(args[key], item[key])) return true;
+						}
+						return false;
+					};
+					var cachedObject = this[what];
+					if (what === "all") cached = this.all;
+					else if (isArray(cachedObject)) for (var i = 0; i < cachedObject.length; i++) {
+						var item = cachedObject[i];
+						if (argsKeys.length && findCacheDiff(item)) continue;
+						cached = item._value;
+						break;
+					}
+					if (!cached && this.all) {
+						var iterResult = new iterresult(what, args);
+						for (var i = 0; i < this.all.length; i++) if (!iterResult.accept(this.all[i])) break;
+						cached = iterResult.getValue();
+						this._cacheAdd(what, cached, args);
+					}
+					return isArray(cached) ? cloneDates(cached) : cached instanceof Date ? dateutil_clone(cached) : cached;
+				};
+				return Cache;
+			}();
+			var M365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], repeat(1, 31), true), repeat(2, 28), true), repeat(3, 31), true), repeat(4, 30), true), repeat(5, 31), true), repeat(6, 30), true), repeat(7, 31), true), repeat(8, 31), true), repeat(9, 30), true), repeat(10, 31), true), repeat(11, 30), true), repeat(12, 31), true), repeat(1, 7), true);
+			var M366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], repeat(1, 31), true), repeat(2, 29), true), repeat(3, 31), true), repeat(4, 30), true), repeat(5, 31), true), repeat(6, 30), true), repeat(7, 31), true), repeat(8, 31), true), repeat(9, 30), true), repeat(10, 31), true), repeat(11, 30), true), repeat(12, 31), true), repeat(1, 7), true);
+			var M28 = range(1, 29);
+			var M29 = range(1, 30);
+			var M30 = range(1, 31);
+			var M31 = range(1, 32);
+			var MDAY366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], M31, true), M29, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31.slice(0, 7), true);
+			var MDAY365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], M31, true), M28, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31.slice(0, 7), true);
+			var NM28 = range(-28, 0);
+			var NM29 = range(-29, 0);
+			var NM30 = range(-30, 0);
+			var NM31 = range(-31, 0);
+			var NMDAY366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], NM31, true), NM29, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31.slice(0, 7), true);
+			var NMDAY365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], NM31, true), NM28, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31.slice(0, 7), true);
+			var M366RANGE = [
+				0,
+				31,
+				60,
+				91,
+				121,
+				152,
+				182,
+				213,
+				244,
+				274,
+				305,
+				335,
+				366
+			];
+			var M365RANGE = [
+				0,
+				31,
+				59,
+				90,
+				120,
+				151,
+				181,
+				212,
+				243,
+				273,
+				304,
+				334,
+				365
+			];
+			var WDAYMASK = (function() {
+				var wdaymask = [];
+				for (var i = 0; i < 55; i++) wdaymask = wdaymask.concat(range(7));
+				return wdaymask;
+			})();
+			function rebuildYear(year, options) {
+				var firstyday = datetime(year, 1, 1);
+				var yearlen = isLeapYear(year) ? 366 : 365;
+				var nextyearlen = isLeapYear(year + 1) ? 366 : 365;
+				var yearordinal = toOrdinal(firstyday);
+				var yearweekday = getWeekday(firstyday);
+				var result = __assign(__assign({
+					yearlen,
+					nextyearlen,
+					yearordinal,
+					yearweekday
+				}, baseYearMasks(year)), { wnomask: null });
+				if (empty(options.byweekno)) return result;
+				result.wnomask = repeat(0, yearlen + 7);
+				var firstwkst;
+				var wyearlen;
+				var no1wkst = firstwkst = pymod(7 - yearweekday + options.wkst, 7);
+				if (no1wkst >= 4) {
+					no1wkst = 0;
+					wyearlen = result.yearlen + pymod(yearweekday - options.wkst, 7);
+				} else wyearlen = yearlen - no1wkst;
+				var div = Math.floor(wyearlen / 7);
+				var mod = pymod(wyearlen, 7);
+				var numweeks = Math.floor(div + mod / 4);
+				for (var j = 0; j < options.byweekno.length; j++) {
+					var n = options.byweekno[j];
+					if (n < 0) n += numweeks + 1;
+					if (!(n > 0 && n <= numweeks)) continue;
+					var i = void 0;
+					if (n > 1) {
+						i = no1wkst + (n - 1) * 7;
+						if (no1wkst !== firstwkst) i -= 7 - firstwkst;
+					} else i = no1wkst;
+					for (var k = 0; k < 7; k++) {
+						result.wnomask[i] = 1;
+						i++;
+						if (result.wdaymask[i] === options.wkst) break;
+					}
+				}
+				if (includes(options.byweekno, 1)) {
+					var i = no1wkst + numweeks * 7;
+					if (no1wkst !== firstwkst) i -= 7 - firstwkst;
+					if (i < yearlen) for (var j = 0; j < 7; j++) {
+						result.wnomask[i] = 1;
+						i += 1;
+						if (result.wdaymask[i] === options.wkst) break;
+					}
+				}
+				if (no1wkst) {
+					var lnumweeks = void 0;
+					if (!includes(options.byweekno, -1)) {
+						var lyearweekday = getWeekday(datetime(year - 1, 1, 1));
+						var lno1wkst = pymod(7 - lyearweekday.valueOf() + options.wkst, 7);
+						var lyearlen = isLeapYear(year - 1) ? 366 : 365;
+						var weekst = void 0;
+						if (lno1wkst >= 4) {
+							lno1wkst = 0;
+							weekst = lyearlen + pymod(lyearweekday - options.wkst, 7);
+						} else weekst = yearlen - no1wkst;
+						lnumweeks = Math.floor(52 + pymod(weekst, 7) / 4);
+					} else lnumweeks = -1;
+					if (includes(options.byweekno, lnumweeks)) for (var i = 0; i < no1wkst; i++) result.wnomask[i] = 1;
+				}
+				return result;
+			}
+			function baseYearMasks(year) {
+				var yearlen = isLeapYear(year) ? 366 : 365;
+				var wday = getWeekday(datetime(year, 1, 1));
+				if (yearlen === 365) return {
+					mmask: M365MASK,
+					mdaymask: MDAY365MASK,
+					nmdaymask: NMDAY365MASK,
+					wdaymask: WDAYMASK.slice(wday),
+					mrange: M365RANGE
+				};
+				return {
+					mmask: M366MASK,
+					mdaymask: MDAY366MASK,
+					nmdaymask: NMDAY366MASK,
+					wdaymask: WDAYMASK.slice(wday),
+					mrange: M366RANGE
+				};
+			}
+			function rebuildMonth(year, month, yearlen, mrange, wdaymask, options) {
+				var result = {
+					lastyear: year,
+					lastmonth: month,
+					nwdaymask: []
+				};
+				var ranges = [];
+				if (options.freq === RRule.YEARLY) if (empty(options.bymonth)) ranges = [[0, yearlen]];
+				else for (var j = 0; j < options.bymonth.length; j++) {
+					month = options.bymonth[j];
+					ranges.push(mrange.slice(month - 1, month + 1));
+				}
+				else if (options.freq === RRule.MONTHLY) ranges = [mrange.slice(month - 1, month + 1)];
+				if (empty(ranges)) return result;
+				result.nwdaymask = repeat(0, yearlen);
+				for (var j = 0; j < ranges.length; j++) {
+					var rang = ranges[j];
+					var first = rang[0];
+					var last = rang[1] - 1;
+					for (var k = 0; k < options.bynweekday.length; k++) {
+						var i = void 0;
+						var _a = options.bynweekday[k], wday = _a[0], n = _a[1];
+						if (n < 0) {
+							i = last + (n + 1) * 7;
+							i -= pymod(wdaymask[i] - wday, 7);
+						} else {
+							i = first + (n - 1) * 7;
+							i += pymod(7 - wdaymask[i] + wday, 7);
+						}
+						if (first <= i && i <= last) result.nwdaymask[i] = 1;
+					}
+				}
+				return result;
+			}
+			function easter(y, offset) {
+				if (offset === void 0) offset = 0;
+				var a = y % 19;
+				var b = Math.floor(y / 100);
+				var c = y % 100;
+				var d = Math.floor(b / 4);
+				var e = b % 4;
+				var f = Math.floor((b + 8) / 25);
+				var g = Math.floor((b - f + 1) / 3);
+				var h = Math.floor(19 * a + b - d - g + 15) % 30;
+				var i = Math.floor(c / 4);
+				var k = c % 4;
+				var l = Math.floor(32 + 2 * e + 2 * i - h - k) % 7;
+				var m = Math.floor((a + 11 * h + 22 * l) / 451);
+				var month = Math.floor((h + l - 7 * m + 114) / 31);
+				var day = (h + l - 7 * m + 114) % 31 + 1;
+				var date = Date.UTC(y, month - 1, day + offset);
+				var yearStart = Date.UTC(y, 0, 1);
+				return [Math.ceil((date - yearStart) / (1e3 * 60 * 60 * 24))];
+			}
+			const iterinfo = function() {
+				function Iterinfo(options) {
+					this.options = options;
+				}
+				Iterinfo.prototype.rebuild = function(year, month) {
+					var options = this.options;
+					if (year !== this.lastyear) this.yearinfo = rebuildYear(year, options);
+					if (notEmpty(options.bynweekday) && (month !== this.lastmonth || year !== this.lastyear)) {
+						var _a = this.yearinfo, yearlen = _a.yearlen, mrange = _a.mrange, wdaymask = _a.wdaymask;
+						this.monthinfo = rebuildMonth(year, month, yearlen, mrange, wdaymask, options);
+					}
+					if (isPresent(options.byeaster)) this.eastermask = easter(year, options.byeaster);
+				};
+				Object.defineProperty(Iterinfo.prototype, "lastyear", {
+					get: function() {
+						return this.monthinfo ? this.monthinfo.lastyear : null;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "lastmonth", {
+					get: function() {
+						return this.monthinfo ? this.monthinfo.lastmonth : null;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "yearlen", {
+					get: function() {
+						return this.yearinfo.yearlen;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "yearordinal", {
+					get: function() {
+						return this.yearinfo.yearordinal;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "mrange", {
+					get: function() {
+						return this.yearinfo.mrange;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "wdaymask", {
+					get: function() {
+						return this.yearinfo.wdaymask;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "mmask", {
+					get: function() {
+						return this.yearinfo.mmask;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "wnomask", {
+					get: function() {
+						return this.yearinfo.wnomask;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "nwdaymask", {
+					get: function() {
+						return this.monthinfo ? this.monthinfo.nwdaymask : [];
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "nextyearlen", {
+					get: function() {
+						return this.yearinfo.nextyearlen;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "mdaymask", {
+					get: function() {
+						return this.yearinfo.mdaymask;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Object.defineProperty(Iterinfo.prototype, "nmdaymask", {
+					get: function() {
+						return this.yearinfo.nmdaymask;
+					},
+					enumerable: false,
+					configurable: true
+				});
+				Iterinfo.prototype.ydayset = function() {
+					return [
+						range(this.yearlen),
+						0,
+						this.yearlen
+					];
+				};
+				Iterinfo.prototype.mdayset = function(_, month) {
+					var start = this.mrange[month - 1];
+					var end = this.mrange[month];
+					var set = repeat(null, this.yearlen);
+					for (var i = start; i < end; i++) set[i] = i;
+					return [
+						set,
+						start,
+						end
+					];
+				};
+				Iterinfo.prototype.wdayset = function(year, month, day) {
+					var set = repeat(null, this.yearlen + 7);
+					var i = toOrdinal(datetime(year, month, day)) - this.yearordinal;
+					var start = i;
+					for (var j = 0; j < 7; j++) {
+						set[i] = i;
+						++i;
+						if (this.wdaymask[i] === this.options.wkst) break;
+					}
+					return [
+						set,
+						start,
+						i
+					];
+				};
+				Iterinfo.prototype.ddayset = function(year, month, day) {
+					var set = repeat(null, this.yearlen);
+					var i = toOrdinal(datetime(year, month, day)) - this.yearordinal;
+					set[i] = i;
+					return [
+						set,
+						i,
+						i + 1
+					];
+				};
+				Iterinfo.prototype.htimeset = function(hour, _, second, millisecond) {
+					var _this = this;
+					var set = [];
+					this.options.byminute.forEach(function(minute) {
+						set = set.concat(_this.mtimeset(hour, minute, second, millisecond));
+					});
+					sort(set);
+					return set;
+				};
+				Iterinfo.prototype.mtimeset = function(hour, minute, _, millisecond) {
+					var set = this.options.bysecond.map(function(second) {
+						return new Time(hour, minute, second, millisecond);
+					});
+					sort(set);
+					return set;
+				};
+				Iterinfo.prototype.stimeset = function(hour, minute, second, millisecond) {
+					return [new Time(hour, minute, second, millisecond)];
+				};
+				Iterinfo.prototype.getdayset = function(freq) {
+					switch (freq) {
+						case Frequency.YEARLY: return this.ydayset.bind(this);
+						case Frequency.MONTHLY: return this.mdayset.bind(this);
+						case Frequency.WEEKLY: return this.wdayset.bind(this);
+						case Frequency.DAILY: return this.ddayset.bind(this);
+						default: return this.ddayset.bind(this);
+					}
+				};
+				Iterinfo.prototype.gettimeset = function(freq) {
+					switch (freq) {
+						case Frequency.HOURLY: return this.htimeset.bind(this);
+						case Frequency.MINUTELY: return this.mtimeset.bind(this);
+						case Frequency.SECONDLY: return this.stimeset.bind(this);
+					}
+				};
+				return Iterinfo;
+			}();
+			function buildPoslist(bysetpos, timeset, start, end, ii, dayset) {
+				var poslist = [];
+				for (var j = 0; j < bysetpos.length; j++) {
+					var daypos = void 0;
+					var timepos = void 0;
+					var pos = bysetpos[j];
+					if (pos < 0) {
+						daypos = Math.floor(pos / timeset.length);
+						timepos = pymod(pos, timeset.length);
+					} else {
+						daypos = Math.floor((pos - 1) / timeset.length);
+						timepos = pymod(pos - 1, timeset.length);
+					}
+					var tmp = [];
+					for (var k = start; k < end; k++) {
+						var val = dayset[k];
+						if (!isPresent(val)) continue;
+						tmp.push(val);
+					}
+					var i = void 0;
+					if (daypos < 0) i = tmp.slice(daypos)[0];
+					else i = tmp[daypos];
+					var time = timeset[timepos];
+					var res = combine(fromOrdinal(ii.yearordinal + i), time);
+					if (!includes(poslist, res)) poslist.push(res);
+				}
+				sort(poslist);
+				return poslist;
+			}
+			function iter(iterResult, options) {
+				var dtstart = options.dtstart, freq = options.freq, interval = options.interval, until = options.until, bysetpos = options.bysetpos;
+				var count = options.count;
+				if (count === 0 || interval === 0) return emitResult(iterResult);
+				var counterDate = DateTime.fromDate(dtstart);
+				var ii = new iterinfo(options);
+				ii.rebuild(counterDate.year, counterDate.month);
+				var timeset = makeTimeset(ii, counterDate, options);
+				for (;;) {
+					var _a = ii.getdayset(freq)(counterDate.year, counterDate.month, counterDate.day), dayset = _a[0], start = _a[1], end = _a[2];
+					var filtered = removeFilteredDays(dayset, start, end, ii, options);
+					if (notEmpty(bysetpos)) {
+						var poslist = buildPoslist(bysetpos, timeset, start, end, ii, dayset);
+						for (var j = 0; j < poslist.length; j++) {
+							var res = poslist[j];
+							if (until && res > until) return emitResult(iterResult);
+							if (res >= dtstart) {
+								var rezonedDate = rezoneIfNeeded(res, options);
+								if (!iterResult.accept(rezonedDate)) return emitResult(iterResult);
+								if (count) {
+									--count;
+									if (!count) return emitResult(iterResult);
+								}
+							}
+						}
+					} else for (var j = start; j < end; j++) {
+						var currentDay = dayset[j];
+						if (!isPresent(currentDay)) continue;
+						var date = fromOrdinal(ii.yearordinal + currentDay);
+						for (var k = 0; k < timeset.length; k++) {
+							var time = timeset[k];
+							var res = combine(date, time);
+							if (until && res > until) return emitResult(iterResult);
+							if (res >= dtstart) {
+								var rezonedDate = rezoneIfNeeded(res, options);
+								if (!iterResult.accept(rezonedDate)) return emitResult(iterResult);
+								if (count) {
+									--count;
+									if (!count) return emitResult(iterResult);
+								}
+							}
+						}
+					}
+					if (options.interval === 0) return emitResult(iterResult);
+					counterDate.add(options, filtered);
+					if (counterDate.year > MAXYEAR) return emitResult(iterResult);
+					if (!freqIsDailyOrGreater(freq)) timeset = ii.gettimeset(freq)(counterDate.hour, counterDate.minute, counterDate.second, 0);
+					ii.rebuild(counterDate.year, counterDate.month);
+				}
+			}
+			function isFiltered(ii, currentDay, options) {
+				var bymonth = options.bymonth, byweekno = options.byweekno, byweekday = options.byweekday, byeaster = options.byeaster, bymonthday = options.bymonthday, bynmonthday = options.bynmonthday, byyearday = options.byyearday;
+				return notEmpty(bymonth) && !includes(bymonth, ii.mmask[currentDay]) || notEmpty(byweekno) && !ii.wnomask[currentDay] || notEmpty(byweekday) && !includes(byweekday, ii.wdaymask[currentDay]) || notEmpty(ii.nwdaymask) && !ii.nwdaymask[currentDay] || byeaster !== null && !includes(ii.eastermask, currentDay) || (notEmpty(bymonthday) || notEmpty(bynmonthday)) && !includes(bymonthday, ii.mdaymask[currentDay]) && !includes(bynmonthday, ii.nmdaymask[currentDay]) || notEmpty(byyearday) && (currentDay < ii.yearlen && !includes(byyearday, currentDay + 1) && !includes(byyearday, -ii.yearlen + currentDay) || currentDay >= ii.yearlen && !includes(byyearday, currentDay + 1 - ii.yearlen) && !includes(byyearday, -ii.nextyearlen + currentDay - ii.yearlen));
+			}
+			function rezoneIfNeeded(date, options) {
+				return new DateWithZone(date, options.tzid).rezonedDate();
+			}
+			function emitResult(iterResult) {
+				return iterResult.getValue();
+			}
+			function removeFilteredDays(dayset, start, end, ii, options) {
+				var filtered = false;
+				for (var dayCounter = start; dayCounter < end; dayCounter++) {
+					var currentDay = dayset[dayCounter];
+					filtered = isFiltered(ii, currentDay, options);
+					if (filtered) dayset[currentDay] = null;
+				}
+				return filtered;
+			}
+			function makeTimeset(ii, counterDate, options) {
+				var freq = options.freq, byhour = options.byhour, byminute = options.byminute, bysecond = options.bysecond;
+				if (freqIsDailyOrGreater(freq)) return buildTimeset(options);
+				if (freq >= RRule.HOURLY && notEmpty(byhour) && !includes(byhour, counterDate.hour) || freq >= RRule.MINUTELY && notEmpty(byminute) && !includes(byminute, counterDate.minute) || freq >= RRule.SECONDLY && notEmpty(bysecond) && !includes(bysecond, counterDate.second)) return [];
+				return ii.gettimeset(freq)(counterDate.hour, counterDate.minute, counterDate.second, counterDate.millisecond);
+			}
+			var Days = {
+				MO: new Weekday(0),
+				TU: new Weekday(1),
+				WE: new Weekday(2),
+				TH: new Weekday(3),
+				FR: new Weekday(4),
+				SA: new Weekday(5),
+				SU: new Weekday(6)
+			};
+			var DEFAULT_OPTIONS = {
+				freq: Frequency.YEARLY,
+				dtstart: null,
+				interval: 1,
+				wkst: Days.MO,
+				count: null,
+				until: null,
+				tzid: null,
+				bysetpos: null,
+				bymonth: null,
+				bymonthday: null,
+				bynmonthday: null,
+				byyearday: null,
+				byweekno: null,
+				byweekday: null,
+				bynweekday: null,
+				byhour: null,
+				byminute: null,
+				bysecond: null,
+				byeaster: null
+			};
+			var defaultKeys = Object.keys(DEFAULT_OPTIONS);
+			/**
+			*
+			* @param {Options?} options - see <http://labix.org/python-dateutil/#head-cf004ee9a75592797e076752b2a889c10f445418>
+			* - The only required option is `freq`, one of RRule.YEARLY, RRule.MONTHLY, ...
+			* @constructor
+			*/
+			var RRule = function() {
+				function RRule(options, noCache) {
+					if (options === void 0) options = {};
+					if (noCache === void 0) noCache = false;
+					this._cache = noCache ? null : new Cache();
+					this.origOptions = initializeOptions(options);
+					this.options = parseOptions(options).parsedOptions;
+				}
+				RRule.parseText = function(text, language) {
+					return parseText(text, language);
+				};
+				RRule.fromText = function(text, language) {
+					return fromText(text, language);
+				};
+				RRule.fromString = function(str) {
+					return new RRule(RRule.parseString(str) || void 0);
+				};
+				RRule.prototype._iter = function(iterResult) {
+					return iter(iterResult, this.options);
+				};
+				RRule.prototype._cacheGet = function(what, args) {
+					if (!this._cache) return false;
+					return this._cache._cacheGet(what, args);
+				};
+				RRule.prototype._cacheAdd = function(what, value, args) {
+					if (!this._cache) return;
+					return this._cache._cacheAdd(what, value, args);
+				};
+				/**
+				* @param {Function} iterator - optional function that will be called
+				* on each date that is added. It can return false
+				* to stop the iteration.
+				* @return Array containing all recurrences.
+				*/
+				RRule.prototype.all = function(iterator) {
+					if (iterator) return this._iter(new callbackiterresult("all", {}, iterator));
+					var result = this._cacheGet("all");
+					if (result === false) {
+						result = this._iter(new iterresult("all", {}));
+						this._cacheAdd("all", result);
+					}
+					return result;
+				};
+				/**
+				* Returns all the occurrences of the rrule between after and before.
+				* The inc keyword defines what happens if after and/or before are
+				* themselves occurrences. With inc == True, they will be included in the
+				* list, if they are found in the recurrence set.
+				*
+				* @return Array
+				*/
+				RRule.prototype.between = function(after, before, inc, iterator) {
+					if (inc === void 0) inc = false;
+					if (!isValidDate(after) || !isValidDate(before)) throw new Error("Invalid date passed in to RRule.between");
+					var args = {
+						before,
+						after,
+						inc
+					};
+					if (iterator) return this._iter(new callbackiterresult("between", args, iterator));
+					var result = this._cacheGet("between", args);
+					if (result === false) {
+						result = this._iter(new iterresult("between", args));
+						this._cacheAdd("between", result, args);
+					}
+					return result;
+				};
+				/**
+				* Returns the last recurrence before the given datetime instance.
+				* The inc keyword defines what happens if dt is an occurrence.
+				* With inc == True, if dt itself is an occurrence, it will be returned.
+				*
+				* @return Date or null
+				*/
+				RRule.prototype.before = function(dt, inc) {
+					if (inc === void 0) inc = false;
+					if (!isValidDate(dt)) throw new Error("Invalid date passed in to RRule.before");
+					var args = {
+						dt,
+						inc
+					};
+					var result = this._cacheGet("before", args);
+					if (result === false) {
+						result = this._iter(new iterresult("before", args));
+						this._cacheAdd("before", result, args);
+					}
+					return result;
+				};
+				/**
+				* Returns the first recurrence after the given datetime instance.
+				* The inc keyword defines what happens if dt is an occurrence.
+				* With inc == True, if dt itself is an occurrence, it will be returned.
+				*
+				* @return Date or null
+				*/
+				RRule.prototype.after = function(dt, inc) {
+					if (inc === void 0) inc = false;
+					if (!isValidDate(dt)) throw new Error("Invalid date passed in to RRule.after");
+					var args = {
+						dt,
+						inc
+					};
+					var result = this._cacheGet("after", args);
+					if (result === false) {
+						result = this._iter(new iterresult("after", args));
+						this._cacheAdd("after", result, args);
+					}
+					return result;
+				};
+				/**
+				* Returns the number of recurrences in this set. It will have go trough
+				* the whole recurrence, if this hasn't been done before.
+				*/
+				RRule.prototype.count = function() {
+					return this.all().length;
+				};
+				/**
+				* Converts the rrule into its string representation
+				*
+				* @see <http://www.ietf.org/rfc/rfc2445.txt>
+				* @return String
+				*/
+				RRule.prototype.toString = function() {
+					return optionsToString(this.origOptions);
+				};
+				/**
+				* Will convert all rules described in nlp:ToText
+				* to text.
+				*/
+				RRule.prototype.toText = function(gettext, language, dateFormatter) {
+					return toText(this, gettext, language, dateFormatter);
+				};
+				RRule.prototype.isFullyConvertibleToText = function() {
+					return isFullyConvertible(this);
+				};
+				/**
+				* @return a RRule instance with the same freq and options
+				* as this one (cache is not cloned)
+				*/
+				RRule.prototype.clone = function() {
+					return new RRule(this.origOptions);
+				};
+				RRule.FREQUENCIES = [
+					"YEARLY",
+					"MONTHLY",
+					"WEEKLY",
+					"DAILY",
+					"HOURLY",
+					"MINUTELY",
+					"SECONDLY"
+				];
+				RRule.YEARLY = Frequency.YEARLY;
+				RRule.MONTHLY = Frequency.MONTHLY;
+				RRule.WEEKLY = Frequency.WEEKLY;
+				RRule.DAILY = Frequency.DAILY;
+				RRule.HOURLY = Frequency.HOURLY;
+				RRule.MINUTELY = Frequency.MINUTELY;
+				RRule.SECONDLY = Frequency.SECONDLY;
+				RRule.MO = Days.MO;
+				RRule.TU = Days.TU;
+				RRule.WE = Days.WE;
+				RRule.TH = Days.TH;
+				RRule.FR = Days.FR;
+				RRule.SA = Days.SA;
+				RRule.SU = Days.SU;
+				RRule.parseString = parseString;
+				RRule.optionsToString = optionsToString;
+				return RRule;
+			}();
+			function iterSet(iterResult, _rrule, _exrule, _rdate, _exdate, tzid) {
+				var _exdateHash = {};
+				var _accept = iterResult.accept;
+				function evalExdate(after, before) {
+					_exrule.forEach(function(rrule) {
+						rrule.between(after, before, true).forEach(function(date) {
+							_exdateHash[Number(date)] = true;
+						});
+					});
+				}
+				_exdate.forEach(function(date) {
+					var zonedDate = new DateWithZone(date, tzid).rezonedDate();
+					_exdateHash[Number(zonedDate)] = true;
+				});
+				iterResult.accept = function(date) {
+					var dt = Number(date);
+					if (isNaN(dt)) return _accept.call(this, date);
+					if (!_exdateHash[dt]) {
+						evalExdate(/* @__PURE__ */ new Date(dt - 1), new Date(dt + 1));
+						if (!_exdateHash[dt]) {
+							_exdateHash[dt] = true;
+							return _accept.call(this, date);
+						}
+					}
+					return true;
+				};
+				if (iterResult.method === "between") {
+					evalExdate(iterResult.args.after, iterResult.args.before);
+					iterResult.accept = function(date) {
+						var dt = Number(date);
+						if (!_exdateHash[dt]) {
+							_exdateHash[dt] = true;
+							return _accept.call(this, date);
+						}
+						return true;
+					};
+				}
+				for (var i = 0; i < _rdate.length; i++) {
+					var zonedDate = new DateWithZone(_rdate[i], tzid).rezonedDate();
+					if (!iterResult.accept(new Date(zonedDate.getTime()))) break;
+				}
+				_rrule.forEach(function(rrule) {
+					iter(iterResult, rrule.options);
+				});
+				var res = iterResult._result;
+				sort(res);
+				switch (iterResult.method) {
+					case "all":
+					case "between": return res;
+					case "before": return res.length && res[res.length - 1] || null;
+					default: return res.length && res[0] || null;
+				}
+			}
+			/**
+			* RRuleStr
+			* To parse a set of rrule strings
+			*/
+			var rrulestr_DEFAULT_OPTIONS = {
+				dtstart: null,
+				cache: false,
+				unfold: false,
+				forceset: false,
+				compatible: false,
+				tzid: null
+			};
+			function parseInput(s, options) {
+				var rrulevals = [];
+				var rdatevals = [];
+				var exrulevals = [];
+				var exdatevals = [];
+				var parsedDtstart = parseDtstart(s);
+				var dtstart = parsedDtstart.dtstart;
+				var tzid = parsedDtstart.tzid;
+				splitIntoLines(s, options.unfold).forEach(function(line) {
+					var _a;
+					if (!line) return;
+					var _b = breakDownLine(line), name = _b.name, parms = _b.parms, value = _b.value;
+					switch (name.toUpperCase()) {
+						case "RRULE":
+							if (parms.length) throw new Error("unsupported RRULE parm: ".concat(parms.join(",")));
+							rrulevals.push(parseString(line));
+							break;
+						case "RDATE":
+							var rdateTzid = ((_a = /RDATE(?:;TZID=([^:=]+))?/i.exec(line)) !== null && _a !== void 0 ? _a : [])[1];
+							if (rdateTzid && !tzid) tzid = rdateTzid;
+							rdatevals = rdatevals.concat(parseRDate(value, parms));
+							break;
+						case "EXRULE":
+							if (parms.length) throw new Error("unsupported EXRULE parm: ".concat(parms.join(",")));
+							exrulevals.push(parseString(value));
+							break;
+						case "EXDATE":
+							exdatevals = exdatevals.concat(parseRDate(value, parms));
+							break;
+						case "DTSTART": break;
+						default: throw new Error("unsupported property: " + name);
+					}
+				});
+				return {
+					dtstart,
+					tzid,
+					rrulevals,
+					rdatevals,
+					exrulevals,
+					exdatevals
+				};
+			}
+			function buildRule(s, options) {
+				var _a = parseInput(s, options), rrulevals = _a.rrulevals, rdatevals = _a.rdatevals, exrulevals = _a.exrulevals, exdatevals = _a.exdatevals, dtstart = _a.dtstart, tzid = _a.tzid;
+				var noCache = options.cache === false;
+				if (options.compatible) {
+					options.forceset = true;
+					options.unfold = true;
+				}
+				if (options.forceset || rrulevals.length > 1 || rdatevals.length || exrulevals.length || exdatevals.length) {
+					var rset_1 = new RRuleSet(noCache);
+					rset_1.dtstart(dtstart);
+					rset_1.tzid(tzid || void 0);
+					rrulevals.forEach(function(val) {
+						rset_1.rrule(new RRule(groomRruleOptions(val, dtstart, tzid), noCache));
+					});
+					rdatevals.forEach(function(date) {
+						rset_1.rdate(date);
+					});
+					exrulevals.forEach(function(val) {
+						rset_1.exrule(new RRule(groomRruleOptions(val, dtstart, tzid), noCache));
+					});
+					exdatevals.forEach(function(date) {
+						rset_1.exdate(date);
+					});
+					if (options.compatible && options.dtstart) rset_1.rdate(dtstart);
+					return rset_1;
+				}
+				var val = rrulevals[0] || {};
+				return new RRule(groomRruleOptions(val, val.dtstart || options.dtstart || dtstart, val.tzid || options.tzid || tzid), noCache);
+			}
+			function rrulestr(s, options) {
+				if (options === void 0) options = {};
+				return buildRule(s, rrulestr_initializeOptions(options));
+			}
+			function groomRruleOptions(val, dtstart, tzid) {
+				return __assign(__assign({}, val), {
+					dtstart,
+					tzid
+				});
+			}
+			function rrulestr_initializeOptions(options) {
+				var invalid = [];
+				var keys = Object.keys(options);
+				var defaultKeys = Object.keys(rrulestr_DEFAULT_OPTIONS);
+				keys.forEach(function(key) {
+					if (!includes(defaultKeys, key)) invalid.push(key);
+				});
+				if (invalid.length) throw new Error("Invalid options: " + invalid.join(", "));
+				return __assign(__assign({}, rrulestr_DEFAULT_OPTIONS), options);
+			}
+			function extractName(line) {
+				if (line.indexOf(":") === -1) return {
+					name: "RRULE",
+					value: line
+				};
+				var _a = split(line, ":", 1);
+				return {
+					name: _a[0],
+					value: _a[1]
+				};
+			}
+			function breakDownLine(line) {
+				var _a = extractName(line), name = _a.name, value = _a.value;
+				var parms = name.split(";");
+				if (!parms) throw new Error("empty property name");
+				return {
+					name: parms[0].toUpperCase(),
+					parms: parms.slice(1),
+					value
+				};
+			}
+			function splitIntoLines(s, unfold) {
+				if (unfold === void 0) unfold = false;
+				s = s && s.trim();
+				if (!s) throw new Error("Invalid empty string");
+				if (!unfold) return s.split(/\s/);
+				var lines = s.split("\n");
+				var i = 0;
+				while (i < lines.length) {
+					var line = lines[i] = lines[i].replace(/\s+$/g, "");
+					if (!line) lines.splice(i, 1);
+					else if (i > 0 && line[0] === " ") {
+						lines[i - 1] += line.slice(1);
+						lines.splice(i, 1);
+					} else i += 1;
+				}
+				return lines;
+			}
+			function validateDateParm(parms) {
+				parms.forEach(function(parm) {
+					if (!/(VALUE=DATE(-TIME)?)|(TZID=)/.test(parm)) throw new Error("unsupported RDATE/EXDATE parm: " + parm);
+				});
+			}
+			function parseRDate(rdateval, parms) {
+				validateDateParm(parms);
+				return rdateval.split(",").map(function(datestr) {
+					return untilStringToDate(datestr);
+				});
+			}
+			function createGetterSetter(fieldName) {
+				var _this = this;
+				return function(field) {
+					if (field !== void 0) _this["_".concat(fieldName)] = field;
+					if (_this["_".concat(fieldName)] !== void 0) return _this["_".concat(fieldName)];
+					for (var i = 0; i < _this._rrule.length; i++) {
+						var field_1 = _this._rrule[i].origOptions[fieldName];
+						if (field_1) return field_1;
+					}
+				};
+			}
+			var RRuleSet = function(_super) {
+				__extends(RRuleSet, _super);
+				/**
+				*
+				* @param {Boolean?} noCache
+				* The same stratagy as RRule on cache, default to false
+				* @constructor
+				*/
+				function RRuleSet(noCache) {
+					if (noCache === void 0) noCache = false;
+					var _this = _super.call(this, {}, noCache) || this;
+					_this.dtstart = createGetterSetter.apply(_this, ["dtstart"]);
+					_this.tzid = createGetterSetter.apply(_this, ["tzid"]);
+					_this._rrule = [];
+					_this._rdate = [];
+					_this._exrule = [];
+					_this._exdate = [];
+					return _this;
+				}
+				RRuleSet.prototype._iter = function(iterResult) {
+					return iterSet(iterResult, this._rrule, this._exrule, this._rdate, this._exdate, this.tzid());
+				};
+				/**
+				* Adds an RRule to the set
+				*
+				* @param {RRule}
+				*/
+				RRuleSet.prototype.rrule = function(rrule) {
+					_addRule(rrule, this._rrule);
+				};
+				/**
+				* Adds an EXRULE to the set
+				*
+				* @param {RRule}
+				*/
+				RRuleSet.prototype.exrule = function(rrule) {
+					_addRule(rrule, this._exrule);
+				};
+				/**
+				* Adds an RDate to the set
+				*
+				* @param {Date}
+				*/
+				RRuleSet.prototype.rdate = function(date) {
+					_addDate(date, this._rdate);
+				};
+				/**
+				* Adds an EXDATE to the set
+				*
+				* @param {Date}
+				*/
+				RRuleSet.prototype.exdate = function(date) {
+					_addDate(date, this._exdate);
+				};
+				/**
+				* Get list of included rrules in this recurrence set.
+				*
+				* @return List of rrules
+				*/
+				RRuleSet.prototype.rrules = function() {
+					return this._rrule.map(function(e) {
+						return rrulestr(e.toString());
+					});
+				};
+				/**
+				* Get list of excluded rrules in this recurrence set.
+				*
+				* @return List of exrules
+				*/
+				RRuleSet.prototype.exrules = function() {
+					return this._exrule.map(function(e) {
+						return rrulestr(e.toString());
+					});
+				};
+				/**
+				* Get list of included datetimes in this recurrence set.
+				*
+				* @return List of rdates
+				*/
+				RRuleSet.prototype.rdates = function() {
+					return this._rdate.map(function(e) {
+						return new Date(e.getTime());
+					});
+				};
+				/**
+				* Get list of included datetimes in this recurrence set.
+				*
+				* @return List of exdates
+				*/
+				RRuleSet.prototype.exdates = function() {
+					return this._exdate.map(function(e) {
+						return new Date(e.getTime());
+					});
+				};
+				RRuleSet.prototype.valueOf = function() {
+					var result = [];
+					if (!this._rrule.length && this._dtstart) result = result.concat(optionsToString({ dtstart: this._dtstart }));
+					this._rrule.forEach(function(rrule) {
+						result = result.concat(rrule.toString().split("\n"));
+					});
+					this._exrule.forEach(function(exrule) {
+						result = result.concat(exrule.toString().split("\n").map(function(line) {
+							return line.replace(/^RRULE:/, "EXRULE:");
+						}).filter(function(line) {
+							return !/^DTSTART/.test(line);
+						}));
+					});
+					if (this._rdate.length) result.push(rdatesToString("RDATE", this._rdate, this.tzid()));
+					if (this._exdate.length) result.push(rdatesToString("EXDATE", this._exdate, this.tzid()));
+					return result;
+				};
+				/**
+				* to generate recurrence field such as:
+				* DTSTART:19970902T010000Z
+				* RRULE:FREQ=YEARLY;COUNT=2;BYDAY=TU
+				* RRULE:FREQ=YEARLY;COUNT=1;BYDAY=TH
+				*/
+				RRuleSet.prototype.toString = function() {
+					return this.valueOf().join("\n");
+				};
+				/**
+				* Create a new RRuleSet Object completely base on current instance
+				*/
+				RRuleSet.prototype.clone = function() {
+					var rrs = new RRuleSet(!!this._cache);
+					this._rrule.forEach(function(rule) {
+						return rrs.rrule(rule.clone());
+					});
+					this._exrule.forEach(function(rule) {
+						return rrs.exrule(rule.clone());
+					});
+					this._rdate.forEach(function(date) {
+						return rrs.rdate(new Date(date.getTime()));
+					});
+					this._exdate.forEach(function(date) {
+						return rrs.exdate(new Date(date.getTime()));
+					});
+					return rrs;
+				};
+				return RRuleSet;
+			}(RRule);
+			function _addRule(rrule, collection) {
+				if (!(rrule instanceof RRule)) throw new TypeError(String(rrule) + " is not RRule instance");
+				if (!includes(collection.map(String), String(rrule))) collection.push(rrule);
+			}
+			function _addDate(date, collection) {
+				if (!(date instanceof Date)) throw new TypeError(String(date) + " is not Date instance");
+				if (!includes(collection.map(Number), Number(date))) {
+					collection.push(date);
+					sort(collection);
+				}
+			}
+			function rdatesToString(param, rdates, tzid) {
+				var isUTC = !tzid || tzid.toUpperCase() === "UTC";
+				var header = isUTC ? "".concat(param, ":") : "".concat(param, ";TZID=").concat(tzid, ":");
+				var dateString = rdates.map(function(rdate) {
+					return timeToUntilString(rdate.valueOf(), isUTC);
+				}).join(",");
+				return "".concat(header).concat(dateString);
+			}
+			return __webpack_exports__;
+		})();
+	});
+})))();
+const PACKED_DATE_MULTIPLIER = 128;
+const PACKED_DATE_DAY_MASK = 31;
+const PACKED_DATE_MONTH_MASK = 15;
+const PACKED_DATE_MONTH_SHIFT = 5;
+const PACKED_DATE_YEAR_SHIFT = 9;
+const THINGS_REMINDER_HOUR_SCALE = 67108864;
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isValidPackedDate = (parts) => isValidDateOnlyParts(parts);
+const formatFloatingDate = (parts) => {
+	const formatted = parts ? formatDateOnlyParts(parts) : null;
+	return formatted ? `${formatted.replaceAll("-", "")}T000000` : null;
+};
+const dateOnlyEpochToLocalMidnightInstant = (epochMs) => {
+	const parts = epochToDateOnlyParts(epochMs);
+	if (!parts) return null;
+	return new Date(parts.year, parts.month - 1, parts.day).getTime();
+};
+const decodeThingsPackedDateParts = (value) => {
+	if (!isFiniteNumber(value)) return null;
+	const integer = Math.trunc(value);
+	if (integer <= 0 || integer % PACKED_DATE_MULTIPLIER !== 0) return null;
+	const packed = integer / PACKED_DATE_MULTIPLIER;
+	const parts = {
+		day: packed % (PACKED_DATE_DAY_MASK + 1),
+		month: Math.trunc(packed / 2 ** PACKED_DATE_MONTH_SHIFT) % (PACKED_DATE_MONTH_MASK + 1),
+		year: Math.trunc(packed / 2 ** PACKED_DATE_YEAR_SHIFT)
+	};
+	return isValidPackedDate(parts) ? parts : null;
+};
+const decodeThingsPackedDate = (value) => {
 	const parts = decodeThingsPackedDateParts(value);
 	if (!parts) return null;
 	return dateOnlyPartsToEpoch(parts);
@@ -2380,7 +5151,6 @@ const THINGS_WEEKDAY_TO_RRULE = [
 	"FR",
 	"SA"
 ];
-const { RRule, rrulestr } = rrule;
 const parseNumericPlistField = (xml, key) => {
 	const match = new RegExp(`<key>${key}</key>\\s*<(integer|real)>([^<]+)</\\1>`).exec(xml);
 	if (!match?.[2]) return null;
@@ -2406,8 +5176,8 @@ const parseOffsets = (xml) => {
 };
 const parseRRule = (rule) => {
 	try {
-		const parsed = rrulestr(rule);
-		return parsed instanceof RRule ? parsed : null;
+		const parsed = (0, import_rrule.rrulestr)(rule);
+		return parsed instanceof import_rrule.RRule ? parsed : null;
 	} catch {
 		return null;
 	}
@@ -2993,8 +5763,6 @@ const pushTaskMutation = (ctx, tasks, taskLabels, checklistItems, mutationOption
 			creatorId: ctx.creatorId,
 			deadlineAt: decodeThingsPackedDate(mutationOptions.task.deadline),
 			deadlineSuppressionAt: decodeThingsPackedDate(mutationOptions.task.deadlineSuppressionDate),
-			delegateId: null,
-			delegatedAt: null,
 			description: appendMetadataBlock(mutationOptions.task.notes, ctx.metadataMode, buildTaskMetadata(mutationOptions.task, contact, buildChecklistOverflowMetadata(mutationOptions.task, ctx.checklistByTaskId))),
 			headingId: mutationOptions.task.headingId === null ? null : ctx.headingIdBySourceId.get(mutationOptions.task.headingId) ?? null,
 			lastReminderInteractionAt: decodeThingsUnixSeconds(mutationOptions.task.lastReminderInteractionDate),
@@ -3867,12 +6635,173 @@ const runLabelShow = async (context, labelRef, options) => {
 	writeInfo(context, `createdAt: ${formatEpochDate(label.createdAt) ?? "(none)"}`);
 	writeInfo(context, `updatedAt: ${formatEpochDate(label.updatedAt) ?? "(none)"}`);
 };
+const UUID_REGEX$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const resolveTaskForLabel = async (context, options) => {
+	const taskRef = options.taskRef.trim();
+	if (!taskRef) throw new Error("Task id is required.");
+	const exact = await loadTaskById(context, {
+		baseUrl: options.commandContext.apiBaseUrl,
+		taskId: taskRef,
+		token: options.commandContext.token
+	});
+	if (exact) return exact;
+	if (UUID_REGEX$1.test(taskRef)) throw new Error(`Task "${taskRef}" not found.`);
+	if (taskRef.length < 4) throw new Error("Task id prefix must be at least 4 characters.");
+	const { workspace } = await resolveWorkspace(context, {
+		apiBaseUrl: options.commandContext.apiBaseUrl,
+		storedWorkspaceId: options.commandContext.localContext.workspaceId,
+		token: options.commandContext.token,
+		workspaceRef: options.workspaceRef
+	});
+	const matches = (await loadTasksByWorkspace(context, {
+		baseUrl: options.commandContext.apiBaseUrl,
+		token: options.commandContext.token,
+		workspaceId: workspace.id
+	})).filter((task) => task.id.startsWith(taskRef));
+	if (matches.length === 0) throw new Error(`Task "${taskRef}" not found.`);
+	if (matches.length === 1) {
+		const [match] = matches;
+		if (!match) throw new Error(`Task "${taskRef}" not found.`);
+		return match;
+	}
+	throw new Error(`Task prefix "${taskRef}" is ambiguous (${matches.length} matches). Use the full id.`);
+};
+const runLabelCreate = async (context, title, options) => {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace } = await resolveWorkspace(context, {
+		apiBaseUrl: commandContext.apiBaseUrl,
+		storedWorkspaceId: commandContext.localContext.workspaceId,
+		token: commandContext.token,
+		workspaceRef: normalizeWorkspaceRef(options.workspace)
+	});
+	const labelId = randomUUID();
+	const now = Date.now();
+	await mutateModel(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				action: "INSERT",
+				clientId: commandContext.localContext.clientId,
+				clientTxId: randomUUID(),
+				modelId: labelId,
+				modelName: "Label",
+				payload: {
+					createdAt: now,
+					key: labelId.replaceAll("-", "").slice(0, 8),
+					title: title.trim(),
+					updatedAt: now,
+					workspaceId: workspace.id
+				}
+			}]
+		},
+		token: commandContext.token
+	});
+	if (context.json) {
+		writeOutput(context, {
+			created: true,
+			id: labelId,
+			title: title.trim()
+		});
+		return;
+	}
+	writeSuccess(context, `Created label: ${title.trim()}`);
+};
+const runLabelAdd = async (context, taskRef, labelRef, options) => {
+	const commandContext = await resolveCommandContext(context);
+	const workspaceRef = normalizeWorkspaceRef(options.workspace);
+	const task = await resolveTaskForLabel(context, {
+		commandContext,
+		taskRef,
+		workspaceRef
+	});
+	const label = await resolveLabel(context, {
+		commandContext,
+		labelRef,
+		workspaceRef
+	});
+	await mutateModel(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				action: "INSERT",
+				clientId: commandContext.localContext.clientId,
+				clientTxId: randomUUID(),
+				modelId: `${task.id}:${label.id}`,
+				modelName: "TaskLabel",
+				payload: {
+					createdAt: Date.now(),
+					labelId: label.id,
+					taskId: task.id,
+					workspaceId: task.workspaceId
+				}
+			}]
+		},
+		token: commandContext.token
+	});
+	if (context.json) {
+		writeOutput(context, {
+			added: true,
+			labelId: label.id,
+			labelTitle: label.title,
+			taskId: task.id
+		});
+		return;
+	}
+	writeSuccess(context, `Added label "${label.title}" to task "${task.title}"`);
+};
+const runLabelRemove = async (context, taskRef, labelRef, options) => {
+	const commandContext = await resolveCommandContext(context);
+	const workspaceRef = normalizeWorkspaceRef(options.workspace);
+	const task = await resolveTaskForLabel(context, {
+		commandContext,
+		taskRef,
+		workspaceRef
+	});
+	const label = await resolveLabel(context, {
+		commandContext,
+		labelRef,
+		workspaceRef
+	});
+	await mutateModel(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				action: "DELETE",
+				clientId: commandContext.localContext.clientId,
+				clientTxId: randomUUID(),
+				modelId: `${task.id}:${label.id}`,
+				modelName: "TaskLabel",
+				payload: {
+					labelId: label.id,
+					taskId: task.id
+				}
+			}]
+		},
+		token: commandContext.token
+	});
+	if (context.json) {
+		writeOutput(context, {
+			labelId: label.id,
+			labelTitle: label.title,
+			removed: true,
+			taskId: task.id
+		});
+		return;
+	}
+	writeSuccess(context, `Removed label "${label.title}" from task "${task.title}"`);
+};
 const registerLabelCommands = (program, workspaceOverride) => {
 	const label = program.command("label").alias("labels").description("Manage labels").addHelpText("after", `
 Examples:
   donebear label
   donebear label list --sort alpha
   donebear label show bug
+  donebear label create "urgent"
+  donebear label add <task-id> <label>
+  donebear label remove <task-id> <label>
 `).action(async (_options, command) => {
 		const context = contextFromCommand(command);
 		await runWithErrorHandling(context, async () => {
@@ -3894,6 +6823,24 @@ Examples:
 			await runLabelShow(context, labelRef, { workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0 });
 		});
 	});
+	label.command("create").description("Create a new label").argument("<title>", "Label title").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (title, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLabelCreate(context, title, { workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0 });
+		});
+	});
+	label.command("add").description("Add a label to a task").argument("<task-id>", "Task id or prefix").argument("<label>", "Label id, title, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskRef, labelRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLabelAdd(context, taskRef, labelRef, { workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0 });
+		});
+	});
+	label.command("remove").alias("rm").description("Remove a label from a task").argument("<task-id>", "Task id or prefix").argument("<label>", "Label id, title, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskRef, labelRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLabelRemove(context, taskRef, labelRef, { workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0 });
+		});
+	});
 };
 //#endregion
 //#region src/confirm.ts
@@ -4510,6 +7457,7 @@ const runTaskAdd = async (context, title, options, workspaceOverride) => {
 					creatorId: userId,
 					deadlineAt: deadlineEpoch,
 					description: notes,
+					key: taskId.replaceAll("-", "").slice(0, 8),
 					projectId,
 					sortOrder: 0,
 					teamId,