@jsarc/cooks 0.0.0

package/ts/cooks.ts

@@ -0,0 +1,1159 @@
+// @ts-nocheck
+
+interface Window {
+    default: typeof defaultElementGF;
+    Cooks: any;
+    Timez: any;
+    __bundledModules: any;
+}
+
+interface TimezFormatOptions {
+    strict?: boolean;
+    timezone?: string;
+}
+
+
+interface ParseResult {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    millisecond: number;
+    timezoneOffset?: number;
+}
+
+
+type TimezInput = Date | string | number | typeof Timez | undefined;
+
+interface CooksOptions {
+    expires?: Date | number; 
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+}
+
+
+type Serializable =
+    | string
+    | number
+    | boolean
+    | Date
+    | object
+    | Array<any>
+    | null
+    | undefined;
+
+const globalFunct = (function(global: any) {
+    'use strict';
+    
+    
+    const NODEENV: 'development' | 'production' | 'debug' = 'development'; // development | debug | production
+
+    const langs = ['en', 'fr'];
+    const langCodes = {
+        'fr': 'fr_FR',
+        'en': 'en_US',
+    };
+
+    const dateTimeFormatInitial = '%Y-%m-%dT%H:%M:%S.%fZ';
+    const dateFormatInitial = '%Y-%m-%d';
+    const timeFormatInitial = '%H:%M:%S.%fZ';
+
+    const dateFormatForFile = '%Y%m%d%H%M%S';
+    const dateFormat1 = '%Y/%m/%d %H:%M:%S.%fZ';
+    const dateFormat2 = '%Y/%m/%d %H:%M:%S';
+    const dateFormat3 = '%Y/%m/%d %H:%M';
+    const dateFormat4 = '%d/%m/%Y %H:%M:%S GMT%z';
+    const dateFormat5 = '%Y/%m/%d';
+    const timeFormat1 = '%H:%M:%S.%fZ';
+    const timeFormat2 = '%H:%M:%S';
+    const timeFormat3 = '%H:%M:%S.%f';
+    const pagesPossibles = [5, 10, 15, 25, 50, 100, -1];
+
+    const regExpForAlphanumeric = /^[\w\s]{1,}/;
+
+    const tabNumerique = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+    const tabAlphabetique = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
+    const tabAlphabetiqueInsensitive = [...tabAlphabetique, ...tabAlphabetique.map(x => x.toUpperCase())];
+    const tabAlphanumerique = [...tabNumerique, ...tabAlphabetique];
+    const tabAlphanumeriqueInsensitive = [...tabNumerique, ...tabAlphabetiqueInsensitive];
+    
+
+
+
+
+
+
+    class Timez {
+        private _date?: Date;
+        private static readonly FORMAT_TOKENS: { [key: string]: (timez: Timez) => string | undefined } = {
+            '%Y': (t) => t.year()?.toString().padStart(4, '0'),
+            '%y': (t) => t.year()?.toString().slice(-2).padStart(2, '0'),
+            '%m': (t) => t.month()?.toString().padStart(2, '0'),
+            '%d': (t) => t.date()?.toString().padStart(2, '0'),
+            '%H': (t) => t.hour()?.toString().padStart(2, '0'),
+            '%M': (t) => t.minute()?.toString().padStart(2, '0'),
+            '%S': (t) => t.second()?.toString().padStart(2, '0'),
+            '%f': (t) => t.millisecond()?.toString().padStart(3, '0'),
+            '%z': (t) => {
+                const offset = t.utcOffset();
+                if (!offset) {
+                    return undefined;
+                }
+                const sign = offset >= 0 ? '+' : '-';
+                const hours = Math.floor(Math.abs(offset) / 60).toString().padStart(2, '0');
+                const minutes = (Math.abs(offset) % 60).toString().padStart(2, '0');
+                return `${sign}${hours}${minutes}`;
+            },
+            '%s': (t) => {
+                const val = t.valueOf();
+                return !!val ? Math.floor(val / 1000).toString() : undefined;
+            },
+        };
+
+        static readonly PREDEFINED_FORMATS: { [key: string]: string } = {
+            ISO: '%Y-%m-%dT%H:%M:%S.%fZ',
+            ISO_DATE: '%Y-%m-%d',
+            ISO_TIME: '%H:%M:%S.%fZ',
+            COMPACT: '%Y%m%d%H%M%S',
+            SLASH_DATETIME: '%Y/%m/%d %H:%M:%S.%fZ',
+            SLASH_DATETIME_SEC: '%Y/%m/%d %H:%M:%S',
+            SLASH_DATETIME_MIN: '%Y/%m/%d %H:%M',
+            EUROPEAN: '%d/%m/%Y %H:%M:%S GMT%z',
+            SLASH_DATE: '%Y/%m/%d',
+            TIME_MICRO: '%H:%M:%S.%fZ',
+            TIME_SEC: '%H:%M:%S',
+            CUSTOM_GREETING: '[Bonjour celestin, ][la date actuelle est:: le] %d/%m/%Y [à] %H:%M:%S.%f[Z]',
+        };
+
+        constructor(input?: TimezInput, enableException: boolean = false) {
+            if(this.dateChecker(input) === false) {
+                this._date = undefined;
+            } else {
+                if (input instanceof Timez && !!input && !!input?._date) {
+                    this._date = new Date(input?._date);
+                } else if (input instanceof Date) {
+                    this._date = new Date(input);
+                } else if (typeof input === 'string') {
+                    this._date = Timez.parseString(input, enableException);
+                } else if (typeof input === 'number') {
+                    this._date = new Date(input);
+                } else if(
+                    input === undefined || 
+                    input === null || 
+                    (typeof input === 'number' && isNaN(input))
+                ) {
+                    this._date = new Date();
+                } else {
+                    this._date = undefined;
+                }
+            }
+        }
+
+        static now(): Timez {
+            return new Timez();
+        }
+
+        static parse(dateString: any, format?: string): Timez {
+            if (
+                typeof format === 'string' &&
+                format.length > 0 && (
+                    (
+                        dateString instanceof Timez &&
+                        !!dateString &&
+                        !!dateString?._date
+                    ) ||
+                    dateString instanceof Date ||
+                    typeof dateString === 'string' ||
+                    typeof dateString === 'number' || (
+                        dateString === undefined || 
+                        dateString === null || 
+                        (typeof dateString === 'number' && isNaN(dateString))
+                    )
+                )
+            ) {
+                return Timez.parseWithFormat(dateString, format) || new Timez(dateString);
+            }
+            return new Timez(dateString);
+        }
+
+        static unix(timestamp: number): Timez {
+            return new Timez(timestamp * 1000);
+        }
+
+        static utc(): Timez {
+            const now = new Date();
+            return new Timez(Date.UTC(
+                now.getUTCFullYear(),
+                now.getUTCMonth(),
+                now.getUTCDate(),
+                now.getUTCHours(),
+                now.getUTCMinutes(),
+                now.getUTCSeconds(),
+                now.getUTCMilliseconds()
+            ));
+        }
+
+        year(): number | undefined {
+            return this._date?.getFullYear();
+        }
+
+        month(): number | undefined {
+            return !!this._date ? this._date.getMonth() + 1 : undefined;
+        }
+
+        date(): number | undefined {
+            return this._date?.getDate();
+        }
+
+        hour(): number | undefined {
+            return this._date?.getHours();
+        }
+
+        minute(): number | undefined {
+            return this._date?.getMinutes();
+        }
+
+        second(): number | undefined {
+            return this._date?.getSeconds();
+        }
+
+        millisecond(): number | undefined {
+            return this._date?.getMilliseconds();
+        }
+
+        day(): number | undefined {
+            return this._date?.getDay();
+        }
+
+        add(amount: number, unit: 'years' | 'months' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds'): Timez {
+            if (!this._date) {
+                return new Timez(undefined);
+            }
+            const newDate = new Date(this._date);
+
+            switch (unit) {
+                case 'years':
+                    newDate.setFullYear(newDate.getFullYear() + amount);
+                    break;
+                case 'months':
+                    newDate.setMonth(newDate.getMonth() + amount);
+                    break;
+                case 'days':
+                    newDate.setDate(newDate.getDate() + amount);
+                    break;
+                case 'hours':
+                    newDate.setHours(newDate.getHours() + amount);
+                    break;
+                case 'minutes':
+                    newDate.setMinutes(newDate.getMinutes() + amount);
+                    break;
+                case 'seconds':
+                    newDate.setSeconds(newDate.getSeconds() + amount);
+                    break;
+                case 'milliseconds':
+                    newDate.setMilliseconds(newDate.getMilliseconds() + amount);
+                    break;
+            }
+
+            return new Timez(newDate);
+        }
+
+        subtract(amount: number, unit: 'years' | 'months' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds'): Timez {
+            return this.add(-amount, unit);
+        }
+
+        startOf(unit: 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'): Timez {
+            if (!this._date) {
+                return new Timez(undefined);
+            }
+            const newDate = new Date(this._date);
+
+            switch (unit) {
+                case 'year':
+                    newDate.setMonth(0, 1);
+                    newDate.setHours(0, 0, 0, 0);
+                    break;
+                case 'month':
+                    newDate.setDate(1);
+                    newDate.setHours(0, 0, 0, 0);
+                    break;
+                case 'day':
+                    newDate.setHours(0, 0, 0, 0);
+                    break;
+                case 'hour':
+                    newDate.setMinutes(0, 0, 0);
+                    break;
+                case 'minute':
+                    newDate.setSeconds(0, 0);
+                    break;
+                case 'second':
+                    newDate.setMilliseconds(0);
+                    break;
+            }
+
+            return new Timez(newDate);
+        }
+
+        endOf(unit: 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'): Timez {
+            const start = this.startOf(unit);
+
+            switch (unit) {
+                case 'year':
+                    return start.add(1, 'years').subtract(1, 'milliseconds');
+                case 'month':
+                    return start.add(1, 'months').subtract(1, 'milliseconds');
+                case 'day':
+                    return start.add(1, 'days').subtract(1, 'milliseconds');
+                case 'hour':
+                    return start.add(1, 'hours').subtract(1, 'milliseconds');
+                case 'minute':
+                    return start.add(1, 'minutes').subtract(1, 'milliseconds');
+                case 'second':
+                    return start.add(1, 'seconds').subtract(1, 'milliseconds');
+                default:
+                    return start;
+            }
+        }
+
+        isBefore(other: TimezInput, inclusivity: '()' | '(]' = '()'): boolean {
+            const isIncluded = inclusivity[1] === ']';
+            const otherTimez = other instanceof Timez ? other : new Timez(other);
+            if (!this._date || !otherTimez._date) {
+                return false;
+            }
+            return (
+                (
+                    !isIncluded &&
+                    this._date < otherTimez._date
+                ) || 
+                (
+                    !!isIncluded &&
+                    this._date <= otherTimez._date
+                )
+            );
+        }
+
+        isAfter(other: TimezInput, inclusivity: '()' | '[)' = '()'): boolean {
+            const isIncluded = inclusivity[0] === '[';
+            const otherTimez = other instanceof Timez ? other : new Timez(other);
+            if (!this._date || !otherTimez._date) {
+                return false;
+            }
+            return (
+                (
+                    !isIncluded &&
+                    this._date > otherTimez._date
+                ) || 
+                (
+                    !!isIncluded &&
+                    this._date >= otherTimez._date
+                )
+            );
+        }
+
+        isSame(other: TimezInput, unit?: 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'): boolean {
+            const otherTimez = other instanceof Timez ? other : new Timez(other);
+
+            if (!unit && this._date && otherTimez._date) {
+                return this._date.getTime() === otherTimez._date.getTime();
+            }
+
+            const thisStart = !!unit ? this.startOf(unit) : undefined;
+            const otherStart = !!unit ? otherTimez.startOf(unit) : undefined;
+
+            if (!thisStart || !thisStart?._date || !otherStart || !otherStart?._date) {
+                return false;
+            }
+            return thisStart._date.getTime() === otherStart._date.getTime();
+        }
+
+        isBetween(start: TimezInput, end: TimezInput, inclusivity: '()' | '[]' | '(]' | '[)' = '()'): boolean {
+            const startTimez: any = start instanceof Timez ? start : new Timez(start);
+            const endTimez: any = end instanceof Timez ? end : new Timez(end);
+
+            const startIncluded = inclusivity[0] === '[';
+            const endIncluded = inclusivity[1] === ']';
+
+            const afterStart = startIncluded ?
+                this.isSame(startTimez) || this.isAfter(startTimez) :
+                this.isAfter(startTimez);
+
+            const beforeEnd = endIncluded ?
+                this.isSame(endTimez) || this.isBefore(endTimez) :
+                this.isBefore(endTimez);
+
+            return afterStart && beforeEnd;
+        }
+
+        format(formatString?: string): string | undefined {
+            if (!formatString) {
+                return this.toISOString();
+            }
+
+            const predefinedFormat = Timez.PREDEFINED_FORMATS[formatString];
+            if (predefinedFormat) {
+                return this.format(predefinedFormat);
+            }
+
+            let result = '';
+            let i = 0;
+
+            while (i < formatString.length) {
+                if (formatString[i] === '[') {
+                    const endIndex = formatString.indexOf(']', i);
+                    if (endIndex === -1) {
+                        result += formatString[i];
+                        i++;
+                        continue;
+                    }
+
+                    const literal = formatString.substring(i + 1, endIndex);
+                    result += literal;
+                    i = endIndex + 1;
+                } else if (formatString[i] === '%' && i + 1 < formatString.length) {
+                    const token = `%${formatString[i + 1]}`;
+                    const formatter = Timez.FORMAT_TOKENS[token];
+
+                    if (formatter) {
+                        result += formatter(this);
+                    } else {
+                        result += token;
+                    }
+
+                    i += 2;
+                } else {
+                    result += formatString[i];
+                    i++;
+                }
+            }
+
+            return result;
+        }
+        setTimezone(timezone: string): Timez {
+            if (!this._date) {
+                return new Timez(undefined);
+            }
+
+            const currentOffset = this._date.getTimezoneOffset();
+            const targetOffset = this.parseTimezoneOffset(timezone);
+
+            const adjustedDate = new Date(this._date.getTime() + (targetOffset - currentOffset) * 60000);
+            return new Timez(adjustedDate);
+        }
+
+        utc(): Timez {
+            if (!this._date) {
+                return new Timez(undefined);
+            }
+            return new Timez(new Date(Date.UTC(
+                this._date.getUTCFullYear(),
+                this._date.getUTCMonth(),
+                this._date.getUTCDate(),
+                this._date.getUTCHours(),
+                this._date.getUTCMinutes(),
+                this._date.getUTCSeconds(),
+                this._date.getUTCMilliseconds()
+            )));
+        }
+
+        local(): Timez {
+            if (!this._date) {
+                return new Timez(undefined);
+            }
+            return new Timez(new Date(
+                this._date.getFullYear(),
+                this._date.getMonth(),
+                this._date.getDate(),
+                this._date.getHours(),
+                this._date.getMinutes(),
+                this._date.getSeconds(),
+                this._date.getMilliseconds()
+            ));
+        }
+
+        toString(): string | undefined {
+            return this._date?.toString();
+        }
+
+        toISOString(): string | undefined {
+            return this._date?.toISOString();
+        }
+
+        toDate(): Date | undefined {
+            return !!this._date ? new Date(this._date) : undefined;
+        }
+
+        valueOf(): number | undefined {
+            return this._date?.getTime();
+        }
+
+        unix(): number | undefined {
+            return !!this._date ? Math.floor(this._date.getTime() / 1000) : undefined;
+        }
+
+        utcOffset(): number | undefined {
+            return this._date ? -this._date.getTimezoneOffset() : undefined;
+        }
+
+        isCorrect(): boolean {
+            return !!this._date && !isNaN(this._date.getTime());
+        }
+
+        timezone(): string | undefined {
+            if (!this._date) return undefined;
+
+            try {
+                const formatter = new Intl.DateTimeFormat();
+                const timezone = formatter.resolvedOptions().timeZone;
+                return timezone || undefined;
+            } catch (error) {
+                return this.timezoneFromOffset();
+            }
+        }
+
+        timezoneAbbr(): string | undefined {
+            if (!this._date) return undefined;
+
+            try {
+                const formatter = new Intl.DateTimeFormat('en', {
+                    timeZoneName: 'short'
+                });
+                const parts = formatter.formatToParts(this._date);
+                const timezonePart = parts.find(part => part.type === 'timeZoneName');
+                return timezonePart?.value || undefined;
+            } catch (error) {
+                return this.timezoneAbbrFromOffset();
+            }
+        }
+
+        timezoneName(): string | undefined {
+            if (!this._date) return undefined;
+
+            try {
+                const formatter = new Intl.DateTimeFormat('en', {
+                    timeZoneName: 'long'
+                });
+                const parts = formatter.formatToParts(this._date);
+                const timezonePart = parts.find(part => part.type === 'timeZoneName');
+                return timezonePart?.value || undefined;
+            } catch (error) {
+                return this.timezoneNameFromOffset();
+            }
+        }
+
+        timezoneOffsetString(): string | undefined {
+            const offset = this.utcOffset();
+            if (offset === undefined) return undefined;
+
+            const sign = offset >= 0 ? '+' : '-';
+            const hours = Math.floor(Math.abs(offset) / 60).toString().padStart(2, '0');
+            const minutes = (Math.abs(offset) % 60).toString().padStart(2, '0');
+
+            return `${sign}${hours}:${minutes}`;
+        }
+
+
+
+        private dateChecker(input: any): boolean {
+            return (
+                (
+                    input instanceof Timez &&
+                    !!input &&
+                    !!input?._date
+                ) ||
+                input instanceof Date ||
+                typeof input === 'string' ||
+                typeof input === 'number' || (
+                    input === undefined || 
+                    input === null || 
+                    (typeof input === 'number' && isNaN(input))
+                )
+            );
+        }
+        private timezoneFromOffset(): string | undefined {
+            const offset = this.utcOffset();
+            if (offset === undefined) return undefined;
+
+            // Mapping basique des offsets vers les timezones IANA
+            const offsetToTimezone: { [key: number]: string } = {
+                0: 'Etc/UTC',
+                60: 'Europe/Paris',
+                120: 'Europe/Athens',
+                180: 'Europe/Moscow',
+                240: 'Asia/Dubai',
+                270: 'Asia/Tehran',
+                300: 'Asia/Karachi',
+                330: 'Asia/Kolkata',
+                345: 'Asia/Rangoon',
+                360: 'Asia/Dhaka',
+                390: 'Asia/Yangon',
+                420: 'Asia/Bangkok',
+                480: 'Asia/Shanghai',
+                525: 'Asia/Kathmandu',
+                540: 'Asia/Tokyo',
+                570: 'Australia/Adelaide',
+                600: 'Australia/Sydney',
+                630: 'Australia/Lord_Howe',
+                660: 'Pacific/Noumea',
+                675: 'Australia/Eucla',
+                720: 'Pacific/Auckland',
+                780: 'Pacific/Chatham',
+
+                [-60]: 'Atlantic/Azores',
+                [-120]: 'America/Noronha',
+                [-180]: 'America/Argentina/Buenos_Aires',
+                [-210]: 'America/St_Johns',
+                [-240]: 'America/Halifax',
+                [-270]: 'America/Caracas',
+                [-300]: 'America/New_York',
+                [-360]: 'America/Chicago',
+                [-420]: 'America/Denver',
+                [-480]: 'America/Los_Angeles',
+                [-540]: 'America/Anchorage',
+                [-600]: 'Pacific/Honolulu',
+                [-660]: 'Pacific/Pago_Pago',
+                [-720]: 'Pacific/Kiritimati',
+            };
+
+            return offsetToTimezone[offset] || `Etc/GMT${offset >= 0 ? '-' : '+'}${Math.abs(offset) / 60}`;
+        }
+
+        private timezoneAbbrFromOffset(): string | undefined {
+            const offset = this.utcOffset();
+            if (offset === undefined) return undefined;
+
+            const offsetToAbbr: { [key: number]: string } = {
+                0: 'GMT',
+                60: 'CET',
+                [-300]: 'EST',
+                [-360]: 'CST',
+                [-420]: 'MST',
+                [-480]: 'PST',
+            };
+
+            return offsetToAbbr[offset] || `GMT${offset >= 0 ? '+' : ''}${offset / 60}`;
+        }
+
+        private timezoneNameFromOffset(): string | undefined {
+            const offset = this.utcOffset();
+            if (offset === undefined) return undefined;
+
+            const offsetToName: { [key: number]: string } = {
+                0: 'Greenwich Mean Time',
+                60: 'Central European Time',
+                [-300]: 'Eastern Standard Time',
+                [-360]: 'Central Standard Time',
+                [-420]: 'Mountain Standard Time',
+                [-480]: 'Pacific Standard Time',
+            };
+
+            return offsetToName[offset] || `GMT${offset >= 0 ? '+' : ''}${offset / 60}`;
+        }
+
+        // Vérifie si la date est en heure d'été (Daylight Saving Time)
+        isDST(): boolean | undefined {
+            if (!this._date) return undefined;
+
+            try {
+                const jan = new Date(this._date.getFullYear(), 0, 1);
+                const jul = new Date(this._date.getFullYear(), 6, 1);
+
+                const stdOffset = Math.max(
+                    jan.getTimezoneOffset(),
+                    jul.getTimezoneOffset()
+                );
+
+                return this._date.getTimezoneOffset() < stdOffset;
+            } catch (error) {
+                return undefined;
+            }
+        }
+
+        private static parseString(dateString: string, enableException: boolean = false): Date | undefined {
+            const isoDate = new Date(dateString);
+            if (!isNaN(isoDate.getTime())) {
+                return isoDate;
+            }
+
+            const formats = [
+                /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})Z$/,
+                /^(\d{4})-(\d{2})-(\d{2})$/,
+                /^(\d{4})\/(\d{2})\/(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,
+                /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/
+            ];
+
+            for (const regex of formats) {
+                const match = dateString.match(regex);
+                if (match) {
+                    const components = match.slice(1).map(Number);
+                    if (regex === formats[0]) {
+                        // ISO with milliseconds
+                        return new Date(Date.UTC(components[0], components[1] - 1, components[2], components[3], components[4], components[5], components[6]));
+                    } else if (regex === formats[1]) {
+                        // Date only
+                        return new Date(components[0], components[1] - 1, components[2]);
+                    } else if (regex === formats[2]) {
+                        // Slash format
+                        return new Date(components[0], components[1] - 1, components[2], components[3], components[4], components[5]);
+                    } else if (regex === formats[3]) {
+                        // Compact format
+                        return new Date(components[0], components[1] - 1, components[2], components[3], components[4], components[5]);
+                    }
+                }
+            }
+
+            const fallback = new Date(dateString);
+            if (!isNaN(fallback.getTime())) {
+                return fallback;
+            }
+
+            if (!!enableException) {
+                throw new Error(`Unable to parse date string: ${dateString}`);
+            }
+        }
+
+        private static parseWithFormat(value: any, format: string): Timez | undefined {
+            if (!value || !format) return undefined;
+
+            const valueStr = String(value).trim();
+            if (!valueStr) return undefined;
+
+            // Table de mapping des tokens vers les regex et les extracteurs
+            const tokenHandlers: { [key: string]: { regex: RegExp, extract: (match: string) => number } } = {
+                'Y': { 
+                    regex: /\d{4}/, 
+                    extract: (match) => parseInt(match, 10) 
+                },
+                'y': { 
+                    regex: /\d{2}/, 
+                    extract: (match) => {
+                        const year = parseInt(match, 10);
+                        return year >= 70 ? 1900 + year : 2000 + year;
+                    }
+                },
+                'm': { 
+                    regex: /\d{1,2}/, 
+                    extract: (match) => parseInt(match, 10) 
+                },
+                'd': { 
+                    regex: /\d{1,2}/, 
+                    extract: (match) => parseInt(match, 10) 
+                },
+                'H': { 
+                    regex: /\d{1,2}/, 
+                    extract: (match) => parseInt(match, 10) 
+                },
+                'M': { 
+                    regex: /\d{1,2}/, 
+                    extract: (match) => parseInt(match, 10) 
+                },
+                'S': { 
+                    regex: /\d{1,2}/, 
+                    extract: (match) => parseInt(match, 10) 
+                },
+                'f': { 
+                    regex: /\d{1,3}/, 
+                    extract: (match) => parseInt(match, 10) 
+                }
+            };
+
+            const result = {
+                year: new Date().getFullYear(),
+                month: 1,
+                day: 1,
+                hour: 0,
+                minute: 0,
+                second: 0,
+                millisecond: 0
+            };
+
+            let valueIndex = 0;
+            let formatIndex = 0;
+            let inLiteral = false;
+            let currentLiteral = '';
+
+            while (formatIndex < format.length && valueIndex < valueStr.length) {
+                const formatChar = format[formatIndex];
+
+                if (formatChar === '[') {
+                    // Début d'un littéral
+                    inLiteral = true;
+                    currentLiteral = '';
+                    formatIndex++;
+                } else if (formatChar === ']' && inLiteral) {
+                    // Fin d'un littéral - vérifier qu'il correspond dans la valeur
+                    if (valueStr.substring(valueIndex, valueIndex + currentLiteral.length) === currentLiteral) {
+                        valueIndex += currentLiteral.length;
+                    } else {
+                        // Littéral non trouvé, échec du parsing
+                        return undefined;
+                    }
+                    inLiteral = false;
+                    currentLiteral = '';
+                    formatIndex++;
+                } else if (inLiteral) {
+                    // Accumuler le littéral
+                    currentLiteral += formatChar;
+                    formatIndex++;
+                } else if (formatChar === '%' && formatIndex + 1 < format.length) {
+                    // Token de format
+                    const token = format[formatIndex + 1];
+                    const handler = tokenHandlers[token];
+
+                    if (handler) {
+                        // Trouver la partie correspondante dans la valeur
+                        const remainingValue = valueStr.substring(valueIndex);
+                        const match = remainingValue.match(handler.regex);
+
+                        if (match && match.index === 0) {
+                            const matchedValue = match[0];
+                            const numericValue = handler.extract(matchedValue);
+
+                            // Assigner la valeur au composant correspondant
+                            switch (token) {
+                                case 'Y':
+                                case 'y':
+                                    result.year = numericValue;
+                                    break;
+                                case 'm':
+                                    result.month = numericValue;
+                                    break;
+                                case 'd':
+                                    result.day = numericValue;
+                                    break;
+                                case 'H':
+                                    result.hour = numericValue;
+                                    break;
+                                case 'M':
+                                    result.minute = numericValue;
+                                    break;
+                                case 'S':
+                                    result.second = numericValue;
+                                    break;
+                                case 'f':
+                                    result.millisecond = numericValue;
+                                    break;
+                            }
+
+                            valueIndex += matchedValue.length;
+                        } else {
+                            // Token non trouvé, échec du parsing
+                            return undefined;
+                        }
+                    } else {
+                        // Token non reconnu, avancer d'un caractère
+                        valueIndex++;
+                    }
+
+                    formatIndex += 2;
+                } else {
+                    // Caractère littéral - doit correspondre exactement
+                    if (formatChar === valueStr[valueIndex]) {
+                        valueIndex++;
+                        formatIndex++;
+                    } else {
+                        // Caractère ne correspond pas, échec du parsing
+                        return undefined;
+                    }
+                }
+            }
+
+            // Validation des valeurs
+            if (result.month < 1 || result.month > 12) return undefined;
+            if (result.day < 1 || result.day > 31) return undefined;
+            if (result.hour < 0 || result.hour > 23) return undefined;
+            if (result.minute < 0 || result.minute > 59) return undefined;
+            if (result.second < 0 || result.second > 59) return undefined;
+            if (result.millisecond < 0 || result.millisecond > 999) return undefined;
+
+            try {
+                const date = new Date(
+                    result.year,
+                    result.month - 1, // Mois 0-indexed en JS
+                    result.day,
+                    result.hour,
+                    result.minute,
+                    result.second,
+                    result.millisecond
+                );
+
+                // Vérifier que la date est valide
+                if (isNaN(date.getTime())) {
+                    return undefined;
+                }
+
+                return new Timez(date);
+            } catch (error) {
+                return undefined;
+            }
+        }
+
+        private static getTokenLength(token: string): number {
+            const tokenLengths: { [key: string]: number } = {
+                'Y': 4, // 4 digits pour l'année
+                'y': 2, // 2 digits pour l'année
+                'm': 2, // 2 digits pour le mois
+                'd': 2, // 2 digits pour le jour
+                'H': 2, // 2 digits pour l'heure
+                'M': 2, // 2 digits pour les minutes
+                'S': 2, // 2 digits pour les secondes
+                'f': 3, // 3 digits pour les millisecondes
+                'z': 5  // ±HHMM pour le timezone
+            };
+            return tokenLengths[token] || 1;
+        }
+
+        private parseTimezoneOffset(timezone: string): number {
+            const offsets: { [key: string]: number } = {
+                'UTC': 0,
+                'EST': -300, // -5 hours
+                'EDT': -240, // -4 hours
+                'CST': -360, // -6 hours
+                'CDT': -300, // -5 hours
+                'PST': -480, // -8 hours
+                'PDT': -420, // -7 hours
+            };
+
+            if (offsets[timezone.toUpperCase()] !== undefined) {
+                return offsets[timezone.toUpperCase()];
+            }
+
+            // Gérer les formats ±HH:MM, ±HHMM, ±HH
+            const match = timezone.match(/^([+-])(\d{1,2}):?(\d{2})?$/);
+            if (match) {
+                const sign = match[1] === '+' ? 1 : -1;
+                const hours = parseInt(match[2], 10);
+                const minutes = match[3] ? parseInt(match[3], 10) : 0;
+                return sign * (hours * 60 + minutes);
+            }
+
+            return this._date ? -this._date.getTimezoneOffset() : 0;
+        }
+
+        static get FORMATS() {
+            return { ...Timez.PREDEFINED_FORMATS };
+        }
+
+        static exposeToGlobal(): void {
+            if (typeof window !== 'undefined') {
+                (window as any).Timez = Timez;
+            }
+        }
+    }
+
+    if (typeof window !== 'undefined') {
+        (window as any).Timez = Timez;
+    }
+
+
+
+    
+
+
+
+
+
+
+
+    class Cooks {
+        private static DEFAULT_OPTIONS: CooksOptions = {
+            path: '/',
+            secure: true,
+            sameSite: 'lax' as const
+        };
+
+        public static set<T extends Serializable>(key: string, value: T, options: CooksOptions = {}): void {
+            if (!this.isBrowser()) return;
+
+            try {
+                const serializedValue = this.serialize(value);
+                const encodedValue = encodeURIComponent(serializedValue);
+                const cookieString = this.buildCookieString(key, encodedValue, options);
+
+                document.cookie = cookieString;
+            } catch (error) {
+                console.error(`Cooks: Error setting cookie "${key}":`, error);
+            }
+        }
+
+        public static get<T extends Serializable>(key: string): T | null {
+            if (!this.isBrowser()) return null;
+
+            try {
+                const cookies = this.getAllCookies();
+                const encodedValue = cookies[key];
+
+                if (!encodedValue) return null;
+
+                const decodedValue = decodeURIComponent(encodedValue);
+                return this.deserialize<T>(decodedValue);
+            } catch (error) {
+                console.error(`Cooks: Error getting cookie "${key}":`, error);
+                return null;
+            }
+        }
+
+        public static remove(key: string, path: string = '/', domain?: string): void {
+            if (!this.isBrowser()) return;
+
+            const options: CooksOptions = {
+                expires: new Date(0),
+                path,
+                domain
+            };
+
+            this.set(key, '', options);
+        }
+
+        public static has(key: string): boolean {
+            return this.get(key) !== null;
+        }
+
+        public static keys(): string[] {
+            if (!this.isBrowser()) return [];
+
+            const cookies = this.getAllCookies();
+            return Object.keys(cookies);
+        }
+
+        public static clear(): void {
+            if (!this.isBrowser()) return;
+
+            const cookies = this.getAllCookies();
+            Object.keys(cookies).forEach(key => {
+                this.remove(key);
+            });
+        }
+
+        private static serialize(value: Serializable): string {
+            if (value instanceof Date) {
+                return JSON.stringify({
+                    __type: 'Date',
+                    __value: value.toISOString()
+                });
+            }
+
+            return JSON.stringify(value);
+        }
+
+        private static deserialize<T>(value: string): T {
+            const parsed = JSON.parse(value);
+
+            if (parsed && typeof parsed === 'object' && parsed.__type === 'Date') {
+                return new Date(parsed.__value) as T;
+            }
+
+            return parsed as T;
+        }
+
+        private static buildCookieString(key: string, value: string, options: CooksOptions): string {
+            const mergedOptions = { ...this.DEFAULT_OPTIONS, ...options };
+            let cookieString = `${key}=${value}`;
+
+            if (mergedOptions.expires !== undefined) {
+                let expirationDate: Date;
+
+                if (typeof mergedOptions.expires === 'number') {
+                    const expirationDateInitial = new Timez().add(mergedOptions.expires, 'seconds').toDate();
+
+                    if(!!expirationDateInitial) {
+                        expirationDate = expirationDateInitial;
+                    } else {
+                        expirationDate = new Date();
+                    }
+
+                } else {
+
+                    expirationDate = mergedOptions.expires;
+                }
+
+                cookieString += `; expires=${expirationDate.toUTCString()}`;
+            }
+
+            if (mergedOptions.path) cookieString += `; path=${mergedOptions.path}`;
+            if (mergedOptions.domain) cookieString += `; domain=${mergedOptions.domain}`;
+            if (mergedOptions.secure) cookieString += `; secure`;
+            if (mergedOptions.sameSite) cookieString += `; samesite=${mergedOptions.sameSite}`;
+
+            if(NODEENV === 'development') {
+                console.log(`Cooks - buildCookieString | cookieString:: `, cookieString);
+            }
+
+            return cookieString;
+        }
+
+        private static getAllCookies(): Record<string, string> {
+            return document.cookie
+                .split(';')
+                .reduce((cookies, cookie) => {
+                    const [key, value] = cookie.split('=').map(part => part.trim());
+                    if (key) {
+                        cookies[key] = value || '';
+                    }
+                    return cookies;
+                }, {} as Record<string, string>);
+        }
+
+        private static isBrowser(): boolean {
+            return typeof window !== 'undefined' && typeof document !== 'undefined';
+        }
+        static exposeToGlobal(): void {
+            if (typeof window !== "undefined") {
+                (window as any).Cooks = Cooks;
+            }
+        }
+    }
+
+    if (typeof window !== "undefined") {
+        (window as any).Cooks = Cooks;
+    }
+
+
+
+    
+    const globalFunctModule = {
+        default: Cooks,
+        Cooks: Cooks,
+    };
+    
+    
+    const __bundledModules = globalFunctModule;
+    
+    if (typeof global !== 'undefined') {
+        (global as any).default = Cooks;
+        (global as any).Cooks = Cooks;
+        (global as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof window !== "undefined") {
+        (window as any).default = Cooks;
+        (window as any).Cooks = Cooks;
+        (window as any).__bundledModules = __bundledModules;
+    }
+    
+    if (typeof exports !== 'undefined') {
+        exports.default = Cooks;
+        exports.Cooks = Cooks;
+    }
+	return globalFunctModule;
+
+})(typeof global !== 'undefined' ? global : 
+   typeof window !== 'undefined' ? window : 
+   typeof self !== 'undefined' ? self : 
+   typeof globalThis !== 'undefined' ? globalThis : 
+   {});
+
+type CooksElementTypeGF = typeof globalFunct.Cooks;
+
+type DefaultElementTypeGF = typeof globalFunct.default;
+
+const CooksElementGF: CooksElementTypeGF = globalFunct.Cooks;
+
+const defaultElementGF: DefaultElementTypeGF = globalFunct.default;
+
+
+