native-dates 0.0.0-stage → 0.0.6

package/src/helpers/fields.js

@@ -0,0 +1,194 @@
+import { guard, refuse, refuseType } from './errors.js';
+import { IS_DURATION } from './identity.js';
+import { isDevelopment, isNumber, isPlainObject, isString } from './types.js';
+import { isDigits, isTemporalDuration, plural, unit } from './units.js';
+
+export const fieldNames = [
+  'years',
+  'months',
+  'weeks',
+  'days',
+  'hours',
+  'minutes',
+  'seconds',
+  'milliseconds',
+  'microseconds',
+  'nanoseconds',
+];
+
+// a fractional quantity spills into the next unit down: 1.5 days is a day and 12 hours. a month has no
+// next unit, so a fraction of one is refused rather than guessed
+const spillsInto = {
+  year: ['month', 12],
+  week: ['day', 7],
+  day: ['hour', 24],
+  hour: ['minute', 60],
+  minute: ['second', 60],
+  second: ['millisecond', 1000],
+  millisecond: ['microsecond', 1000],
+  microsecond: ['nanosecond', 1000],
+};
+
+export const spill = (fields, name, value) => {
+  if (name === 'quarter') {
+    return spill(fields, 'month', value * 3);
+  }
+  if (!Number.isFinite(value)) {
+    refuse('notFinite', `${value} ${name}`);
+  }
+  const whole = Math.trunc(value);
+  const fraction = Number((value - whole).toFixed(9));
+  fields[plural(name)] = (fields[plural(name)] ?? 0) + whole;
+  if (fraction) {
+    const next = spillsInto[name];
+    if (!next) {
+      refuse('fractionalMonth', `${value} ${name}`, {
+        explanation: isDevelopment
+          ? 'months and nanoseconds have no smaller unit to spill into. write whole months, or days'
+          : 0,
+      });
+    }
+    spill(fields, next[0], Number((fraction * next[1]).toFixed(9)));
+  }
+  return fields;
+};
+
+// the nonzero fields of a Temporal.Duration as a plain object
+export const fieldsOf = (temporal) => {
+  const fields = {};
+  for (const field of fieldNames) {
+    if (temporal[field]) {
+      fields[field] = temporal[field];
+    }
+  }
+  return fields;
+};
+
+const quantity = /([-+]?)(\d+(?:\.\d+)?)\s*([a-zµ]+)/gi;
+
+// '1h 30m', '2 weeks and 3 days', '90 minutes', '1500' (milliseconds).
+// a leading minus with the rest unsigned negates the whole phrase, the way a person means '-1h 30m',
+// and a sign on each quantity is taken as written
+const parseWords = (text) => {
+  const phrase = text.trim().replace(/,|\band\b/gi, ' ');
+  if (!phrase) {
+    refuse('unreadableDuration', text, {
+      explanation: isDevelopment ? 'an empty string is not a length. duration(0) is zero' : 0,
+    });
+  }
+  if (/^-?\d+(\.\d+)?$/.test(phrase)) {
+    return spill({}, 'millisecond', Number(phrase));
+  }
+  const found = [];
+  const rest = phrase.replace(quantity, (_, sign, amount, name) => {
+    found.push([sign, Number(amount), unit(name)]);
+    return '';
+  });
+  if (rest.trim()) {
+    refuse('unreadableDuration', text, {
+      explanation: isDevelopment
+        ? "write quantities with units, '1h 30m' or '2 weeks 3 days', or an ISO duration like PT1H30M"
+        : 0,
+    });
+  }
+  const negateAll = found[0]?.[0] === '-' && found.slice(1).every(([sign]) => sign === '');
+  const fields = {};
+  for (const [sign, amount, name] of found) {
+    spill(fields, name, negateAll || sign === '-' ? -amount : amount);
+  }
+  return fields;
+};
+
+// a duration has one sign. '1h -30m' has no meaning until it is subtracted from a point
+const oneSign = (fields, at) => {
+  const signs = new Set(Object.values(fields).filter(Boolean).map(Math.sign));
+  if (signs.size > 1) {
+    refuse('mixedSigns', at, {
+      explanation: isDevelopment
+        ? 'a duration has one sign. subtract from a point instead: start.plus(months(1)).minus(days(3))'
+        : 0,
+    });
+  }
+  return fields;
+};
+
+// every shape a duration can be written as, as plural Temporal fields
+export const fieldsFrom = (input, name) => {
+  if (input?.[IS_DURATION]) {
+    if (name !== undefined) {
+      refuseType('notADuration', `${input} ${name}`, {
+        explanation: isDevelopment
+          ? "a duration already has its units. a unit goes with a number: duration(90, 'minutes')"
+          : 0,
+      });
+    }
+    return input.toFields();
+  }
+  if (isTemporalDuration(input)) {
+    return fieldsOf(input);
+  }
+  if (isNumber(input)) {
+    return spill({}, name === undefined ? 'millisecond' : unit(name), input);
+  }
+  if (isString(input)) {
+    // a count from a form or a query string is text, and '30' beside 'days' is thirty days
+    if (name !== undefined && isDigits(input)) {
+      return spill({}, unit(name), Number(input));
+    }
+    return /^[-+]?P/i.test(input.trim())
+      ? fieldsOf(guard(() => Temporal.Duration.from(input.trim()), 'unreadableDuration', input))
+      : oneSign(parseWords(input), input);
+  }
+  if (isPlainObject(input)) {
+    const fields = {};
+    for (const [key, value] of Object.entries(input)) {
+      spill(fields, unit(key), value);
+    }
+    return oneSign(fields, JSON.stringify(input));
+  }
+  return refuseType('notADuration', String(input), {
+    explanation: isDevelopment
+      ? "a duration is a number with a unit, a phrase like '2h 30m', an ISO string like PT2H30M, or a fields object"
+      : 0,
+  });
+};
+
+export const clockFields = (fields) => {
+  const clock = {};
+  for (const field of fieldNames.slice(4)) {
+    if (fields[field]) {
+      clock[field] = fields[field];
+    }
+  }
+  return clock;
+};
+
+// years, months, weeks and days stay field-wise: they are calendar units, and folding 25 hours into a
+// day would move a deadline across a daylight saving change. hours and below combine through Temporal
+// so a subtraction balances to one sign: 2h minus 30m is 1h 30m
+export const addFields = (a, b, sign) => {
+  const fields = {};
+  for (const field of ['years', 'months', 'weeks', 'days']) {
+    const sum = (a[field] ?? 0) + sign * (b[field] ?? 0);
+    if (sum) {
+      fields[field] = sum;
+    }
+  }
+  const clockA = temporalDurationOf(clockFields(a));
+  const clockB = temporalDurationOf(clockFields(b));
+  Object.assign(fields, fieldsOf(sign > 0 ? clockA.add(clockB) : clockA.subtract(clockB)));
+  return oneSign(fields, JSON.stringify(fields));
+};
+
+// Temporal refuses an empty fields object, and a zero duration has no nonzero field to offer it
+export const temporalDurationOf = (fields) =>
+  Object.keys(fields).length
+    ? guard(() => Temporal.Duration.from(fields), 'unreadableDuration', JSON.stringify(fields))
+    : new Temporal.Duration();
+
+export const temporalDurationFrom = (input, name) => temporalDurationOf(fieldsFrom(input, name));
+
+// plural keys are how Temporal writes a length, singular keys how it writes a point, so { hours: 2 }
+// is two hours where { hour: 2 } is two o'clock
+export const isDurationFields = (value) =>
+  isPlainObject(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => fieldNames.includes(key));

package/src/helpers/format.js

@@ -0,0 +1,93 @@
+import { refuse } from './errors.js';
+import { plainDateTimeFormat, zonedDateTimeFormat } from './intl.js';
+import { isDevelopment, isPlainObject, isString } from './types.js';
+import { locale as pickLocale } from './zones.js';
+
+const presets = {
+  datetime: {
+    short: { dateStyle: 'short', timeStyle: 'short' },
+    medium: { dateStyle: 'medium', timeStyle: 'short' },
+    long: { dateStyle: 'long', timeStyle: 'short' },
+    full: { dateStyle: 'full', timeStyle: 'short' },
+    date: { dateStyle: 'medium' },
+    time: { timeStyle: 'short' },
+    month: { month: 'long', year: 'numeric' },
+    text: {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric',
+      hour: 'numeric',
+      minute: '2-digit',
+      timeZoneName: 'short',
+    },
+  },
+  date: {
+    short: { dateStyle: 'short' },
+    medium: { dateStyle: 'medium' },
+    long: { dateStyle: 'long' },
+    full: { dateStyle: 'full' },
+    month: { month: 'long', year: 'numeric' },
+  },
+  time: {
+    default: { timeStyle: 'short' },
+    short: { timeStyle: 'short' },
+    medium: { timeStyle: 'medium' },
+    long: { timeStyle: 'long' },
+    full: { timeStyle: 'full' },
+  },
+};
+
+// frozen, so a preset keys its formatter by identity and a format call serializes nothing
+for (const kind of Object.values(presets)) {
+  for (const options of Object.values(kind)) {
+    Object.freeze(options);
+  }
+}
+
+// a preset name or an Intl options bag resolves to Intl options, anything else resolves to undefined
+export const intlOptions = (kind, spec) => {
+  if (spec === undefined) {
+    return presets[kind].default ?? presets[kind].medium;
+  }
+  if (isPlainObject(spec)) {
+    return spec;
+  }
+  if (!isString(spec)) {
+    refuse('unknownFormat', String(spec), {
+      explanation: isDevelopment
+        ? "a format is a preset like 'medium', an Intl options object, or a token pattern with plugins/tokens"
+        : 0,
+    });
+  }
+  return Object.hasOwn(presets[kind], spec) ? presets[kind][spec] : undefined;
+};
+
+export const unknownFormat = (spec) =>
+  refuse('unknownFormat', String(spec), {
+    explanation: isDevelopment
+      ? "a format is a preset like 'medium' or an Intl options object. import '@native-dates/plugins/tokens' for patterns like 'YYYY-MM-DD'"
+      : 0,
+  });
+
+// Intl gets epoch milliseconds and a zone on every engine. a date is its UTC midnight read in UTC, a
+// time is that clock on the epoch day, so the fields print unshifted whether Temporal is native or not
+export const epochOf = (kind, subject) => {
+  if (kind === 'date') {
+    // Date.UTC reads a year under 100 as the 1900s, setUTCFullYear reads it as written
+    const stamp = new Date(0);
+    stamp.setUTCFullYear(subject.year, subject.month - 1, subject.day);
+    return stamp.getTime();
+  }
+  if (kind === 'time') {
+    return Date.UTC(1970, 0, 1, subject.hour, subject.minute, subject.second, subject.millisecond);
+  }
+  return subject;
+};
+
+export const formatter = (kind, options, locale, zone) =>
+  kind === 'datetime'
+    ? zonedDateTimeFormat(pickLocale(locale), options, zone)
+    : plainDateTimeFormat(pickLocale(locale), options);
+
+export const formatIntl = (kind, subject, options, locale, zone) =>
+  formatter(kind, options, locale, zone).format(epochOf(kind, subject));

package/src/helpers/identity.js

@@ -0,0 +1,10 @@
+// Symbol.for keys survive cross-realm boundaries (bundles, iframes), so
+// `instanceof DateTime` works against any realm's class definition
+export const IS_DATE_TIME = Symbol.for('native-dates/DateTime');
+export const IS_CALENDAR_DATE = Symbol.for('native-dates/CalendarDate');
+export const IS_TIME = Symbol.for('native-dates/Time');
+export const IS_DURATION = Symbol.for('native-dates/Duration');
+export const IS_RANGE = Symbol.for('native-dates/Range');
+export const IS_DATE_RANGE = Symbol.for('native-dates/DateRange');
+export const IS_DATE_TIME_RANGE = Symbol.for('native-dates/DateTimeRange');
+export const IS_TIME_RANGE = Symbol.for('native-dates/TimeRange');

package/src/helpers/intl.js

@@ -0,0 +1,45 @@
+import { guard } from './errors.js';
+import { isPlainObject } from './types.js';
+
+// an Intl constructor costs about a hundred format calls, so each formatter is built once per argument
+// list and reused. the arguments key nested maps, a string by value and a frozen options object by
+// identity, so a preset costs no serialization on a format call. a caller's own object may change
+// between calls, so it keys by its fields. every call of one formatter passes the same number of arguments
+export const cached = (make) => {
+  const root = new Map();
+  return (...args) => {
+    let level = root;
+    const last = args.length - 1;
+    for (let index = 0; index <= last; index++) {
+      const arg = args[index];
+      const key = isPlainObject(arg) && !Object.isFrozen(arg) ? JSON.stringify(arg) : arg;
+      let next = level.get(key);
+      if (next === undefined) {
+        next = index === last ? make(...args) : new Map();
+        level.set(key, next);
+      }
+      level = next;
+    }
+    return level;
+  };
+};
+
+// a datetime prints in its zone unless the options name one. a date or a time has no instant, so its
+// fields print through UTC whatever the options say. an unknown option throws as the formatter is built,
+// so the refusal wraps the build alone and a call that finds its formatter pays nothing for it
+export const zonedDateTimeFormat = cached((locale, options, zone) =>
+  guard(() => new Intl.DateTimeFormat(locale, { timeZone: zone, ...options }), 'unknownFormat', JSON.stringify(options))
+);
+export const plainDateTimeFormat = cached((locale, options) =>
+  guard(
+    () => new Intl.DateTimeFormat(locale, { ...options, timeZone: 'UTC' }),
+    'unknownFormat',
+    JSON.stringify(options),
+  )
+);
+export const durationFormat = cached((locale, style, hoursDisplay) =>
+  new Intl.DurationFormat(locale, { style, hoursDisplay })
+);
+export const unitFormat = cached((locale, unit, unitDisplay) =>
+  new Intl.NumberFormat(locale, { style: 'unit', unit, unitDisplay })
+);

package/src/helpers/types.js

@@ -0,0 +1,20 @@
+// leads the file without optional chaining so bundlers fold process.env.NODE_ENV across modules
+export const isDevelopment = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : false;
+
+const toString = Object.prototype.toString;
+
+export const isObject = (value) => value !== null && typeof value === 'object';
+
+export const isPlainObject = (value) => {
+  if (!isObject(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+};
+
+export const isString = (value) => typeof value === 'string';
+export const isNumber = (value) => typeof value === 'number';
+export const isFunction = (value) => typeof value === 'function';
+export const isArray = Array.isArray;
+export const isDate = (value) => toString.call(value) === '[object Date]';

package/src/helpers/units.js

@@ -0,0 +1,147 @@
+import { refuse } from './errors.js';
+import { isDevelopment, isNumber, isPlainObject, isString } from './types.js';
+
+if (!globalThis.Temporal) {
+  refuse('noTemporal', 'globalThis.Temporal', {
+    explanation: isDevelopment
+      ? 'this library wraps the Temporal API. import @native-dates/polyfill first on a runtime without one'
+      : 0,
+  });
+}
+
+export const inspect = Symbol.for('nodejs.util.inspect.custom');
+
+// every common unit spelling plus the calendar units duration arithmetic refuses to guess at
+const spellings = {
+  y: 'year',
+  yr: 'year',
+  yrs: 'year',
+  year: 'year',
+  years: 'year',
+  q: 'quarter',
+  qtr: 'quarter',
+  quarter: 'quarter',
+  quarters: 'quarter',
+  mo: 'month',
+  mos: 'month',
+  month: 'month',
+  months: 'month',
+  w: 'week',
+  wk: 'week',
+  wks: 'week',
+  week: 'week',
+  weeks: 'week',
+  d: 'day',
+  day: 'day',
+  days: 'day',
+  h: 'hour',
+  hr: 'hour',
+  hrs: 'hour',
+  hour: 'hour',
+  hours: 'hour',
+  m: 'minute',
+  min: 'minute',
+  mins: 'minute',
+  minute: 'minute',
+  minutes: 'minute',
+  s: 'second',
+  sec: 'second',
+  secs: 'second',
+  second: 'second',
+  seconds: 'second',
+  ms: 'millisecond',
+  msec: 'millisecond',
+  msecs: 'millisecond',
+  millisecond: 'millisecond',
+  milliseconds: 'millisecond',
+  us: 'microsecond',
+  'µs': 'microsecond',
+  microsecond: 'microsecond',
+  microseconds: 'microsecond',
+  ns: 'nanosecond',
+  nanosecond: 'nanosecond',
+  nanoseconds: 'nanosecond',
+};
+
+export const units = [
+  'year',
+  'month',
+  'week',
+  'day',
+  'hour',
+  'minute',
+  'second',
+  'millisecond',
+  'microsecond',
+  'nanosecond',
+];
+export const timeUnits = ['hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond'];
+
+// a number written as text, the way a form or a query string carries one
+export const isDigits = (value) => isString(value) && /^\s*[-+]?\d+(?:\.\d+)?\s*$/.test(value);
+
+// day.js keeps M for month and m for minute, and the tokens plugin does too, so the one capital is kept
+export const unit = (input) => {
+  const key = input === 'M' ? 'month' : isString(input) ? input.trim().toLowerCase() : '';
+  const found = Object.hasOwn(spellings, key) && spellings[key];
+  return found || refuse('unknownUnit', String(input), {
+    explanation: isDevelopment
+      ? `units are ${units.join(', ')} or quarter, singular or plural, or an abbreviation like h, min, d`
+      : 0,
+  });
+};
+
+export const plural = (name) => `${name}s`;
+
+const weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'];
+
+// ISO numbering, monday is 1 and sunday is 7
+export const weekdayNumber = (input) => {
+  if (isNumber(input) && Number.isInteger(input) && input >= 1 && input <= 7) {
+    return input;
+  }
+  const key = isString(input) ? input.trim().toLowerCase().slice(0, 3) : '';
+  const index = key.length === 3 ? weekdays.findIndex((name) => name.startsWith(key)) : -1;
+  return index === -1
+    ? refuse('unknownWeekday', String(input), {
+      explanation: isDevelopment ? `weekdays are ${weekdays.join(', ')} or 1 through 7 from monday` : 0,
+    })
+    : index + 1;
+};
+
+export const isZonedDateTime = (value) => value instanceof Temporal.ZonedDateTime;
+export const isInstant = (value) => value instanceof Temporal.Instant;
+export const isPlainDate = (value) => value instanceof Temporal.PlainDate;
+export const isPlainDateTime = (value) => value instanceof Temporal.PlainDateTime;
+export const isPlainTime = (value) => value instanceof Temporal.PlainTime;
+export const isTemporalDuration = (value) => value instanceof Temporal.Duration;
+
+export const pad = (value, width = 2) => String(Math.abs(value)).padStart(width, '0');
+
+// Temporal truncates 9.5 to 9 before it checks a range, so a fraction is refused before it gets there
+export const wholeNumbers = (values) => values.every((value) => !isNumber(value) || Number.isInteger(value));
+
+// set() replaces parts as strictly as a factory reads them: whole numbers, in range
+export const withParts = (temporal, changes) => {
+  if (!wholeNumbers(Object.values(changes))) {
+    throw new RangeError('a part is a whole number');
+  }
+  return temporal.with(changes, { overflow: 'reject' });
+};
+
+// singular keys, the shape Temporal's with() takes, from any spelling a caller wrote
+export const singularKeys = (fields) => {
+  const out = {};
+  for (const [key, value] of Object.entries(fields)) {
+    out[unit(key)] = value;
+  }
+  return out;
+};
+
+export const quarterStart = (month) => Math.floor((month - 1) / 3) * 3 + 1;
+
+// one whole unit as duration fields
+export const stepOf = (name) => (name === 'quarter' ? { months: 3 } : { [plural(name)]: 1 });
+
+// the second argument of a factory is a zone, or an options bag { zone, loose }
+export const zoneOptions = (value) => (isPlainObject(value) ? value : { zone: value });

package/src/helpers/zones.js

@@ -0,0 +1,113 @@
+import { guard, refuse, requireLoose } from './errors.js';
+import { isDevelopment, isPlainObject, isString } from './types.js';
+import { weekdayNumber } from './units.js';
+
+// process-wide defaults, zoneAliases being the names a zone answers to when plugins/zones is loaded
+const settings = { zone: undefined, locale: undefined, weekStart: 1, dayFirst: false, zoneAliases: {} };
+const resolved = new Map([['UTC', 'UTC']]);
+
+export const canonicalZone = (id) => {
+  try {
+    return Temporal.Instant.fromEpochMilliseconds(0).toZonedDateTimeISO(id).timeZoneId;
+  }
+  catch {
+    return undefined;
+  }
+};
+
+let zoneExtension = null;
+
+export const setZoneExtension = (resolver) => {
+  zoneExtension = resolver;
+  resolved.clear();
+  resolved.set('UTC', 'UTC');
+};
+
+// an IANA name, a fixed offset, or UTC in core, plus cities, abbreviations and zoneAliases when
+// plugins/zones is loaded. resolves once per spelling and hands back the canonical id
+export const zoneId = (id) => {
+  if (id === undefined || id === null) {
+    return settings.zone ?? Temporal.Now.timeZoneId();
+  }
+  if (!isString(id)) {
+    refuse('unknownZone', String(id), {
+      explanation: isDevelopment
+        ? 'a zone is an IANA name like America/New_York, a fixed offset like +05:30, or UTC'
+        : 0,
+    });
+  }
+  const known = resolved.get(id);
+  if (known) {
+    return known;
+  }
+  const found = zoneExtension ? zoneExtension(id, settings.zoneAliases) : canonicalZone(id.trim());
+  if (!found) {
+    refuse('unknownZone', id, {
+      explanation: isDevelopment
+        ? zoneExtension
+          ? "a zone is an IANA name like America/New_York, a city like Berlin or los angeles, an abbreviation like PT or CET, a fixed offset like +05:30, or UTC. name your own once: configure({ zoneAliases: { hq: 'Europe/Berlin' } })"
+          : "a zone is an IANA name like America/New_York, a fixed offset like +05:30, or UTC. import '@native-dates/plugins/zones' for cities like Berlin, abbreviations like PT, and zoneAliases"
+        : 0,
+    });
+  }
+  resolved.set(id, found);
+  return found;
+};
+
+export const configure = ({ zone, locale, weekStart, dayFirst, zoneAliases } = {}) => {
+  if (zoneAliases !== undefined) {
+    if (!zoneExtension) {
+      refuse('missingPlugin', 'zoneAliases', {
+        explanation: isDevelopment
+          ? "import '@native-dates/plugins/zones' for zoneAliases"
+          : 0,
+      });
+    }
+    if (!isPlainObject(zoneAliases)) {
+      refuse('unknownZone', String(zoneAliases), {
+        explanation: isDevelopment ? "zoneAliases is an object of names to zones: { hq: 'Europe/Berlin' }" : 0,
+      });
+    }
+    for (const [name, target] of Object.entries(zoneAliases)) {
+      settings.zoneAliases[name] = zoneId(target);
+    }
+    resolved.clear();
+    resolved.set('UTC', 'UTC');
+  }
+  if (zone !== undefined) {
+    settings.zone = zone === null ? undefined : zoneId(zone);
+  }
+  if (locale !== undefined) {
+    settings.locale = locale === null ? undefined : checkedLocale(locale);
+  }
+  if (weekStart !== undefined) {
+    settings.weekStart = weekdayNumber(weekStart);
+  }
+  if (dayFirst !== undefined) {
+    requireLoose('dayFirst');
+    settings.dayFirst = !!dayFirst;
+  }
+  return { ...settings, zoneAliases: { ...settings.zoneAliases } };
+};
+
+// an Accept-Language header is the classic first attempt, and Intl would refuse it far from the cause
+const knownLocales = new Set();
+const checkedLocale = (tag) => {
+  const key = String(tag);
+  if (!knownLocales.has(key)) {
+    guard(
+      () => Intl.getCanonicalLocales(tag),
+      'unknownLocale',
+      key,
+      isDevelopment
+        ? "a locale is a BCP 47 tag like 'en-US' or 'de', or a list of them. pick one out of an Accept-Language header"
+        : 0,
+    );
+    knownLocales.add(key);
+  }
+  return tag;
+};
+
+export const locale = (override) => (override === undefined ? settings.locale : checkedLocale(override));
+export const dayFirst = (override) => (override === undefined ? settings.dayFirst : !!override);
+export const weekStart = (override) => (override === undefined ? settings.weekStart : weekdayNumber(override));

package/src/index.js

@@ -0,0 +1,30 @@
+// nouns
+export { CalendarDate } from './calendar-date.js';
+export { DateTime } from './date-time.js';
+export { Duration } from './duration.js';
+export { Time } from './time.js';
+
+// factories
+export { date, today, tomorrow, yesterday } from './calendar-date.js';
+export { datetime, endOfToday, now, startOfToday } from './date-time.js';
+export { days, duration, hours, milliseconds, minutes, months, seconds, weeks, years } from './duration.js';
+export { time } from './time.js';
+
+// guards, comparisons, brands and setup
+export { isCalendarDate } from './calendar-date.js';
+export { isDateTime } from './date-time.js';
+export { isDuration } from './duration.js';
+export { compare, earliest, kindOf, latest } from './helpers/compare.js';
+export {
+  IS_CALENDAR_DATE,
+  IS_DATE_RANGE,
+  IS_DATE_TIME,
+  IS_DATE_TIME_RANGE,
+  IS_DURATION,
+  IS_RANGE,
+  IS_TIME,
+  IS_TIME_RANGE,
+} from './helpers/identity.js';
+export { weekdayNumber as weekday } from './helpers/units.js';
+export { configure } from './helpers/zones.js';
+export { isTime } from './time.js';