@jsarc/timez 0.0.0

package/web/timez.js

@@ -0,0 +1,740 @@
+const globalFunct = (function (global) {
+    'use strict';
+    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;
+            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 { ...Timez.PREDEFINED_FORMATS };
+        }
+        static exposeToGlobal() {
+            if (typeof window !== 'undefined') {
+                window.Timez = Timez;
+            }
+        }
+    }
+    if (typeof window !== 'undefined') {
+        window.Timez = Timez;
+    }
+    const globalFunctModule = {
+        default: Timez,
+        Timez: Timez,
+    };
+    const __bundledModules = globalFunctModule;
+    if (typeof global !== 'undefined') {
+        global.default = Timez;
+        global.Timez = Timez;
+        global.__bundledModules = __bundledModules;
+    }
+    if (typeof window !== "undefined") {
+        window.default = Timez;
+        window.Timez = Timez;
+        window.__bundledModules = __bundledModules;
+    }
+    if (typeof exports !== 'undefined') {
+        exports.default = Timez;
+        exports.Timez = Timez;
+    }
+    return globalFunctModule;
+})(typeof global !== 'undefined' ? global :
+    typeof window !== 'undefined' ? window :
+        typeof self !== 'undefined' ? self :
+            typeof globalThis !== 'undefined' ? globalThis :
+                {});
+const TimezElementGF = globalFunct.Timez;
+const defaultElementGF = globalFunct.default;