@design-edito/tools 0.5.1 → 0.5.3

package/agnostic/time/dates/format-date/index.test.js

@@ -0,0 +1,154 @@
+import { describe, it, expect } from 'vitest';
+import { formatDate } from './index.js';
+import { getDateParts } from './parts.js';
+// Thursday, January 1st 2026, 15:05:09.042 — read in the runtime's own timezone,
+// which is also the one the fixture is built in, so the tests hold anywhere.
+const thursdayAfternoon = new Date(2026, 0, 1, 15, 5, 9, 42);
+describe('formatDate', () => {
+    describe('template', () => {
+        it('fills a template with the parts of the date', () => {
+            expect(formatDate(thursdayAfternoon, '{{YYYY}}-{{MM}}-{{DD}} {{hh}}:{{mm}} {{A}}'))
+                .toBe('2026-01-01 03:05 PM');
+        });
+        it('keeps whatever sits outside the placeholders', () => {
+            expect(formatDate(thursdayAfternoon, 'le {{D}} {{MMMM}} {{YYYY}}', 'fr'))
+                .toBe('le 1 janvier 2026');
+        });
+        it('does not substitute a bare letter outside a placeholder', () => {
+            expect(formatDate(thursdayAfternoon, 'D M Y {{D}}')).toBe('D M Y 1');
+        });
+        it('substitutes every occurrence of a repeated token', () => {
+            expect(formatDate(thursdayAfternoon, '{{D}}/{{D}}')).toBe('1/1');
+        });
+        it('leaves an unknown token untouched, braces included', () => {
+            expect(formatDate(thursdayAfternoon, '{{ZZ}} {{YYYY}}')).toBe('{{ZZ}} 2026');
+        });
+    });
+    describe('padding', () => {
+        it('pads the doubled tokens to two digits', () => {
+            expect(formatDate(thursdayAfternoon, '{{DD}} {{MM}} {{HH}} {{hh}} {{mm}} {{ss}}'))
+                .toBe('01 01 15 03 05 09');
+        });
+        it('leaves the bare twins unpadded', () => {
+            expect(formatDate(thursdayAfternoon, '{{D}} {{M}} {{H}} {{h}} {{m}} {{s}}'))
+                .toBe('1 1 15 3 5 9');
+        });
+        it('pads milliseconds to three digits', () => {
+            expect(formatDate(thursdayAfternoon, '{{ms}}')).toBe('042');
+        });
+        it('truncates YY to the last two digits of the year', () => {
+            expect(formatDate(thursdayAfternoon, '{{YY}}')).toBe('26');
+        });
+    });
+    describe('12-hour clock', () => {
+        it('writes midnight as 12 AM', () => {
+            expect(formatDate(new Date(2026, 0, 1, 0, 30), '{{h}}:{{mm}} {{A}}')).toBe('12:30 AM');
+        });
+        it('writes noon as 12 PM', () => {
+            expect(formatDate(new Date(2026, 0, 1, 12, 30), '{{h}}:{{mm}} {{A}}')).toBe('12:30 PM');
+        });
+        it('starts the afternoon back at 1', () => {
+            expect(formatDate(new Date(2026, 0, 1, 13), '{{h}} {{a}}')).toBe('1 pm');
+        });
+    });
+    describe('locales', () => {
+        it('names the weekday and the month in English by default', () => {
+            expect(formatDate(thursdayAfternoon, '{{dd}} {{d}} {{MMMM}} {{MMM}}'))
+                .toBe('Thursday Thu January Jan');
+        });
+        it('names them in the requested locale', () => {
+            expect(formatDate(thursdayAfternoon, '{{dd}} {{MMMM}}', 'fr')).toBe('jeudi janvier');
+        });
+    });
+    describe('ordinal suffix', () => {
+        it('follows the English rule', () => {
+            const suffix = (day) => formatDate(new Date(2026, 0, day), '{{D}}{{th}}');
+            expect(suffix(1)).toBe('1st');
+            expect(suffix(2)).toBe('2nd');
+            expect(suffix(3)).toBe('3rd');
+            expect(suffix(4)).toBe('4th');
+            expect(suffix(21)).toBe('21st');
+            expect(suffix(22)).toBe('22nd');
+            expect(suffix(23)).toBe('23rd');
+        });
+        it('keeps the teens on th, where the last digit would say otherwise', () => {
+            const suffix = (day) => formatDate(new Date(2026, 0, day), '{{D}}{{th}}');
+            expect(suffix(11)).toBe('11th');
+            expect(suffix(12)).toBe('12th');
+            expect(suffix(13)).toBe('13th');
+        });
+        it('marks only the 1st in French', () => {
+            expect(formatDate(new Date(2026, 0, 1), '{{D}}{{th}}', 'fr')).toBe('1er');
+            expect(formatDate(new Date(2026, 0, 2), '{{D}}{{th}}', 'fr')).toBe('2');
+        });
+    });
+});
+describe('getDateParts', () => {
+    describe('quantities', () => {
+        it('hands over plain numbers, unpadded', () => {
+            expect(getDateParts(thursdayAfternoon)).toMatchObject({
+                D: 1,
+                M: 1,
+                YYYY: 2026,
+                H: 15,
+                h: 3,
+                m: 5,
+                s: 9,
+                ms: 42
+            });
+        });
+        it('numbers the months from 1, where Date numbers them from 0', () => {
+            expect(getDateParts(new Date(2026, 11, 25)).M).toBe(12);
+        });
+        it('reaches every part under its readable name too', () => {
+            const parts = getDateParts(thursdayAfternoon);
+            expect(parts).toMatchObject({
+                dayOfMonth: parts.D,
+                shortWeekdayName: parts.d,
+                fullWeekdayName: parts.dd,
+                monthNumber: parts.M,
+                shortMonthName: parts.MMM,
+                fullMonthName: parts.MMMM,
+                year: parts.YYYY,
+                hours24: parts.H,
+                hours12: parts.h,
+                minutes: parts.m,
+                seconds: parts.s,
+                milliseconds: parts.ms,
+                upperCaseMeridiem: parts.A,
+                lowerCaseMeridiem: parts.a,
+                dayOrdinalSuffix: parts.th
+            });
+        });
+    });
+    describe('12-hour clock', () => {
+        it('reads both midnight and noon as 12', () => {
+            expect(getDateParts(new Date(2026, 0, 1, 0)).h).toBe(12);
+            expect(getDateParts(new Date(2026, 0, 1, 12)).h).toBe(12);
+        });
+        it('splits the meridiem at noon', () => {
+            expect(getDateParts(new Date(2026, 0, 1, 11, 59))).toMatchObject({ A: 'AM', a: 'am' });
+            expect(getDateParts(new Date(2026, 0, 1, 12, 0))).toMatchObject({ A: 'PM', a: 'pm' });
+        });
+    });
+    describe('locales', () => {
+        it('localises the weekday and month names', () => {
+            expect(getDateParts(thursdayAfternoon, 'fr')).toMatchObject({
+                d: 'jeu.',
+                dd: 'jeudi',
+                MMM: 'janv.',
+                MMMM: 'janvier'
+            });
+        });
+        it('falls back to English on a locale the runtime does not support', () => {
+            expect(getDateParts(thursdayAfternoon, 'xx')).toMatchObject({
+                dd: 'Thursday',
+                MMMM: 'January',
+                th: 'st'
+            });
+        });
+        it('leaves the ordinal suffix empty for a locale that has no rule here', () => {
+            expect(getDateParts(thursdayAfternoon, 'es').th).toBe('');
+        });
+    });
+});

package/agnostic/time/dates/format-date/parts.d.ts

@@ -0,0 +1,28 @@
+import type { DateParts } from './types.js';
+/**
+ * Breaks a `Date` down into every fragment `formatDate` knows how to render,
+ * localised and ready to concatenate.
+ *
+ * Reach for this over `formatDate` when the fragments go somewhere a template
+ * string can't — separate DOM nodes, a `<time>` element's parts, an object
+ * handed to a view layer.
+ *
+ * @param date - The `Date` to break down.
+ * @param locale - Optional locale code, falling back to `'en'` when the runtime
+ * doesn't support it.
+ * @returns The parts, each one reachable under its unit token and under its
+ * readable name. Quantities come out as numbers — `formatDate` is what pads
+ * them.
+ * @see {@link DateParts}
+ *
+ * @remarks
+ * Every fragment is read off the `Date` in the runtime's local timezone, since a
+ * `Date` carries no timezone of its own.
+ *
+ * @example
+ * const parts = getDateParts(new Date(2026, 0, 1, 15, 5), 'fr')
+ * parts.MMMM            // => 'janvier'
+ * parts.fullMonthName   // => 'janvier', the same value
+ * parts.D               // => 1, the number — '01' is formatDate's business
+ */
+export declare function getDateParts(date: Date, locale?: string): DateParts;

package/agnostic/time/dates/format-date/parts.js

@@ -0,0 +1,136 @@
+/**
+ * The localised weekday names, indexed the way `Date.prototype.getDay` numbers
+ * them. January 1st 2023 was a Sunday, so the week is walked from there.
+ */
+function weekdayNames(locale, weekday) {
+    const formatter = new Intl.DateTimeFormat(locale, { weekday });
+    return [...Array(7)].map((_, i) => formatter.format(new Date(2023, 0, i + 1)));
+}
+/**
+ * The localised month names, indexed the way `Date.prototype.getMonth` numbers
+ * them — January at 0.
+ */
+function monthNames(locale, month) {
+    const formatter = new Intl.DateTimeFormat(locale, { month });
+    return [...Array(12)].map((_, i) => formatter.format(new Date(2023, i, 1)));
+}
+/** The ordinal suffix a locale appends to a day number, empty when it has none. */
+function dayOrdinalSuffix(day, locale) {
+    if (locale.startsWith('fr'))
+        return day === 1 ? 'er' : '';
+    if (!locale.startsWith('en'))
+        return '';
+    const mod10 = day % 10;
+    const mod100 = day % 100;
+    if (mod10 === 1 && mod100 !== 11)
+        return 'st';
+    if (mod10 === 2 && mod100 !== 12)
+        return 'nd';
+    if (mod10 === 3 && mod100 !== 13)
+        return 'rd';
+    return 'th';
+}
+/**
+ * Breaks a `Date` down into every fragment `formatDate` knows how to render,
+ * localised and ready to concatenate.
+ *
+ * Reach for this over `formatDate` when the fragments go somewhere a template
+ * string can't — separate DOM nodes, a `<time>` element's parts, an object
+ * handed to a view layer.
+ *
+ * @param date - The `Date` to break down.
+ * @param locale - Optional locale code, falling back to `'en'` when the runtime
+ * doesn't support it.
+ * @returns The parts, each one reachable under its unit token and under its
+ * readable name. Quantities come out as numbers — `formatDate` is what pads
+ * them.
+ * @see {@link DateParts}
+ *
+ * @remarks
+ * Every fragment is read off the `Date` in the runtime's local timezone, since a
+ * `Date` carries no timezone of its own.
+ *
+ * @example
+ * const parts = getDateParts(new Date(2026, 0, 1, 15, 5), 'fr')
+ * parts.MMMM            // => 'janvier'
+ * parts.fullMonthName   // => 'janvier', the same value
+ * parts.D               // => 1, the number — '01' is formatDate's business
+ */
+export function getDateParts(date, locale = 'en') {
+    const safeLocale = Intl.DateTimeFormat.supportedLocalesOf(locale).length === 0
+        ? 'en'
+        : locale;
+    const day = date.getDate();
+    const dayOfWeek = date.getDay();
+    const month = date.getMonth();
+    const hours = date.getHours();
+    const isPM = hours >= 12;
+    const tokens = {
+        'D': day,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        'd': weekdayNames(safeLocale, 'short')[dayOfWeek],
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        'dd': weekdayNames(safeLocale, 'long')[dayOfWeek],
+        'M': month + 1,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        'MMM': monthNames(safeLocale, 'short')[month],
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        'MMMM': monthNames(safeLocale, 'long')[month],
+        'YYYY': date.getFullYear(),
+        'H': hours,
+        'h': hours % 12 === 0 ? 12 : hours % 12,
+        'm': date.getMinutes(),
+        's': date.getSeconds(),
+        'ms': date.getMilliseconds(),
+        'A': isPM ? 'PM' : 'AM',
+        'a': isPM ? 'pm' : 'am',
+        'th': dayOrdinalSuffix(day, safeLocale)
+    };
+    return {
+        ...tokens,
+        dayOfMonth: tokens.D,
+        shortWeekdayName: tokens.d,
+        fullWeekdayName: tokens.dd,
+        monthNumber: tokens.M,
+        shortMonthName: tokens.MMM,
+        fullMonthName: tokens.MMMM,
+        year: tokens.YYYY,
+        hours24: tokens.H,
+        hours12: tokens.h,
+        minutes: tokens.m,
+        seconds: tokens.s,
+        milliseconds: tokens.ms,
+        upperCaseMeridiem: tokens.A,
+        lowerCaseMeridiem: tokens.a,
+        dayOrdinalSuffix: tokens.th
+    };
+}
+// [WIP] timezone tokens were removed since JavaScript's Date object doesn't hold
+// timezone data — those templates would only reflect the current client's
+// timezone, no matter what the input Date obj was
+// 'ZZ': () => {
+//   const timezoneOffset = date.getTimezoneOffset()
+//   const offsetHours = Math.floor(Math.abs(timezoneOffset) / 60)
+//   const offsetMinutes = Math.abs(timezoneOffset) % 60
+//   const sign = timezoneOffset > 0 ? '-' : '+'
+//   return `${sign}${String(offsetHours).padStart(2, '0')}:${String(offsetMinutes).padStart(2, '0')}`
+// },
+// 'Z': () => {
+//   const timezoneOffset = date.getTimezoneOffset()
+//   if (timezoneOffset === 0) return 'Z'
+//   const offsetHours = Math.floor(Math.abs(timezoneOffset) / 60)
+//   const offsetMinutes = Math.abs(timezoneOffset) % 60
+//   const sign = timezoneOffset > 0 ? '-' : '+'
+//   return `${sign}${String(offsetHours).padStart(2, '0')}:${String(offsetMinutes).padStart(2, '0')}`
+// },
+// 'z': () => {
+//   return Intl.DateTimeFormat(locale, { timeZoneName: 'short' })
+//     .formatToParts(date)
+//     .find(part => part.type === 'timeZoneName')?.value || ''
+// },
+// 'zz': () => {
+//   return Intl.DateTimeFormat(locale, { timeZoneName: 'long' })
+//     .formatToParts(date)
+//     .find(part => part.type === 'timeZoneName')?.value || ''
+// },
+// 'tz': () => Intl.DateTimeFormat().resolvedOptions().timeZone || ''

package/agnostic/time/dates/format-date/types.d.ts

@@ -0,0 +1,84 @@
+/** Every token `formatDate` substitutes in a template. */
+export type DateToken = 'D' | 'DD' | 'd' | 'dd' | 'M' | 'MM' | 'MMM' | 'MMMM' | 'YY' | 'YYYY' | 'H' | 'HH' | 'h' | 'hh' | 'm' | 'mm' | 's' | 'ss' | 'ms' | 'A' | 'a' | 'th';
+/**
+ * A date's parts, keyed by unit token.
+ *
+ * Quantities are **numbers** — a day of month is `1`, not `'01'`. Padding and
+ * truncation are rendering concerns and belong to `formatDate`, which is why the
+ * `DD`, `MM`, `YY`, `HH`, `hh`, `mm` and `ss` tokens have no entry here: they
+ * render the same quantity as their unpadded twin. The parts that are localised
+ * text rather than a quantity stay strings.
+ */
+export type DateTokenParts = {
+    /** Day of month, 1–31. */
+    D: number;
+    /** Short weekday name, localised. */
+    d: string;
+    /** Full weekday name, localised. */
+    dd: string;
+    /** Month number, 1–12 — January is `1`, not `0`. */
+    M: number;
+    /** Short month name, localised. */
+    MMM: string;
+    /** Full month name, localised. */
+    MMMM: string;
+    /** Full year. */
+    YYYY: number;
+    /** Hours on a 24-hour clock, 0–23. */
+    H: number;
+    /** Hours on a 12-hour clock, 1–12. Midnight and noon are both `12`. */
+    h: number;
+    /** Minutes, 0–59. */
+    m: number;
+    /** Seconds, 0–59. */
+    s: number;
+    /** Milliseconds, 0–999. */
+    ms: number;
+    /** Upper-case meridiem, `'AM'` or `'PM'`. */
+    A: string;
+    /** Lower-case meridiem, `'am'` or `'pm'`. */
+    a: string;
+    /**
+     * Day ordinal suffix — `'st'`, `'nd'`, `'rd'` or `'th'` in English, `'er'` for
+     * the French 1st. Empty for every other locale, and for French days 2 onwards.
+     */
+    th: string;
+};
+/**
+ * The same parts as {@link DateTokenParts}, under names that read on their own —
+ * one per token, same value.
+ */
+export type NamedDateParts = {
+    /** {@link DateTokenParts.D} */
+    dayOfMonth: number;
+    /** {@link DateTokenParts.d} */
+    shortWeekdayName: string;
+    /** {@link DateTokenParts.dd} */
+    fullWeekdayName: string;
+    /** {@link DateTokenParts.M} */
+    monthNumber: number;
+    /** {@link DateTokenParts.MMM} */
+    shortMonthName: string;
+    /** {@link DateTokenParts.MMMM} */
+    fullMonthName: string;
+    /** {@link DateTokenParts.YYYY} */
+    year: number;
+    /** {@link DateTokenParts.H} */
+    hours24: number;
+    /** {@link DateTokenParts.h} */
+    hours12: number;
+    /** {@link DateTokenParts.m} */
+    minutes: number;
+    /** {@link DateTokenParts.s} */
+    seconds: number;
+    /** {@link DateTokenParts.ms} */
+    milliseconds: number;
+    /** {@link DateTokenParts.A} */
+    upperCaseMeridiem: string;
+    /** {@link DateTokenParts.a} */
+    lowerCaseMeridiem: string;
+    /** {@link DateTokenParts.th} */
+    dayOrdinalSuffix: string;
+};
+/** Every part of a date, reachable both by unit token and by name. */
+export type DateParts = DateTokenParts & NamedDateParts;

package/agnostic/time/dates/format-date/types.js

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

package/agnostic/time/duration/format-duration/index.d.ts

@@ -0,0 +1,42 @@
+import type { Duration } from '../index.js';
+import type { FormatDurationOptions } from './types.js';
+/**
+ * Formats a duration into a string according to a custom template.
+ *
+ * The breakdown follows the template: the units it mentions are the units the
+ * duration is split across, each taking its whole part and handing the rest
+ * down. `'{{h}}:{{mm}}:{{ss}}'` therefore reads a duration as hours, minutes and
+ * seconds, while `'{{s}}s'` puts the whole duration on seconds.
+ *
+ * Supported tokens (placeholders must be wrapped in `{{...}}`). The bare form is
+ * the plain number, the doubled form the same number padded to two digits:
+ *
+ * - `Y` / `YY` : Years
+ * - `M` / `MM` : Months
+ * - `w` / `ww` : Weeks
+ * - `d` / `dd` : Days
+ * - `h` / `hh` : Hours
+ * - `m` / `mm` : Minutes
+ * - `s` / `ss` : Seconds
+ * - `ms` : Milliseconds, padded to three digits
+ *
+ * @param duration - The duration to format, as a {@link Duration} or a number of
+ * milliseconds.
+ * @param format - The template string containing tokens.
+ * @param options - How to handle the remainder and the month/year approximation.
+ * @returns Formatted duration string. An unknown token is left untouched, braces
+ * included.
+ * @see {@link getDurationParts} to reach the same parts as plain values.
+ *
+ * @remarks
+ * A negative duration yields negative parts, so every token renders a signed
+ * number — `'{{m}}:{{ss}}'` gives `-1:-30`, not `-1:30`. This is deliberate: the
+ * output stays faithful to the parts, and keeping a duration positive is the
+ * caller's business. Format the magnitude and write the sign yourself when a
+ * single leading minus is what you need.
+ *
+ * @example
+ * formatDuration(seconds(3725), '{{h}}:{{mm}}:{{ss}}')
+ * // => "1:02:05"
+ */
+export declare function formatDuration(duration: Duration | number, format: string, options?: FormatDurationOptions): string;

package/agnostic/time/duration/format-duration/index.js

@@ -0,0 +1,94 @@
+import { getDurationParts } from './parts.js';
+// Alternation is ordered, and the first branch that fits wins — so the longest
+// tokens come first. `m` ahead of `ms` or `mm` would swallow them.
+const tokenRegexp = /\{\{(YY|MM|ww|dd|hh|mm|ss|ms|Y|M|w|d|h|m|s)\}\}/gv;
+/** Which tokens read which unit, longest unit first. */
+const unitTokens = [
+    ['Y', ['Y', 'YY']],
+    ['M', ['M', 'MM']],
+    ['w', ['w', 'ww']],
+    ['d', ['d', 'dd']],
+    ['h', ['h', 'hh']],
+    ['m', ['m', 'mm']],
+    ['s', ['s', 'ss']],
+    ['ms', ['ms']]
+];
+function pad(value, length) {
+    return `${value}`.padStart(length, '0');
+}
+/**
+ * How each token renders the parts it reads. This is where padding lives —
+ * {@link getDurationParts} hands over plain quantities, and a doubled token is
+ * the same quantity written on two digits.
+ */
+const renderers = {
+    'Y': parts => `${parts.Y}`,
+    'YY': parts => pad(parts.Y, 2),
+    'M': parts => `${parts.M}`,
+    'MM': parts => pad(parts.M, 2),
+    'w': parts => `${parts.w}`,
+    'ww': parts => pad(parts.w, 2),
+    'd': parts => `${parts.d}`,
+    'dd': parts => pad(parts.d, 2),
+    'h': parts => `${parts.h}`,
+    'hh': parts => pad(parts.h, 2),
+    'm': parts => `${parts.m}`,
+    'mm': parts => pad(parts.m, 2),
+    's': parts => `${parts.s}`,
+    'ss': parts => pad(parts.s, 2),
+    'ms': parts => pad(parts.ms, 3)
+};
+/** The units a template asks for, read off the tokens it actually uses. */
+function unitsInFormat(format) {
+    return unitTokens
+        .filter(([, tokens]) => tokens.some(token => format.includes(`{{${token}}}`)))
+        .map(([unit]) => unit);
+}
+/**
+ * Formats a duration into a string according to a custom template.
+ *
+ * The breakdown follows the template: the units it mentions are the units the
+ * duration is split across, each taking its whole part and handing the rest
+ * down. `'{{h}}:{{mm}}:{{ss}}'` therefore reads a duration as hours, minutes and
+ * seconds, while `'{{s}}s'` puts the whole duration on seconds.
+ *
+ * Supported tokens (placeholders must be wrapped in `{{...}}`). The bare form is
+ * the plain number, the doubled form the same number padded to two digits:
+ *
+ * - `Y` / `YY` : Years
+ * - `M` / `MM` : Months
+ * - `w` / `ww` : Weeks
+ * - `d` / `dd` : Days
+ * - `h` / `hh` : Hours
+ * - `m` / `mm` : Minutes
+ * - `s` / `ss` : Seconds
+ * - `ms` : Milliseconds, padded to three digits
+ *
+ * @param duration - The duration to format, as a {@link Duration} or a number of
+ * milliseconds.
+ * @param format - The template string containing tokens.
+ * @param options - How to handle the remainder and the month/year approximation.
+ * @returns Formatted duration string. An unknown token is left untouched, braces
+ * included.
+ * @see {@link getDurationParts} to reach the same parts as plain values.
+ *
+ * @remarks
+ * A negative duration yields negative parts, so every token renders a signed
+ * number — `'{{m}}:{{ss}}'` gives `-1:-30`, not `-1:30`. This is deliberate: the
+ * output stays faithful to the parts, and keeping a duration positive is the
+ * caller's business. Format the magnitude and write the sign yourself when a
+ * single leading minus is what you need.
+ *
+ * @example
+ * formatDuration(seconds(3725), '{{h}}:{{mm}}:{{ss}}')
+ * // => "1:02:05"
+ */
+export function formatDuration(duration, format, options = {}) {
+    const { floorSmallestUnit = true, useApproximateMonthAndYear = true } = options;
+    const parts = getDurationParts(duration, {
+        units: unitsInFormat(format),
+        floorSmallestUnit,
+        useApproximateMonthAndYear
+    });
+    return format.replace(tokenRegexp, (_match, token) => renderers[token](parts));
+}

package/agnostic/time/duration/format-duration/index.test.d.ts

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