@arc-js/cooks 0.0.1

package/cooks.all.js

@@ -0,0 +1,910 @@
+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'];
+[...tabAlphabetique, ...tabAlphabetique.map(x => x.toUpperCase())];
+
+class Timez {
+    _date;
+    static FORMAT_TOKENS = {
+        '%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 PREDEFINED_FORMATS = {
+        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, enableException = 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() {
+        return new Timez();
+    }
+    static parse(dateString, format) {
+        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) {
+        return new Timez(timestamp * 1000);
+    }
+    static utc() {
+        const now = new Date();
+        return new Timez(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), now.getUTCHours(), now.getUTCMinutes(), now.getUTCSeconds(), now.getUTCMilliseconds()));
+    }
+    year() {
+        return this._date?.getFullYear();
+    }
+    month() {
+        return !!this._date ? this._date.getMonth() + 1 : undefined;
+    }
+    date() {
+        return this._date?.getDate();
+    }
+    hour() {
+        return this._date?.getHours();
+    }
+    minute() {
+        return this._date?.getMinutes();
+    }
+    second() {
+        return this._date?.getSeconds();
+    }
+    millisecond() {
+        return this._date?.getMilliseconds();
+    }
+    day() {
+        return this._date?.getDay();
+    }
+    add(amount, unit) {
+        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, unit) {
+        return this.add(-amount, unit);
+    }
+    startOf(unit) {
+        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) {
+        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, inclusivity = '()') {
+        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, inclusivity = '()') {
+        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, unit) {
+        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, end, inclusivity = '()') {
+        const startTimez = start instanceof Timez ? start : new Timez(start);
+        const endTimez = 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) {
+        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) {
+        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() {
+        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() {
+        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() {
+        return this._date?.toString();
+    }
+    toISOString() {
+        return this._date?.toISOString();
+    }
+    toDate() {
+        return !!this._date ? new Date(this._date) : undefined;
+    }
+    valueOf() {
+        return this._date?.getTime();
+    }
+    unix() {
+        return !!this._date ? Math.floor(this._date.getTime() / 1000) : undefined;
+    }
+    utcOffset() {
+        return this._date ? -this._date.getTimezoneOffset() : undefined;
+    }
+    isCorrect() {
+        return !!this._date && !isNaN(this._date.getTime());
+    }
+    timezone() {
+        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() {
+        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() {
+        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() {
+        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}`;
+    }
+    dateChecker(input) {
+        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))));
+    }
+    timezoneFromOffset() {
+        const offset = this.utcOffset();
+        if (offset === undefined)
+            return undefined;
+        // Mapping basique des offsets vers les timezones IANA
+        const offsetToTimezone = {
+            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}`;
+    }
+    timezoneAbbrFromOffset() {
+        const offset = this.utcOffset();
+        if (offset === undefined)
+            return undefined;
+        const offsetToAbbr = {
+            0: 'GMT',
+            60: 'CET',
+            [-300]: 'EST',
+            [-360]: 'CST',
+            [-420]: 'MST',
+            [-480]: 'PST',
+        };
+        return offsetToAbbr[offset] || `GMT${offset >= 0 ? '+' : ''}${offset / 60}`;
+    }
+    timezoneNameFromOffset() {
+        const offset = this.utcOffset();
+        if (offset === undefined)
+            return undefined;
+        const offsetToName = {
+            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() {
+        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;
+        }
+    }
+    static parseString(dateString, enableException = false) {
+        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}`);
+        }
+    }
+    static parseWithFormat(value, format) {
+        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 = {
+            '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;
+        }
+    }
+    static getTokenLength(token) {
+        const tokenLengths = {
+            '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;
+    }
+    parseTimezoneOffset(timezone) {
+        const offsets = {
+            '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() {
+        if (typeof window !== 'undefined') {
+            window.Timez = Timez;
+        }
+    }
+}
+if (typeof window !== 'undefined') {
+    window.Timez = Timez;
+}
+
+class Cooks {
+    static DEFAULT_OPTIONS = {
+        path: '/',
+        secure: true,
+        sameSite: 'lax'
+    };
+    /**
+     * Définit un cookie avec une valeur sérialisée
+     */
+    static set(key, value, options = {}) {
+        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);
+        }
+    }
+    /**
+     * Récupère et désérialise un cookie
+     */
+    static get(key) {
+        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(decodedValue);
+        }
+        catch (error) {
+            console.error(`Cooks: Error getting cookie "${key}":`, error);
+            return null;
+        }
+    }
+    /**
+     * Supprime un cookie
+     */
+    static remove(key, path = '/', domain) {
+        if (!this.isBrowser())
+            return;
+        const options = {
+            expires: new Date(0),
+            path,
+            domain
+        };
+        this.set(key, '', options);
+    }
+    /**
+     * Vérifie si un cookie existe
+     */
+    static has(key) {
+        return this.get(key) !== null;
+    }
+    /**
+     * Retourne toutes les clés de cookies disponibles
+     */
+    static keys() {
+        if (!this.isBrowser())
+            return [];
+        const cookies = this.getAllCookies();
+        return Object.keys(cookies);
+    }
+    /**
+     * Nettoie tous les cookies (optionnel - à utiliser avec précaution)
+     */
+    static clear() {
+        if (!this.isBrowser())
+            return;
+        const cookies = this.getAllCookies();
+        Object.keys(cookies).forEach(key => {
+            this.remove(key);
+        });
+    }
+    /**
+     * Sérialise une valeur en string JSON avec support des Dates
+     */
+    static serialize(value) {
+        if (value instanceof Date) {
+            return JSON.stringify({
+                __type: 'Date',
+                __value: value.toISOString()
+            });
+        }
+        return JSON.stringify(value);
+    }
+    /**
+     * Désérialise une string JSON avec support des Dates
+     */
+    static deserialize(value) {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && parsed.__type === 'Date') {
+            return new Date(parsed.__value);
+        }
+        return parsed;
+    }
+    /**
+     * Construit la string du cookie avec les options
+     */
+    static buildCookieString(key, value, options) {
+        const mergedOptions = { ...this.DEFAULT_OPTIONS, ...options };
+        let cookieString = `${key}=${value}`;
+        // Gestion de l'expiration en secondes
+        if (mergedOptions.expires !== undefined) {
+            let expirationDate;
+            if (typeof mergedOptions.expires === 'number') {
+                const expirationDateInitial = new Timez().add(mergedOptions.expires, 'seconds').toDate();
+                // Si c'est un nombre, on le traite comme des secondes
+                if (!!expirationDateInitial) {
+                    expirationDate = expirationDateInitial;
+                }
+                else {
+                    expirationDate = new Date();
+                }
+                // expirationDate = new Date(Date.now() + mergedOptions.expires * 1000);
+            }
+            else {
+                // Si c'est déjà une Date, on l'utilise directement
+                expirationDate = mergedOptions.expires;
+            }
+            cookieString += `; expires=${expirationDate.toUTCString()}`;
+        }
+        // Ajout des autres options
+        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}`;
+        {
+            console.log(`Cooks - buildCookieString | cookieString:: `, cookieString);
+        }
+        return cookieString;
+    }
+    /**
+     * Parse tous les cookies en un objet
+     */
+    static getAllCookies() {
+        return document.cookie
+            .split(';')
+            .reduce((cookies, cookie) => {
+            const [key, value] = cookie.split('=').map(part => part.trim());
+            if (key) {
+                cookies[key] = value || '';
+            }
+            return cookies;
+        }, {});
+    }
+    /**
+     * Vérifie si l'environnement est un navigateur
+     */
+    static isBrowser() {
+        return typeof window !== 'undefined' && typeof document !== 'undefined';
+    }
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.Cooks = Cooks;
+        }
+    }
+}
+if (typeof window !== "undefined") {
+    window.Cooks = Cooks;
+}
+
+export { Cooks, Cooks as default };