better-supabase 0.11.0 → 0.13.0

package/dist/result-mijqfoJN.d.ts

@@ -0,0 +1,346 @@
+//#region src/core/errors.d.ts
+/**
+ * Extra fields carried by each error kind. Plugins can add kinds through the
+ * `errors` extension point; apps that want the new kinds in the union can add
+ * them to this interface.
+ */
+interface DbErrorKinds {
+  not_found: Record<never, never>;
+  unauthorized: Record<never, never>;
+  /**
+   * `required`: the assurance level the route needs, when a second factor is
+   * missing. `scopes`: the OAuth scopes the route needs, when a delegated token
+   * lacks one (`INSUFFICIENT_SCOPE`). `permission`: the key an `Authorizer`
+   * denied. `permissions`: the keys the caller lacks, such as the ones a
+   * workflow's steps need (`WORKFLOW_PUBLISHER_FORBIDDEN`). `approval`: the
+   * pending approval when the answer is `APPROVAL_REQUIRED`.
+   */
+  forbidden: {
+    required?: "aal1" | "aal2";
+    scopes?: readonly string[];
+    permission?: string;
+    permissions?: readonly string[];
+    approval?: {
+      readonly id: string;
+    };
+  };
+  conflict: {
+    constraint?: string;
+    columns?: readonly string[];
+  };
+  foreign_key: {
+    constraint?: string;
+    columns?: readonly string[];
+  };
+  check: {
+    constraint?: string;
+  };
+  not_null: {
+    column?: string;
+  };
+  exclusion: {
+    constraint?: string;
+  };
+  invalid_input: Record<never, never>;
+  /**
+   * A stored value the app type can't hold, e.g. `infinity` for a Temporal
+   * timestamp.
+   */
+  invalid_value: {
+    column?: string;
+  };
+  raised: Record<never, never>;
+  timeout: Record<never, never>;
+  serialization: Record<never, never>;
+  /**
+   * The database or a service could not be reached. `retryAfter`: seconds until
+   * a retry can succeed, when known (a paused connection pool).
+   */
+  network: {
+    retryAfter?: number;
+  };
+  aborted: Record<never, never>;
+  invalid_request: Record<never, never>;
+  validation: {
+    issues: readonly ValidationIssue[];
+  };
+  multiple_rows: Record<never, never>;
+  stale: Record<never, never>;
+  /**
+   * An `updateMany` or `deleteMany` matched more rows than its `maxAffected`
+   * allows; nothing was written. `maxAffected`: the limit, when known.
+   */
+  max_affected: {
+    maxAffected?: number;
+  };
+  /** `retryAfter`: seconds until the window resets (the `Retry-After` header). */
+  rate_limited: {
+    retryAfter?: number;
+  };
+  /**
+   * A usage quota is used up (`consume_quota`, SQLSTATE `BSQ29`). `meter`: what
+   * was metered, `limit`: the quota, `retryAfter`: seconds until the period
+   * resets.
+   */
+  quota_exceeded: {
+    meter?: string;
+    limit?: number;
+    retryAfter?: number;
+  };
+  /**
+   * The executor or its dialect can't run this operation (an include on SQLite,
+   * say).
+   */
+  unsupported: Record<never, never>;
+  unexpected: Record<never, never>;
+}
+type DbErrorKind = keyof DbErrorKinds;
+interface ValidationIssue {
+  readonly message: string;
+  readonly path?: readonly PropertyKey[];
+}
+interface DbErrorBase<K extends DbErrorKind> {
+  readonly kind: K;
+  readonly message: string;
+  /** SQLSTATE or PostgREST code (`23505`, `PGRST116`), when known. */
+  readonly code?: string;
+  /** Suggested HTTP status, used by the RFC 9457 mapping. */
+  readonly status: number;
+  readonly details?: string;
+  /** Postgres `HINT`. `raised` errors use it as an app-level error code. */
+  readonly hint?: string;
+  /** App-cased table key the operation ran against. */
+  readonly table?: string;
+}
+/**
+ * A database error as plain, serializable data. Safe to send across server
+ * action and RPC boundaries.
+ */
+type DbError = { [K in DbErrorKind]: DbErrorBase<K> & DbErrorKinds[K]; }[DbErrorKind];
+type DbErrorOf<K extends DbErrorKind> = Extract<DbError, {
+  kind: K;
+}>;
+declare function statusOf(kind: DbErrorKind): number;
+type ExtraOf<K extends DbErrorKind> = Record<never, never> extends DbErrorKinds[K] ? [extra?: DbErrorKinds[K] & Partial<Omit<DbErrorBase<K>, "kind">>] : [extra: DbErrorKinds[K] & Partial<Omit<DbErrorBase<K>, "kind">>];
+/** Creates a `DbError` with the default status for its kind. */
+declare function dbError<K extends DbErrorKind>(kind: K, message: string, ...[extra]: ExtraOf<K>): DbErrorOf<K>;
+declare function isDbError(value: unknown): value is DbError;
+/**
+ * A unique violation, optionally for one constraint. Accepts a `DbError` or a
+ * `DbException`. Pass the generated `UniqueConstraint` type to check names:
+ * `isConflict<UniqueConstraint>(error, 'customers_organization_id_kvk_key')`.
+ */
+declare const isConflict: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"conflict"> & {
+  readonly constraint: C;
+};
+/** A CHECK violation, optionally for one constraint (`CheckConstraint`). */
+declare const isCheck: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"check"> & {
+  readonly constraint: C;
+};
+/**
+ * A foreign key violation, optionally for one constraint
+ * (`ForeignKeyConstraint`).
+ */
+declare const isForeignKey: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"foreign_key"> & {
+  readonly constraint: C;
+};
+/**
+ * Handlers for `matchDbError`: one per error kind, plus `codes` for SQLSTATE
+ * codes.
+ */
+type DbErrorMatchers = { readonly [K in DbErrorKind]?: (error: DbErrorOf<K>) => unknown; } & {
+  /**
+   * Handlers by SQLSTATE or PostgREST code (`23505`, `PGRST116`). They run
+   * before the handler for the error's kind.
+   */
+  readonly codes?: Readonly<Record<string, (error: DbError) => unknown>>;
+};
+/**
+ * Builds the factory `.orThrow()` takes from handlers per error kind and per
+ * SQLSTATE code. A handler that returns `undefined`, and an error no handler
+ * matches, throw a `DbException`.
+ */
+declare function matchDbError(matchers: DbErrorMatchers): (error: DbError) => unknown;
+/** Raw error shape shared by PostgREST responses and `pg` errors. */
+interface RawDbError {
+  readonly message?: string;
+  readonly code?: string;
+  readonly details?: string | null;
+  readonly hint?: string | null;
+  readonly constraint?: string;
+  readonly column?: string;
+  readonly table?: string;
+  readonly name?: string;
+  /**
+   * Milliseconds until a retry can succeed, from `@supabase/server`'s pool
+   * errors.
+   */
+  readonly retryAfterMs?: number;
+}
+type ErrorMapper = (raw: RawDbError, fallback: DbError) => DbError | undefined;
+/**
+ * Maps a PostgREST or Postgres error to a `DbError`. Custom mappers run first;
+ * the first one that returns an error wins.
+ */
+declare function mapDbError(raw: RawDbError, mappers?: readonly ErrorMapper[]): DbError;
+//#endregion
+//#region src/core/result.d.ts
+/**
+ * Turns a `DbError` into the error `.orThrow()` throws; set with
+ * `betterSupabase.mapError()`.
+ */
+type ThrowMapper = (error: DbError) => unknown;
+type Ok<T> = {
+  readonly ok: true;
+  readonly data: T;
+  readonly error: null;
+};
+type Err<E = DbError> = {
+  readonly ok: false;
+  readonly data: null;
+  readonly error: E;
+};
+type Result<T, E = DbError> = Ok<T> | Err<E>;
+declare function ok<T>(data: T): Ok<T>;
+declare function err<E = DbError>(error: E): Err<E>;
+/**
+ * A lazy-free `PromiseLike<Result<T>>` with helpers. `await` gives the
+ * `Result`; `.orThrow()` gives the data or throws a `DbException`.
+ */
+declare class AsyncResult<T> implements PromiseLike<Result<T>> {
+  #private;
+  constructor(promise: Promise<Result<T>>);
+  static from<T>(run: () => Promise<Result<T>>): AsyncResult<T>;
+  static ok<T>(data: T): AsyncResult<T>;
+  static err<T = never>(error: DbError): AsyncResult<T>;
+  then<R1 = Result<T>, R2 = never>(onfulfilled?: ((value: Result<T>) => R1 | PromiseLike<R1>) | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
+  /**
+   * Resolves with the data, or rejects with a `DbException`. Pass `factory` to
+   * throw your own error instead, e.g. an HTTP error for your framework;
+   * without it, the mapper from `betterSupabase.mapError()` applies when one is
+   * set.
+   */
+  orThrow(factory?: (error: DbError) => unknown): Promise<T>;
+  /** Resolves with the data, or `fallback` when the result is an error. */
+  unwrapOr<F>(fallback: F): Promise<T | F>;
+  map<U>(fn: (data: T) => U): AsyncResult<U>;
+  mapError(fn: (error: DbError) => DbError): AsyncResult<T>;
+  andThen<U>(fn: (data: T) => PromiseLike<Result<U>>): AsyncResult<U>;
+}
+/**
+ * What `toBetterResult` returns: the `status`/`value`/`error` fields every
+ * better-result value has.
+ */
+type BetterResultValue<T, E> = {
+  readonly status: "ok";
+  readonly value: T;
+} | {
+  readonly status: "error";
+  readonly error: E;
+};
+/** The part of better-result's `Result` namespace `toBetterResult` calls. */
+interface BetterResultApi<T, E> {
+  ok(value: NoInfer<T>): unknown;
+  err(error: NoInfer<E>): unknown;
+}
+/** The value type of a better-result `Result` type. */
+type BetterResultOk<R> = R extends {
+  readonly status: "ok";
+  readonly value: infer T;
+} ? T : never;
+/** The error type of a better-result `Result` type. */
+type BetterResultErr<R> = R extends {
+  readonly status: "error";
+  readonly error: infer E;
+} ? E : never;
+/**
+ * Builds a better-result value with the `Result` namespace you pass, so
+ * better-result stays your dependency. Errors go through `mapError`, or, for a
+ * result from a `db` of `betterSupabase.mapError(fn)`, through `fn` (typed
+ * `unknown`).
+ *
+ * The value is typed as better-result's `Result<T, E>` when the call has one as
+ * its expected type (an annotation or a function's return type) or as its type
+ * argument. That type is checked against the row type and `mapError`. Without
+ * one, it is a `BetterResultValue<T, E>`.
+ *
+ * ```ts
+ * import { Result } from "better-result";
+ * const customer: Result<Customer, AppError> = toBetterResult(
+ *   await db.customers.findById(id),
+ *   Result,
+ *   toAppError,
+ * );
+ * ```
+ */
+declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: Result<BetterResultOk<R>>, api: BetterResultApi<BetterResultOk<R>, BetterResultErr<R>>, mapError: (error: DbError) => BetterResultErr<R>): R;
+declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: Result<BetterResultOk<R>> & (DbError extends BetterResultErr<R> ? unknown : never), api: BetterResultApi<BetterResultOk<R>, DbError>): R;
+declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: AsyncResult<BetterResultOk<R>>, api: BetterResultApi<BetterResultOk<R>, BetterResultErr<R>>, mapError: (error: DbError) => BetterResultErr<R>): Promise<R>;
+declare function toBetterResult<R extends BetterResultValue<unknown, unknown> = never>(result: AsyncResult<BetterResultOk<R>> & (unknown extends BetterResultErr<R> ? unknown : never), api: BetterResultApi<BetterResultOk<R>, unknown>): Promise<R>;
+declare function toBetterResult<T, E>(result: Result<T>, api: BetterResultApi<T, E>, mapError: (error: DbError) => E): BetterResultValue<T, E>;
+declare function toBetterResult<T>(result: Result<T>, api: BetterResultApi<T, DbError>): BetterResultValue<T, DbError>;
+declare function toBetterResult<T, E>(result: AsyncResult<T>, api: BetterResultApi<T, E>, mapError: (error: DbError) => E): Promise<BetterResultValue<T, E>>;
+declare function toBetterResult<T>(result: AsyncResult<T>, api: BetterResultApi<T, unknown>): Promise<BetterResultValue<T, unknown>>;
+/**
+ * An error class for one `DbError` kind. better-result's `class NotFound
+ * extends TaggedError("NotFound")<{ message: string; error: DbError }> {}`
+ * fits, as does any class whose constructor takes `{ message, error }`.
+ */
+type DbErrorClass<K extends DbErrorKind = DbErrorKind> = new (props: {
+  readonly message: string;
+  readonly error: DbErrorOf<K>;
+}) => unknown;
+/** Error classes by `DbError` kind; kinds left out use the fallback class. */
+type DbErrorClasses = { readonly [K in DbErrorKind]?: DbErrorClass<K>; };
+/** The error a `DbError` of kind `K` becomes. */
+type MappedDbError<M extends DbErrorClasses, F extends DbErrorClass, K extends DbErrorKind = DbErrorKind> = K extends keyof M ? M[K] extends (abstract new (...args: never[]) => infer I) ? I : F extends (abstract new (...args: never[]) => infer I) ? I : never : F extends (abstract new (...args: never[]) => infer I) ? I : never;
+/**
+ * Converts results with a fixed `Result` namespace and error mapping. Like
+ * `toBetterResult`, the value is typed as better-result's `Result<T, E>` when
+ * the call has one as its expected type, and `E` must accept every error the
+ * mapping returns.
+ */
+interface BetterResultErrors<M extends DbErrorClasses, F extends DbErrorClass> {
+  <R extends BetterResultValue<unknown, unknown> = never>(result: Result<BetterResultOk<R>> & (MappedDbError<M, F> extends BetterResultErr<R> ? unknown : never)): R;
+  <R extends BetterResultValue<unknown, unknown> = never>(result: AsyncResult<BetterResultOk<R>> & (MappedDbError<M, F> extends BetterResultErr<R> ? unknown : never)): Promise<R>;
+  <T>(result: Result<T>): BetterResultValue<T, MappedDbError<M, F>>;
+  <T>(result: AsyncResult<T>): Promise<BetterResultValue<T, MappedDbError<M, F>>>;
+  /** The error instance for one `DbError`, typed by its kind. */
+  map<E extends DbError>(error: E): MappedDbError<M, F, E["kind"]>;
+}
+/**
+ * A typed mapping from `DbError` kinds to error classes, usually better-result
+ * `TaggedError` classes, bound to better-result's `Result` namespace. Kinds
+ * without a class use `fallback`. Each instance gets the error's `message` and
+ * the `DbError` itself as `error`.
+ *
+ * ```ts
+ * import { Result, TaggedError } from "better-result";
+ * class NotFound extends TaggedError("NotFound")<{
+ *   message: string;
+ *   error: DbError;
+ * }> {}
+ * class DbFailure extends TaggedError("DbFailure")<{
+ *   message: string;
+ *   error: DbError;
+ * }> {}
+ * const toResult = defineBetterResultErrors(
+ *   Result,
+ *   { not_found: NotFound },
+ *   DbFailure,
+ * );
+ * const customer: Result<Customer, NotFound | DbFailure> = await toResult(
+ *   db.customers.findById(id),
+ * );
+ * ```
+ */
+declare function defineBetterResultErrors<const M extends DbErrorClasses, F extends DbErrorClass>(api: BetterResultApi<unknown, unknown>, classes: M, fallback: F): BetterResultErrors<M, F>;
+/**
+ * Converts a better-result value back into a `Result`, by its `status` field,
+ * so it works across better-result versions. A `DbError`, or an error whose
+ * `cause` is one, is kept; others go through `mapError` (default `toDbError`).
+ */
+declare function fromBetterResult<T>(result: BetterResultValue<T, unknown>, mapError?: (error: unknown) => DbError): Result<T>;
+declare function toDbError(cause: unknown): DbError;
+//#endregion
+export { isConflict as A, DbErrorMatchers as C, ValidationIssue as D, RawDbError as E, statusOf as F, isForeignKey as M, mapDbError as N, dbError as O, matchDbError as P, DbErrorKinds as S, ErrorMapper as T, ok as _, BetterResultOk as a, DbError as b, DbErrorClasses as c, Ok as d, Result as f, fromBetterResult as g, err as h, BetterResultErrors as i, isDbError as j, isCheck as k, Err as l, defineBetterResultErrors as m, BetterResultApi as n, BetterResultValue as o, ThrowMapper as p, BetterResultErr as r, DbErrorClass as s, AsyncResult as t, MappedDbError as u, toBetterResult as v, DbErrorOf as w, DbErrorKind as x, toDbError as y };

package/dist/rrule-CesB9Rxd.js

@@ -0,0 +1,290 @@
+import { t as temporal } from "./temporal-required-Dt4mcPsi.js";
+//#region src/blocks/reminders/rrule.ts
+/**
+* Expands an RFC 5545 recurrence rule on `Temporal.ZonedDateTime`, so a local
+* time stays on the same clock time across a daylight-saving change. Covered
+* parts: FREQ, INTERVAL, COUNT, UNTIL, BYDAY (with ordinals), BYMONTHDAY,
+* BYMONTH, BYSETPOS and WKST.
+*/
+const DAYS = {
+	MO: 1,
+	TU: 2,
+	WE: 3,
+	TH: 4,
+	FR: 5,
+	SA: 6,
+	SU: 7
+};
+const DAY_NAME = [
+	"",
+	"MO",
+	"TU",
+	"WE",
+	"TH",
+	"FR",
+	"SA",
+	"SU"
+];
+function part(text) {
+	const body = text.replace(/^RRULE:/i, "").trim();
+	const fields = new Map(body.split(";").map((item) => {
+		const eq = item.indexOf("=");
+		return [item.slice(0, eq).toUpperCase(), item.slice(eq + 1)];
+	}));
+	const frequency = frequencyOf(fields.get("FREQ"));
+	const interval = Number(fields.get("INTERVAL") ?? "1");
+	if (!Number.isInteger(interval) || interval < 1) throw new TypeError("INTERVAL must be a positive integer");
+	const countText = fields.get("COUNT");
+	const count = countText === void 0 ? void 0 : Number(countText);
+	if (count !== void 0 && (!Number.isInteger(count) || count < 1)) throw new TypeError("COUNT must be a positive integer");
+	const untilText = fields.get("UNTIL");
+	const byDay = (fields.get("BYDAY") ?? "").split(",").filter(Boolean).map(dayRule);
+	return {
+		frequency,
+		interval,
+		count,
+		until: untilText === void 0 ? void 0 : until(untilText),
+		byDay,
+		byMonthDay: numbers(fields.get("BYMONTHDAY")),
+		byMonth: numbers(fields.get("BYMONTH")),
+		bySetPos: numbers(fields.get("BYSETPOS")),
+		weekStart: DAYS[fields.get("WKST") ?? "MO"] ?? 1
+	};
+}
+function dayRule(text) {
+	const match = /^([+-]?\d+)?(MO|TU|WE|TH|FR|SA|SU)$/.exec(text.toUpperCase());
+	if (!match) throw new TypeError(`BYDAY value ${text} is not a weekday`);
+	const day = DAYS[match[2] ?? ""];
+	if (day === void 0) throw new TypeError(`BYDAY value ${text} is not a weekday`);
+	return {
+		ordinal: match[1] === void 0 ? void 0 : Number(match[1]),
+		day
+	};
+}
+function numbers(text) {
+	if (text === void 0 || text === "") return [];
+	return text.split(",").map((item) => {
+		const value = Number(item);
+		if (!Number.isInteger(value) || value === 0) throw new TypeError(`recurrence part ${item} is not a non-zero integer`);
+		return value;
+	});
+}
+function until(text) {
+	const match = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z$/.exec(text);
+	if (!match) throw new TypeError("UNTIL must be a UTC date-time");
+	const [, year, month, day, hour, minute, second] = match;
+	return temporal().Instant.from(`${year}-${month}-${day}T${hour}:${minute}:${second}Z`);
+}
+const COLUMN_FREQUENCY = {
+	daily: "DAILY",
+	weekly: "WEEKLY",
+	monthly: "MONTHLY",
+	yearly: "YEARLY"
+};
+function frequencyOf(value) {
+	if (value === "DAILY" || value === "WEEKLY" || value === "MONTHLY" || value === "YEARLY") return value;
+	throw new TypeError("an RRULE needs FREQ of DAILY, WEEKLY, MONTHLY or YEARLY");
+}
+function fromColumns(columns) {
+	const frequency = COLUMN_FREQUENCY[columns.frequency];
+	const byDay = columns.monthWeekday === void 0 ? (columns.weekDays ?? []).map((day) => ({
+		ordinal: void 0,
+		day
+	})) : [{
+		ordinal: columns.monthOrdinal,
+		day: columns.monthWeekday
+	}];
+	return {
+		frequency,
+		interval: columns.interval ?? 1,
+		count: columns.count,
+		until: columns.until,
+		byDay,
+		byMonthDay: columns.monthDay === void 0 ? [] : [columns.monthDay],
+		byMonth: [],
+		bySetPos: [],
+		weekStart: 1
+	};
+}
+function at(date, start) {
+	return date.toZonedDateTime({
+		timeZone: start.timeZoneId,
+		plainTime: start.toPlainTime()
+	});
+}
+function monthDay(year, month, which) {
+	const dates = temporal().PlainDate;
+	const length = dates.from({
+		year,
+		month,
+		day: 1
+	}).daysInMonth;
+	const day = which > 0 ? which : length + which + 1;
+	if (day < 1 || day > length) return;
+	return dates.from({
+		year,
+		month,
+		day
+	});
+}
+function nthWeekday(year, month, ordinal, weekday) {
+	const dates = temporal().PlainDate;
+	const first = dates.from({
+		year,
+		month,
+		day: 1
+	});
+	const length = first.daysInMonth;
+	if (ordinal > 0) {
+		const day = 1 + (weekday - first.dayOfWeek + 7) % 7 + (ordinal - 1) * 7;
+		if (day > length) return;
+		return dates.from({
+			year,
+			month,
+			day
+		});
+	}
+	const day = length - (dates.from({
+		year,
+		month,
+		day: length
+	}).dayOfWeek - weekday + 7) % 7 + (ordinal + 1) * 7;
+	if (day < 1) return;
+	return dates.from({
+		year,
+		month,
+		day
+	});
+}
+function weekOf(date, weekStart) {
+	const delta = (date.dayOfWeek - weekStart + 7) % 7;
+	return date.subtract({ days: delta });
+}
+function periodDates(start, rule, index) {
+	const anchor = start.toPlainDate();
+	if (rule.frequency === "DAILY") {
+		const date = anchor.add({ days: index * rule.interval });
+		if (rule.byDay.length > 0 && !rule.byDay.some((item) => item.day === date.dayOfWeek)) return [];
+		return [date];
+	}
+	if (rule.frequency === "WEEKLY") {
+		const week = weekOf(anchor, rule.weekStart).add({ weeks: index * rule.interval });
+		return (rule.byDay.length === 0 ? [{
+			ordinal: void 0,
+			day: anchor.dayOfWeek
+		}] : rule.byDay).map((item) => week.add({ days: (item.day - rule.weekStart + 7) % 7 }));
+	}
+	const moved = rule.frequency === "MONTHLY" ? anchor.add({ months: index * rule.interval }) : anchor.add({ years: index * rule.interval });
+	const months = rule.byMonth.length === 0 ? [moved.month] : rule.byMonth;
+	const dates = [];
+	for (const month of months) {
+		const year = rule.frequency === "YEARLY" ? moved.year : moved.year;
+		if (rule.byDay.some((item) => item.ordinal !== void 0)) {
+			for (const item of rule.byDay) {
+				if (item.ordinal === void 0) continue;
+				const date = nthWeekday(year, month, item.ordinal, item.day);
+				if (date) dates.push(date);
+			}
+			continue;
+		}
+		if (rule.byDay.length > 0) {
+			const datesOf = temporal().PlainDate;
+			const length = datesOf.from({
+				year,
+				month,
+				day: 1
+			}).daysInMonth;
+			for (let day = 1; day <= length; day += 1) {
+				const date = datesOf.from({
+					year,
+					month,
+					day
+				});
+				if (rule.byDay.some((item) => item.day === date.dayOfWeek)) dates.push(date);
+			}
+		} else if (rule.byMonthDay.length > 0) for (const which of rule.byMonthDay) {
+			const date = monthDay(year, month, which);
+			if (date) dates.push(date);
+		}
+		else {
+			const date = monthDay(year, month, moved.day);
+			if (date) dates.push(date);
+		}
+	}
+	return dates;
+}
+function applySetPos(dates, positions) {
+	const sorted = dates.toSorted((a, b) => temporal().PlainDate.compare(a, b));
+	const picked = /* @__PURE__ */ new Set();
+	for (const position of positions) {
+		const date = sorted[position > 0 ? position - 1 : sorted.length + position];
+		if (date) picked.add(date.toString());
+	}
+	return sorted.filter((date) => picked.has(date.toString()));
+}
+/** The occurrences of a rule, in order, starting at `dtstart` when it matches. */
+function expandRule(input) {
+	if (input.rrule === void 0 && input.columns === void 0) throw new TypeError("expandRule needs an rrule or columns");
+	const rule = input.columns === void 0 ? part(input.rrule ?? "") : fromColumns(input.columns);
+	const start = input.dtstart;
+	const span = input.window;
+	const cap = span === void 0 ? Math.min(rule.count ?? input.limit ?? 366, input.limit ?? 366) : input.limit ?? 1e3;
+	const first = span === void 0 || rule.count !== void 0 ? 0 : skipTo(start, rule, span.from);
+	const found = [];
+	let generated = 0;
+	for (let index = first; found.length < cap && index < first + 4e3; index += 1) {
+		let dates = periodDates(start, rule, index);
+		if (rule.bySetPos.length > 0) dates = applySetPos(dates, rule.bySetPos);
+		const time = temporal();
+		const ordered = dates.toSorted((a, b) => time.PlainDate.compare(a, b));
+		for (const date of ordered) {
+			const when = at(date, start);
+			if (time.ZonedDateTime.compare(when, start) < 0) continue;
+			const instant = when.toInstant();
+			if (rule.until !== void 0 && time.Instant.compare(instant, rule.until) > 0) return found;
+			generated += 1;
+			if (rule.count !== void 0 && generated > rule.count) return found;
+			if (span !== void 0) {
+				if (time.Instant.compare(instant, span.until) >= 0) return found;
+				if (time.Instant.compare(instant, span.from) < 0) continue;
+			}
+			found.push(when);
+			if (found.length >= cap) return found;
+		}
+	}
+	return found;
+}
+/** The first period index that can reach `from`, for a rule without COUNT. */
+function skipTo(start, rule, from) {
+	const anchor = start.toPlainDate();
+	const target = from.toZonedDateTimeISO(start.timeZoneId).toPlainDate();
+	if (temporal().PlainDate.compare(target, anchor) <= 0) return 0;
+	let periods;
+	switch (rule.frequency) {
+		case "DAILY":
+			periods = target.since(anchor, { largestUnit: "days" }).days;
+			break;
+		case "WEEKLY":
+			periods = Math.floor(target.since(weekOf(anchor, rule.weekStart), { largestUnit: "days" }).days / 7);
+			break;
+		case "MONTHLY":
+			periods = (target.year - anchor.year) * 12 + target.month - anchor.month;
+			break;
+		case "YEARLY":
+			periods = target.year - anchor.year;
+			break;
+		default: {
+			const never = rule.frequency;
+			throw new TypeError(`unknown frequency ${String(never)}`);
+		}
+	}
+	return Math.max(0, Math.floor(periods / rule.interval) - 1);
+}
+/** A weekday name for a column-format rule, 1 (Monday) through 7 (Sunday). */
+function weekdayName(day) {
+	const name = DAY_NAME[day];
+	if (name === void 0 || name === "") throw new TypeError("weekday must be 1 (Monday) through 7 (Sunday)");
+	return name;
+}
+//#endregion
+export { weekdayName as n, expandRule as t };