@arc-js/config-manager 0.0.92 → 0.0.95

package/config.js

@@ -1,7 +1,904 @@
-const DEFAULT_CONFIG = 'base';
-let configManagerConfig = null;
-const setConfigManagerConfig = (config) => {
-    configManagerConfig = config;
+var cooks = {};
+
+var timez = {};
+
+var hasRequiredTimez;
+
+function requireTimez () {
+	if (hasRequiredTimez) return timez;
+	hasRequiredTimez = 1;
+
+	Object.defineProperty(timez, '__esModule', { value: true });
+
+	class Timez {
+	    constructor(input, enableException = false) {
+	        if (this.dateChecker(input) === false) {
+	            this._date = undefined;
+	        }
+	        else {
+	            if (input instanceof Timez && !!input && !!(input === null || input === void 0 ? void 0 : input._date)) {
+	                this._date = new Date(input === null || input === void 0 ? void 0 : 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 === null || dateString === void 0 ? void 0 : 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() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getFullYear();
+	    }
+	    month() {
+	        return !!this._date ? this._date.getMonth() + 1 : undefined;
+	    }
+	    date() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getDate();
+	    }
+	    hour() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getHours();
+	    }
+	    minute() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getMinutes();
+	    }
+	    second() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getSeconds();
+	    }
+	    millisecond() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getMilliseconds();
+	    }
+	    day() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.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 === null || thisStart === void 0 ? void 0 : thisStart._date) || !otherStart || !(otherStart === null || otherStart === void 0 ? void 0 : 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() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.toString();
+	    }
+	    toISOString() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.toISOString();
+	    }
+	    toDate() {
+	        return !!this._date ? new Date(this._date) : undefined;
+	    }
+	    valueOf() {
+	        var _a;
+	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.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 === null || timezonePart === void 0 ? void 0 : 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 === null || timezonePart === void 0 ? void 0 : 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 === null || input === void 0 ? void 0 : 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;
+	        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}`;
+	    }
+	    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]) {
+	                    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]) {
+	                    return new Date(components[0], components[1] - 1, components[2]);
+	                }
+	                else if (regex === formats[2]) {
+	                    return new Date(components[0], components[1] - 1, components[2], components[3], components[4], components[5]);
+	                }
+	                else if (regex === formats[3]) {
+	                    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;
+	        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 === '[') {
+	                inLiteral = true;
+	                currentLiteral = '';
+	                formatIndex++;
+	            }
+	            else if (formatChar === ']' && inLiteral) {
+	                if (valueStr.substring(valueIndex, valueIndex + currentLiteral.length) === currentLiteral) {
+	                    valueIndex += currentLiteral.length;
+	                }
+	                else {
+	                    return undefined;
+	                }
+	                inLiteral = false;
+	                currentLiteral = '';
+	                formatIndex++;
+	            }
+	            else if (inLiteral) {
+	                currentLiteral += formatChar;
+	                formatIndex++;
+	            }
+	            else if (formatChar === '%' && formatIndex + 1 < format.length) {
+	                const token = format[formatIndex + 1];
+	                const handler = tokenHandlers[token];
+	                if (handler) {
+	                    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);
+	                        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 {
+	                        return undefined;
+	                    }
+	                }
+	                else {
+	                    valueIndex++;
+	                }
+	                formatIndex += 2;
+	            }
+	            else {
+	                if (formatChar === valueStr[valueIndex]) {
+	                    valueIndex++;
+	                    formatIndex++;
+	                }
+	                else {
+	                    return undefined;
+	                }
+	            }
+	        }
+	        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, 
+	            result.day, result.hour, result.minute, result.second, result.millisecond);
+	            if (isNaN(date.getTime())) {
+	                return undefined;
+	            }
+	            return new Timez(date);
+	        }
+	        catch (error) {
+	            return undefined;
+	        }
+	    }
+	    static getTokenLength(token) {
+	        const tokenLengths = {
+	            'Y': 4, 
+	            'y': 2, 
+	            'm': 2, 
+	            'd': 2, 
+	            'H': 2, 
+	            'M': 2, 
+	            'S': 2, 
+	            'f': 3, 
+	            'z': 5 
+	        };
+	        return tokenLengths[token] || 1;
+	    }
+	    parseTimezoneOffset(timezone) {
+	        const offsets = {
+	            'UTC': 0,
+	            'EST': -300, 
+	            'EDT': -240, 
+	            'CST': -360, 
+	            'CDT': -300, 
+	            'PST': -480, 
+	            'PDT': -420, 
+	        };
+	        if (offsets[timezone.toUpperCase()] !== undefined) {
+	            return offsets[timezone.toUpperCase()];
+	        }
+	        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 Object.assign({}, Timez.PREDEFINED_FORMATS);
+	    }
+	    static exposeToGlobal() {
+	        if (typeof window !== 'undefined') {
+	            window.Timez = Timez;
+	        }
+	    }
+	}
+	Timez.FORMAT_TOKENS = {
+	    '%Y': (t) => { var _a; return (_a = t.year()) === null || _a === void 0 ? void 0 : _a.toString().padStart(4, '0'); },
+	    '%y': (t) => { var _a; return (_a = t.year()) === null || _a === void 0 ? void 0 : _a.toString().slice(-2).padStart(2, '0'); },
+	    '%m': (t) => { var _a; return (_a = t.month()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
+	    '%d': (t) => { var _a; return (_a = t.date()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
+	    '%H': (t) => { var _a; return (_a = t.hour()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
+	    '%M': (t) => { var _a; return (_a = t.minute()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
+	    '%S': (t) => { var _a; return (_a = t.second()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
+	    '%f': (t) => { var _a; return (_a = t.millisecond()) === null || _a === void 0 ? void 0 : _a.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;
+	    },
+	};
+	Timez.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]',
+	};
+	if (typeof window !== 'undefined') {
+	    window.Timez = Timez;
+	}
+
+	timez.Timez = Timez;
+	timez.default = Timez;
+	return timez;
+}
+
+var hasRequiredCooks;
+
+function requireCooks () {
+	if (hasRequiredCooks) return cooks;
+	hasRequiredCooks = 1;
+
+	Object.defineProperty(cooks, '__esModule', { value: true });
+
+	var timez = requireTimez();
+
+	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 Cooks {
+	    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);
+	        }
+	    }
+	    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;
+	        }
+	    }
+	    static remove(key, path = '/', domain) {
+	        if (!this.isBrowser())
+	            return;
+	        const options = {
+	            expires: new Date(0),
+	            path,
+	            domain
+	        };
+	        this.set(key, '', options);
+	    }
+	    static has(key) {
+	        return this.get(key) !== null;
+	    }
+	    static keys() {
+	        if (!this.isBrowser())
+	            return [];
+	        const cookies = this.getAllCookies();
+	        return Object.keys(cookies);
+	    }
+	    static clear() {
+	        if (!this.isBrowser())
+	            return;
+	        const cookies = this.getAllCookies();
+	        Object.keys(cookies).forEach(key => {
+	            this.remove(key);
+	        });
+	    }
+	    static serialize(value) {
+	        if (value instanceof Date) {
+	            return JSON.stringify({
+	                __type: 'Date',
+	                __value: value.toISOString()
+	            });
+	        }
+	        return JSON.stringify(value);
+	    }
+	    static deserialize(value) {
+	        const parsed = JSON.parse(value);
+	        if (parsed && typeof parsed === 'object' && parsed.__type === 'Date') {
+	            return new Date(parsed.__value);
+	        }
+	        return parsed;
+	    }
+	    static buildCookieString(key, value, options) {
+	        const mergedOptions = Object.assign(Object.assign({}, this.DEFAULT_OPTIONS), options);
+	        let cookieString = `${key}=${value}`;
+	        if (mergedOptions.expires !== undefined) {
+	            let expirationDate;
+	            if (typeof mergedOptions.expires === 'number') {
+	                const expirationDateInitial = new timez.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}`;
+	        {
+	            console.log(`Cooks - buildCookieString | cookieString:: `, cookieString);
+	        }
+	        return cookieString;
+	    }
+	    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;
+	        }, {});
+	    }
+	    static isBrowser() {
+	        return typeof window !== 'undefined' && typeof document !== 'undefined';
+	    }
+	    static exposeToGlobal() {
+	        if (typeof window !== "undefined") {
+	            window.Cooks = Cooks;
+	        }
+	    }
+	}
+	Cooks.DEFAULT_OPTIONS = {
+	    path: '/',
+	    secure: true,
+	    sameSite: 'lax'
+	};
+	if (typeof window !== "undefined") {
+	    window.Cooks = Cooks;
+	}
+
+	cooks.Cooks = Cooks;
+	cooks.default = Cooks;
+	return cooks;
+}
+
+var cooksExports = requireCooks();
+
+const DEFAULT_SCOPE = 'app';
+const COOKIE_NAME = 'app_config_scope';
+const getSavedScope = () => {
+    const saved = cooksExports.Cooks.get(COOKIE_NAME);
+    return saved || DEFAULT_SCOPE;
+};
+const saveScope = (scope) => {
+    cooksExports.Cooks.set(COOKIE_NAME, scope, { expires: 365 * 24 * 3600, sameSite: 'strict' });
 };
 
-export { DEFAULT_CONFIG, configManagerConfig, setConfigManagerConfig };
+export { COOKIE_NAME, DEFAULT_SCOPE, getSavedScope, saveScope };