@arc-js/config-manager 0.0.94 → 0.0.95

package/core/ConfigService.js

@@ -8,7 +8,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
+        step((generator = generator.apply(thisArg, [])).next());
     });
 }
 
@@ -17,6 +17,901 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+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;
+}
+
+requireCooks();
+
+const DEFAULT_SCOPE = 'app';
+
 const mergeDeep = (target, source) => {
     if (typeof target !== 'object' || typeof source !== 'object')
         return source;
@@ -34,42 +929,47 @@ const mergeDeep = (target, source) => {
     return output;
 };
 
-let configManagerConfig = null;
-
-const loadBaseConfig = () => __awaiter(void 0, void 0, void 0, function* () {
+const loadBaseConfig = (scope, configManagerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.base[scope])) {
+        console.warn(`❌ No base config found for scope: ${scope}`);
+        console.warn('Available scopes:', (configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.base) ? Object.keys(configManagerConfig.base) : 'none');
+        return {};
+    }
     try {
-        if (!(configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.base)) {
-            console.warn('No base config found');
-            return {};
-        }
-        const baseConfigs = yield Promise.all(Object.entries(configManagerConfig.base).map((_a) => __awaiter(void 0, [_a], void 0, function* ([key, loader]) {
-            try {
-                const config = yield loader();
-                return { key, config };
-            }
-            catch (error) {
-                console.error(`Failed to load base config ${key}:`, error);
-                return { key, config: {} };
-            }
-        })));
-        return baseConfigs.reduce((acc, { key, config }) => {
-            return Object.assign(Object.assign({}, acc), config);
-        }, {});
+        const loader = configManagerConfig.base[scope];
+        const result = yield loader();
+        return result;
     }
     catch (error) {
-        console.error('Failed to load base config:', error);
+        console.error(`❌ Failed to load base ${scope} config`, error);
         return {};
     }
 });
-const loadModulesConfigs = () => __awaiter(void 0, void 0, void 0, function* () {
+const loadModulesConfig = (configManagerConfig) => __awaiter(void 0, void 0, void 0, function* () {
     const results = [];
-    {
+    if (!(configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.modules)) {
+        console.warn(`⚠️ No modules configuration found`);
         return results;
     }
+    for (const [moduleName, moduleLoader] of Object.entries(configManagerConfig.modules)) {
+        try {
+            const config = yield moduleLoader();
+            results.push({
+                moduleName,
+                config
+            });
+        }
+        catch (error) {
+            console.error(`❌ Failed to load config for module "${moduleName}"`, error);
+        }
+    }
+    return results;
 });
-const loadModuleConfig = (moduleName) => __awaiter(void 0, void 0, void 0, function* () {
+const loadModuleConfig = (moduleName, configManagerConfig) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
-    if (!((_a = void 0 ) === null || _a === void 0 ? void 0 : _a[moduleName])) {
+    if (!((_a = configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.modules) === null || _a === void 0 ? void 0 : _a[moduleName])) {
+        console.warn(`❌ No config found for module "${moduleName}"`);
+        console.warn('Available modules:', (configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.modules) ? Object.keys(configManagerConfig.modules) : 'none');
         return undefined;
     }
     try {
@@ -81,70 +981,134 @@ const loadModuleConfig = (moduleName) => __awaiter(void 0, void 0, void 0, funct
         };
     }
     catch (error) {
-        console.error(`Failed to load config for module "${moduleName}"`, error);
+        console.error(`❌ Failed to load config for module "${moduleName}"`, error);
         return undefined;
     }
 });
 
 class ConfigService {
-    constructor() {
-        Object.defineProperty(this, "resources", {
+    constructor(supportedScopes = [DEFAULT_SCOPE], configManagerConfig) {
+        Object.defineProperty(this, "configs", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "currentScope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: DEFAULT_SCOPE
+        });
         Object.defineProperty(this, "loadedModules", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Set()
         });
+        Object.defineProperty(this, "supportedScopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [DEFAULT_SCOPE]
+        });
+        Object.defineProperty(this, "configManagerConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.supportedScopes = supportedScopes;
+        if (configManagerConfig) {
+            this.configManagerConfig = configManagerConfig;
+        }
+    }
+    setConfigManagerConfig(config) {
+        this.configManagerConfig = config;
     }
-    initialize() {
+    initialize(scope) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.loadAllConfigs();
+            if (!this.configManagerConfig) {
+                console.error('❌ No config manager config set in ConfigService');
+                throw new Error('Config manager config not set');
+            }
+            this.currentScope = scope;
+            yield this.loadScope(scope);
         });
     }
-    loadAllConfigs() {
+    loadScope(scope) {
         return __awaiter(this, void 0, void 0, function* () {
-            const base = yield loadBaseConfig();
-            const modules = yield loadModulesConfigs();
-            this.resources = modules.reduce((acc, { moduleName, config }) => {
+            if (!this.supportedScopes.includes(scope)) {
+                console.warn(`⚠️ Scope ${scope} is not supported`);
+                return;
+            }
+            if (!this.configManagerConfig) {
+                console.error('❌ No config manager config available');
+                return;
+            }
+            const base = yield loadBaseConfig(scope, this.configManagerConfig);
+            const allModules = yield loadModulesConfig(this.configManagerConfig);
+            this.configs[scope] = allModules.reduce((acc, { moduleName, config }) => {
                 return mergeDeep(acc, { [moduleName]: config });
-            }, { base });
-            modules.forEach(({ moduleName }) => {
-                this.loadedModules.add(moduleName);
-            });
+            }, { app: base });
         });
     }
     loadModule(moduleName) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.loadedModules.has(moduleName))
+            if (this.loadedModules.has(moduleName)) {
+                return;
+            }
+            if (!this.configManagerConfig) {
+                console.error('❌ No config manager config available');
                 return;
-            const moduleData = yield loadModuleConfig(moduleName);
+            }
+            const moduleData = yield loadModuleConfig(moduleName, this.configManagerConfig);
             if (moduleData === null || moduleData === void 0 ? void 0 : moduleData.config) {
-                this.resources[moduleName] = mergeDeep(this.resources[moduleName] || {}, moduleData.config);
-                this.loadedModules.add(moduleName);
+                for (const scope of this.supportedScopes) {
+                    if (!this.configs[scope]) {
+                        this.configs[scope] = { app: {} };
+                    }
+                    this.configs[scope][moduleName] = moduleData.config;
+                }
+            }
+            else {
+                console.warn(`⚠️ No config found for module ${moduleName}`);
             }
+            this.loadedModules.add(moduleName);
         });
     }
     get(key, options = {}) {
-        const { moduleName = 'base', defaultValue = undefined, pathSeparator = '.' } = options;
-        const resource = this.resources[moduleName];
-        if (!resource) {
-            return defaultValue;
+        const { moduleName = 'app', defaultValue = undefined, } = options;
+        const config = this.findConfig(key, moduleName) || defaultValue;
+        return config;
+    }
+    findConfig(key, moduleName) {
+        const configs = this.configs[this.currentScope];
+        if (!configs) {
+            console.error(`❌ No configs found for scope: ${this.currentScope}`);
+            console.error('Available scopes:', Object.keys(this.configs));
+            return undefined;
         }
-        const result = key.split(pathSeparator).reduce((acc, part) => {
+        if (!configs[moduleName]) {
+            console.error(`❌ Module "${moduleName}" not found in configs for scope ${this.currentScope}`);
+            console.error('Available modules:', Object.keys(configs));
+            return undefined;
+        }
+        const result = key.split('.').reduce((acc, part) => {
             return acc && acc[part] !== undefined ? acc[part] : undefined;
-        }, resource);
-        return result !== undefined ? result : defaultValue;
+        }, configs[moduleName]);
+        return result;
+    }
+    setScope(scope) {
+        if (this.supportedScopes.includes(scope)) {
+            this.currentScope = scope;
+        }
     }
-    getConfig(moduleName = 'base') {
-        return this.resources[moduleName] || {};
+    getCurrentScope() {
+        return this.currentScope;
     }
-    reload() {
-        return this.loadAllConfigs();
+    getAllConfigs() {
+        return this.configs[this.currentScope] || {};
     }
 }