Epoch converter

// Pure browser arithmetic. Time API calls take the resulting ISO instant.
/** Calendar helpers for the shared timezone tool. The API converts the selected instant. */
function isToolDate(value) {
    if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || value.startsWith('0000'))
        return false;
    const date = new Date(`${value}T00:00:00Z`);
    return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
}
function isToolTime(value) {
    return /^(?:[01]\d|2[0-3]):[0-5]\d$/.test(value);
}
function isToolTimezone(value) {
    if (!value || value.length > 64)
        return false;
    try {
        new Intl.DateTimeFormat('en-US', { timeZone: value });
        return true;
    }
    catch {
        return false;
    }
}
function wallFormatter(zone) {
    return new Intl.DateTimeFormat('en-CA', {
        timeZone: zone,
        year: 'numeric', month: '2-digit', day: '2-digit',
        hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
    });
}
function wallParts(formatter, instant) {
    const parts = Object.fromEntries(formatter.formatToParts(instant).map((p) => [p.type, p.value]));
    return {
        date: `${parts.year.padStart(4, '0')}-${parts.month}-${parts.day}`,
        time: `${parts.hour}:${parts.minute}:${parts.second}`,
    };
}
/**
 * Find exact mappings, never normalize a missing hour into a different time.
 * Sample either side of the date to collect the offsets around an IANA change,
 * then round-trip each candidate. This also handles half-hour DST changes and
 * a whole skipped date. The user chooses when two mappings are possible.
 */
function resolveToolWallTime(date, time, zone) {
    if (!isToolDate(date) || !isToolTime(time) || !isToolTimezone(zone))
        return { kind: 'invalid', instants: [] };
    const wall = Date.parse(`${date}T${time}:00Z`);
    const formatter = wallFormatter(zone);
    const offsets = new Set();
    for (let hours = -48; hours <= 48; hours += 6) {
        const sample = wall + hours * 3600000;
        const seen = wallParts(formatter, sample);
        offsets.add(Date.parse(`${seen.date}T${seen.time}Z`) - sample);
    }
    const instants = [...offsets]
        .map((offset) => wall - offset)
        .filter((instant) => {
        if (!Number.isFinite(instant))
            return false;
        const seen = wallParts(formatter, instant);
        return seen.date === date && seen.time === `${time}:00`;
    })
        .sort((a, b) => a - b);
    if (!instants.length)
        return { kind: 'gap', instants: [] };
    return { kind: instants.length === 1 ? 'unique' : 'repeated', instants };
}

/** One instant, with the date and offset kept beside the local clock. */
function formatToolClock(instant, timezone, locale = 'en-US') {
    const parts = Object.fromEntries(new Intl.DateTimeFormat('en-US', {
        timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit', era: 'short',
        hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
    }).formatToParts(instant).map(part => [part.type, part.value]));
    if (parts.era !== 'AD' || Number(parts.year) > 9999)
        throw new RangeError('The local date is outside years 1-9999.');
    const isoDate = `${parts.year.padStart(4, '0')}-${parts.month}-${parts.day}`;
    const wallTime = `${parts.hour}:${parts.minute}:${parts.second}`;
    const date = new Intl.DateTimeFormat(locale, { timeZone: timezone, weekday: 'long', month: 'long', day: 'numeric', year: 'numeric' }).format(instant);
    const time = new Intl.DateTimeFormat(locale, { timeZone: timezone, hour: 'numeric', minute: '2-digit', second: '2-digit' }).format(instant);
    const zoneName = new Intl.DateTimeFormat(locale, { timeZone: timezone, timeZoneName: 'long' }).formatToParts(instant).find(part => part.type === 'timeZoneName')?.value ?? timezone;
    const offset = new Intl.DateTimeFormat('en-US', { timeZone: timezone, timeZoneName: 'longOffset' }).formatToParts(instant).find(part => part.type === 'timeZoneName')?.value.replace(/^GMT/, 'UTC') ?? 'UTC';
    return { date, time, zoneName, offset, isoDate, wallTime, summary: `${date}, ${time}, ${zoneName} (${timezone}, ${offset})` };
}

const MIN_INSTANT = Date.parse('0001-01-01T00:00:00Z');
const MAX_INSTANT = Date.parse('9999-12-31T23:59:59.999Z');
/** Explicit units, exact millisecond precision, and no exponent/hex coercion. */
function parseToolEpoch(raw, unit) {
    const value = raw.trim();
    if (!value)
        return { error: 'Enter a Unix timestamp.' };
    if (!(unit === 'seconds' ? /^-?\d+(?:\.\d{1,3})?$/ : /^-?\d+$/).test(value)) {
        return { error: unit === 'seconds' ? 'Enter seconds as a number with up to three decimal places.' : 'Enter milliseconds as a whole number.' };
    }
    const number = Number(value);
    const instant = unit === 'seconds' ? Math.round(number * 1000) : number;
    if (!Number.isSafeInteger(instant) || instant < MIN_INSTANT || instant > MAX_INSTANT)
        return { error: 'That timestamp is outside the supported calendar years 1-9999. Check whether the value is seconds or milliseconds.' };
    return { instant };
}
function toolEpochFormats(instant) {
    return { seconds: String(instant / 1000), milliseconds: String(instant), iso: new Date(instant).toISOString() };
}
/** Reuse the existing explicit DST choice, retaining entered seconds and milliseconds. */
function resolveEpochWallTime(date, time, timezone) {
    const match = time.match(/^((?:[01]\d|2[0-3]):[0-5]\d)(?::([0-5]\d)(?:\.(\d{1,3}))?)?$/);
    if (!match)
        return { kind: 'invalid', instants: [] };
    const base = resolveToolWallTime(date, match[1], timezone);
    if (base.kind === 'invalid' || base.kind === 'gap')
        return base;
    const seconds = Number(match[2] ?? 0);
    const milliseconds = Number((match[3] ?? '').padEnd(3, '0'));
    const candidates = base.instants.map(value => value + seconds * 1000 + milliseconds);
    const instants = candidates.filter(value => {
        if (value < MIN_INSTANT || value > MAX_INSTANT)
            return false;
        try {
            const clock = formatToolClock(value, timezone);
            return clock.isoDate === date && clock.wallTime === `${match[1]}:${String(seconds).padStart(2, '0')}`;
        }
        catch {
            return false;
        }
    });
    return instants.length ? { kind: instants.length > 1 ? 'repeated' : 'unique', instants } : { kind: candidates.some(value => value < MIN_INSTANT || value > MAX_INSTANT) ? 'range' : 'gap', instants: [] };
}