ts-time-utils 0.0.1 → 1.1.0

package/dist/recurrence.d.ts

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Recurring events and pattern-based date generation utilities
+ * Provides RRULE-inspired recurrence patterns for creating repeating events
+ */
+import type { DateInput, RecurrenceRule } from './types.js';
+/**
+ * Creates a recurrence pattern generator
+ * @param rule - The recurrence rule defining the pattern
+ * @returns An object with methods to work with the recurrence
+ *
+ * @example
+ * ```ts
+ * // Daily recurrence
+ * const daily = createRecurrence({
+ *   frequency: 'daily',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01')
+ * });
+ *
+ * // Weekly on Monday and Wednesday
+ * const weekly = createRecurrence({
+ *   frequency: 'weekly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 3] // Monday = 1, Wednesday = 3
+ * });
+ *
+ * // Monthly on the 15th
+ * const monthly = createRecurrence({
+ *   frequency: 'monthly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byMonthDay: [15]
+ * });
+ * ```
+ */
+export declare function createRecurrence(rule: RecurrenceRule): {
+    rule: RecurrenceRule;
+    getNextOccurrence: (afterDate?: DateInput) => Date | null;
+    getOccurrencesBetween: (start: DateInput, end: DateInput, limit?: number) => Date[];
+    isRecurrenceDate: (date: DateInput) => boolean;
+    getAllOccurrences: (limit?: number) => Date[];
+};
+/**
+ * Gets the next occurrence of a recurring event after a specified date
+ * @param rule - The recurrence rule
+ * @param afterDate - Date to find next occurrence after (defaults to now)
+ * @returns The next occurrence date, or null if no more occurrences
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'daily',
+ *   interval: 2,
+ *   startDate: new Date('2024-01-01')
+ * };
+ *
+ * const next = getNextOccurrence(rule, new Date('2024-01-05'));
+ * // Returns Date('2024-01-07') - every other day
+ * ```
+ */
+export declare function getNextOccurrence(rule: RecurrenceRule, afterDate?: DateInput): Date | null;
+/**
+ * Gets all occurrences of a recurring event between two dates
+ * @param rule - The recurrence rule
+ * @param start - Start date of the range
+ * @param end - End date of the range
+ * @param limit - Maximum number of occurrences to return (default: 1000)
+ * @returns Array of dates that match the recurrence pattern
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'weekly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 5] // Monday and Friday
+ * };
+ *
+ * const occurrences = getOccurrencesBetween(
+ *   rule,
+ *   new Date('2024-01-01'),
+ *   new Date('2024-01-31')
+ * );
+ * // Returns all Mondays and Fridays in January 2024
+ * ```
+ */
+export declare function getOccurrencesBetween(rule: RecurrenceRule, start: DateInput, end: DateInput, limit?: number): Date[];
+/**
+ * Checks if a specific date matches a recurrence rule
+ * @param date - The date to check
+ * @param rule - The recurrence rule
+ * @returns True if the date matches the recurrence pattern
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'weekly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1] // Mondays only
+ * };
+ *
+ * isRecurrenceDate(new Date('2024-01-08'), rule); // true (Monday)
+ * isRecurrenceDate(new Date('2024-01-09'), rule); // false (Tuesday)
+ * ```
+ */
+export declare function isRecurrenceDate(date: DateInput, rule: RecurrenceRule): boolean;
+/**
+ * Validates a recurrence rule
+ * @param rule - The recurrence rule to validate
+ * @returns True if the rule is valid
+ *
+ * @example
+ * ```ts
+ * isValidRecurrenceRule({
+ *   frequency: 'daily',
+ *   interval: 1,
+ *   startDate: new Date()
+ * }); // true
+ *
+ * isValidRecurrenceRule({
+ *   frequency: 'daily',
+ *   interval: 0, // Invalid
+ *   startDate: new Date()
+ * }); // false
+ * ```
+ */
+export declare function isValidRecurrenceRule(rule: Partial<RecurrenceRule>): boolean;
+/**
+ * Converts a recurrence rule to a human-readable string
+ * @param rule - The recurrence rule
+ * @returns A human-readable description
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'weekly',
+ *   interval: 2,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 3, 5]
+ * };
+ *
+ * recurrenceToString(rule);
+ * // "Every 2 weeks on Monday, Wednesday, Friday"
+ * ```
+ */
+export declare function recurrenceToString(rule: RecurrenceRule): string;
+//# sourceMappingURL=recurrence.d.ts.map

package/dist/recurrence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../src/recurrence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;oCAKjB,SAAS;mCACV,SAAS,OAAO,SAAS,UAAU,MAAM;6BAE/C,SAAS;;EAqBrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAyC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,KAAK,SAAO,GACX,IAAI,EAAE,CA6BR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAW/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAgC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CA6C/D"}

package/dist/recurrence.js

@@ -0,0 +1,404 @@
+/**
+ * @fileoverview Recurring events and pattern-based date generation utilities
+ * Provides RRULE-inspired recurrence patterns for creating repeating events
+ */
+import { addTime } from './calculate.js';
+/**
+ * Creates a recurrence pattern generator
+ * @param rule - The recurrence rule defining the pattern
+ * @returns An object with methods to work with the recurrence
+ *
+ * @example
+ * ```ts
+ * // Daily recurrence
+ * const daily = createRecurrence({
+ *   frequency: 'daily',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01')
+ * });
+ *
+ * // Weekly on Monday and Wednesday
+ * const weekly = createRecurrence({
+ *   frequency: 'weekly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 3] // Monday = 1, Wednesday = 3
+ * });
+ *
+ * // Monthly on the 15th
+ * const monthly = createRecurrence({
+ *   frequency: 'monthly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byMonthDay: [15]
+ * });
+ * ```
+ */
+export function createRecurrence(rule) {
+    const startDate = new Date(rule.startDate);
+    return {
+        rule,
+        getNextOccurrence: (afterDate) => getNextOccurrence(rule, afterDate),
+        getOccurrencesBetween: (start, end, limit) => getOccurrencesBetween(rule, start, end, limit),
+        isRecurrenceDate: (date) => isRecurrenceDate(date, rule),
+        getAllOccurrences: (limit = 100) => {
+            const occurrences = [];
+            let current = new Date(startDate);
+            let count = 0;
+            while (count < limit) {
+                if (rule.until && current > new Date(rule.until))
+                    break;
+                if (rule.count && count >= rule.count)
+                    break;
+                const next = getNextOccurrence(rule, current);
+                if (!next)
+                    break;
+                occurrences.push(next);
+                current = new Date(next.getTime() + 1);
+                count++;
+            }
+            return occurrences;
+        }
+    };
+}
+/**
+ * Gets the next occurrence of a recurring event after a specified date
+ * @param rule - The recurrence rule
+ * @param afterDate - Date to find next occurrence after (defaults to now)
+ * @returns The next occurrence date, or null if no more occurrences
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'daily',
+ *   interval: 2,
+ *   startDate: new Date('2024-01-01')
+ * };
+ *
+ * const next = getNextOccurrence(rule, new Date('2024-01-05'));
+ * // Returns Date('2024-01-07') - every other day
+ * ```
+ */
+export function getNextOccurrence(rule, afterDate) {
+    const after = afterDate ? new Date(afterDate) : new Date();
+    const start = new Date(rule.startDate);
+    // If afterDate is before start, check if start matches
+    if (after < start) {
+        if (matchesRecurrenceRule(start, rule)) {
+            return new Date(start);
+        }
+    }
+    // Check if we've exceeded count or until date
+    if (rule.until && after >= new Date(rule.until)) {
+        return null;
+    }
+    // Start searching from the day after 'after'
+    // We want strictly greater than after, so start from the next potential occurrence
+    let candidate = addTime(after, 1, 'day');
+    // Preserve time from start date
+    candidate.setHours(start.getHours(), start.getMinutes(), start.getSeconds(), start.getMilliseconds());
+    const maxIterations = 1000; // Prevent infinite loops
+    let iterations = 0;
+    while (iterations < maxIterations) {
+        if (rule.until && candidate > new Date(rule.until)) {
+            return null;
+        }
+        if (matchesRecurrenceRule(candidate, rule)) {
+            return new Date(candidate);
+        }
+        // Move to next potential date based on frequency
+        candidate = getNextCandidate(candidate, rule);
+        iterations++;
+    }
+    return null;
+}
+/**
+ * Gets all occurrences of a recurring event between two dates
+ * @param rule - The recurrence rule
+ * @param start - Start date of the range
+ * @param end - End date of the range
+ * @param limit - Maximum number of occurrences to return (default: 1000)
+ * @returns Array of dates that match the recurrence pattern
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'weekly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 5] // Monday and Friday
+ * };
+ *
+ * const occurrences = getOccurrencesBetween(
+ *   rule,
+ *   new Date('2024-01-01'),
+ *   new Date('2024-01-31')
+ * );
+ * // Returns all Mondays and Fridays in January 2024
+ * ```
+ */
+export function getOccurrencesBetween(rule, start, end, limit = 1000) {
+    const startDate = new Date(start);
+    const endDate = new Date(end);
+    const occurrences = [];
+    let current = new Date(rule.startDate);
+    // Fast forward to start date if recurrence starts before range
+    if (current < startDate) {
+        current = new Date(startDate);
+    }
+    let iterations = 0;
+    const maxIterations = limit * 10; // Safety limit
+    while (current <= endDate && occurrences.length < limit && iterations < maxIterations) {
+        if (rule.until && current > new Date(rule.until)) {
+            break;
+        }
+        if (matchesRecurrenceRule(current, rule) && current >= startDate) {
+            occurrences.push(new Date(current));
+        }
+        current = getNextCandidate(current, rule);
+        iterations++;
+    }
+    return occurrences;
+}
+/**
+ * Checks if a specific date matches a recurrence rule
+ * @param date - The date to check
+ * @param rule - The recurrence rule
+ * @returns True if the date matches the recurrence pattern
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'weekly',
+ *   interval: 1,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1] // Mondays only
+ * };
+ *
+ * isRecurrenceDate(new Date('2024-01-08'), rule); // true (Monday)
+ * isRecurrenceDate(new Date('2024-01-09'), rule); // false (Tuesday)
+ * ```
+ */
+export function isRecurrenceDate(date, rule) {
+    const checkDate = new Date(date);
+    const start = new Date(rule.startDate);
+    // Must be on or after start date
+    if (checkDate < start)
+        return false;
+    // Must be before until date if specified
+    if (rule.until && checkDate > new Date(rule.until))
+        return false;
+    return matchesRecurrenceRule(checkDate, rule);
+}
+/**
+ * Validates a recurrence rule
+ * @param rule - The recurrence rule to validate
+ * @returns True if the rule is valid
+ *
+ * @example
+ * ```ts
+ * isValidRecurrenceRule({
+ *   frequency: 'daily',
+ *   interval: 1,
+ *   startDate: new Date()
+ * }); // true
+ *
+ * isValidRecurrenceRule({
+ *   frequency: 'daily',
+ *   interval: 0, // Invalid
+ *   startDate: new Date()
+ * }); // false
+ * ```
+ */
+export function isValidRecurrenceRule(rule) {
+    if (!rule.frequency || !rule.startDate)
+        return false;
+    const validFrequencies = ['daily', 'weekly', 'monthly', 'yearly'];
+    if (!validFrequencies.includes(rule.frequency))
+        return false;
+    if (rule.interval !== undefined && rule.interval < 1)
+        return false;
+    if (rule.count !== undefined && rule.count < 1)
+        return false;
+    if (rule.until) {
+        const until = new Date(rule.until);
+        const start = new Date(rule.startDate);
+        if (until <= start)
+            return false;
+    }
+    if (rule.byWeekday) {
+        if (!Array.isArray(rule.byWeekday))
+            return false;
+        if (!rule.byWeekday.every((d) => d >= 0 && d <= 6))
+            return false;
+    }
+    if (rule.byMonthDay) {
+        if (!Array.isArray(rule.byMonthDay))
+            return false;
+        if (!rule.byMonthDay.every((d) => d >= 1 && d <= 31))
+            return false;
+    }
+    if (rule.byMonth) {
+        if (!Array.isArray(rule.byMonth))
+            return false;
+        if (!rule.byMonth.every((m) => m >= 1 && m <= 12))
+            return false;
+    }
+    return true;
+}
+/**
+ * Converts a recurrence rule to a human-readable string
+ * @param rule - The recurrence rule
+ * @returns A human-readable description
+ *
+ * @example
+ * ```ts
+ * const rule = {
+ *   frequency: 'weekly',
+ *   interval: 2,
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 3, 5]
+ * };
+ *
+ * recurrenceToString(rule);
+ * // "Every 2 weeks on Monday, Wednesday, Friday"
+ * ```
+ */
+export function recurrenceToString(rule) {
+    const interval = rule.interval || 1;
+    let result = interval === 1 ? 'Every' : `Every ${interval}`;
+    switch (rule.frequency) {
+        case 'daily':
+            result += interval === 1 ? ' day' : ' days';
+            break;
+        case 'weekly':
+            result += interval === 1 ? ' week' : ' weeks';
+            if (rule.byWeekday && rule.byWeekday.length > 0) {
+                const days = rule.byWeekday.map((d) => ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][d]);
+                result += ` on ${days.join(', ')}`;
+            }
+            break;
+        case 'monthly':
+            result += interval === 1 ? ' month' : ' months';
+            if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+                result += ` on day ${rule.byMonthDay.join(', ')}`;
+            }
+            break;
+        case 'yearly':
+            result += interval === 1 ? ' year' : ' years';
+            if (rule.byMonth && rule.byMonth.length > 0) {
+                const months = rule.byMonth.map((m) => ['January', 'February', 'March', 'April', 'May', 'June',
+                    'July', 'August', 'September', 'October', 'November', 'December'][m - 1]);
+                result += ` in ${months.join(', ')}`;
+            }
+            if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+                result += ` on day ${rule.byMonthDay.join(', ')}`;
+            }
+            break;
+    }
+    if (rule.count) {
+        result += ` (${rule.count} times)`;
+    }
+    else if (rule.until) {
+        result += ` until ${new Date(rule.until).toLocaleDateString()}`;
+    }
+    return result;
+}
+// Helper functions
+function matchesRecurrenceRule(date, rule) {
+    const start = new Date(rule.startDate);
+    start.setHours(0, 0, 0, 0);
+    const checkDate = new Date(date);
+    checkDate.setHours(0, 0, 0, 0);
+    const interval = rule.interval || 1;
+    // Check if date matches the frequency and interval
+    switch (rule.frequency) {
+        case 'daily': {
+            // Calculate days difference more reliably
+            const msPerDay = 1000 * 60 * 60 * 24;
+            const daysDiff = Math.round((checkDate.getTime() - start.getTime()) / msPerDay);
+            if (daysDiff < 0)
+                return false;
+            if (daysDiff % interval !== 0)
+                return false;
+            break;
+        }
+        case 'weekly': {
+            // If byWeekday is specified, check if current day matches
+            if (rule.byWeekday && rule.byWeekday.length > 0) {
+                if (!rule.byWeekday.includes(date.getDay())) {
+                    return false;
+                }
+            }
+            else {
+                // No specific weekdays - match same day of week as start
+                if (date.getDay() !== start.getDay())
+                    return false;
+            }
+            // Check interval
+            const msPerDay = 1000 * 60 * 60 * 24;
+            const daysDiff = Math.round((checkDate.getTime() - start.getTime()) / msPerDay);
+            const weeksDiff = Math.floor(daysDiff / 7);
+            if (weeksDiff % interval !== 0)
+                return false;
+            break;
+        }
+        case 'monthly': {
+            const monthsDiff = (date.getFullYear() - start.getFullYear()) * 12 +
+                (date.getMonth() - start.getMonth());
+            if (monthsDiff < 0)
+                return false;
+            if (monthsDiff % interval !== 0)
+                return false;
+            if (rule.byMonthDay && !rule.byMonthDay.includes(date.getDate())) {
+                return false;
+            }
+            break;
+        }
+        case 'yearly': {
+            const yearsDiff = date.getFullYear() - start.getFullYear();
+            if (yearsDiff < 0)
+                return false;
+            if (yearsDiff % interval !== 0)
+                return false;
+            if (rule.byMonth && !rule.byMonth.includes(date.getMonth() + 1)) {
+                return false;
+            }
+            if (rule.byMonthDay && !rule.byMonthDay.includes(date.getDate())) {
+                return false;
+            }
+            break;
+        }
+    }
+    return true;
+}
+function getNextCandidate(date, rule) {
+    const interval = rule.interval || 1;
+    switch (rule.frequency) {
+        case 'daily':
+            // For daily recurrence, always increment by 1 day to check each day
+            // matchesRecurrenceRule will filter based on interval
+            return addTime(date, 1, 'day');
+        case 'weekly':
+            // If we have specific weekdays, try next day, otherwise skip full interval
+            if (rule.byWeekday && rule.byWeekday.length > 0) {
+                return addTime(date, 1, 'day');
+            }
+            return addTime(date, interval * 7, 'day');
+        case 'monthly':
+            // If we have specific days of month, try next day, otherwise skip full interval
+            if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+                return addTime(date, 1, 'day');
+            }
+            return addTime(date, interval, 'month');
+        case 'yearly':
+            // If we have specific months or days, try next day, otherwise skip full interval
+            if ((rule.byMonth && rule.byMonth.length > 0) ||
+                (rule.byMonthDay && rule.byMonthDay.length > 0)) {
+                return addTime(date, 1, 'day');
+            }
+            return addTime(date, interval, 'year');
+        default:
+            return addTime(date, 1, 'day');
+    }
+}

package/dist/serialize.d.ts

@@ -0,0 +1,73 @@
+import type { DateInput, SerializationOptions, DateObject, EpochTimestamp } from './types.js';
+/**
+ * Safe JSON date serialization and deserialization utilities
+ */
+/**
+ * Safely serialize a date to JSON with various format options
+ */
+export declare function serializeDate(date: DateInput, options?: SerializationOptions): string | number | DateObject;
+/**
+ * Safely deserialize a date from various formats
+ */
+export declare function deserializeDate(serializedDate: string | number | DateObject, options?: SerializationOptions): Date | null;
+/**
+ * Create a safe JSON reviver function for automatic date parsing
+ */
+export declare function createDateReviver(dateKeys?: string[], options?: SerializationOptions): (key: string, value: any) => any;
+/**
+ * Create a safe JSON replacer function for automatic date serialization
+ */
+export declare function createDateReplacer(dateKeys?: string[], options?: SerializationOptions): (key: string, value: any) => any;
+/**
+ * Parse ISO string with better error handling
+ */
+export declare function parseISOString(isoString: string, useUTC?: boolean): Date | null;
+/**
+ * Convert date to epoch timestamp with specified precision
+ */
+export declare function toEpochTimestamp(date: DateInput, precision?: 'milliseconds' | 'seconds' | 'microseconds'): number;
+/**
+ * Create date from epoch timestamp with specified precision
+ */
+export declare function fromEpochTimestamp(timestamp: number, precision?: 'milliseconds' | 'seconds' | 'microseconds'): Date;
+/**
+ * Create epoch timestamp with metadata
+ */
+export declare function createEpochTimestamp(date: DateInput, precision?: 'milliseconds' | 'seconds' | 'microseconds', timezone?: string): EpochTimestamp;
+/**
+ * Convert date to safe object representation
+ */
+export declare function toDateObject(date: DateInput, includeTimezone?: boolean): DateObject;
+/**
+ * Create date from object representation
+ */
+export declare function fromDateObject(dateObj: DateObject): Date;
+/**
+ * Check if a string is a valid ISO date string for serialization
+ */
+export declare function isValidISODateString(dateString: string): boolean;
+/**
+ * Check if a number is a valid epoch timestamp
+ */
+export declare function isValidEpochTimestamp(timestamp: number, precision?: 'milliseconds' | 'seconds' | 'microseconds'): boolean;
+/**
+ * Clone a date safely (avoids reference issues)
+ */
+export declare function cloneDate(date: DateInput): Date | null;
+/**
+ * Compare two dates for equality (ignoring milliseconds if specified)
+ */
+export declare function datesEqual(date1: DateInput, date2: DateInput, precision?: 'milliseconds' | 'seconds' | 'minutes'): boolean;
+/**
+ * Get current timestamp in various formats
+ */
+export declare function now(format?: 'date' | 'iso' | 'epoch-ms' | 'epoch-s'): Date | string | number;
+/**
+ * Safely handle JSON parsing with date conversion
+ */
+export declare function parseJSONWithDates(jsonString: string, dateKeys?: string[], options?: SerializationOptions): any;
+/**
+ * Safely handle JSON stringification with date conversion
+ */
+export declare function stringifyWithDates(obj: any, dateKeys?: string[], options?: SerializationOptions, space?: string | number): string;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../src/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,oBAAoB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9F;;GAEG;AAEH;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,oBAAyB,GACjC,MAAM,GAAG,MAAM,GAAG,UAAU,CAmC9B;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,EAC5C,OAAO,GAAE,oBAAyB,GACjC,IAAI,GAAG,IAAI,CA2Bb;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,GAAE,MAAM,EAAoD,EACpE,OAAO,GAAE,oBAAyB,GACjC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,CAQlC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,GAAE,MAAM,EAAoD,EACpE,OAAO,GAAE,oBAAyB,GACjC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,CAgBlC;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,OAAe,GAAG,IAAI,GAAG,IAAI,CA4BtF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,GAAE,cAAc,GAAG,SAAS,GAAG,cAA+B,GAAG,MAAM,CAiBjI;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,SAAS,GAAE,cAAc,GAAG,SAAS,GAAG,cAA+B,GACtE,IAAI,CAiBN;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EACf,SAAS,GAAE,cAAc,GAAG,SAAS,GAAG,cAA+B,EACvE,QAAQ,CAAC,EAAE,MAAM,GAChB,cAAc,CAMhB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,eAAe,GAAE,OAAe,GAAG,UAAU,CA0B1F;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAsCxD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAOhE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,GAAE,cAAc,GAAG,SAAS,GAAG,cAA+B,GAAG,OAAO,CA0BzI;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAGtD;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,SAAS,EAChB,SAAS,GAAE,cAAc,GAAG,SAAS,GAAG,SAA0B,GACjE,OAAO,CAuBT;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,MAAM,GAAE,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,SAAkB,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,CAcpG;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,EACnB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,GAAG,CAML;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,GAAG,EACR,QAAQ,CAAC,EAAE,MAAM,EAAE,EACnB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,CAMR"}