@oneluiz/dual-datepicker 3.4.0 → 3.5.0

package/esm2022/core/preset.engine.mjs

@@ -0,0 +1,209 @@
+/**
+ * Headless Preset Engine
+ * Pure functions that resolve date ranges WITHOUT render dependency
+ * Perfect for SSR, global state, dashboard filters
+ */
+import { formatISODate } from './range.validator';
+/**
+ * Registry of built-in presets
+ * Can be extended by consumers
+ */
+export class PresetEngine {
+    presets = new Map();
+    constructor() {
+        this.registerBuiltInPresets();
+    }
+    /**
+     * Register a custom preset
+     */
+    register(key, preset) {
+        this.presets.set(key, preset);
+    }
+    /**
+     * Resolve a preset to date range
+     */
+    resolve(key, now = new Date()) {
+        const preset = this.presets.get(key);
+        if (!preset)
+            return null;
+        const { start, end } = preset.resolve(now);
+        return {
+            start: formatISODate(start),
+            end: formatISODate(end)
+        };
+    }
+    /**
+     * Get all available preset keys
+     */
+    getPresetKeys() {
+        return Array.from(this.presets.keys());
+    }
+    /**
+     * Register all built-in presets
+     */
+    registerBuiltInPresets() {
+        // Today
+        this.register('TODAY', {
+            resolve: (now) => ({ start: now, end: now })
+        });
+        // Yesterday
+        this.register('YESTERDAY', {
+            resolve: (now) => {
+                const date = new Date(now);
+                date.setDate(date.getDate() - 1);
+                return { start: date, end: date };
+            }
+        });
+        // Last N Days
+        this.register('LAST_7_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 6);
+                return { start, end };
+            }
+        });
+        this.register('LAST_14_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 13);
+                return { start, end };
+            }
+        });
+        this.register('LAST_30_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 29);
+                return { start, end };
+            }
+        });
+        this.register('LAST_60_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 59);
+                return { start, end };
+            }
+        });
+        this.register('LAST_90_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 89);
+                return { start, end };
+            }
+        });
+        // This Week (Monday to Sunday)
+        this.register('THIS_WEEK', {
+            resolve: (now) => {
+                const dayOfWeek = now.getDay();
+                const start = new Date(now);
+                const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+                start.setDate(start.getDate() - daysToMonday);
+                const end = new Date(start);
+                end.setDate(end.getDate() + 6);
+                return { start, end };
+            }
+        });
+        // Last Week
+        this.register('LAST_WEEK', {
+            resolve: (now) => {
+                const dayOfWeek = now.getDay();
+                const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+                const lastMonday = new Date(now);
+                lastMonday.setDate(lastMonday.getDate() - daysToMonday - 7);
+                const lastSunday = new Date(lastMonday);
+                lastSunday.setDate(lastSunday.getDate() + 6);
+                return { start: lastMonday, end: lastSunday };
+            }
+        });
+        // This Month
+        this.register('THIS_MONTH', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), now.getMonth(), 1);
+                const end = new Date(now.getFullYear(), now.getMonth() + 1, 0);
+                return { start, end };
+            }
+        });
+        // Last Month
+        this.register('LAST_MONTH', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+                const end = new Date(now.getFullYear(), now.getMonth(), 0);
+                return { start, end };
+            }
+        });
+        // Month to Date
+        this.register('MONTH_TO_DATE', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), now.getMonth(), 1);
+                return { start, end: now };
+            }
+        });
+        // This Quarter
+        this.register('THIS_QUARTER', {
+            resolve: (now) => {
+                const currentMonth = now.getMonth();
+                const quarterStartMonth = Math.floor(currentMonth / 3) * 3;
+                const start = new Date(now.getFullYear(), quarterStartMonth, 1);
+                const end = new Date(now.getFullYear(), quarterStartMonth + 3, 0);
+                return { start, end };
+            }
+        });
+        // Last Quarter
+        this.register('LAST_QUARTER', {
+            resolve: (now) => {
+                const currentMonth = now.getMonth();
+                const lastQuarterStartMonth = Math.floor(currentMonth / 3) * 3 - 3;
+                const start = new Date(now.getFullYear(), lastQuarterStartMonth, 1);
+                const end = new Date(now.getFullYear(), lastQuarterStartMonth + 3, 0);
+                return { start, end };
+            }
+        });
+        // Quarter to Date
+        this.register('QUARTER_TO_DATE', {
+            resolve: (now) => {
+                const currentMonth = now.getMonth();
+                const quarterStartMonth = Math.floor(currentMonth / 3) * 3;
+                const start = new Date(now.getFullYear(), quarterStartMonth, 1);
+                return { start, end: now };
+            }
+        });
+        // This Year
+        this.register('THIS_YEAR', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), 0, 1);
+                const end = new Date(now.getFullYear(), 11, 31);
+                return { start, end };
+            }
+        });
+        // Last Year
+        this.register('LAST_YEAR', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear() - 1, 0, 1);
+                const end = new Date(now.getFullYear() - 1, 11, 31);
+                return { start, end };
+            }
+        });
+        // Year to Date
+        this.register('YEAR_TO_DATE', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), 0, 1);
+                return { start, end: now };
+            }
+        });
+    }
+}
+/**
+ * Create a custom preset from a function
+ */
+export function createPreset(resolver) {
+    return { resolve: resolver };
+}
+/**
+ * Singleton preset engine instance
+ */
+export const presetEngine = new PresetEngine();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset.engine.js","sourceRoot":"","sources":["../../../src/core/preset.engine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Headless Preset Engine\n * Pure functions that resolve date ranges WITHOUT render dependency\n * Perfect for SSR, global state, dashboard filters\n */\n\nimport { formatISODate } from './range.validator';\n\nexport interface RangePreset {\n  /**\n   * Resolve preset to actual date range\n   * @param now - Current date for deterministic calculation\n   */\n  resolve(now: Date): { start: Date; end: Date };\n}\n\nexport interface PresetRange {\n  start: string; // ISO format\n  end: string; // ISO format\n}\n\n/**\n * Registry of built-in presets\n * Can be extended by consumers\n */\nexport class PresetEngine {\n  private presets = new Map<string, RangePreset>();\n\n  constructor() {\n    this.registerBuiltInPresets();\n  }\n\n  /**\n   * Register a custom preset\n   */\n  register(key: string, preset: RangePreset): void {\n    this.presets.set(key, preset);\n  }\n\n  /**\n   * Resolve a preset to date range\n   */\n  resolve(key: string, now: Date = new Date()): PresetRange | null {\n    const preset = this.presets.get(key);\n    if (!preset) return null;\n\n    const { start, end } = preset.resolve(now);\n    return {\n      start: formatISODate(start),\n      end: formatISODate(end)\n    };\n  }\n\n  /**\n   * Get all available preset keys\n   */\n  getPresetKeys(): string[] {\n    return Array.from(this.presets.keys());\n  }\n\n  /**\n   * Register all built-in presets\n   */\n  private registerBuiltInPresets(): void {\n    // Today\n    this.register('TODAY', {\n      resolve: (now) => ({ start: now, end: now })\n    });\n\n    // Yesterday\n    this.register('YESTERDAY', {\n      resolve: (now) => {\n        const date = new Date(now);\n        date.setDate(date.getDate() - 1);\n        return { start: date, end: date };\n      }\n    });\n\n    // Last N Days\n    this.register('LAST_7_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 6);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_14_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 13);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_30_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 29);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_60_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 59);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_90_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 89);\n        return { start, end };\n      }\n    });\n\n    // This Week (Monday to Sunday)\n    this.register('THIS_WEEK', {\n      resolve: (now) => {\n        const dayOfWeek = now.getDay();\n        const start = new Date(now);\n        const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;\n        start.setDate(start.getDate() - daysToMonday);\n\n        const end = new Date(start);\n        end.setDate(end.getDate() + 6);\n\n        return { start, end };\n      }\n    });\n\n    // Last Week\n    this.register('LAST_WEEK', {\n      resolve: (now) => {\n        const dayOfWeek = now.getDay();\n        const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;\n\n        const lastMonday = new Date(now);\n        lastMonday.setDate(lastMonday.getDate() - daysToMonday - 7);\n\n        const lastSunday = new Date(lastMonday);\n        lastSunday.setDate(lastSunday.getDate() + 6);\n\n        return { start: lastMonday, end: lastSunday };\n      }\n    });\n\n    // This Month\n    this.register('THIS_MONTH', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), now.getMonth(), 1);\n        const end = new Date(now.getFullYear(), now.getMonth() + 1, 0);\n        return { start, end };\n      }\n    });\n\n    // Last Month\n    this.register('LAST_MONTH', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), now.getMonth() - 1, 1);\n        const end = new Date(now.getFullYear(), now.getMonth(), 0);\n        return { start, end };\n      }\n    });\n\n    // Month to Date\n    this.register('MONTH_TO_DATE', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), now.getMonth(), 1);\n        return { start, end: now };\n      }\n    });\n\n    // This Quarter\n    this.register('THIS_QUARTER', {\n      resolve: (now) => {\n        const currentMonth = now.getMonth();\n        const quarterStartMonth = Math.floor(currentMonth / 3) * 3;\n        const start = new Date(now.getFullYear(), quarterStartMonth, 1);\n        const end = new Date(now.getFullYear(), quarterStartMonth + 3, 0);\n        return { start, end };\n      }\n    });\n\n    // Last Quarter\n    this.register('LAST_QUARTER', {\n      resolve: (now) => {\n        const currentMonth = now.getMonth();\n        const lastQuarterStartMonth = Math.floor(currentMonth / 3) * 3 - 3;\n        const start = new Date(now.getFullYear(), lastQuarterStartMonth, 1);\n        const end = new Date(now.getFullYear(), lastQuarterStartMonth + 3, 0);\n        return { start, end };\n      }\n    });\n\n    // Quarter to Date\n    this.register('QUARTER_TO_DATE', {\n      resolve: (now) => {\n        const currentMonth = now.getMonth();\n        const quarterStartMonth = Math.floor(currentMonth / 3) * 3;\n        const start = new Date(now.getFullYear(), quarterStartMonth, 1);\n        return { start, end: now };\n      }\n    });\n\n    // This Year\n    this.register('THIS_YEAR', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), 0, 1);\n        const end = new Date(now.getFullYear(), 11, 31);\n        return { start, end };\n      }\n    });\n\n    // Last Year\n    this.register('LAST_YEAR', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear() - 1, 0, 1);\n        const end = new Date(now.getFullYear() - 1, 11, 31);\n        return { start, end };\n      }\n    });\n\n    // Year to Date\n    this.register('YEAR_TO_DATE', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), 0, 1);\n        return { start, end: now };\n      }\n    });\n  }\n}\n\n/**\n * Create a custom preset from a function\n */\nexport function createPreset(\n  resolver: (now: Date) => { start: Date; end: Date }\n): RangePreset {\n  return { resolve: resolver };\n}\n\n/**\n * Singleton preset engine instance\n */\nexport const presetEngine = new PresetEngine();\n"]}

package/esm2022/core/range.validator.mjs

@@ -0,0 +1,105 @@
+/**
+ * Pure validation functions for date ranges
+ * No dependencies, no side effects - just logic
+ * Perfect for SSR, testing, and reusability
+ */
+/**
+ * Validate that end date is not before start date
+ */
+export function validateRangeOrder(start, end) {
+    if (!start || !end) {
+        return { valid: true }; // Allow incomplete selection
+    }
+    if (end < start) {
+        return {
+            valid: false,
+            error: 'End date cannot be before start date'
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate that date is within min/max bounds
+ */
+export function validateDateBounds(date, minDate, maxDate) {
+    if (!date) {
+        return { valid: true };
+    }
+    if (minDate && date < minDate) {
+        return {
+            valid: false,
+            error: `Date cannot be before ${minDate.toISOString().split('T')[0]}`
+        };
+    }
+    if (maxDate && date > maxDate) {
+        return {
+            valid: false,
+            error: `Date cannot be after ${maxDate.toISOString().split('T')[0]}`
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate that a range is within bounds
+ */
+export function validateRangeBounds(start, end, minDate, maxDate) {
+    const startValidation = validateDateBounds(start, minDate, maxDate);
+    if (!startValidation.valid) {
+        return startValidation;
+    }
+    const endValidation = validateDateBounds(end, minDate, maxDate);
+    if (!endValidation.valid) {
+        return endValidation;
+    }
+    return { valid: true };
+}
+/**
+ * Check if a date is disabled
+ */
+export function isDateDisabled(date, disabledDates) {
+    if (!disabledDates) {
+        return false;
+    }
+    if (typeof disabledDates === 'function') {
+        return disabledDates(date);
+    }
+    // Array of disabled dates - compare by date string
+    const dateStr = date.toISOString().split('T')[0];
+    return disabledDates.some(d => d.toISOString().split('T')[0] === dateStr);
+}
+/**
+ * Apply bounds to a date (clamp it)
+ */
+export function applyBounds(date, minDate, maxDate) {
+    let result = date;
+    if (minDate && result < minDate) {
+        result = minDate;
+    }
+    if (maxDate && result > maxDate) {
+        result = maxDate;
+    }
+    return result;
+}
+/**
+ * Parse ISO date string to Date object (deterministic)
+ */
+export function parseISODate(dateStr) {
+    if (!dateStr)
+        return null;
+    const [year, month, day] = dateStr.split('-').map(Number);
+    if (!year || !month || !day)
+        return null;
+    return new Date(year, month - 1, day);
+}
+/**
+ * Format Date to ISO string (YYYY-MM-DD)
+ */
+export function formatISODate(date) {
+    if (!date)
+        return '';
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range.validator.js","sourceRoot":"","sources":["../../../src/core/range.validator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure validation functions for date ranges\n * No dependencies, no side effects - just logic\n * Perfect for SSR, testing, and reusability\n */\n\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n}\n\n/**\n * Validate that end date is not before start date\n */\nexport function validateRangeOrder(start: Date | null, end: Date | null): ValidationResult {\n  if (!start || !end) {\n    return { valid: true }; // Allow incomplete selection\n  }\n\n  if (end < start) {\n    return {\n      valid: false,\n      error: 'End date cannot be before start date'\n    };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate that date is within min/max bounds\n */\nexport function validateDateBounds(\n  date: Date | null,\n  minDate?: Date,\n  maxDate?: Date\n): ValidationResult {\n  if (!date) {\n    return { valid: true };\n  }\n\n  if (minDate && date < minDate) {\n    return {\n      valid: false,\n      error: `Date cannot be before ${minDate.toISOString().split('T')[0]}`\n    };\n  }\n\n  if (maxDate && date > maxDate) {\n    return {\n      valid: false,\n      error: `Date cannot be after ${maxDate.toISOString().split('T')[0]}`\n    };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate that a range is within bounds\n */\nexport function validateRangeBounds(\n  start: Date | null,\n  end: Date | null,\n  minDate?: Date,\n  maxDate?: Date\n): ValidationResult {\n  const startValidation = validateDateBounds(start, minDate, maxDate);\n  if (!startValidation.valid) {\n    return startValidation;\n  }\n\n  const endValidation = validateDateBounds(end, minDate, maxDate);\n  if (!endValidation.valid) {\n    return endValidation;\n  }\n\n  return { valid: true };\n}\n\n/**\n * Check if a date is disabled\n */\nexport function isDateDisabled(\n  date: Date,\n  disabledDates?: Date[] | ((date: Date) => boolean)\n): boolean {\n  if (!disabledDates) {\n    return false;\n  }\n\n  if (typeof disabledDates === 'function') {\n    return disabledDates(date);\n  }\n\n  // Array of disabled dates - compare by date string\n  const dateStr = date.toISOString().split('T')[0];\n  return disabledDates.some(\n    d => d.toISOString().split('T')[0] === dateStr\n  );\n}\n\n/**\n * Apply bounds to a date (clamp it)\n */\nexport function applyBounds(date: Date, minDate?: Date, maxDate?: Date): Date {\n  let result = date;\n\n  if (minDate && result < minDate) {\n    result = minDate;\n  }\n\n  if (maxDate && result > maxDate) {\n    result = maxDate;\n  }\n\n  return result;\n}\n\n/**\n * Parse ISO date string to Date object (deterministic)\n */\nexport function parseISODate(dateStr: string): Date | null {\n  if (!dateStr) return null;\n\n  const [year, month, day] = dateStr.split('-').map(Number);\n  if (!year || !month || !day) return null;\n\n  return new Date(year, month - 1, day);\n}\n\n/**\n * Format Date to ISO string (YYYY-MM-DD)\n */\nexport function formatISODate(date: Date | null): string {\n  if (!date) return '';\n\n  const year = date.getFullYear();\n  const month = String(date.getMonth() + 1).padStart(2, '0');\n  const day = String(date.getDate()).padStart(2, '0');\n\n  return `${year}-${month}-${day}`;\n}\n"]}

package/esm2022/public-api.mjs

@@ -5,6 +5,9 @@ export { DualDatepickerComponent } from './dual-datepicker.component';
 // Date Adapter System
 export { DateAdapter, DATE_ADAPTER } from './date-adapter';
 export { NativeDateAdapter } from './native-date-adapter';
-// Preset Utilities
+// Preset Utilities (deprecated - use core/preset.engine instead)
 export * from './preset-utils';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFHdEUsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFMUQsbUJBQW1CO0FBQ25CLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBAb25lbHVpei9kdWFsLWRhdGVwaWNrZXJcbiAqL1xuXG5leHBvcnQgeyBEdWFsRGF0ZXBpY2tlckNvbXBvbmVudCB9IGZyb20gJy4vZHVhbC1kYXRlcGlja2VyLmNvbXBvbmVudCc7XG5leHBvcnQgdHlwZSB7IERhdGVSYW5nZSwgTXVsdGlEYXRlUmFuZ2UsIFByZXNldENvbmZpZywgUHJlc2V0UmFuZ2UsIExvY2FsZUNvbmZpZywgVGhlbWVUeXBlIH0gZnJvbSAnLi9kdWFsLWRhdGVwaWNrZXIuY29tcG9uZW50JztcblxuLy8gRGF0ZSBBZGFwdGVyIFN5c3RlbVxuZXhwb3J0IHsgRGF0ZUFkYXB0ZXIsIERBVEVfQURBUFRFUiB9IGZyb20gJy4vZGF0ZS1hZGFwdGVyJztcbmV4cG9ydCB7IE5hdGl2ZURhdGVBZGFwdGVyIH0gZnJvbSAnLi9uYXRpdmUtZGF0ZS1hZGFwdGVyJztcblxuLy8gUHJlc2V0IFV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9wcmVzZXQtdXRpbHMnO1xuIl19
+// NEW v3.5.0: Headless Core - Use without UI
+// Perfect for SSR, global state, dashboard filters
+export * from './core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFHdEUsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFMUQsaUVBQWlFO0FBQ2pFLGNBQWMsZ0JBQWdCLENBQUM7QUFFL0IsNkNBQTZDO0FBQzdDLG1EQUFtRDtBQUNuRCxjQUFjLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIEBvbmVsdWl6L2R1YWwtZGF0ZXBpY2tlclxuICovXG5cbmV4cG9ydCB7IER1YWxEYXRlcGlja2VyQ29tcG9uZW50IH0gZnJvbSAnLi9kdWFsLWRhdGVwaWNrZXIuY29tcG9uZW50JztcbmV4cG9ydCB0eXBlIHsgRGF0ZVJhbmdlLCBNdWx0aURhdGVSYW5nZSwgUHJlc2V0Q29uZmlnLCBQcmVzZXRSYW5nZSwgTG9jYWxlQ29uZmlnLCBUaGVtZVR5cGUgfSBmcm9tICcuL2R1YWwtZGF0ZXBpY2tlci5jb21wb25lbnQnO1xuXG4vLyBEYXRlIEFkYXB0ZXIgU3lzdGVtXG5leHBvcnQgeyBEYXRlQWRhcHRlciwgREFURV9BREFQVEVSIH0gZnJvbSAnLi9kYXRlLWFkYXB0ZXInO1xuZXhwb3J0IHsgTmF0aXZlRGF0ZUFkYXB0ZXIgfSBmcm9tICcuL25hdGl2ZS1kYXRlLWFkYXB0ZXInO1xuXG4vLyBQcmVzZXQgVXRpbGl0aWVzIChkZXByZWNhdGVkIC0gdXNlIGNvcmUvcHJlc2V0LmVuZ2luZSBpbnN0ZWFkKVxuZXhwb3J0ICogZnJvbSAnLi9wcmVzZXQtdXRpbHMnO1xuXG4vLyBORVcgdjMuNS4wOiBIZWFkbGVzcyBDb3JlIC0gVXNlIHdpdGhvdXQgVUlcbi8vIFBlcmZlY3QgZm9yIFNTUiwgZ2xvYmFsIHN0YXRlLCBkYXNoYm9hcmQgZmlsdGVyc1xuZXhwb3J0ICogZnJvbSAnLi9jb3JlJztcbiJdfQ==