@reykjavik/webtools 0.1.29 → 0.1.31

package/CHANGELOG.md

@@ -4,21 +4,37 @@
 
 - ... <!-- Add new lines here. -->
 
-## 0.1.29
+## 0.1.31
 
-_2024-08-26_
+_2024-09-23_
+
+- `@reykjavik/webtools/async`:
+  - feat: `maxWait` returns full `PromiseSettledResult` objects
+  - fix: `maxWait` result objects should remain stable
+  - fix: `maxWait` should distinguish between unresolved and rejected promises
+
+## 0.1.30
+
+_2024-09-15_
 
 - `@reykjavik/webtools/http`:
-  - feat: Add `cacheControlHeaders` helper that returns a `HeadersInit` object
-  - fix: `cacheControl` with `maxAge: 'unset'` didn't delete `X-Cache-Control`
-    in dev mode
+  - feat: Add `toMs` duration helper
+- `@reykjavik/webtools/fixIcelandicLocale`:
+  - feat: Patch `Intl.RelativeTimeFormat`
+  - feat: Patch all `supportedLocalesOf` methods to report "is\*" as supported
+  - fix: Incorrect `PluralRules` results for negative values
+  - fix: Use each `Intl.*` class' `supportedLocalesOf` method to map locales
+  - fix: Remove unnecessary `Intl.\*` method instance-bindings
 
-## 0.1.28
+## 0.1.28 – 0.1.29
 
 _2024-08-26_
 
 - `@reykjavik/webtools/http`:
+  - feat: Add `cacheControlHeaders` helper that returns a `HeadersInit` object
   - feat: `cacheControl` now also accepts `Map<string, string>` for headers
+  - fix: `cacheControl` with `maxAge: 'unset'` didn't delete `X-Cache-Control`
+    in dev mode
 
 ## 0.1.27
 

package/README.md

@@ -23,6 +23,7 @@ bun add @reykjavik/webtools
   - [`cacheControlHeaders` helper](#cachecontrolheaders-helper)
     - [Type `TTLConfig`](#type-ttlconfig)
   - [`toSec` TTL helper](#tosec-ttl-helper)
+  - [`toMs` duration helper](#toms-duration-helper)
 - [`@reykjavik/webtools/async`](#reykjavikwebtoolsasync)
   - [`promiseAllObject`](#promiseallobject)
   - [`maxWait`](#maxwait)
@@ -206,7 +207,7 @@ behavior.
 **Syntax:**
 `` toSec(ttl: number | `${number}${'s'|'m'|'h'|'d'|'w'}`): number ``
 
-Converts a `TTL` (max-age) value into seconds, and returns `0` for bad and/or
+Converts a `TTL` (max-age) value into seconds. Returns `0` for bad and/or
 negative input values.
 
 ```js
@@ -217,6 +218,22 @@ const ttl: TTL = '2h';
 const ttlSec = toSec(ttl);
 ```
 
+### `toMs` duration helper
+
+**Syntax:**
+`` toSec(duration: number | `${number}${'s'|'m'|'h'|'d'|'w'}`): number ``
+
+Converts a `TTL` (duration) value into milliseconds. Returns `0` for bad
+and/or negative input values.
+
+```js
+import type { toMs, TTL } from '@reykjavik/webtools/http';
+
+const ttl: TTL = '2h';
+
+const ttlSec = toMs(ttl);
+```
+
 ---
 
 ## `@reykjavik/webtools/async`
@@ -248,23 +265,21 @@ const { user, posts } = await promiseAllObject({
 
 **Syntax:** `maxWait(timeout: number, promises: Array<any>): Promise<void>`  
 **Syntax:**
-`maxWait<T extends PlainObj>(timeout: number, promises: T): Promise<{ [K in keyof T]: { value: Awaited<T[K]> } | undefined }>`
+`maxWait<T extends PlainObj>(timeout: number, promises: T): Promise<{ [K in keyof T]: PromiseSettledResult<T[K]> } | undefined }>`
 
-This somewhat esoteric helper resolves soon as all of the passed `promises`
-have resolved, or after `timeout` milliseconds — whichever comes first.
+This somewhat esoteric helper resolves soon when all of the passed `promises`
+have settled (resolved or rejected), OR after `timeout` milliseconds —
+whichever comes first.
 
 If an object is passed, the resolved value will be an object with the same
-keys, with undefined values for any promises that didn't resolve in time, and
-the resolved values in a `value` container object.
-
-If any of the promises reject, their values become undefined in the returned
-object.
+keys, and any settled values in a `PromiseSettledResult` object, and
+`undefined` for any promises that didn't settle in time.
 
 ```ts
 import { maxWait } from '@reykjavik/webtools/async';
 
-const user = fetchUser();
-const posts = fetchPosts();
+const user = fetchUser(); // Promise<User>
+const posts = fetchPosts(); // Promise<Array<Post>>
 
 // Array of promises resolves to void
 await maxWait(500, [user, posts]);
@@ -274,6 +289,8 @@ const { user, posts } = await maxWait(500, { user, posts });
 
 console.log(user?.value); // undefined | User
 console.log(posts?.value); // undefined | Array<Post>
+console.log(posts?.status); // 'fulfilled' | 'rejected'
+console.log(posts?.reason); // undefined | unknown
 ```
 
 ---
@@ -288,15 +305,16 @@ This module patches the following methods/classes by substituting the `is`
 locale with `da` (Danish) and apply a few post-hoc fixes to their return
 values.
 
-- `Intl.Collator` and `String.prototype.localeCompare`
-- `Intl.NumberFormat` and `Number.prototype.toLocaleString`
+- `Intl.Collator` and `String.prototype.localeCompare` (\*)
+- `Intl.NumberFormat` and `Number.prototype.toLocaleString` (\*)
 - `Intl.DateTimeFormat` and `Date.prototype.toLocaleString`,
-  `.toLocaleDateString`, and `.toLocaleTimeString`
+  `.toLocaleDateString`, and `.toLocaleTimeString` (\*)
+- `Intl.RelativeDateFormat`
 - `Intl.PluralRules`
 - `Intl.ListFormat`
 
-This provides usable (but not perfect) results, with a few caveats that are
-listed below.
+(\*) The results are quite usable, but not entirely perfect. The
+limitations/caveats are listed below.
 
 To apply the patch, simply "side-effect import" this module at the top of your
 app's entry point:
@@ -315,11 +333,10 @@ detection test.)
 
 **`Intl.Collator` and `localeCompare`:**
 
-- It incorrectly treats `ð` and `d` as the same letter (most of the time), and
-  the acute-accented characters `á`, `é`, `í`, `ó`, `ú` and `ý` get lumped in
-  with their non-accented counterparts (unless the compared).  
-  We fix this only for the first letter in the string, but not for the rest of
-  it.
+- It sorts initial letters correctly but in the rest of the string, it
+  incorrectly treats `ð` and `d` as the same letter (most of the time), and
+  lumps the acute-accented characters `á`, `é`, `í`, `ó`, `ú` and `ý` in with
+  their non-accented counterparts.
 
 **`Intl.NumberFormat` and `toLocaleString`:**
 
@@ -338,6 +355,8 @@ detection test.)
 - The `dayPeriod` option has a couple of slight mismatches, at 5 am and 12
   noon.
 
+We eagerly accept bugfixes, additions, etc. to this module!
+
 ---
 
 ## `@reykjavik/webtools/SiteImprove`
@@ -573,19 +592,19 @@ export const myClass = vanillaClass(`
 // more complex styles.
 export const myOtherClass = vanillaClass(
   (className) => `
-  .${className} {
-    background-color: #ccc;
-    padding: .5em 1em;
-  }
-  .${className} > strong {
-    color: #c00;
-  }
-  @media (min-width: 800px) {
-    .${className} {
-      background-color: #eee;
+    .${className} { 
+      background-color: #ccc;
+      padding: .5em 1em;
     }
-  }
-`
+    .${className} > strong {
+      color: #c00;
+    }
+    @media (min-width: 800px) {
+      .${className} {
+        background-color: #eee;
+      }
+    }
+  `
 );
 
 export const humanReadableClass = vanillaClass(

package/async.d.ts

@@ -1,3 +1,4 @@
+import { EitherObj } from '@reykjavik/hanna-utils';
 type PlainObj = Record<string, unknown>;
 /**
  * Simple sleep function. Returns a promise that resolves after `length`
@@ -5,16 +6,19 @@ type PlainObj = Record<string, unknown>;
  */
 export declare const sleep: (length: number) => Promise<void>;
 /**
- * Resolves soon as all of the passed `promises` have resolved, or after
- * `timeout` milliseconds — whichever comes first.
+ * Returns a function that adds lag/delay to a promise chain,
+ * passing the promise payload through.
+ */
+export declare const addLag: (length: number) => <T>(res: T) => Promise<T>;
+/**
+ * Resolves as soon as all of the passed `promises` have resolved/settled,
+ * or after `timeout` milliseconds — whichever comes first.
  *
  * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#maxwait
  */
 export declare function maxWait(timeout: number, promises: Array<unknown>): Promise<void>;
 export declare function maxWait<PromiseMap extends PlainObj>(timeout: number, promises: PromiseMap): Promise<{
-    -readonly [K in keyof PromiseMap]: {
-        value: Awaited<PromiseMap[K]>;
-    } | undefined;
+    -readonly [K in keyof PromiseMap]: EitherObj<PromiseFulfilledResult<Awaited<PromiseMap[K]>>, PromiseRejectedResult> | undefined;
 }>;
 /**
  * A variation of `Promise.all()` that accepts an object with named promises

package/async.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promiseAllObject = exports.maxWait = exports.sleep = void 0;
+exports.promiseAllObject = exports.maxWait = exports.addLag = exports.sleep = void 0;
 /**
  * Simple sleep function. Returns a promise that resolves after `length`
  * milliseconds.
  */
 const sleep = (length) => new Promise((resolve) => setTimeout(resolve, length));
 exports.sleep = sleep;
+/**
+ * Returns a function that adds lag/delay to a promise chain,
+ * passing the promise payload through.
+ */
+const addLag = (length) => (res) => (0, exports.sleep)(length).then(() => res);
+exports.addLag = addLag;
 function maxWait(timeout, promises) {
     if (Array.isArray(promises)) {
         return Promise.race([
@@ -19,17 +25,17 @@ function maxWait(timeout, promises) {
         Object.entries(promises).forEach(([key, value]) => {
             if (value instanceof Promise) {
                 retObj[key] = undefined;
-                value
-                    .then((value) => {
-                    retObj[key] = { value };
-                })
-                    .catch(() => undefined);
+                value.then((value) => {
+                    retObj[key] = { status: 'fulfilled', value };
+                }, (reason) => {
+                    retObj[key] = { status: 'rejected', reason };
+                });
             }
             else {
-                retObj[key] = { value };
+                retObj[key] = { status: 'fulfilled', value };
             }
         });
-        return (0, exports.sleep)(0).then(() => retObj);
+        return Promise.resolve().then(() => ({ ...retObj }));
     });
 }
 exports.maxWait = maxWait;

package/esm/async.d.ts

@@ -1,3 +1,4 @@
+import { EitherObj } from '@reykjavik/hanna-utils';
 type PlainObj = Record<string, unknown>;
 /**
  * Simple sleep function. Returns a promise that resolves after `length`
@@ -5,16 +6,19 @@ type PlainObj = Record<string, unknown>;
  */
 export declare const sleep: (length: number) => Promise<void>;
 /**
- * Resolves soon as all of the passed `promises` have resolved, or after
- * `timeout` milliseconds — whichever comes first.
+ * Returns a function that adds lag/delay to a promise chain,
+ * passing the promise payload through.
+ */
+export declare const addLag: (length: number) => <T>(res: T) => Promise<T>;
+/**
+ * Resolves as soon as all of the passed `promises` have resolved/settled,
+ * or after `timeout` milliseconds — whichever comes first.
  *
  * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#maxwait
  */
 export declare function maxWait(timeout: number, promises: Array<unknown>): Promise<void>;
 export declare function maxWait<PromiseMap extends PlainObj>(timeout: number, promises: PromiseMap): Promise<{
-    -readonly [K in keyof PromiseMap]: {
-        value: Awaited<PromiseMap[K]>;
-    } | undefined;
+    -readonly [K in keyof PromiseMap]: EitherObj<PromiseFulfilledResult<Awaited<PromiseMap[K]>>, PromiseRejectedResult> | undefined;
 }>;
 /**
  * A variation of `Promise.all()` that accepts an object with named promises

package/esm/async.js

@@ -3,6 +3,11 @@
  * milliseconds.
  */
 export const sleep = (length) => new Promise((resolve) => setTimeout(resolve, length));
+/**
+ * Returns a function that adds lag/delay to a promise chain,
+ * passing the promise payload through.
+ */
+export const addLag = (length) => (res) => sleep(length).then(() => res);
 export function maxWait(timeout, promises) {
     if (Array.isArray(promises)) {
         return Promise.race([
@@ -15,17 +20,17 @@ export function maxWait(timeout, promises) {
         Object.entries(promises).forEach(([key, value]) => {
             if (value instanceof Promise) {
                 retObj[key] = undefined;
-                value
-                    .then((value) => {
-                    retObj[key] = { value };
-                })
-                    .catch(() => undefined);
+                value.then((value) => {
+                    retObj[key] = { status: 'fulfilled', value };
+                }, (reason) => {
+                    retObj[key] = { status: 'rejected', reason };
+                });
             }
             else {
-                retObj[key] = { value };
+                retObj[key] = { status: 'fulfilled', value };
             }
         });
-        return sleep(0).then(() => retObj);
+        return Promise.resolve().then(() => ({ ...retObj }));
     });
 }
 // ---------------------------------------------------------------------------

package/esm/fixIcelandicLocale.js

@@ -1,10 +1,10 @@
-import { _PatchedCollator, _PatchedDateTimeFormat, _patchedDateToLocaleDateString, _patchedDateToLocaleString, _patchedDateToLocaleTimeString, _PatchedListFormat, _PatchedNumberFormat, _patchedNumberToLocaleString, _PatchedPluralRules, _patchedStringLocaleCompare, } from './fixIcelandicLocale.privates.js';
+import { _PatchedCollator, _PatchedDateTimeFormat, _patchedDateToLocaleDateString, _patchedDateToLocaleString, _patchedDateToLocaleTimeString, _PatchedListFormat, _PatchedNumberFormat, _patchedNumberToLocaleString, _PatchedPluralRules, _PatchedRelativeTimeFormat, _patchedStringLocaleCompare, } from './fixIcelandicLocale.privates.js';
 /*
   Mantra: Partial Icelandic suppoort is better than none. Partial Icelandic
   suppoort is better than none. Partial Icelandic suppoort is better than
   none. Partial Icelandic suppoort is better than none. Partial Icelandic...
 */
-if (Intl.Collator.supportedLocalesOf(['is']).length < 1) {
+if (!Intl.Collator.supportedLocalesOf(['is']).length) {
     Intl.Collator = _PatchedCollator;
     String.prototype.localeCompare = _patchedStringLocaleCompare;
     Intl.NumberFormat = _PatchedNumberFormat;
@@ -15,10 +15,15 @@ if (Intl.Collator.supportedLocalesOf(['is']).length < 1) {
     Date.prototype.toLocaleTimeString = _patchedDateToLocaleTimeString;
 }
 /* eslint-disable @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-unnecessary-condition */
-if (Intl.ListFormat && Intl.ListFormat.supportedLocalesOf(['is']).length < 1) {
+if (Intl.ListFormat && !Intl.ListFormat.supportedLocalesOf(['is']).length) {
     Intl.ListFormat = _PatchedListFormat;
 }
-if (Intl.PluralRules && Intl.PluralRules.supportedLocalesOf(['is']).length < 1) {
+if (Intl.PluralRules && !Intl.PluralRules.supportedLocalesOf(['is']).length) {
     Intl.PluralRules = _PatchedPluralRules;
 }
+if (Intl.RelativeTimeFormat &&
+    !Intl.RelativeTimeFormat.supportedLocalesOf(['is']).length) {
+    Intl.RelativeTimeFormat =
+        _PatchedRelativeTimeFormat;
+}
 /* eslint-enable @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-unnecessary-condition */

package/esm/fixIcelandicLocale.privates.d.ts

@@ -75,3 +75,9 @@ export declare const _PatchedListFormat: {
 } & {
     $original: typeof Intl.ListFormat;
 };
+export declare const _PatchedRelativeTimeFormat: {
+    new (locales?: string | string[] | undefined, options?: Intl.RelativeTimeFormatOptions | undefined): Intl.RelativeTimeFormat;
+    supportedLocalesOf(locales?: string | string[] | undefined, options?: Intl.RelativeTimeFormatOptions | undefined): string[];
+} & {
+    $original: typeof Intl.RelativeTimeFormat;
+};

package/esm/fixIcelandicLocale.privates.js

@@ -1,10 +1,10 @@
-var _a, _b;
-const _Collator = Intl.Collator;
-const mapLocales = (locales) => {
+var _a, _b, _c;
+const islLocaleRe = /^isl?(?:-|$)/i;
+const mapLocales = (constr, locales) => {
     locales = typeof locales === 'string' ? [locales] : locales || [];
     for (let i = 0, loc; (loc = locales[i]); i++) {
-        const isIsLocale = /^isl?(?:-|$)/i.test(loc);
-        if (isIsLocale) {
+        const isIslLocale = islLocaleRe.test(loc);
+        if (isIslLocale) {
             // Danish feels like a "good enough" substitution for Icelandic.
             // For alphabetization, it seems to just the internal order of `Ø` and `Ö`
             // that's different, and when the `sensitivity` option is set to "base"
@@ -15,22 +15,49 @@ const mapLocales = (locales) => {
             // as fully equal to the base letter.
             return ['da'];
         }
-        if (_Collator.supportedLocalesOf(loc).length) {
+        if (constr.supportedLocalesOf(loc).length) {
             return; // no mapping needed. YOLO!
         }
     }
 };
+const patchSupportedLocalesOf = (constr) => {
+    const BASE_CHAR_CODE = 64; // 'A'.charCodeAt(0) - 1; // used for generating unique suffix for fake locales
+    const sLO = (locales, options) => {
+        let localesArr = typeof locales === 'string' ? [locales] : locales;
+        const memoIsl = [];
+        localesArr = localesArr.map((locale) => {
+            if (islLocaleRe.test(locale)) {
+                // Some engines throw a RangeError if the locale is weirdly shaped,
+                // so we must use a short, safe, unique fake locale instead,
+                // and store the actual locale in `memoIsl` for later reinsertion.
+                memoIsl.push(locale);
+                return `da-X${String.fromCharCode(BASE_CHAR_CODE + memoIsl.length)}`;
+            }
+            return locale;
+        });
+        const supportedLocales = constr.supportedLocalesOf(localesArr, options);
+        if (!memoIsl.length) {
+            return supportedLocales;
+        }
+        return supportedLocales.map((locale) => locale.startsWith('da-X') ? memoIsl.shift() : locale);
+    };
+    return sLO;
+};
 const combineParts = (parts) => parts.map(({ value }) => value).join('');
+// ===========================================================================
+// Collator
+// ===========================================================================
+const _Collator = Intl.Collator;
 const PatchedCollator = function Collator(locales, options) {
     if (!(this instanceof PatchedCollator)) {
         // @ts-expect-error  (YOLO! Can't be arsed)
         return new PatchedCollator(locales, options);
     }
-    const mappedLocales = mapLocales(locales);
-    const parent = _Collator(mappedLocales || locales, options);
+    const mappedLocales = mapLocales(_Collator, locales);
+    const super_ = _Collator(mappedLocales || locales, options);
     const mapped = !!mappedLocales;
     this.compare = (a, b) => {
-        const res1 = parent.compare(a, b);
+        const res1 = super_.compare(a, b);
         if (!mapped) {
             return res1;
         }
@@ -39,14 +66,13 @@ const PatchedCollator = function Collator(locales, options) {
         if (/\d/.test(a0 + b0)) {
             return res1;
         }
-        const res2 = parent.compare(a0, b0);
+        const res2 = super_.compare(a0, b0);
         return res2 !== 0 ? res2 : res1;
     };
-    this.resolvedOptions = () => parent.resolvedOptions();
+    this.resolvedOptions = () => super_.resolvedOptions();
 };
 PatchedCollator.prototype = { constructor: PatchedCollator };
-// Static methods (not patched since "is" is not ACTUALLY supported.)
-PatchedCollator.supportedLocalesOf = _Collator.supportedLocalesOf;
+PatchedCollator.supportedLocalesOf = /*#__PURE__*/ patchSupportedLocalesOf(_Collator);
 PatchedCollator.$original = _Collator;
 export const _PatchedCollator = PatchedCollator;
 // ---------------------------------------------------------------------------
@@ -78,24 +104,26 @@ const PatchedNumberFormat = function NumberFormat(locales, options) {
         // @ts-expect-error  (YOLO! Can't be arsed)
         return new PatchedNumberFormat(locales, options);
     }
-    const mappedLocales = mapLocales(locales);
-    const parent = _NumberFormat(mappedLocales || locales, options);
+    const mappedLocales = mapLocales(_NumberFormat, locales);
+    const super_ = _NumberFormat(mappedLocales || locales, options);
     const mapped = !!mappedLocales;
-    this.format = (value) => combineParts(this.formatToParts(value));
-    this.formatRange = (value1, value2) => combineParts(this.formatRangeToParts(value1, value2));
+    this.format = (value) => mapped ? combineParts(this.formatToParts(value)) : super_.format(value);
+    this.formatRange = (value1, value2) => mapped
+        ? combineParts(this.formatRangeToParts(value1, value2))
+        : super_.formatRange(value1, value2);
     this.formatToParts = (value) => {
-        const parts = parent.formatToParts(value);
-        return mapped ? reformatNumberParts(parent, parts) : parts;
+        const parts = super_.formatToParts(value);
+        return mapped ? reformatNumberParts(super_, parts) : parts;
     };
     this.formatRangeToParts = (value1, value2) => {
-        const parts = parent.formatRangeToParts(value1, value2);
-        return mapped ? reformatNumberParts(parent, parts) : parts;
+        const parts = super_.formatRangeToParts(value1, value2);
+        return mapped ? reformatNumberParts(super_, parts) : parts;
     };
-    this.resolvedOptions = () => parent.resolvedOptions();
+    this.resolvedOptions = () => super_.resolvedOptions();
 };
 PatchedNumberFormat.prototype = { constructor: PatchedNumberFormat };
-// Static methods (not patched since "is" is not ACTUALLY supported.)
-PatchedNumberFormat.supportedLocalesOf = _NumberFormat.supportedLocalesOf;
+PatchedNumberFormat.supportedLocalesOf =
+    /*#__PURE__*/ patchSupportedLocalesOf(_NumberFormat);
 PatchedNumberFormat.$original = _NumberFormat;
 export const _PatchedNumberFormat = PatchedNumberFormat;
 // ---------------------------------------------------------------------------
@@ -197,7 +225,7 @@ const PatchedDateTimeFormat = function DateTimeFormat(locales, options) {
         // @ts-expect-error  (YOLO! Can't be arsed)
         return new PatchedDateTimeFormat(locales, options);
     }
-    const mappedLocales = mapLocales(locales);
+    const mappedLocales = mapLocales(_DateTimeFormat, locales);
     if (options === null || options === void 0 ? void 0 : options.hour12) {
         options = {
             ...options,
@@ -205,23 +233,25 @@ const PatchedDateTimeFormat = function DateTimeFormat(locales, options) {
             hourCycle: 'h11',
         };
     }
-    const parent = _DateTimeFormat(mappedLocales || locales, options);
+    const super_ = _DateTimeFormat(mappedLocales || locales, options);
     const mapped = !!mappedLocales;
-    this.format = (value) => combineParts(this.formatToParts(value));
-    this.formatRange = (value1, value2) => combineParts(this.formatRangeToParts(value1, value2));
+    this.format = (value) => mapped ? combineParts(this.formatToParts(value)) : super_.format(value);
+    this.formatRange = (value1, value2) => mapped
+        ? combineParts(this.formatRangeToParts(value1, value2))
+        : super_.formatRange(value1, value2);
     this.formatToParts = (value) => {
-        const parts = parent.formatToParts(value);
-        return mapped ? reformatDateTimeParts(parent, parts) : parts;
+        const parts = super_.formatToParts(value);
+        return mapped ? reformatDateTimeParts(super_, parts) : parts;
     };
     this.formatRangeToParts = (value1, value2) => {
-        const parts = parent.formatRangeToParts(value1, value2);
-        return mapped ? reformatDateTimeParts(parent, parts) : parts;
+        const parts = super_.formatRangeToParts(value1, value2);
+        return mapped ? reformatDateTimeParts(super_, parts) : parts;
     };
-    this.resolvedOptions = () => parent.resolvedOptions();
+    this.resolvedOptions = () => super_.resolvedOptions();
 };
 PatchedDateTimeFormat.prototype = { constructor: PatchedDateTimeFormat };
-// Static methods (not patched since "is" is not ACTUALLY supported.)
-PatchedDateTimeFormat.supportedLocalesOf = _DateTimeFormat.supportedLocalesOf;
+PatchedDateTimeFormat.supportedLocalesOf =
+    /*#__PURE__*/ patchSupportedLocalesOf(_DateTimeFormat);
 PatchedDateTimeFormat.$original = _DateTimeFormat;
 export const _PatchedDateTimeFormat = PatchedDateTimeFormat;
 // ---------------------------------------------------------------------------
@@ -299,15 +329,14 @@ let PatchedPluralRules;
 if (_PluralRules) {
     PatchedPluralRules = (_a = class PluralRules extends _PluralRules {
             pluralIsl(n) {
+                n = n < 0 ? -n : n;
                 return this.ord ? 'other' : n % 10 !== 1 || n % 100 === 11 ? 'other' : 'one';
             }
             constructor(locales, options) {
-                const mappedLocales = mapLocales(locales);
+                const mappedLocales = mapLocales(_PluralRules, locales);
                 super(mappedLocales || locales, options);
                 this.mapped = !!mappedLocales;
                 this.ord = (options === null || options === void 0 ? void 0 : options.type) === 'ordinal';
-                this.select = this.select.bind(this);
-                this.selectRange = this.selectRange.bind(this);
             }
             select(n) {
                 if (this.mapped) {
@@ -325,6 +354,7 @@ if (_PluralRules) {
                 return super.selectRange(n, n2);
             }
         },
+        _a.supportedLocalesOf = patchSupportedLocalesOf(_PluralRules),
         _a.$original = _PluralRules,
         _a);
 }
@@ -338,11 +368,9 @@ let PatchedListFormat;
 if (_ListFormat) {
     PatchedListFormat = (_b = class ListFormat extends _ListFormat {
             constructor(locales, options) {
-                const mappedLocales = mapLocales(locales);
+                const mappedLocales = mapLocales(_ListFormat, locales);
                 super(mappedLocales || locales, options);
                 this.mapped = !!mappedLocales;
-                this.format = this.format.bind(this);
-                this.formatToParts = this.formatToParts.bind(this);
             }
             format(list) {
                 return this.mapped ? combineParts(this.formatToParts(list)) : super.format(list);
@@ -351,8 +379,8 @@ if (_ListFormat) {
                 const parts = super.formatToParts(list);
                 if (this.mapped) {
                     for (const item of parts) {
-                        const { value } = item;
-                        if (item.type === 'literal' && (value === ' el. ' || value === ' eller ')) {
+                        const { type, value } = item;
+                        if (type === 'literal' && (value === ' el. ' || value === ' eller ')) {
                             item.value = ' eða ';
                         }
                     }
@@ -360,7 +388,112 @@ if (_ListFormat) {
                 return parts;
             }
         },
+        _b.supportedLocalesOf = patchSupportedLocalesOf(_ListFormat),
         _b.$original = _ListFormat,
         _b);
 }
 export const _PatchedListFormat = PatchedListFormat;
+// ===========================================================================
+// RelativeTimeFormat
+// ===========================================================================
+const _RelativeTimeFormat = Intl.RelativeTimeFormat;
+let PatchedRelativeTimeFormat;
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+if (_RelativeTimeFormat) {
+    let pluralIsl;
+    let numFormatIsl;
+    const islUnits = {
+        year: [['ári', 'árum', 'ár', 'ár'], ''],
+        quarter: [['ársfjórðungi', 'ársfjórðungum', 'ársfjórðung', 'ársfjórðunga'], 'ársfj.'],
+        month: [['mánuði', 'mánuðum', 'mánuð', 'mánuði'], 'mán.'],
+        week: [['viku', 'vikum', 'viku', 'vikur'], ''],
+        day: [['degi', 'dögum', 'dag', 'daga'], ''],
+        hour: [['klukkustund', 'klukkustundum', 'klukkustund', 'klukkustundir'], 'klst.'],
+        minute: [['mínútu', 'mínútum', 'mínútu', 'mínútur'], 'mín.'],
+        second: [['sekúndu', 'sekúndum', 'sekúndu', 'sekúndur'], 'sek.'],
+    };
+    const phrases = {
+        nu: 'núna',
+        'næste år': 'á næsta ári',
+        'sidste år': 'á síðasta ári',
+        'i år': 'á þessu ári',
+        'sidste kvartal': 'síðasti ársfjórðungur',
+        'dette kvartal': 'þessi ársfjórðungur',
+        'næste kvartal': 'næsti ársfjórðungur',
+        'sidste kvt.': 'síðasti ársfj.',
+        'dette kvt.': 'þessi ársfj.',
+        'næste kvt.': 'næsti ársfj.',
+        'sidste måned': 'í síðasta mánuði',
+        'denne måned': 'í þessum mánuði',
+        'næste måned': 'í næsta mánuði',
+        'sidste md.': 'í síðasta mán.',
+        'denne md.': 'í þessum mán.',
+        'næste md.': 'í næsta mán.',
+        'sidste uge': 'í síðustu viku',
+        'denne uge': 'í þessari viku',
+        'næste uge': 'í næstu viku',
+        'i forgårs': 'í fyrradag',
+        'i går': 'í gær',
+        'i dag': 'í dag',
+        'i morgen': 'á morgun',
+        'i overmorgen': 'eftir tvo daga',
+        'denne time': 'þessa stundina',
+        'dette minut': 'á þessari mínútu',
+    };
+    PatchedRelativeTimeFormat = (_c = class RelativeTimeFormat extends _RelativeTimeFormat {
+            constructor(locales, options) {
+                const mappedLocales = mapLocales(_RelativeTimeFormat, locales);
+                super(mappedLocales || locales, options);
+                this.mapped = !!mappedLocales;
+            }
+            format(value, unit) {
+                return this.mapped
+                    ? combineParts(this.formatToParts(value, unit))
+                    : super.format(value, unit);
+            }
+            // eslint-disable-next-line complexity
+            formatToParts(value, unit) {
+                const parts = super.formatToParts(value, unit);
+                if (!this.mapped) {
+                    return parts;
+                }
+                if (!pluralIsl) {
+                    pluralIsl = new _PatchedPluralRules('is');
+                }
+                if (!numFormatIsl) {
+                    numFormatIsl = new _PatchedNumberFormat('is');
+                }
+                const options = this.resolvedOptions();
+                const unitSngl = unit.replace(/s$/, '');
+                if (parts.length === 1) {
+                    const firstPart = parts[0];
+                    firstPart.value = phrases[firstPart.value] || firstPart.value;
+                    return parts;
+                }
+                const [long, short] = islUnits[unitSngl];
+                const idx = (value < 0 ? 0 : 2) + (pluralIsl.select(value) === 'one' ? 0 : 1);
+                const prefixStr = options.style === 'narrow' &&
+                    (unitSngl === 'second' || unitSngl === 'minute' || unitSngl === 'hour')
+                    ? value < 0
+                        ? '-'
+                        : '+'
+                    : value < 0
+                        ? 'fyrir '
+                        : 'eftir ';
+                const valueStr = (options.style !== 'long' && short) || long[idx];
+                const islParts = [
+                    { type: 'literal', value: prefixStr },
+                    ...numFormatIsl.formatToParts(Math.abs(value)).map((part) => {
+                        part.unit =
+                            unitSngl;
+                        return part;
+                    }),
+                    { type: 'literal', value: ` ${valueStr}` },
+                ];
+                return islParts;
+            }
+        },
+        _c.$original = _RelativeTimeFormat,
+        _c);
+}
+export const _PatchedRelativeTimeFormat = PatchedRelativeTimeFormat;

package/esm/http.d.ts

@@ -158,12 +158,19 @@ type TTLObj = {
  */
 export type TTLConfig = TTL | TTLKeywords | TTLObj;
 /**
- * Converts a `TTL` (max-age) value into seconds, and returns `0` for bad
- * and/or negative input values.
+ * Converts a `TTL` (max-age) value into seconds. Returns `0` for bad and/or
+ * negative input values.
  *
  * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#tosec-ttl-helper
  */
 export declare const toSec: (ttl: TTL) => number;
+/**
+ * Converts a `TTL` (duration) value into milliseconds. Returns `0` for bad
+ * and/or negative input values.
+ *
+ * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#toms-duration-helper
+ */
+export declare const toMs: (ttl: TTL) => number;
 type ServerResponseStub = Pick<ServerResponse, 'setHeader' | 'getHeader' | 'removeHeader'> & {
     headers?: Record<string, string | Array<string>>;
 };

package/esm/http.js

@@ -133,8 +133,8 @@ const unitToSeconds = {
     w: 7 * 24 * 3600,
 };
 /**
- * Converts a `TTL` (max-age) value into seconds, and returns `0` for bad
- * and/or negative input values.
+ * Converts a `TTL` (max-age) value into seconds. Returns `0` for bad and/or
+ * negative input values.
  *
  * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#tosec-ttl-helper
  */
@@ -146,6 +146,13 @@ export const toSec = (ttl) => {
     }
     return Math.max(0, Math.round(ttl)) || 0;
 };
+/**
+ * Converts a `TTL` (duration) value into milliseconds. Returns `0` for bad
+ * and/or negative input values.
+ *
+ * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#toms-duration-helper
+ */
+export const toMs = (ttl) => toSec(ttl) * 1000;
 const toRespnseStubHeaders = (response) => {
     if (response instanceof Map) {
         return response;

package/fixIcelandicLocale.js

@@ -6,7 +6,7 @@ const fixIcelandicLocale_privates_js_1 = require("./fixIcelandicLocale.privates.
   suppoort is better than none. Partial Icelandic suppoort is better than
   none. Partial Icelandic suppoort is better than none. Partial Icelandic...
 */
-if (Intl.Collator.supportedLocalesOf(['is']).length < 1) {
+if (!Intl.Collator.supportedLocalesOf(['is']).length) {
     Intl.Collator = fixIcelandicLocale_privates_js_1._PatchedCollator;
     String.prototype.localeCompare = fixIcelandicLocale_privates_js_1._patchedStringLocaleCompare;
     Intl.NumberFormat = fixIcelandicLocale_privates_js_1._PatchedNumberFormat;
@@ -17,10 +17,15 @@ if (Intl.Collator.supportedLocalesOf(['is']).length < 1) {
     Date.prototype.toLocaleTimeString = fixIcelandicLocale_privates_js_1._patchedDateToLocaleTimeString;
 }
 /* eslint-disable @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-unnecessary-condition */
-if (Intl.ListFormat && Intl.ListFormat.supportedLocalesOf(['is']).length < 1) {
+if (Intl.ListFormat && !Intl.ListFormat.supportedLocalesOf(['is']).length) {
     Intl.ListFormat = fixIcelandicLocale_privates_js_1._PatchedListFormat;
 }
-if (Intl.PluralRules && Intl.PluralRules.supportedLocalesOf(['is']).length < 1) {
+if (Intl.PluralRules && !Intl.PluralRules.supportedLocalesOf(['is']).length) {
     Intl.PluralRules = fixIcelandicLocale_privates_js_1._PatchedPluralRules;
 }
+if (Intl.RelativeTimeFormat &&
+    !Intl.RelativeTimeFormat.supportedLocalesOf(['is']).length) {
+    Intl.RelativeTimeFormat =
+        fixIcelandicLocale_privates_js_1._PatchedRelativeTimeFormat;
+}
 /* eslint-enable @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-unnecessary-condition */

package/fixIcelandicLocale.privates.d.ts

@@ -75,3 +75,9 @@ export declare const _PatchedListFormat: {
 } & {
     $original: typeof Intl.ListFormat;
 };
+export declare const _PatchedRelativeTimeFormat: {
+    new (locales?: string | string[] | undefined, options?: Intl.RelativeTimeFormatOptions | undefined): Intl.RelativeTimeFormat;
+    supportedLocalesOf(locales?: string | string[] | undefined, options?: Intl.RelativeTimeFormatOptions | undefined): string[];
+} & {
+    $original: typeof Intl.RelativeTimeFormat;
+};

package/fixIcelandicLocale.privates.js

@@ -1,13 +1,13 @@
 "use strict";
-var _a, _b;
+var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._PatchedListFormat = exports._PatchedPluralRules = exports._patchedDateToLocaleTimeString = exports._patchedDateToLocaleDateString = exports._patchedDateToLocaleString = exports._PatchedDateTimeFormat = exports._patchedNumberToLocaleString = exports._PatchedNumberFormat = exports._patchedStringLocaleCompare = exports._PatchedCollator = void 0;
-const _Collator = Intl.Collator;
-const mapLocales = (locales) => {
+exports._PatchedRelativeTimeFormat = exports._PatchedListFormat = exports._PatchedPluralRules = exports._patchedDateToLocaleTimeString = exports._patchedDateToLocaleDateString = exports._patchedDateToLocaleString = exports._PatchedDateTimeFormat = exports._patchedNumberToLocaleString = exports._PatchedNumberFormat = exports._patchedStringLocaleCompare = exports._PatchedCollator = void 0;
+const islLocaleRe = /^isl?(?:-|$)/i;
+const mapLocales = (constr, locales) => {
     locales = typeof locales === 'string' ? [locales] : locales || [];
     for (let i = 0, loc; (loc = locales[i]); i++) {
-        const isIsLocale = /^isl?(?:-|$)/i.test(loc);
-        if (isIsLocale) {
+        const isIslLocale = islLocaleRe.test(loc);
+        if (isIslLocale) {
             // Danish feels like a "good enough" substitution for Icelandic.
             // For alphabetization, it seems to just the internal order of `Ø` and `Ö`
             // that's different, and when the `sensitivity` option is set to "base"
@@ -18,22 +18,49 @@ const mapLocales = (locales) => {
             // as fully equal to the base letter.
             return ['da'];
         }
-        if (_Collator.supportedLocalesOf(loc).length) {
+        if (constr.supportedLocalesOf(loc).length) {
             return; // no mapping needed. YOLO!
         }
     }
 };
+const patchSupportedLocalesOf = (constr) => {
+    const BASE_CHAR_CODE = 64; // 'A'.charCodeAt(0) - 1; // used for generating unique suffix for fake locales
+    const sLO = (locales, options) => {
+        let localesArr = typeof locales === 'string' ? [locales] : locales;
+        const memoIsl = [];
+        localesArr = localesArr.map((locale) => {
+            if (islLocaleRe.test(locale)) {
+                // Some engines throw a RangeError if the locale is weirdly shaped,
+                // so we must use a short, safe, unique fake locale instead,
+                // and store the actual locale in `memoIsl` for later reinsertion.
+                memoIsl.push(locale);
+                return `da-X${String.fromCharCode(BASE_CHAR_CODE + memoIsl.length)}`;
+            }
+            return locale;
+        });
+        const supportedLocales = constr.supportedLocalesOf(localesArr, options);
+        if (!memoIsl.length) {
+            return supportedLocales;
+        }
+        return supportedLocales.map((locale) => locale.startsWith('da-X') ? memoIsl.shift() : locale);
+    };
+    return sLO;
+};
 const combineParts = (parts) => parts.map(({ value }) => value).join('');
+// ===========================================================================
+// Collator
+// ===========================================================================
+const _Collator = Intl.Collator;
 const PatchedCollator = function Collator(locales, options) {
     if (!(this instanceof PatchedCollator)) {
         // @ts-expect-error  (YOLO! Can't be arsed)
         return new PatchedCollator(locales, options);
     }
-    const mappedLocales = mapLocales(locales);
-    const parent = _Collator(mappedLocales || locales, options);
+    const mappedLocales = mapLocales(_Collator, locales);
+    const super_ = _Collator(mappedLocales || locales, options);
     const mapped = !!mappedLocales;
     this.compare = (a, b) => {
-        const res1 = parent.compare(a, b);
+        const res1 = super_.compare(a, b);
         if (!mapped) {
             return res1;
         }
@@ -42,14 +69,13 @@ const PatchedCollator = function Collator(locales, options) {
         if (/\d/.test(a0 + b0)) {
             return res1;
         }
-        const res2 = parent.compare(a0, b0);
+        const res2 = super_.compare(a0, b0);
         return res2 !== 0 ? res2 : res1;
     };
-    this.resolvedOptions = () => parent.resolvedOptions();
+    this.resolvedOptions = () => super_.resolvedOptions();
 };
 PatchedCollator.prototype = { constructor: PatchedCollator };
-// Static methods (not patched since "is" is not ACTUALLY supported.)
-PatchedCollator.supportedLocalesOf = _Collator.supportedLocalesOf;
+PatchedCollator.supportedLocalesOf = /*#__PURE__*/ patchSupportedLocalesOf(_Collator);
 PatchedCollator.$original = _Collator;
 exports._PatchedCollator = PatchedCollator;
 // ---------------------------------------------------------------------------
@@ -82,24 +108,26 @@ const PatchedNumberFormat = function NumberFormat(locales, options) {
         // @ts-expect-error  (YOLO! Can't be arsed)
         return new PatchedNumberFormat(locales, options);
     }
-    const mappedLocales = mapLocales(locales);
-    const parent = _NumberFormat(mappedLocales || locales, options);
+    const mappedLocales = mapLocales(_NumberFormat, locales);
+    const super_ = _NumberFormat(mappedLocales || locales, options);
     const mapped = !!mappedLocales;
-    this.format = (value) => combineParts(this.formatToParts(value));
-    this.formatRange = (value1, value2) => combineParts(this.formatRangeToParts(value1, value2));
+    this.format = (value) => mapped ? combineParts(this.formatToParts(value)) : super_.format(value);
+    this.formatRange = (value1, value2) => mapped
+        ? combineParts(this.formatRangeToParts(value1, value2))
+        : super_.formatRange(value1, value2);
     this.formatToParts = (value) => {
-        const parts = parent.formatToParts(value);
-        return mapped ? reformatNumberParts(parent, parts) : parts;
+        const parts = super_.formatToParts(value);
+        return mapped ? reformatNumberParts(super_, parts) : parts;
     };
     this.formatRangeToParts = (value1, value2) => {
-        const parts = parent.formatRangeToParts(value1, value2);
-        return mapped ? reformatNumberParts(parent, parts) : parts;
+        const parts = super_.formatRangeToParts(value1, value2);
+        return mapped ? reformatNumberParts(super_, parts) : parts;
     };
-    this.resolvedOptions = () => parent.resolvedOptions();
+    this.resolvedOptions = () => super_.resolvedOptions();
 };
 PatchedNumberFormat.prototype = { constructor: PatchedNumberFormat };
-// Static methods (not patched since "is" is not ACTUALLY supported.)
-PatchedNumberFormat.supportedLocalesOf = _NumberFormat.supportedLocalesOf;
+PatchedNumberFormat.supportedLocalesOf =
+    /*#__PURE__*/ patchSupportedLocalesOf(_NumberFormat);
 PatchedNumberFormat.$original = _NumberFormat;
 exports._PatchedNumberFormat = PatchedNumberFormat;
 // ---------------------------------------------------------------------------
@@ -202,7 +230,7 @@ const PatchedDateTimeFormat = function DateTimeFormat(locales, options) {
         // @ts-expect-error  (YOLO! Can't be arsed)
         return new PatchedDateTimeFormat(locales, options);
     }
-    const mappedLocales = mapLocales(locales);
+    const mappedLocales = mapLocales(_DateTimeFormat, locales);
     if (options === null || options === void 0 ? void 0 : options.hour12) {
         options = {
             ...options,
@@ -210,23 +238,25 @@ const PatchedDateTimeFormat = function DateTimeFormat(locales, options) {
             hourCycle: 'h11',
         };
     }
-    const parent = _DateTimeFormat(mappedLocales || locales, options);
+    const super_ = _DateTimeFormat(mappedLocales || locales, options);
     const mapped = !!mappedLocales;
-    this.format = (value) => combineParts(this.formatToParts(value));
-    this.formatRange = (value1, value2) => combineParts(this.formatRangeToParts(value1, value2));
+    this.format = (value) => mapped ? combineParts(this.formatToParts(value)) : super_.format(value);
+    this.formatRange = (value1, value2) => mapped
+        ? combineParts(this.formatRangeToParts(value1, value2))
+        : super_.formatRange(value1, value2);
     this.formatToParts = (value) => {
-        const parts = parent.formatToParts(value);
-        return mapped ? reformatDateTimeParts(parent, parts) : parts;
+        const parts = super_.formatToParts(value);
+        return mapped ? reformatDateTimeParts(super_, parts) : parts;
     };
     this.formatRangeToParts = (value1, value2) => {
-        const parts = parent.formatRangeToParts(value1, value2);
-        return mapped ? reformatDateTimeParts(parent, parts) : parts;
+        const parts = super_.formatRangeToParts(value1, value2);
+        return mapped ? reformatDateTimeParts(super_, parts) : parts;
     };
-    this.resolvedOptions = () => parent.resolvedOptions();
+    this.resolvedOptions = () => super_.resolvedOptions();
 };
 PatchedDateTimeFormat.prototype = { constructor: PatchedDateTimeFormat };
-// Static methods (not patched since "is" is not ACTUALLY supported.)
-PatchedDateTimeFormat.supportedLocalesOf = _DateTimeFormat.supportedLocalesOf;
+PatchedDateTimeFormat.supportedLocalesOf =
+    /*#__PURE__*/ patchSupportedLocalesOf(_DateTimeFormat);
 PatchedDateTimeFormat.$original = _DateTimeFormat;
 exports._PatchedDateTimeFormat = PatchedDateTimeFormat;
 // ---------------------------------------------------------------------------
@@ -307,15 +337,14 @@ let PatchedPluralRules;
 if (_PluralRules) {
     PatchedPluralRules = (_a = class PluralRules extends _PluralRules {
             pluralIsl(n) {
+                n = n < 0 ? -n : n;
                 return this.ord ? 'other' : n % 10 !== 1 || n % 100 === 11 ? 'other' : 'one';
             }
             constructor(locales, options) {
-                const mappedLocales = mapLocales(locales);
+                const mappedLocales = mapLocales(_PluralRules, locales);
                 super(mappedLocales || locales, options);
                 this.mapped = !!mappedLocales;
                 this.ord = (options === null || options === void 0 ? void 0 : options.type) === 'ordinal';
-                this.select = this.select.bind(this);
-                this.selectRange = this.selectRange.bind(this);
             }
             select(n) {
                 if (this.mapped) {
@@ -333,6 +362,7 @@ if (_PluralRules) {
                 return super.selectRange(n, n2);
             }
         },
+        _a.supportedLocalesOf = patchSupportedLocalesOf(_PluralRules),
         _a.$original = _PluralRules,
         _a);
 }
@@ -346,11 +376,9 @@ let PatchedListFormat;
 if (_ListFormat) {
     PatchedListFormat = (_b = class ListFormat extends _ListFormat {
             constructor(locales, options) {
-                const mappedLocales = mapLocales(locales);
+                const mappedLocales = mapLocales(_ListFormat, locales);
                 super(mappedLocales || locales, options);
                 this.mapped = !!mappedLocales;
-                this.format = this.format.bind(this);
-                this.formatToParts = this.formatToParts.bind(this);
             }
             format(list) {
                 return this.mapped ? combineParts(this.formatToParts(list)) : super.format(list);
@@ -359,8 +387,8 @@ if (_ListFormat) {
                 const parts = super.formatToParts(list);
                 if (this.mapped) {
                     for (const item of parts) {
-                        const { value } = item;
-                        if (item.type === 'literal' && (value === ' el. ' || value === ' eller ')) {
+                        const { type, value } = item;
+                        if (type === 'literal' && (value === ' el. ' || value === ' eller ')) {
                             item.value = ' eða ';
                         }
                     }
@@ -368,7 +396,112 @@ if (_ListFormat) {
                 return parts;
             }
         },
+        _b.supportedLocalesOf = patchSupportedLocalesOf(_ListFormat),
         _b.$original = _ListFormat,
         _b);
 }
 exports._PatchedListFormat = PatchedListFormat;
+// ===========================================================================
+// RelativeTimeFormat
+// ===========================================================================
+const _RelativeTimeFormat = Intl.RelativeTimeFormat;
+let PatchedRelativeTimeFormat;
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+if (_RelativeTimeFormat) {
+    let pluralIsl;
+    let numFormatIsl;
+    const islUnits = {
+        year: [['ári', 'árum', 'ár', 'ár'], ''],
+        quarter: [['ársfjórðungi', 'ársfjórðungum', 'ársfjórðung', 'ársfjórðunga'], 'ársfj.'],
+        month: [['mánuði', 'mánuðum', 'mánuð', 'mánuði'], 'mán.'],
+        week: [['viku', 'vikum', 'viku', 'vikur'], ''],
+        day: [['degi', 'dögum', 'dag', 'daga'], ''],
+        hour: [['klukkustund', 'klukkustundum', 'klukkustund', 'klukkustundir'], 'klst.'],
+        minute: [['mínútu', 'mínútum', 'mínútu', 'mínútur'], 'mín.'],
+        second: [['sekúndu', 'sekúndum', 'sekúndu', 'sekúndur'], 'sek.'],
+    };
+    const phrases = {
+        nu: 'núna',
+        'næste år': 'á næsta ári',
+        'sidste år': 'á síðasta ári',
+        'i år': 'á þessu ári',
+        'sidste kvartal': 'síðasti ársfjórðungur',
+        'dette kvartal': 'þessi ársfjórðungur',
+        'næste kvartal': 'næsti ársfjórðungur',
+        'sidste kvt.': 'síðasti ársfj.',
+        'dette kvt.': 'þessi ársfj.',
+        'næste kvt.': 'næsti ársfj.',
+        'sidste måned': 'í síðasta mánuði',
+        'denne måned': 'í þessum mánuði',
+        'næste måned': 'í næsta mánuði',
+        'sidste md.': 'í síðasta mán.',
+        'denne md.': 'í þessum mán.',
+        'næste md.': 'í næsta mán.',
+        'sidste uge': 'í síðustu viku',
+        'denne uge': 'í þessari viku',
+        'næste uge': 'í næstu viku',
+        'i forgårs': 'í fyrradag',
+        'i går': 'í gær',
+        'i dag': 'í dag',
+        'i morgen': 'á morgun',
+        'i overmorgen': 'eftir tvo daga',
+        'denne time': 'þessa stundina',
+        'dette minut': 'á þessari mínútu',
+    };
+    PatchedRelativeTimeFormat = (_c = class RelativeTimeFormat extends _RelativeTimeFormat {
+            constructor(locales, options) {
+                const mappedLocales = mapLocales(_RelativeTimeFormat, locales);
+                super(mappedLocales || locales, options);
+                this.mapped = !!mappedLocales;
+            }
+            format(value, unit) {
+                return this.mapped
+                    ? combineParts(this.formatToParts(value, unit))
+                    : super.format(value, unit);
+            }
+            // eslint-disable-next-line complexity
+            formatToParts(value, unit) {
+                const parts = super.formatToParts(value, unit);
+                if (!this.mapped) {
+                    return parts;
+                }
+                if (!pluralIsl) {
+                    pluralIsl = new exports._PatchedPluralRules('is');
+                }
+                if (!numFormatIsl) {
+                    numFormatIsl = new exports._PatchedNumberFormat('is');
+                }
+                const options = this.resolvedOptions();
+                const unitSngl = unit.replace(/s$/, '');
+                if (parts.length === 1) {
+                    const firstPart = parts[0];
+                    firstPart.value = phrases[firstPart.value] || firstPart.value;
+                    return parts;
+                }
+                const [long, short] = islUnits[unitSngl];
+                const idx = (value < 0 ? 0 : 2) + (pluralIsl.select(value) === 'one' ? 0 : 1);
+                const prefixStr = options.style === 'narrow' &&
+                    (unitSngl === 'second' || unitSngl === 'minute' || unitSngl === 'hour')
+                    ? value < 0
+                        ? '-'
+                        : '+'
+                    : value < 0
+                        ? 'fyrir '
+                        : 'eftir ';
+                const valueStr = (options.style !== 'long' && short) || long[idx];
+                const islParts = [
+                    { type: 'literal', value: prefixStr },
+                    ...numFormatIsl.formatToParts(Math.abs(value)).map((part) => {
+                        part.unit =
+                            unitSngl;
+                        return part;
+                    }),
+                    { type: 'literal', value: ` ${valueStr}` },
+                ];
+                return islParts;
+            }
+        },
+        _c.$original = _RelativeTimeFormat,
+        _c);
+}
+exports._PatchedRelativeTimeFormat = PatchedRelativeTimeFormat;

package/http.d.ts

@@ -158,12 +158,19 @@ type TTLObj = {
  */
 export type TTLConfig = TTL | TTLKeywords | TTLObj;
 /**
- * Converts a `TTL` (max-age) value into seconds, and returns `0` for bad
- * and/or negative input values.
+ * Converts a `TTL` (max-age) value into seconds. Returns `0` for bad and/or
+ * negative input values.
  *
  * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#tosec-ttl-helper
  */
 export declare const toSec: (ttl: TTL) => number;
+/**
+ * Converts a `TTL` (duration) value into milliseconds. Returns `0` for bad
+ * and/or negative input values.
+ *
+ * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#toms-duration-helper
+ */
+export declare const toMs: (ttl: TTL) => number;
 type ServerResponseStub = Pick<ServerResponse, 'setHeader' | 'getHeader' | 'removeHeader'> & {
     headers?: Record<string, string | Array<string>>;
 };

package/http.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HTTP_502_BadGateway = exports.HTTP_501_NotImplemented = exports.HTTP_500_InternalServerError = exports.HTTP_451_UnavailableForLegalReasons = exports.HTTP_431_RequestHeaderFieldsTooLarge = exports.HTTP_429_TooManyRequests = exports.HTTP_428_PreconditionRequired = exports.HTTP_426_UpgradeRequired = exports.HTTP_424_FailedDependency = exports.HTTP_423_Locked = exports.HTTP_422_UnprocessableContent = exports.HTTP_421_MisdirectedRequest = exports.HTTP_418_ImATeapot = exports.HTTP_417_ExpectationFailed = exports.HTTP_416_RangeNotSatisfiable = exports.HTTP_415_UnsupportedMediaType = exports.HTTP_414_URITooLong = exports.HTTP_413_PayloadTooLarge = exports.HTTP_412_PreconditionFailed = exports.HTTP_411_LengthRequired = exports.HTTP_410_Gone = exports.HTTP_409_Conflict = exports.HTTP_408_RequestTimeout = exports.HTTP_407_ProxyAuthenticationRequired = exports.HTTP_406_NotAcceptable = exports.HTTP_405_MethodNotAllowed = exports.HTTP_404_NotFound = exports.HTTP_403_Forbidden = exports.HTTP_401_Unauthorized = exports.HTTP_400_BadRequest = exports.HTTP_308_PermanentRedirect = exports.HTTP_307_TemporaryRedirect = exports.HTTP_304_NotModified = exports.HTTP_303_SeeOther = exports.HTTP_302_Found = exports.HTTP_301_MovedPermanently = exports.HTTP_226_IMUsed = exports.HTTP_208_AlreadyReported = exports.HTTP_207_MultiStatus = exports.HTTP_206_PartialContent = exports.HTTP_205_ResetContent = exports.HTTP_204_NoContent = exports.HTTP_203_NonAuthoritativeInformation = exports.HTTP_202_Accepted = exports.HTTP_201_Created = exports.HTTP_200_OK = exports.HTTP_103_EarlyHints = exports.HTTP_102_Processing = exports.HTTP_101_SwitchingProtocols = exports.HTTP_100_Continue = void 0;
-exports.cacheControlHeaders = exports.cacheControl = exports.toSec = exports.HTTP_511_NetworkAuthenticationRequired = exports.HTTP_510_NotExtended = exports.HTTP_508_LoopDetected = exports.HTTP_507_InsufficientStorage = exports.HTTP_506_VariantAlsoNegotiates = exports.HTTP_505_HTTPVersionNotSupported = exports.HTTP_504_GatewayTimeout = exports.HTTP_503_ServiceUnavailable = void 0;
+exports.cacheControlHeaders = exports.cacheControl = exports.toMs = exports.toSec = exports.HTTP_511_NetworkAuthenticationRequired = exports.HTTP_510_NotExtended = exports.HTTP_508_LoopDetected = exports.HTTP_507_InsufficientStorage = exports.HTTP_506_VariantAlsoNegotiates = exports.HTTP_505_HTTPVersionNotSupported = exports.HTTP_504_GatewayTimeout = exports.HTTP_503_ServiceUnavailable = void 0;
 // INFORMATION
 /** The client should continue the request or ignore the response if the request is already finished. */
 exports.HTTP_100_Continue = 100;
@@ -137,8 +137,8 @@ const unitToSeconds = {
     w: 7 * 24 * 3600,
 };
 /**
- * Converts a `TTL` (max-age) value into seconds, and returns `0` for bad
- * and/or negative input values.
+ * Converts a `TTL` (max-age) value into seconds. Returns `0` for bad and/or
+ * negative input values.
  *
  * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#tosec-ttl-helper
  */
@@ -151,6 +151,14 @@ const toSec = (ttl) => {
     return Math.max(0, Math.round(ttl)) || 0;
 };
 exports.toSec = toSec;
+/**
+ * Converts a `TTL` (duration) value into milliseconds. Returns `0` for bad
+ * and/or negative input values.
+ *
+ * @see https://github.com/reykjavikcity/webtools/blob/v0.1/README.md#toms-duration-helper
+ */
+const toMs = (ttl) => (0, exports.toSec)(ttl) * 1000;
+exports.toMs = toMs;
 const toRespnseStubHeaders = (response) => {
     if (response instanceof Map) {
         return response;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@reykjavik/webtools",
-	"version": "0.1.29",
+	"version": "0.1.31",
 	"description": "Misc. JS/TS helpers used by Reykjavík City's web dev teams.",
 	"main": "index.js",
 	"repository": "ssh://git@github.com:reykjavikcity/webtools.git",
@@ -11,7 +11,7 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@reykjavik/hanna-utils": "^0.2.3"
+		"@reykjavik/hanna-utils": "^0.2.16"
 	},
 	"peerDependencies": {
 		"@remix-run/react": "^2.6.0",