@ultimat3/time 1.0.0

package/src/cron-describe.ts

@@ -0,0 +1,159 @@
+/**
+ * Human-readable cron descriptions (`describeCron`): month and weekday names from `Intl`, every
+ * connective phrase supplied by the caller. Tier 1 cannot reach `t()`, and a default set would
+ * ship English to every locale that forgot the argument — so injection is mandatory, not opt-in.
+ */
+
+import { type CronExpression, parseCronOnce } from './cron-parse';
+import { localeInvalid } from './errors';
+
+export interface CronPhrases {
+  everyMinute: string;
+  everyNMinutes: string;
+  everyHour: string;
+  everyNHours: string;
+  at: string;
+  /** Closes a capped clock-time list, e.g. `and {n} more`. */
+  andMore: string;
+  onDaysOfMonth: string;
+  onWeekdays: string;
+  inMonths: string;
+  everyDay: string;
+}
+
+/** `1-59 * * * *` expands to 1416 clock times; a summary that long is not a summary. */
+const MAX_LISTED_TIMES = 6;
+
+/**
+ * `describeCron('0 3 * * MON-FRI', 'en', phrases)` → `at 03:00 on Monday–Friday`.
+ * Every phrase comes from the caller's `t('time.cron.*')`; only the names are `Intl`'s.
+ */
+export function describeCron(
+  expression: string | CronExpression,
+  locale: string,
+  phrases: CronPhrases,
+): string {
+  assertLocale(locale);
+  const cron = parseCronOnce(expression);
+  const list = new Intl.ListFormat(locale, { style: 'long', type: 'conjunction' });
+  const segments: string[] = [];
+
+  const minuteStep = uniformStep(cron.minutes, 60);
+  const hourStep = uniformStep(cron.hours, 24);
+  // Only a fixed clock time reads as "at 03:00 every day"; an interval already says it.
+  let explicitTime = false;
+
+  if (minuteStep !== undefined && cron.hours.length === 24) {
+    segments.push(
+      minuteStep === 1 ? phrases.everyMinute : fill(phrases.everyNMinutes, { n: minuteStep }),
+    );
+  } else if (cron.minutes.length === 1 && cron.minutes[0] === 0 && hourStep !== undefined) {
+    // Only an on-the-hour minute is a bare interval: `15 */6 * * *` must keep its :15 offset.
+    segments.push(hourStep === 1 ? phrases.everyHour : fill(phrases.everyNHours, { n: hourStep }));
+  } else {
+    explicitTime = true;
+    segments.push(fill(phrases.at, { time: clockTimes(cron, phrases, locale, list) }));
+  }
+
+  if (cron.dayOfMonthRestricted) {
+    const days = list.format(cron.daysOfMonth.map(String));
+    segments.push(fill(phrases.onDaysOfMonth, { days }));
+  }
+  if (cron.dayOfWeekRestricted) {
+    const days = list.format(cron.daysOfWeek.map((day) => weekdayName(day, locale)));
+    segments.push(fill(phrases.onWeekdays, { days }));
+  }
+  if (cron.months.length < 12) {
+    const months = list.format(cron.months.map((month) => monthName(month, locale)));
+    segments.push(fill(phrases.inMonths, { months }));
+  }
+  if (explicitTime && segments.length === 1) segments.push(phrases.everyDay);
+  return segments.join(' ');
+}
+
+/** The clock times, capped — the overflow is counted out loud so a cut list never reads whole. */
+function clockTimes(
+  cron: CronExpression,
+  phrases: CronPhrases,
+  locale: string,
+  list: Intl.ListFormat,
+): string {
+  const times = cron.hours.flatMap((hour) =>
+    cron.minutes.map((minute) => `${pad2(hour)}:${pad2(minute)}`),
+  );
+  if (times.length <= MAX_LISTED_TIMES) return list.format(times);
+  // A cut list is not a closed one, so it drops the conjunction: `… and 09:25` would promise
+  // 09:25 is the last time there is. `unit` is ICU's comma-only list for exactly that reason.
+  const open = new Intl.ListFormat(locale, { style: 'long', type: 'unit' });
+  const shown = open.format(times.slice(0, MAX_LISTED_TIMES));
+  return `${shown} ${fill(phrases.andMore, { n: times.length - MAX_LISTED_TIMES })}`;
+}
+
+/** `Intl` throws a bare `RangeError` on a malformed tag; convert it once, at the entry point. */
+function assertLocale(locale: string): void {
+  try {
+    Intl.DateTimeFormat.supportedLocalesOf([locale]);
+  } catch {
+    throw localeInvalid(locale);
+  }
+}
+
+/** Step fields: an evenly spaced set starting at 0 that covers the whole range. */
+function uniformStep(values: readonly number[], size: number): number | undefined {
+  const first = values[0];
+  if (values.length < 2 || first !== 0) return undefined;
+  const step = (values[1] ?? 0) - first;
+  if (step <= 0 || values.length !== Math.ceil(size / step)) return undefined;
+  for (let index = 1; index < values.length; index += 1) {
+    if ((values[index] ?? -1) - (values[index - 1] ?? -1) !== step) return undefined;
+  }
+  return step;
+}
+
+function fill(template: string, vars: Readonly<Record<string, string | number>>): string {
+  return template.replace(/\{(\w+)\}/g, (match, name: string) => {
+    const value = vars[name];
+    return value === undefined ? match : String(value);
+  });
+}
+
+/**
+ * Hard-capped rather than key-normalised, because `locale` can arrive from an Accept-Language
+ * header: `supportedLocalesOf` collapses unknown *tags*, but still returns a distinct string for
+ * every unknown `-u-` extension value, so only a bound keeps the key space finite. FIFO — a `Map`
+ * iterates in insertion order — and a miss costs one `Intl` construction, not a wrong answer.
+ */
+const MAX_CACHED_LOCALES = 32;
+const monthFormatters = new Map<string, Intl.DateTimeFormat>();
+const weekdayFormatters = new Map<string, Intl.DateTimeFormat>();
+
+function formatterFor(
+  cache: Map<string, Intl.DateTimeFormat>,
+  locale: string,
+  options: Intl.DateTimeFormatOptions,
+): Intl.DateTimeFormat {
+  const hit = cache.get(locale);
+  if (hit !== undefined) return hit;
+  const formatter = new Intl.DateTimeFormat(locale, options);
+  if (cache.size >= MAX_CACHED_LOCALES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined) cache.delete(oldest);
+  }
+  cache.set(locale, formatter);
+  return formatter;
+}
+
+function monthName(month: number, locale: string): string {
+  const formatter = formatterFor(monthFormatters, locale, { month: 'long', timeZone: 'UTC' });
+  return formatter.format(new Date(Date.UTC(2026, month - 1, 1)));
+}
+
+function weekdayName(isoDay: number, locale: string): string {
+  const formatter = formatterFor(weekdayFormatters, locale, { weekday: 'long', timeZone: 'UTC' });
+  // 2026-06-01 is a Monday, so ISO day N is that date + (N - 1).
+  return formatter.format(new Date(Date.UTC(2026, 5, isoDay)));
+}
+
+function pad2(value: number): string {
+  return String(value).padStart(2, '0');
+}

package/src/cron-occurrence.ts

@@ -0,0 +1,203 @@
+/**
+ * Cron occurrence math: walking the local wall clock forward to the next matching instant,
+ * converted once with `fromZoned` so DST gaps and overlaps resolve correctly.
+ */
+
+import { type CronExpression, matchesDay, parseCronOnce } from './cron-parse';
+import { cronInvalid } from './errors';
+import { fromEpochMs, type Instant } from './instant';
+import { fromZoned, toZoned } from './zoned';
+import { assertTimeZone, type TimeZone, utcEpoch } from './zones';
+
+/** True when `at` matches the expression in `zone`, to the second. */
+export function matchesCron(
+  expression: string | CronExpression,
+  at: Instant,
+  zone: TimeZone,
+): boolean {
+  const cron = parseCronOnce(expression);
+  const zoned = toZoned(at, zone);
+  return (
+    cron.seconds.includes(zoned.second) &&
+    cron.minutes.includes(zoned.minute) &&
+    cron.hours.includes(zoned.hour) &&
+    cron.months.includes(zoned.month) &&
+    matchesDay(cron, zoned.day, zoned.weekday)
+  );
+}
+
+/**
+ * Iteration guard, counted in field advancements — not in minutes, and not in years. Each step
+ * moves whichever field rejected first, so one step is worth a second or a whole month depending
+ * on the expression; the budget only has to outlast every schedule that can actually match.
+ */
+const MAX_STEPS = 200_000;
+
+/**
+ * The next instant strictly after `after` that matches, computed on the zone's wall clock
+ * and converted with `fromZoned({ gap: 'next', overlap: 'first' })`:
+ *  - spring forward: a 02:30 daily job runs once, at the first existing local time after
+ *    the gap, instead of being silently skipped;
+ *  - fall back: a repeated local time runs once, on its first occurrence.
+ */
+export function nextCronOccurrence(
+  expression: string | CronExpression,
+  zone: TimeZone,
+  after: Instant,
+): Instant {
+  const cron = parseCronOnce(expression);
+  assertTimeZone(zone);
+
+  const start = toZoned(after, zone);
+  const cursor: Cursor = {
+    year: start.year,
+    month: start.month,
+    day: start.day,
+    hour: start.hour,
+    minute: start.minute,
+    second: start.second + 1,
+  };
+  carry(cursor);
+
+  for (let step = 0; step < MAX_STEPS; step += 1) {
+    if (!cron.months.includes(cursor.month)) {
+      cursor.month += 1;
+      cursor.day = 1;
+      resetTime(cursor);
+      carry(cursor);
+      continue;
+    }
+    if (cursor.day > daysInMonth(cursor.year, cursor.month)) {
+      cursor.month += 1;
+      cursor.day = 1;
+      resetTime(cursor);
+      carry(cursor);
+      continue;
+    }
+    if (!matchesDay(cron, cursor.day, isoWeekday(cursor))) {
+      cursor.day += 1;
+      resetTime(cursor);
+      carry(cursor);
+      continue;
+    }
+    if (!cron.hours.includes(cursor.hour)) {
+      cursor.hour += 1;
+      cursor.minute = 0;
+      cursor.second = 0;
+      carry(cursor);
+      continue;
+    }
+    if (!cron.minutes.includes(cursor.minute)) {
+      cursor.minute += 1;
+      cursor.second = 0;
+      carry(cursor);
+      continue;
+    }
+    if (!cron.seconds.includes(cursor.second)) {
+      cursor.second += 1;
+      carry(cursor);
+      continue;
+    }
+
+    const candidate = fromZoned({ ...cursor }, zone, { gap: 'next', overlap: 'first' });
+    if (candidate.getTime() > after.getTime()) return candidate;
+    // The DST gap can push a candidate onto an instant we have already passed; step on.
+    cursor.second += 1;
+    carry(cursor);
+  }
+
+  throw cronInvalid(
+    typeof expression === 'string' ? expression : cron.source,
+    `no occurrence after ${MAX_STEPS} search steps — the date fields can never all match (e.g. "0 0 30 2 *", a 30th of February)`,
+  );
+}
+
+/** The next `count` occurrences, each strictly after the previous one. */
+export function nextCronOccurrences(
+  expression: string | CronExpression,
+  zone: TimeZone,
+  after: Instant,
+  count: number,
+): Instant[] {
+  const cron = parseCronOnce(expression);
+  const results: Instant[] = [];
+  let cursor = after;
+  for (let index = 0; index < count; index += 1) {
+    cursor = nextCronOccurrence(cron, zone, cursor);
+    results.push(cursor);
+  }
+  return results;
+}
+
+/** Exported for the scheduler's leader loop: has this expression fired since `since`? */
+export function firedSince(
+  expression: string | CronExpression,
+  zone: TimeZone,
+  since: Instant,
+  until: Instant,
+): boolean {
+  if (until.getTime() <= since.getTime()) return false;
+  const next = nextCronOccurrence(expression, zone, since);
+  return next.getTime() <= until.getTime();
+}
+
+/** Epoch-ms helper used by the jobs package when it only has a number. */
+export function nextCronOccurrenceMs(
+  expression: string | CronExpression,
+  zone: TimeZone,
+  afterMs: number,
+): number {
+  return nextCronOccurrence(expression, zone, fromEpochMs(afterMs)).getTime();
+}
+
+interface Cursor {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+}
+
+function isoWeekday(cursor: Cursor): number {
+  const day = new Date(utcEpoch(cursor.year, cursor.month, cursor.day)).getUTCDay();
+  return ((day + 6) % 7) + 1;
+}
+
+function daysInMonth(year: number, month: number): number {
+  return new Date(utcEpoch(year, month + 1, 0)).getUTCDate();
+}
+
+function resetTime(cursor: Cursor): void {
+  cursor.hour = 0;
+  cursor.minute = 0;
+  cursor.second = 0;
+}
+
+/** Carry overflow up the fields so the cursor stays a real calendar date. */
+function carry(cursor: Cursor): void {
+  if (cursor.second > 59) {
+    cursor.minute += Math.floor(cursor.second / 60);
+    cursor.second %= 60;
+  }
+  if (cursor.minute > 59) {
+    cursor.hour += Math.floor(cursor.minute / 60);
+    cursor.minute %= 60;
+  }
+  if (cursor.hour > 23) {
+    cursor.day += Math.floor(cursor.hour / 24);
+    cursor.hour %= 24;
+  }
+  while (cursor.month > 12) {
+    cursor.month -= 12;
+    cursor.year += 1;
+  }
+  while (cursor.day > daysInMonth(cursor.year, cursor.month)) {
+    cursor.day -= daysInMonth(cursor.year, cursor.month);
+    cursor.month += 1;
+    if (cursor.month > 12) {
+      cursor.month = 1;
+      cursor.year += 1;
+    }
+  }
+}

package/src/cron-parse.ts

@@ -0,0 +1,193 @@
+/**
+ * Cron expression parsing: field grammar (lists, ranges, steps, names, macros) into the
+ * normalized `CronExpression` shape the occurrence and description modules consume.
+ */
+
+import { cronInvalid } from './errors';
+
+export interface CronExpression {
+  /** The normalized source text. */
+  source: string;
+  seconds: readonly number[];
+  minutes: readonly number[];
+  hours: readonly number[];
+  daysOfMonth: readonly number[];
+  months: readonly number[];
+  /** ISO weekdays, 1 = Monday … 7 = Sunday (cron's 0 and 7 both mean Sunday). */
+  daysOfWeek: readonly number[];
+  /** Vixie semantics: when both day fields are restricted, either one matching is a hit. */
+  dayOfMonthRestricted: boolean;
+  dayOfWeekRestricted: boolean;
+}
+
+const MACROS: Readonly<Record<string, string>> = {
+  '@yearly': '0 0 1 1 *',
+  '@annually': '0 0 1 1 *',
+  '@monthly': '0 0 1 * *',
+  '@weekly': '0 0 * * 0',
+  '@daily': '0 0 * * *',
+  '@midnight': '0 0 * * *',
+  '@hourly': '0 * * * *',
+};
+
+const MONTH_NAMES = [
+  'jan',
+  'feb',
+  'mar',
+  'apr',
+  'may',
+  'jun',
+  'jul',
+  'aug',
+  'sep',
+  'oct',
+  'nov',
+  'dec',
+];
+const DAY_NAMES = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+/** Parse 5 fields (`m h dom mon dow`) or 6 with a leading seconds field. */
+export function parseCron(expression: string): CronExpression {
+  const trimmed = expression.trim().toLowerCase();
+  const expanded = MACROS[trimmed] ?? trimmed;
+  const fields = expanded.split(/\s+/).filter((field) => field !== '');
+
+  if (fields.length !== 5 && fields.length !== 6) {
+    throw cronInvalid(expression, `expected 5 or 6 fields, got ${fields.length}`);
+  }
+  const withSeconds = fields.length === 6;
+  const [secondField, minuteField, hourField, domField, monthField, dowField] = withSeconds
+    ? fields
+    : ['0', ...fields];
+
+  const seconds = parseField(expression, secondField ?? '0', 0, 59);
+  const minutes = parseField(expression, minuteField ?? '*', 0, 59);
+  const hours = parseField(expression, hourField ?? '*', 0, 23);
+  const daysOfMonth = parseField(expression, domField ?? '*', 1, 31);
+  const months = parseField(expression, monthField ?? '*', 1, 12, MONTH_NAMES, 1);
+  const rawDow = parseField(expression, dowField ?? '*', 0, 7, DAY_NAMES, 0);
+
+  // 0 and 7 are both Sunday in cron; ISO calls Sunday 7.
+  const daysOfWeek = [...new Set(rawDow.map((day) => (day === 0 ? 7 : day)))].sort((a, b) => a - b);
+
+  return {
+    source: expanded,
+    seconds,
+    minutes,
+    hours,
+    daysOfMonth,
+    months,
+    daysOfWeek,
+    dayOfMonthRestricted: isRestricted(domField ?? '*'),
+    dayOfWeekRestricted: isRestricted(dowField ?? '*'),
+  };
+}
+
+export function isValidCron(expression: string): boolean {
+  try {
+    parseCron(expression);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function parseCronOnce(expression: string | CronExpression): CronExpression {
+  return typeof expression === 'string' ? parseCron(expression) : expression;
+}
+
+/** True when both day-of-month and day-of-week fields matter and either matching is a hit. */
+export function matchesDay(cron: CronExpression, day: number, weekday: number): boolean {
+  const domHit = cron.daysOfMonth.includes(day);
+  const dowHit = cron.daysOfWeek.includes(weekday);
+  if (cron.dayOfMonthRestricted && cron.dayOfWeekRestricted) return domHit || dowHit;
+  if (cron.dayOfMonthRestricted) return domHit;
+  if (cron.dayOfWeekRestricted) return dowHit;
+  return true;
+}
+
+function parseField(
+  expression: string,
+  field: string,
+  min: number,
+  max: number,
+  names: readonly string[] = [],
+  nameOffset = 0,
+): number[] {
+  const values = new Set<number>();
+  for (const part of field.split(',')) {
+    if (part === '') throw cronInvalid(expression, `empty list item in "${field}"`);
+    const [rangePart, stepPart] = part.split('/');
+    if (rangePart === undefined || (part.includes('/') && stepPart === undefined)) {
+      throw cronInvalid(expression, `malformed step in "${part}"`);
+    }
+    const step = stepPart === undefined ? 1 : parseInteger(stepPart);
+    if (step === undefined || step < 1) {
+      throw cronInvalid(expression, `step must be a positive integer in "${part}"`);
+    }
+
+    let from: number;
+    let to: number;
+    if (isWildcard(rangePart)) {
+      from = min;
+      to = max;
+    } else if (rangePart.includes('-')) {
+      const [left, right] = rangePart.split('-');
+      from = toNumber(expression, left, min, max, names, nameOffset);
+      to = toNumber(expression, right, min, max, names, nameOffset);
+    } else {
+      from = toNumber(expression, rangePart, min, max, names, nameOffset);
+      to = stepPart === undefined ? from : max;
+    }
+
+    if (from > to) {
+      // Wrapping ranges (`fri-mon`, `22-2`) are a real cron idiom.
+      for (let value = from; value <= max; value += step) values.add(value);
+      for (let value = min; value <= to; value += step) values.add(value);
+    } else {
+      for (let value = from; value <= to; value += step) values.add(value);
+    }
+  }
+  if (values.size === 0) throw cronInvalid(expression, `field "${field}" matches nothing`);
+  return [...values].sort((a, b) => a - b);
+}
+
+function toNumber(
+  expression: string,
+  token: string | undefined,
+  min: number,
+  max: number,
+  names: readonly string[],
+  nameOffset: number,
+): number {
+  if (token === undefined || token === '') throw cronInvalid(expression, 'missing value');
+  // Names match on their first three letters, so `mon` and `monday` both work — but a token
+  // carrying anything that is not a letter is a typo, not a name, and falls through to digits.
+  const named = /^[a-z]+$/.test(token) ? names.indexOf(token.slice(0, 3)) : -1;
+  const value = named === -1 ? parseInteger(token) : named + nameOffset;
+  if (value === undefined) {
+    throw cronInvalid(expression, `"${token}" is not a number or a name`);
+  }
+  if (value < min || value > max) {
+    throw cronInvalid(expression, `"${token}" is out of range ${min}-${max}`);
+  }
+  return value;
+}
+
+/**
+ * Digits only. `Number.parseInt('5x')` is 5, which would let `* * * * 5x` validate — a
+ * validator that accepts what the scheduler cannot mean hides the typo until it misfires.
+ */
+function parseInteger(token: string): number | undefined {
+  return /^\d+$/.test(token) ? Number.parseInt(token, 10) : undefined;
+}
+
+function isWildcard(field: string): boolean {
+  const [head] = field.split('/');
+  return head === '*' || head === '?';
+}
+
+/** `*` and `?` are "any"; a step like every-2nd-day restricts, and Vixie's OR rule sees that. */
+function isRestricted(field: string): boolean {
+  return field !== '*' && field !== '?';
+}

package/src/cron.d.ts

@@ -0,0 +1,60 @@
+/**
+ * A real cron parser and occurrence calculator. Timezone-aware through `fromZoned`, so
+ * `0 3 * * *` in `Europe/Berlin` fires at 03:00 local on both sides of a DST change
+ * instead of drifting to 02:00 or 04:00 for half the year.
+ */
+import { type Instant } from './instant';
+import { type TimeZone } from './zones';
+export interface CronExpression {
+    /** The normalized source text. */
+    source: string;
+    seconds: readonly number[];
+    minutes: readonly number[];
+    hours: readonly number[];
+    daysOfMonth: readonly number[];
+    months: readonly number[];
+    /** ISO weekdays, 1 = Monday … 7 = Sunday (cron's 0 and 7 both mean Sunday). */
+    daysOfWeek: readonly number[];
+    /** Vixie semantics: when both day fields are restricted, either one matching is a hit. */
+    dayOfMonthRestricted: boolean;
+    dayOfWeekRestricted: boolean;
+}
+/** Parse 5 fields (`m h dom mon dow`) or 6 with a leading seconds field. */
+export declare function parseCron(expression: string): CronExpression;
+export declare function isValidCron(expression: string): boolean;
+/** True when `at` matches the expression in `zone`, to the second. */
+export declare function matchesCron(expression: string | CronExpression, at: Instant, zone: TimeZone): boolean;
+/**
+ * The next instant strictly after `after` that matches, computed on the zone's wall clock
+ * and converted with `fromZoned({ gap: 'next', overlap: 'first' })`:
+ *  - spring forward: a 02:30 daily job runs once, at the first existing local time after
+ *    the gap, instead of being silently skipped;
+ *  - fall back: a repeated local time runs once, on its first occurrence.
+ */
+export declare function nextCronOccurrence(expression: string | CronExpression, zone: TimeZone, after: Instant): Instant;
+/** The next `count` occurrences, each strictly after the previous one. */
+export declare function nextCronOccurrences(expression: string | CronExpression, zone: TimeZone, after: Instant, count: number): Instant[];
+export interface CronPhrases {
+    everyMinute: string;
+    everyNMinutes: string;
+    everyHour: string;
+    everyNHours: string;
+    at: string;
+    onDaysOfMonth: string;
+    onWeekdays: string;
+    inMonths: string;
+    everyDay: string;
+}
+/** English defaults; the admin dashboard passes `t('time.cron.*')` instead. */
+export declare const DEFAULT_CRON_PHRASES: CronPhrases;
+/**
+ * `describeCron('0 3 * * MON-FRI', 'en')` → `at 03:00 on Monday–Friday`.
+ * Month and weekday names come from `Intl`; the connective phrases are injected so this
+ * package never hardcodes a user-facing English string.
+ */
+export declare function describeCron(expression: string | CronExpression, locale: string, phrases?: Partial<CronPhrases>): string;
+/** Exported for the scheduler's leader loop: has this expression fired since `since`? */
+export declare function firedSince(expression: string | CronExpression, zone: TimeZone, since: Instant, until: Instant): boolean;
+/** Epoch-ms helper used by the jobs package when it only has a number. */
+export declare function nextCronOccurrenceMs(expression: string | CronExpression, zone: TimeZone, afterMs: number): number;
+//# sourceMappingURL=cron.d.ts.map

package/src/cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["cron.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAe,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEtD,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExD,MAAM,WAAW,cAAc;IAC7B,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,+EAA+E;IAC/E,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,0FAA0F;IAC1F,oBAAoB,EAAE,OAAO,CAAC;IAC9B,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AA4BD,4EAA4E;AAC5E,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAkC5D;AAED,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAOvD;AAED,sEAAsE;AACtE,wBAAgB,WAAW,CACzB,UAAU,EAAE,MAAM,GAAG,cAAc,EACnC,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,QAAQ,GACb,OAAO,CAUT;AAKD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,GAAG,cAAc,EACnC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAkET;AAED,0EAA0E;AAC1E,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,GAAG,cAAc,EACnC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,EAAE,CASX;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB,EAAE,WAUlC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,GAAG,cAAc,EACnC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,OAAO,CAAC,WAAW,CAAM,GACjC,MAAM,CAuCR;AAyLD,yFAAyF;AACzF,wBAAgB,UAAU,CACxB,UAAU,EAAE,MAAM,GAAG,cAAc,EACnC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAIT;AAED,0EAA0E;AAC1E,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,GAAG,cAAc,EACnC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,MAAM,GACd,MAAM,CAER"}