@design-edito/tools 0.4.23 → 0.5.0

package/agnostic/time/dates/to-french-republican/index.js

@@ -0,0 +1,82 @@
+// French Republican calendar conversion.
+//
+// Rule: the calendar as it was actually applied (1792–1805). A Republican year
+// begins on the civil day, at the Paris meridian, during which the true autumnal
+// (September) equinox occurs. We simply extrapolate that same rule to any date.
+//
+// Year N starts on the September equinox of Gregorian year (1791 + N):
+//   An I -> equinox of 1792 (22 September 1792).
+//
+// The gap between two consecutive equinox-based new years is 365 or 366 days, so
+// the number of complementary days (5 or 6) falls out automatically — no separate
+// leap-year rule is needed.
+import { gregorianToJdn, republicanYearStartJdn, toRoman, MONTH_NAMES, COMPLEMENTARY_DAY_NAMES, DECADE_DAY_NAMES } from './utils.js';
+/**
+ * Converts a `Date` to the French Republican calendar.
+ *
+ * @param date - The date to convert.
+ * @returns The equivalent {@link FrenchRepublicanDate}.
+ *
+ * @remarks
+ * The date's local calendar day (`getFullYear` / `getMonth` / `getDate`) is
+ * used as the Gregorian date, so the result reflects the runtime's local
+ * timezone. Build the `Date` in the timezone you care about if this matters.
+ *
+ * @example
+ * toFrenchRepublican(new Date(1799, 10, 9)).formatted // => '18 Brumaire an VIII'
+ */
+export function toFrenchRepublican(date) {
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const jdn = gregorianToJdn(year, month, day);
+    // The Republican year that contains this date started at the equinox of some
+    // Gregorian year g. Guess g = the date's Gregorian year, then step back if the
+    // date falls before that year's new year (i.e. it's in Jan..Sep).
+    let g = year;
+    let startJdn = republicanYearStartJdn(g);
+    if (jdn < startJdn) {
+        g -= 1;
+        startJdn = republicanYearStartJdn(g);
+    }
+    const republicanYear = g - 1791;
+    const yearRoman = toRoman(republicanYear);
+    const dayOfYear = jdn - startJdn; // 0-based
+    if (dayOfYear >= 360) {
+        // Complementary day (sansculottide): dayOfYear 360..365 -> index 0..5.
+        const complementaryIndex = dayOfYear - 360;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const dayName = COMPLEMENTARY_DAY_NAMES[complementaryIndex];
+        return {
+            year: republicanYear,
+            yearRoman,
+            isComplementary: true,
+            monthIndex: null,
+            monthName: null,
+            dayOfMonth: complementaryIndex + 1,
+            dayName,
+            decade: null,
+            dayOfYear,
+            formatted: `${dayName}, an ${yearRoman}`
+        };
+    }
+    const monthIndex = Math.floor(dayOfYear / 30); // 0..11
+    const dayOfMonth = (dayOfYear % 30) + 1; // 1..30
+    const decadeDayIndex = (dayOfMonth - 1) % 10; // 0..9
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const monthName = MONTH_NAMES[monthIndex];
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const dayName = DECADE_DAY_NAMES[decadeDayIndex];
+    return {
+        year: republicanYear,
+        yearRoman,
+        isComplementary: false,
+        monthIndex,
+        monthName,
+        dayOfMonth,
+        dayName,
+        decade: Math.floor((dayOfMonth - 1) / 10) + 1, // 1..3
+        dayOfYear,
+        formatted: `${dayOfMonth} ${monthName} an ${yearRoman}`
+    };
+}

package/agnostic/time/dates/to-french-republican/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/time/dates/to-french-republican/index.test.js

@@ -0,0 +1,112 @@
+import { describe, it, expect } from 'vitest';
+import { toFrenchRepublican } from './index.js';
+import { RepublicanMonth, ComplementaryDay, DecadeDay } from './types.js';
+describe('toFrenchRepublican', () => {
+    it('maps the first day of the calendar (An I) to 1 Vendémiaire', () => {
+        const result = toFrenchRepublican(new Date(1792, 8, 22));
+        expect(result).toMatchObject({
+            year: 1,
+            yearRoman: 'I',
+            isComplementary: false,
+            monthIndex: 0,
+            monthName: RepublicanMonth.VENDEMIAIRE,
+            dayOfMonth: 1,
+            dayName: DecadeDay.PRIMIDI,
+            decade: 1,
+            dayOfYear: 0,
+            formatted: '1 Vendémiaire an I'
+        });
+    });
+    it('converts a well-known historical date (18 Brumaire an VIII)', () => {
+        const result = toFrenchRepublican(new Date(1799, 10, 9));
+        expect(result.formatted).toBe('18 Brumaire an VIII');
+        expect(result.year).toBe(8);
+        expect(result.yearRoman).toBe('VIII');
+        expect(result.monthName).toBe(RepublicanMonth.BRUMAIRE);
+        expect(result.dayOfMonth).toBe(18);
+    });
+    it('converts 9 Thermidor an II (fall of Robespierre)', () => {
+        const result = toFrenchRepublican(new Date(1794, 6, 27));
+        expect(result.formatted).toBe('9 Thermidor an II');
+        expect(result.monthName).toBe(RepublicanMonth.THERMIDOR);
+    });
+    describe('regular days', () => {
+        it('computes the décade (1–3) from the day of the month', () => {
+            // 18 Brumaire -> second décade, Octidi (8th day of the décade).
+            const result = toFrenchRepublican(new Date(1799, 10, 9));
+            expect(result.isComplementary).toBe(false);
+            expect(result.decade).toBe(2);
+            expect(result.dayName).toBe(DecadeDay.OCTIDI);
+        });
+        it('never yields a day of month outside 1–30', () => {
+            const result = toFrenchRepublican(new Date(2026, 7, 25));
+            expect(result.isComplementary).toBe(false);
+            expect(result.dayOfMonth).toBeGreaterThanOrEqual(1);
+            expect(result.dayOfMonth).toBeLessThanOrEqual(30);
+            expect(result.dayOfYear).toBeLessThan(360);
+        });
+    });
+    describe('complementary days (sansculottides)', () => {
+        it('nulls out the month fields on a complementary day', () => {
+            const result = toFrenchRepublican(new Date(1795, 8, 17));
+            expect(result).toMatchObject({
+                isComplementary: true,
+                monthIndex: null,
+                monthName: null,
+                decade: null,
+                dayOfMonth: 1,
+                dayName: ComplementaryDay.VERTU,
+                formatted: 'Jour de la vertu, an III'
+            });
+        });
+        it('exposes the 6th complementary day in a sextile year (An III)', () => {
+            // An III is a leap (sextile) year, so it has a sixth sansculottide.
+            const result = toFrenchRepublican(new Date(1795, 8, 22));
+            expect(result.isComplementary).toBe(true);
+            expect(result.dayOfMonth).toBe(6);
+            expect(result.dayName).toBe(ComplementaryDay.REVOLUTION);
+            expect(result.dayOfYear).toBe(365);
+        });
+        it('rolls over to the next year on the following equinox', () => {
+            const lastDay = toFrenchRepublican(new Date(1795, 8, 22));
+            const newYear = toFrenchRepublican(new Date(1795, 8, 23));
+            expect(lastDay.year).toBe(3);
+            expect(newYear.year).toBe(4);
+            expect(newYear.formatted).toBe('1 Vendémiaire an IV');
+            expect(newYear.dayOfYear).toBe(0);
+        });
+    });
+    describe('year handling', () => {
+        it('steps back a Gregorian year for dates before the new year', () => {
+            // January 1800 still belongs to An VIII (started at the 1799 equinox).
+            const result = toFrenchRepublican(new Date(1800, 0, 1));
+            expect(result.year).toBe(8);
+        });
+        it('extrapolates the rule to modern dates', () => {
+            const result = toFrenchRepublican(new Date(2026, 7, 25));
+            expect(result.year).toBe(234);
+            expect(result.yearRoman).toBe('CCXXXIV');
+            expect(result.formatted).toBe('8 Fructidor an CCXXXIV');
+        });
+    });
+});
+describe('Republican calendar enums', () => {
+    it('lists the twelve months in order', () => {
+        const months = Object.values(RepublicanMonth);
+        expect(months).toHaveLength(12);
+        expect(months[0]).toBe('Vendémiaire');
+        expect(months[11]).toBe('Fructidor');
+    });
+    it('lists the six complementary days in order', () => {
+        const days = Object.values(ComplementaryDay);
+        expect(days).toHaveLength(6);
+        expect(days[0]).toBe('Jour de la vertu');
+        expect(days[5]).toBe('Jour de la Révolution');
+    });
+    it('lists the ten décade days in order', () => {
+        const days = Object.values(DecadeDay);
+        expect(days).toHaveLength(10);
+        expect(days[0]).toBe('Primidi');
+        expect(days[9]).toBe('Décadi');
+    });
+});

package/agnostic/time/dates/to-french-republican/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The twelve 30-day months of the Republican year, in order.
+ */
+export declare enum RepublicanMonth {
+    VENDEMIAIRE = "Vend\u00E9miaire",
+    BRUMAIRE = "Brumaire",
+    FRIMAIRE = "Frimaire",
+    NIVOSE = "Niv\u00F4se",
+    PLUVIOSE = "Pluvi\u00F4se",
+    VENTOSE = "Vent\u00F4se",
+    GERMINAL = "Germinal",
+    FLOREAL = "Flor\u00E9al",
+    PRAIRIAL = "Prairial",
+    MESSIDOR = "Messidor",
+    THERMIDOR = "Thermidor",
+    FRUCTIDOR = "Fructidor"
+}
+/**
+ * The complementary days ("les sansculottides"), in order. The 6th only exists
+ * in sextile years.
+ */
+export declare enum ComplementaryDay {
+    VERTU = "Jour de la vertu",
+    GENIE = "Jour du g\u00E9nie",
+    TRAVAIL = "Jour du travail",
+    OPINION = "Jour de l'opinion",
+    RECOMPENSES = "Jour des r\u00E9compenses",
+    REVOLUTION = "Jour de la R\u00E9volution"
+}
+/**
+ * The ten days of a décade, in order. Each month is three décades.
+ */
+export declare enum DecadeDay {
+    PRIMIDI = "Primidi",
+    DUODI = "Duodi",
+    TRIDI = "Tridi",
+    QUARTIDI = "Quartidi",
+    QUINTIDI = "Quintidi",
+    SEXTIDI = "Sextidi",
+    SEPTIDI = "Septidi",
+    OCTIDI = "Octidi",
+    NONIDI = "Nonidi",
+    DECADI = "D\u00E9cadi"
+}
+/**
+ * Fields shared by every Republican date, whether or not it is a complementary
+ * day.
+ */
+type FrenchRepublicanDateCommon = {
+    /** Republican year (An I = 1), counted from the 1792 equinox. */
+    year: number;
+    /** Republican year in Roman numerals (e.g. `'VIII'`). */
+    yearRoman: string;
+    /** 1-based day number within the month or the complementary period. */
+    dayOfMonth: number;
+    /** 0-based day index within the Republican year (0–365). */
+    dayOfYear: number;
+    /** Human-readable French label (e.g. `'18 Brumaire an VIII'`). */
+    formatted: string;
+};
+/**
+ * A regular day, falling inside one of the twelve 30-day months.
+ */
+export type FrenchRepublicanMonthDate = FrenchRepublicanDateCommon & {
+    isComplementary: false;
+    /** 0-based month index (0–11). */
+    monthIndex: number;
+    monthName: RepublicanMonth;
+    /** Name of the day within its décade. */
+    dayName: DecadeDay;
+    /** 1-based décade within the month (1–3). */
+    decade: number;
+};
+/**
+ * A complementary day ("sansculottide"), falling outside any month at the end
+ * of the year.
+ */
+export type FrenchRepublicanComplementaryDate = FrenchRepublicanDateCommon & {
+    isComplementary: true;
+    monthIndex: null;
+    monthName: null;
+    dayName: ComplementaryDay;
+    decade: null;
+};
+/**
+ * A date expressed in the French Republican calendar. Discriminated on
+ * `isComplementary`: month fields are populated for a regular day and `null`
+ * for a complementary day.
+ */
+export type FrenchRepublicanDate = FrenchRepublicanMonthDate | FrenchRepublicanComplementaryDate;
+export {};

package/agnostic/time/dates/to-french-republican/types.js

@@ -0,0 +1,47 @@
+/**
+ * The twelve 30-day months of the Republican year, in order.
+ */
+export var RepublicanMonth;
+(function (RepublicanMonth) {
+    RepublicanMonth["VENDEMIAIRE"] = "Vend\u00E9miaire";
+    RepublicanMonth["BRUMAIRE"] = "Brumaire";
+    RepublicanMonth["FRIMAIRE"] = "Frimaire";
+    RepublicanMonth["NIVOSE"] = "Niv\u00F4se";
+    RepublicanMonth["PLUVIOSE"] = "Pluvi\u00F4se";
+    RepublicanMonth["VENTOSE"] = "Vent\u00F4se";
+    RepublicanMonth["GERMINAL"] = "Germinal";
+    RepublicanMonth["FLOREAL"] = "Flor\u00E9al";
+    RepublicanMonth["PRAIRIAL"] = "Prairial";
+    RepublicanMonth["MESSIDOR"] = "Messidor";
+    RepublicanMonth["THERMIDOR"] = "Thermidor";
+    RepublicanMonth["FRUCTIDOR"] = "Fructidor";
+})(RepublicanMonth || (RepublicanMonth = {}));
+/**
+ * The complementary days ("les sansculottides"), in order. The 6th only exists
+ * in sextile years.
+ */
+export var ComplementaryDay;
+(function (ComplementaryDay) {
+    ComplementaryDay["VERTU"] = "Jour de la vertu";
+    ComplementaryDay["GENIE"] = "Jour du g\u00E9nie";
+    ComplementaryDay["TRAVAIL"] = "Jour du travail";
+    ComplementaryDay["OPINION"] = "Jour de l'opinion";
+    ComplementaryDay["RECOMPENSES"] = "Jour des r\u00E9compenses";
+    ComplementaryDay["REVOLUTION"] = "Jour de la R\u00E9volution";
+})(ComplementaryDay || (ComplementaryDay = {}));
+/**
+ * The ten days of a décade, in order. Each month is three décades.
+ */
+export var DecadeDay;
+(function (DecadeDay) {
+    DecadeDay["PRIMIDI"] = "Primidi";
+    DecadeDay["DUODI"] = "Duodi";
+    DecadeDay["TRIDI"] = "Tridi";
+    DecadeDay["QUARTIDI"] = "Quartidi";
+    DecadeDay["QUINTIDI"] = "Quintidi";
+    DecadeDay["SEXTIDI"] = "Sextidi";
+    DecadeDay["SEPTIDI"] = "Septidi";
+    DecadeDay["OCTIDI"] = "Octidi";
+    DecadeDay["NONIDI"] = "Nonidi";
+    DecadeDay["DECADI"] = "D\u00E9cadi";
+})(DecadeDay || (DecadeDay = {}));

package/agnostic/time/dates/to-french-republican/utils.d.ts

@@ -0,0 +1,32 @@
+import { RepublicanMonth, ComplementaryDay, DecadeDay } from './types.js';
+/** The twelve month names, indexed by 0-based month index. */
+export declare const MONTH_NAMES: RepublicanMonth[];
+/** The six complementary day names, indexed by 0-based complementary index. */
+export declare const COMPLEMENTARY_DAY_NAMES: ComplementaryDay[];
+/** The ten décade day names, indexed by 0-based day-of-décade index. */
+export declare const DECADE_DAY_NAMES: DecadeDay[];
+/**
+ * Julian Day Number (integer, noon-based) for a proleptic Gregorian date.
+ *
+ * @param year - Gregorian year.
+ * @param month - Month, 1–12.
+ * @param day - Day of month, 1–31.
+ * @returns The Julian Day Number.
+ */
+export declare function gregorianToJdn(year: number, month: number, day: number): number;
+/**
+ * JDN of 1 Vendémiaire — the civil day (Paris meridian) hosting the September
+ * equinox of the given Gregorian year.
+ *
+ * @param gregorianYear - The Gregorian year whose equinox opens the Republican year.
+ * @returns The Julian Day Number of that year's 1 Vendémiaire.
+ */
+export declare function republicanYearStartJdn(gregorianYear: number): number;
+/**
+ * Formats a positive integer as a Roman numeral. Non-positive inputs are
+ * returned as their decimal string.
+ *
+ * @param n - The number to format.
+ * @returns The Roman numeral (e.g. `8` -> `'VIII'`).
+ */
+export declare function toRoman(n: number): string;

package/agnostic/time/dates/to-french-republican/utils.js

@@ -0,0 +1,155 @@
+import { RepublicanMonth, ComplementaryDay, DecadeDay } from './types.js';
+// Ordered lookup tables derived from the enums (declaration order).
+/** The twelve month names, indexed by 0-based month index. */
+export const MONTH_NAMES = Object.values(RepublicanMonth);
+/** The six complementary day names, indexed by 0-based complementary index. */
+export const COMPLEMENTARY_DAY_NAMES = Object.values(ComplementaryDay);
+/** The ten décade day names, indexed by 0-based day-of-décade index. */
+export const DECADE_DAY_NAMES = Object.values(DecadeDay);
+// Paris Observatory meridian: 2°20'14" E ≈ +9m21s, expressed in days.
+// The Republican astronomers used the Paris meridian to decide which civil day
+// hosts the equinox, so we keep using it for every year.
+const PARIS_MERIDIAN_OFFSET_DAYS = (2 + 20 / 60 + 14 / 3600) / 360;
+const DEG_TO_RAD = Math.PI / 180;
+// --- Julian Day -------------------------------------------------------------
+/**
+ * Julian Day Number (integer, noon-based) for a proleptic Gregorian date.
+ *
+ * @param year - Gregorian year.
+ * @param month - Month, 1–12.
+ * @param day - Day of month, 1–31.
+ * @returns The Julian Day Number.
+ */
+export function gregorianToJdn(year, month, day) {
+    const a = Math.floor((14 - month) / 12);
+    const y = year + 4800 - a;
+    const m = month + 12 * a - 3;
+    return (day
+        + Math.floor((153 * m + 2) / 5)
+        + 365 * y
+        + Math.floor(y / 4)
+        - Math.floor(y / 100)
+        + Math.floor(y / 400)
+        - 32045);
+}
+// --- Astronomy: September equinox (Meeus, "Astronomical Algorithms", ch. 27) --
+// Periodic-term table 27.A: rows of [A, B (deg), C (deg)].
+const EQUINOX_TERMS = [
+    [485, 324.96, 1934.136], [203, 337.23, 32964.467], [199, 342.08, 20.186],
+    [182, 27.85, 445267.112], [156, 73.14, 45036.886], [136, 171.52, 22518.443],
+    [77, 222.54, 65928.934], [74, 296.72, 3034.906], [70, 243.58, 9037.513],
+    [58, 119.81, 33718.147], [52, 297.17, 150.678], [50, 21.02, 2281.226],
+    [45, 247.54, 29929.562], [44, 325.15, 31555.956], [29, 60.93, 4443.417],
+    [18, 155.12, 67555.328], [17, 288.79, 4562.452], [16, 198.04, 62894.029],
+    [14, 199.76, 31436.921], [12, 95.39, 14577.848], [12, 287.11, 31931.756],
+    [12, 320.81, 34777.259], [9, 227.73, 1222.114], [8, 15.45, 16859.074]
+];
+// Instant of the September equinox for a Gregorian year, as a Julian Ephemeris
+// Day (JDE) in Dynamical Time (TD). Valid roughly for years 1000..3000.
+function septemberEquinoxJde(year) {
+    const y = (year - 2000) / 1000;
+    const jde0 = 2451810.21715
+        + 365242.01767 * y
+        - 0.11575 * y * y
+        + 0.00337 * y * y * y
+        + 0.00078 * y * y * y * y;
+    const t = (jde0 - 2451545.0) / 36525;
+    const w = (35999.373 * t - 2.47) * DEG_TO_RAD;
+    const deltaLambda = 1 + 0.0334 * Math.cos(w) + 0.0007 * Math.cos(2 * w);
+    let s = 0;
+    for (const [a, b, c] of EQUINOX_TERMS) {
+        s += a * Math.cos((b + c * t) * DEG_TO_RAD);
+    }
+    return jde0 + (0.00001 * s) / deltaLambda;
+}
+// TD - UT, in seconds. Espenak & Meeus (2006) polynomial approximations,
+// covering the range that matters here (18th–22nd century) with a parabolic
+// fallback outside it.
+function deltaTSeconds(year) {
+    let t;
+    if (year >= 2005 && year < 2050) {
+        t = year - 2000;
+        return 62.92 + 0.32217 * t + 0.005589 * t * t;
+    }
+    if (year >= 1986 && year < 2005) {
+        t = year - 2000;
+        return (63.86 + 0.3345 * t - 0.060374 * t * t + 0.0017275 * t ** 3
+            + 0.000651814 * t ** 4 + 0.00002373599 * t ** 5);
+    }
+    if (year >= 1961 && year < 1986) {
+        t = year - 1975;
+        return 45.45 + 1.067 * t - (t * t) / 260 - (t ** 3) / 718;
+    }
+    if (year >= 1941 && year < 1961) {
+        t = year - 1950;
+        return 29.07 + 0.407 * t - (t * t) / 233 + (t ** 3) / 2547;
+    }
+    if (year >= 1920 && year < 1941) {
+        t = year - 1920;
+        return 21.20 + 0.84493 * t - 0.076100 * t * t + 0.0020936 * t ** 3;
+    }
+    if (year >= 1900 && year < 1920) {
+        t = year - 1900;
+        return (-2.79 + 1.494119 * t - 0.0598939 * t * t
+            + 0.0061966 * t ** 3 - 0.000197 * t ** 4);
+    }
+    if (year >= 1860 && year < 1900) {
+        t = year - 1860;
+        return (7.62 + 0.5737 * t - 0.251754 * t * t + 0.01680668 * t ** 3
+            - 0.0004473624 * t ** 4 + (t ** 5) / 233174);
+    }
+    if (year >= 1800 && year < 1860) {
+        t = year - 1800;
+        return (13.72 - 0.332447 * t + 0.0068612 * t * t + 0.0041116 * t ** 3
+            - 0.00037436 * t ** 4 + 0.0000121272 * t ** 5
+            - 0.0000001699 * t ** 6 + 0.000000000875 * t ** 7);
+    }
+    if (year >= 1700 && year < 1800) {
+        t = year - 1700;
+        return 8.83 + 0.1603 * t - 0.0059285 * t * t + 0.00013336 * t ** 3 - (t ** 4) / 1174000;
+    }
+    if (year >= 2050 && year < 2150) {
+        return -20 + 32 * ((year - 1820) / 100) ** 2 - 0.5628 * (2150 - year);
+    }
+    const u = (year - 1820) / 100;
+    return -20 + 32 * u * u;
+}
+/**
+ * JDN of 1 Vendémiaire — the civil day (Paris meridian) hosting the September
+ * equinox of the given Gregorian year.
+ *
+ * @param gregorianYear - The Gregorian year whose equinox opens the Republican year.
+ * @returns The Julian Day Number of that year's 1 Vendémiaire.
+ */
+export function republicanYearStartJdn(gregorianYear) {
+    const jde = septemberEquinoxJde(gregorianYear); // TD
+    const ut = jde - deltaTSeconds(gregorianYear) / 86400;
+    const parisMeanTime = ut + PARIS_MERIDIAN_OFFSET_DAYS;
+    return Math.floor(parisMeanTime + 0.5);
+}
+// --- Roman numerals (years were written in Roman numerals: "an VIII") --------
+/**
+ * Formats a positive integer as a Roman numeral. Non-positive inputs are
+ * returned as their decimal string.
+ *
+ * @param n - The number to format.
+ * @returns The Roman numeral (e.g. `8` -> `'VIII'`).
+ */
+export function toRoman(n) {
+    if (n <= 0)
+        return String(n);
+    const table = [
+        [1000, 'M'], [900, 'CM'], [500, 'D'], [400, 'CD'],
+        [100, 'C'], [90, 'XC'], [50, 'L'], [40, 'XL'],
+        [10, 'X'], [9, 'IX'], [5, 'V'], [4, 'IV'], [1, 'I']
+    ];
+    let remaining = n;
+    let result = '';
+    for (const [value, symbol] of table) {
+        while (remaining >= value) {
+            result += symbol;
+            remaining -= value;
+        }
+    }
+    return result;
+}

package/agnostic/time/duration/index.js

@@ -41,6 +41,7 @@ export class Duration {
         else if (type === 'mo' || type === 'mth' || type === 'months') {
             this.type = 'months';
         }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         else if (type === 'y' || type === 'years') {
             this.type = 'years';
         }
@@ -64,6 +65,7 @@ export class Duration {
             return this.value * 1000 * 60 * 60 * 24 * 7;
         if (this.type === 'months')
             return this.value * 1000 * 60 * 60 * 24 * 30;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (this.type === 'years')
             return this.value * 1000 * 60 * 60 * 24 * 365;
         return this.value; // defaults to milliseconds

package/agnostic/time/index.d.ts

@@ -1,5 +1,5 @@
+export * as dates from './dates/index.js'
 export * as duration from './duration/index.js'
+export * as timeout from './timeout/index.js'
 export * as transitions from './transitions/index.js'
 export * as wait from './wait/index.js'
-export * as timeout from './timeout/index.js'
-export * as dates from './dates/index.js'

package/agnostic/time/index.js

@@ -1,5 +1,5 @@
+export * as dates from './dates/index.js'
 export * as duration from './duration/index.js'
+export * as timeout from './timeout/index.js'
 export * as transitions from './transitions/index.js'
 export * as wait from './wait/index.js'
-export * as timeout from './timeout/index.js'
-export * as dates from './dates/index.js'

package/agnostic/time/timeout/index.js

@@ -8,18 +8,18 @@
  */
 export async function timeout(timeoutMs, callback) {
     let hasRejected = false;
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor
-    return await new Promise(async (resolve, reject) => {
+    return await new Promise((resolve, reject) => {
         const rejectTimeout = setTimeout(() => {
-            // eslint-disable-next-line prefer-promise-reject-errors
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             reject(false);
             hasRejected = true;
         }, timeoutMs);
-        // eslint-disable-next-line @typescript-eslint/await-thenable
-        const callbackResult = await callback();
-        if (hasRejected)
-            return;
-        clearTimeout(rejectTimeout);
-        return resolve(callbackResult);
+        void (async () => {
+            const callbackResult = await callback();
+            if (hasRejected)
+                return;
+            clearTimeout(rejectTimeout);
+            resolve(callbackResult);
+        })();
     });
 }

package/agnostic/time/transitions/index.js

@@ -89,13 +89,14 @@ const c5 = (2 * PI) / 4.5;
 const bounceOut = function (x) {
     const n1 = 7.5625;
     const d1 = 2.75;
-    if (x < 1 / d1)
-        return n1 * x * x;
-    if (x < 2 / d1)
-        return n1 * (x -= 1.5 / d1) * x + 0.75;
-    if (x < 2.5 / d1)
-        return n1 * (x -= 2.25 / d1) * x + 0.9375;
-    return n1 * (x -= 2.625 / d1) * x + 0.984375;
+    let t = x;
+    if (t < 1 / d1)
+        return n1 * t * t;
+    if (t < 2 / d1)
+        return n1 * (t -= 1.5 / d1) * t + 0.75;
+    if (t < 2.5 / d1)
+        return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    return n1 * (t -= 2.625 / d1) * t + 0.984375;
 };
 /**
  * Predefined easing functions used internally by transitions.

package/components/BeforeAfter/index.controlled.js

@@ -32,6 +32,7 @@ import cssModule from './styles.module.css';
  * @returns A split-panel container with pointer interaction handlers and ratio state applied.
  */
 export const BeforeAfterControlled = ({ mode = 'horizontal', ratio = 0, before, after, className, children, actionHandlers }) => {
+    // eslint-disable-next-line no-param-reassign
     ratio = clamp(ratio, 0, 1);
     // State & refs
     const rootRef = useRef(null);

package/components/BeforeAfter/index.js

@@ -26,7 +26,9 @@ export const BeforeAfter = ({ mode = 'horizontal', actionHandlers, stateHandlers
     const isControlled = ratio !== undefined;
     const effectiveRatio = isControlled ? ratio : internalRatio;
     const handleDrag = (x, y) => {
+        // eslint-disable-next-line no-param-reassign
         x = 1.02 * x - 0.01;
+        // eslint-disable-next-line no-param-reassign
         y = 1.02 * y - 0.01;
         actionHandlers?.dragged?.(x, y);
         if (!isControlled) {
@@ -35,7 +37,9 @@ export const BeforeAfter = ({ mode = 'horizontal', actionHandlers, stateHandlers
         }
     };
     const handleClick = (x, y) => {
+        // eslint-disable-next-line no-param-reassign
         x = 1.02 * x - 0.01;
+        // eslint-disable-next-line no-param-reassign
         y = 1.02 * y - 0.01;
         actionHandlers?.clicked?.(x, y);
         if (!isControlled) {

package/components/Button/index.d.ts

@@ -1,4 +1,4 @@
-import { type FunctionComponent, type ButtonHTMLAttributes } from 'react';
+import type { FunctionComponent, ButtonHTMLAttributes } from 'react';
 import type { WithClassName } from '../utils/types.js';
 /**
  * Props for the {@link Button} component.

package/components/Clippable/index.js

@@ -51,6 +51,7 @@ export const Clippable = ({ className, children, toClip, actionHandlers, stateHa
             ]);
         }
         catch (err) {
+            // eslint-disable-next-line no-console
             console.error(err);
         }
         stateHandlers?.clipped?.(html);

package/components/Drawer/index.js

@@ -49,7 +49,7 @@ export const Drawer = ({ openerContent, closerContent, initialIsOpened = false,
         setInternalIsOpened(false);
     };
     const handleROCompResize = ({ entry }) => {
-        const { width, height } = entry?.contentRect ?? {};
+        const { width, height } = entry.contentRect;
         setContentDimensions({ width, height });
     };
     // Rendering