@reykjavik/webtools 0.1.14 → 0.1.16

package/CHANGELOG.md

@@ -4,18 +4,29 @@
 
 - ... <!-- Add new lines here. -->
 
-## 0.1.14
+## 0.1.16
 
-_2024-03-06_
+_2024-03-09_
+
+- `@reykjavik/webtools/fixIcelandicLocale`:
+  - fix: Add missing `DateTimeFormat.format*ToParts` methods, fix bugs
+  - refctor: Reduce code-size and simplify logic by dog-fooding `*ToParts`
+    methods internally
+
+## 0.1.15
+
+_2024-03-08_
 
-- fix: Remove unneccessary `@__PURE__` pragma
-- fix: List `fixIcelandicLocale.js` in `pkg.sideEffects`
+- `@reykjavik/webtools/fixIcelandicLocale`:
+  - feat: Patch `Intl.Collator`
+  - feat: Patch `Intl.NumberFormat` and `Number.prototype.toLocaleString`
+  - feat: Patch `Intl.DateTimeFormat` and `Date.prototype.toLocaleDateString`
 
-## 0.1.13
+## 0.1.13 – 0.1.14
 
 _2024-03-06_
 
-- feat: Add `@reykjavik/webtools/fixIcelandicLocale` polyfill module
+- feat: Add `@reykjavik/webtools/fixIcelandicLocale` Chrome paching module
 
 ## 0.1.12
 
@@ -35,7 +46,7 @@ _2024-02-14_
 
 _2024-02-14_
 
-- `@reykjavik/webtools/http`
+- `@reykjavik/webtools/http`:
   - feat: Add the rest of the more obscure HTTP status constants (WebDAV,
     etc.)
   - fix: Add `429`, `432`, `451` to `HTTP_CLIENT_ERROR_ALL` type
@@ -44,7 +55,7 @@ _2024-02-14_
 
 _2023-04-27_
 
-- `@reykjavik/webtools/http`
+- `@reykjavik/webtools/http`:
   - feat: Add `toSec` TTL helper
 
 ## 0.1.7 – 0.1.8

package/README.md

@@ -32,6 +32,7 @@ bun add @reykjavik/webtools
   - [`vanillaClassNested`](#vanillaclassnested)
   - [`vanillaNest`](#vanillanest)
 - [`@reykjavik/webtools/fixIcelandicLocale`](#reykjavikwebtoolsfixicelandiclocale)
+  - [Limitations](#limitations)
 - [Framework Specific Tools](#framework-specific-tools)
   - [Next.js Tools](#nextjs-tools)
 - [Contributing](#contributing)
@@ -427,21 +428,58 @@ vanillaGlobal(`
 
 ## `@reykjavik/webtools/fixIcelandicLocale`
 
-Polyfill for `String.prototype.localeCompare` to provide support for the
-`'is'` locale in browsers that don't support it (\*cough* Chrome \*cough*).
+As of early 2004, Google Chrome still does not support the Icelandic locale
+`is`/`is-IS` in any way. Meanwhile other browsers have supported it for over a
+decade.
 
-At the top of your app's entry point, "side-effect import" this module to
-apply the polyfill:
+This module does attempts to 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.DateTimeFormat` and `Date.prototype.toLocaleDateString`
+
+This provides usable (but not perfect) results, with some caveats listed
+below.
+
+To apply these patches, simply "side-effect import" this module at the top of
+your app's entry point:
 
 ```ts
 import '@reykjavik/webtools/fixIcelandicLocale';
 
-// Then continue with your day
-// and use `localeCompare` as you normally would...
+// Then continue with your day and use `localeCompare` and Intl.Collator,
+// as you normally would. (See "limitations" below.)
 ```
 
-**NOTE** The polyfill is only applied in engines that fail a simple feature
-test.
+(**NOTE** The patch is only applied in engines that fail a simple feature
+detection test.)
+
+### Limitations
+
+**`Intl.Collator` and `localeCompare`:**
+
+- When the `sensitivty` option is set to `"base"` or `"accent"`, it will
+  incorrectly treat `ð` and `d` as the same letter, and the acute-accented
+  characters `á`, `é`, `í`, `ó`, `ú` and `ý` get lumped in with their
+  non-accented counterparts.
+
+**`Intl.NumberFormat` and `toLocaleString`:**
+
+- The `style: "unit"` option is not supported and prints units in Danish. (Soo
+  many units and unit-variants…)
+- The `currencyDisplay: "name"` option is not supported and prints the
+  currency's full name in Danish.
+
+**`Intl.DateTimeFormat` and `toLocaleDateString`:**
+
+- The `month: 'narrow'` and `weekday: 'narrow'` options are not supported, and
+  print the corresponding Danish initials.
+- For `timeZoneName` the values `"long"`, `"shortGeneric"` and `"longGeneric"`
+  will appear in Danish.
+- The `timeStyle: 'full'` option prints the timezone names in Danish
+- The `dayPeriod` option is not supported and prints the day-period in Danish.
 
 ---
 

package/esm/fixIcelandicLocale.js

@@ -1,39 +1,14 @@
+import { _PatchedCollator, _PatchedDateTimeFormat, _patchedLocaleCompare, _PatchedNumberFormat, _patchedToLocaleDateString, _patchedToLocaleString, } from './fixIcelandicLocale.privates.js';
 /*
-  TODO: Also attempt to patch these Classes:
-
-  - `Intl.Collator`
-    Same kind of magic as `String.prototype.localeCompare`
-
-  - `Intl.NumberFormat`
-    Only support default plain-number and percent formatting,
-    not currency or unit — UNLESS we do some string-replacement hackery,
-    and then we may need to handle the possibility of locales arrays
-    already containing Danish ahead of "is".
-
-  - `Intl.DateTimeFormat`
-    Possible with some mad-scientist string-replacement hackery and
-    the `locales` array detection magic, as mentioned above.
-
-  Mantra: Partial Icelandic suppoort is better than no Icelandic support.
+  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...
 */
-const locAliases = {
-    // Danish is good enough substitution for Icelandic
-    is: 'da',
-    'is-is': 'da',
-};
-const mapLocales = (locales) => {
-    locales = typeof locales === 'string' ? [locales] : locales || [];
-    return locales.map((loc) => locAliases[loc.toLowerCase()] || loc);
-};
-// ---------------------------------------------------------------------------
-if ('ö'.localeCompare('p', 'is') < 0) {
-    const _localeCompare = String.prototype.localeCompare;
-    /**
-     * Polyfill for String.prototype.localeCompare for the 'is' locale
-     * in browsers that don't support it (\*cough* Chrome \*cough*).
-     */
-    String.prototype.localeCompare = function (that, locales, options) {
-        return _localeCompare.call(this, that, mapLocales(locales), options);
-    };
+if (Intl.Collator.supportedLocalesOf(['is']).length < 1) {
+    Intl.Collator = _PatchedCollator;
+    String.prototype.localeCompare = _patchedLocaleCompare;
+    Intl.NumberFormat = _PatchedNumberFormat;
+    Number.prototype.toLocaleString = _patchedToLocaleString;
+    Intl.DateTimeFormat = _PatchedDateTimeFormat;
+    Date.prototype.toLocaleDateString = _patchedToLocaleDateString;
 }
-export {};

package/esm/fixIcelandicLocale.privates.d.ts

@@ -0,0 +1,45 @@
+export declare const _PatchedCollator: {
+    (locales?: string | string[] | undefined, options?: Intl.CollatorOptions | undefined): Intl.Collator;
+    new (locales?: string | string[] | undefined, options?: Intl.CollatorOptions | undefined): Intl.Collator;
+    supportedLocalesOf(locales: string | string[], options?: Intl.CollatorOptions | undefined): string[];
+} & {
+    $original: typeof Intl.Collator;
+};
+export declare const _patchedLocaleCompare: {
+    (this: string, that: string, locales?: string | Array<string>, options?: Intl.CollatorOptions): number;
+    $original: {
+        (that: string): number;
+        (that: string, locales?: string | string[] | undefined, options?: Intl.CollatorOptions | undefined): number;
+    };
+};
+export declare const _PatchedNumberFormat: {
+    (locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined): Intl.NumberFormat;
+    new (locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined): Intl.NumberFormat;
+    supportedLocalesOf(locales: string | string[], options?: Intl.NumberFormatOptions | undefined): string[];
+    readonly prototype: Intl.NumberFormat;
+} & {
+    $original: typeof Intl.NumberFormat;
+};
+export declare const _patchedToLocaleString: {
+    (this: number, locales?: string | Array<string>, options?: Intl.NumberFormatOptions): string;
+    $original: {
+        (locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined): string;
+        (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions | undefined): string;
+    };
+};
+export declare const _PatchedDateTimeFormat: {
+    (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): Intl.DateTimeFormat;
+    new (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): Intl.DateTimeFormat;
+    supportedLocalesOf(locales: string | string[], options?: Intl.DateTimeFormatOptions | undefined): string[];
+    readonly prototype: Intl.DateTimeFormat;
+} & {
+    $original: typeof Intl.DateTimeFormat;
+};
+export declare const _patchedToLocaleDateString: {
+    (this: Date, locales?: string | Array<string>, options?: Intl.DateTimeFormatOptions): string;
+    $original: {
+        (): string;
+        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+    };
+};

package/esm/fixIcelandicLocale.privates.js

@@ -0,0 +1,226 @@
+const _Collator = Intl.Collator;
+const _NumberFormat = Intl.NumberFormat;
+const _DateTimeFormat = Intl.DateTimeFormat;
+const mapLocales = (locales) => {
+    locales = typeof locales === 'string' ? [locales] : locales || [];
+    for (let i = 0, loc; (loc = locales[i]); i++) {
+        const isIsLocale = /^isl?(?:-|$)/i.test(loc);
+        if (isIsLocale) {
+            // 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"
+            // or "accent" then `ð` is consiered a variant of `d` and the letters
+            // á, é, í, ó, ú, and ý are not treated as separate letters but simply
+            // variants of a, e, i, o, u, and y.
+            return ['da'];
+        }
+        if (_Collator.supportedLocalesOf(loc).length) {
+            return; // no mapping needed. YOLO!
+        }
+    }
+};
+const combineParts = (parts) => parts.map(({ value }) => value).join('');
+// ===========================================================================
+// Collator
+// ===========================================================================
+const PatchedCollator = function Collator(locales, options) {
+    locales = mapLocales(locales) || locales;
+    const instance = new _Collator(locales, options);
+    Object.setPrototypeOf(instance, PatchedCollator.prototype);
+    return instance;
+};
+PatchedCollator.prototype = Object.create(_Collator.prototype);
+PatchedCollator.prototype.constructor = PatchedCollator;
+// Static methods (not patched since "is" is not ACTUALLY supported.)
+PatchedCollator.supportedLocalesOf = _Collator.supportedLocalesOf;
+PatchedCollator.$original = _Collator;
+export const _PatchedCollator = PatchedCollator;
+// ---------------------------------------------------------------------------
+const _localeCompare = String.prototype.localeCompare;
+export const _patchedLocaleCompare = function localeCompare(that, locales, options) {
+    return _PatchedCollator(locales, options).compare(this, that);
+};
+_patchedLocaleCompare.$original = _localeCompare;
+// ===========================================================================
+// NumberFormat
+// ===========================================================================
+const reformatNumberParts = function (parts) {
+    if (!this.mapped) {
+        return parts;
+    }
+    const options = this.super.resolvedOptions();
+    if (options.style === 'currency' && options.currencyDisplay === 'symbol') {
+        const currency = options.currency;
+        if (currency === 'DKK' || currency === 'ISK') {
+            parts.forEach((part) => {
+                if (part.type === 'currency') {
+                    part.value = currency === 'DKK' ? 'DKK' : 'kr.';
+                }
+            });
+        }
+    }
+    return parts;
+};
+const PatchedNumberFormat = function NumberFormat(locales, options) {
+    if (!(this instanceof PatchedNumberFormat)) {
+        // @ts-expect-error  (YOLO! Can't be arsed)
+        return new PatchedNumberFormat(locales, options);
+    }
+    const mappedLocales = mapLocales(locales);
+    this.super = _NumberFormat(mappedLocales || locales, options);
+    this.mapped = !!mappedLocales;
+};
+// This is all very hacky, but extending the class *AND* preseving the
+// ability to instantiate without `new` is a bit of a pain.
+// Eagerly interested in finding a better way to do this.
+const numberFormatProto = {
+    constructor: PatchedNumberFormat,
+    format(value) {
+        return combineParts(this.formatToParts(value));
+    },
+    formatRange(value1, value2) {
+        return combineParts(this.formatRangeToParts(value1, value2));
+    },
+    formatToParts(value) {
+        return reformatNumberParts.call(this, this.super.formatToParts(value));
+    },
+    formatRangeToParts(value1, value2) {
+        return reformatNumberParts.call(this, this.super.formatRangeToParts(value1, value2));
+    },
+    resolvedOptions() {
+        return this.super.resolvedOptions();
+    },
+};
+PatchedNumberFormat.prototype = numberFormatProto;
+// Static methods (not patched since "is" is not ACTUALLY supported.)
+PatchedNumberFormat.supportedLocalesOf = _NumberFormat.supportedLocalesOf;
+PatchedNumberFormat.$original = _NumberFormat;
+export const _PatchedNumberFormat = PatchedNumberFormat;
+// ---------------------------------------------------------------------------
+const _toLocaleString = Number.prototype.toLocaleString;
+export const _patchedToLocaleString = function toLocaleString(locales, options) {
+    return _PatchedNumberFormat(locales, options).format(this);
+};
+_patchedToLocaleString.$original = _toLocaleString;
+// ===========================================================================
+// DateTimeFormat
+// ===========================================================================
+const months = {
+    jan: 'janúar',
+    feb: 'febrúar',
+    mar: 'mars',
+    apr: 'apríl',
+    maj: 'maí',
+    jun: 'júní',
+    jul: 'júlí',
+    aug: 'ágúst',
+    // sep: 'september', // is the same
+    okt: 'október',
+    nov: 'nóvember',
+    dec: 'desember',
+};
+const weekdays = {
+    man: 'mánudagur',
+    tir: 'þriðjudagur',
+    ons: 'miðvikudagur',
+    tor: 'fimmtudagur',
+    fre: 'föstudagur',
+    lør: 'laugardagur',
+    søn: 'sunnudagur',
+};
+const partMappers = {
+    month: (value) => {
+        const islMonth = months[value.slice(0, 3)];
+        if (islMonth) {
+            return value.endsWith('.') ? `${islMonth.slice(0, 3)}.` : islMonth;
+        }
+    },
+    weekday: (value) => {
+        const isl = weekdays[value.slice(0, 3)];
+        if (isl) {
+            return value.endsWith('.') ? `${isl.slice(0, 3)}.` : isl;
+        }
+    },
+    era: (value) => {
+        if (!value.endsWith('.')) {
+            return value.length === 3
+                ? `${value[0]}.k.`
+                : value[0] === 'f'
+                    ? 'fyrir Krist'
+                    : 'eftir Krist';
+        }
+    },
+    dayPeriod: (value) => {
+        return { AM: 'f.h.', PM: 'e.h.' }[value] || value;
+    },
+    literal: (value, lastType) => {
+        if (value === ' den ') {
+            return 'inn ';
+        }
+        else if (value === '.' && (lastType === 'hour' || lastType === 'minute')) {
+            return ':';
+        }
+    },
+};
+const reformatDateTimeParts = function (parts) {
+    if (!this.mapped) {
+        return parts;
+    }
+    parts.forEach((part, idx) => {
+        var _a;
+        const mapper = partMappers[part.type];
+        const newValue = mapper && mapper(part.value, (_a = parts[idx - 1]) === null || _a === void 0 ? void 0 : _a.type);
+        if (newValue != null) {
+            part.value = newValue;
+        }
+    });
+    return parts;
+};
+const PatchedDateTimeFormat = function DateTimeFormat(locales, options) {
+    if (!(this instanceof PatchedDateTimeFormat)) {
+        // @ts-expect-error  (YOLO! Can't be arsed)
+        return new PatchedDateTimeFormat(locales, options);
+    }
+    const mappedLocales = mapLocales(locales);
+    if (options === null || options === void 0 ? void 0 : options.hour12) {
+        options = {
+            ...options,
+            hour12: undefined,
+            hourCycle: 'h11',
+        };
+    }
+    this.super = _DateTimeFormat(mappedLocales || locales, options);
+    this.mapped = !!mappedLocales;
+};
+// This is all very hacky, but extending the class *AND* preseving the
+// ability to instantiate without `new` is a bit of a pain.
+// Eagerly interested in finding a better way to do this.
+const dateTimeFormatProto = {
+    constructor: PatchedDateTimeFormat,
+    format(value) {
+        return combineParts(this.formatToParts(value));
+    },
+    formatRange(value1, value2) {
+        return combineParts(this.formatRangeToParts(value1, value2));
+    },
+    formatToParts(value) {
+        return reformatDateTimeParts.call(this, this.super.formatToParts(value));
+    },
+    formatRangeToParts(value1, value2) {
+        return reformatDateTimeParts.call(this, this.super.formatRangeToParts(value1, value2));
+    },
+    resolvedOptions() {
+        return this.super.resolvedOptions();
+    },
+};
+PatchedDateTimeFormat.prototype = dateTimeFormatProto;
+// Static methods (not patched since "is" is not ACTUALLY supported.)
+PatchedDateTimeFormat.supportedLocalesOf = _DateTimeFormat.supportedLocalesOf;
+PatchedDateTimeFormat.$original = _DateTimeFormat;
+export const _PatchedDateTimeFormat = PatchedDateTimeFormat;
+// ---------------------------------------------------------------------------
+const _toLocaleDateString = Date.prototype.toLocaleDateString;
+export const _patchedToLocaleDateString = function toLocaleDateString(locales, options) {
+    return _PatchedDateTimeFormat(locales, options).format(this);
+};
+_patchedToLocaleDateString.$original = _toLocaleDateString;

package/fixIcelandicLocale.d.ts

@@ -1,2 +1 @@
-declare const locAliases: Record<string, string>;
-declare const mapLocales: (locales: string | Array<string> | undefined) => string[];
+export {};

package/fixIcelandicLocale.js

@@ -1,39 +1,16 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fixIcelandicLocale_privates_js_1 = require("./fixIcelandicLocale.privates.js");
 /*
-  TODO: Also attempt to patch these Classes:
-
-  - `Intl.Collator`
-    Same kind of magic as `String.prototype.localeCompare`
-
-  - `Intl.NumberFormat`
-    Only support default plain-number and percent formatting,
-    not currency or unit — UNLESS we do some string-replacement hackery,
-    and then we may need to handle the possibility of locales arrays
-    already containing Danish ahead of "is".
-
-  - `Intl.DateTimeFormat`
-    Possible with some mad-scientist string-replacement hackery and
-    the `locales` array detection magic, as mentioned above.
-
-  Mantra: Partial Icelandic suppoort is better than no Icelandic support.
+  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...
 */
-const locAliases = {
-    // Danish is good enough substitution for Icelandic
-    is: 'da',
-    'is-is': 'da',
-};
-const mapLocales = (locales) => {
-    locales = typeof locales === 'string' ? [locales] : locales || [];
-    return locales.map((loc) => locAliases[loc.toLowerCase()] || loc);
-};
-// ---------------------------------------------------------------------------
-if ('ö'.localeCompare('p', 'is') < 0) {
-    const _localeCompare = String.prototype.localeCompare;
-    /**
-     * Polyfill for String.prototype.localeCompare for the 'is' locale
-     * in browsers that don't support it (\*cough* Chrome \*cough*).
-     */
-    String.prototype.localeCompare = function (that, locales, options) {
-        return _localeCompare.call(this, that, mapLocales(locales), options);
-    };
+if (Intl.Collator.supportedLocalesOf(['is']).length < 1) {
+    Intl.Collator = fixIcelandicLocale_privates_js_1._PatchedCollator;
+    String.prototype.localeCompare = fixIcelandicLocale_privates_js_1._patchedLocaleCompare;
+    Intl.NumberFormat = fixIcelandicLocale_privates_js_1._PatchedNumberFormat;
+    Number.prototype.toLocaleString = fixIcelandicLocale_privates_js_1._patchedToLocaleString;
+    Intl.DateTimeFormat = fixIcelandicLocale_privates_js_1._PatchedDateTimeFormat;
+    Date.prototype.toLocaleDateString = fixIcelandicLocale_privates_js_1._patchedToLocaleDateString;
 }

package/fixIcelandicLocale.privates.d.ts

@@ -0,0 +1,45 @@
+export declare const _PatchedCollator: {
+    (locales?: string | string[] | undefined, options?: Intl.CollatorOptions | undefined): Intl.Collator;
+    new (locales?: string | string[] | undefined, options?: Intl.CollatorOptions | undefined): Intl.Collator;
+    supportedLocalesOf(locales: string | string[], options?: Intl.CollatorOptions | undefined): string[];
+} & {
+    $original: typeof Intl.Collator;
+};
+export declare const _patchedLocaleCompare: {
+    (this: string, that: string, locales?: string | Array<string>, options?: Intl.CollatorOptions): number;
+    $original: {
+        (that: string): number;
+        (that: string, locales?: string | string[] | undefined, options?: Intl.CollatorOptions | undefined): number;
+    };
+};
+export declare const _PatchedNumberFormat: {
+    (locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined): Intl.NumberFormat;
+    new (locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined): Intl.NumberFormat;
+    supportedLocalesOf(locales: string | string[], options?: Intl.NumberFormatOptions | undefined): string[];
+    readonly prototype: Intl.NumberFormat;
+} & {
+    $original: typeof Intl.NumberFormat;
+};
+export declare const _patchedToLocaleString: {
+    (this: number, locales?: string | Array<string>, options?: Intl.NumberFormatOptions): string;
+    $original: {
+        (locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined): string;
+        (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions | undefined): string;
+    };
+};
+export declare const _PatchedDateTimeFormat: {
+    (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): Intl.DateTimeFormat;
+    new (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): Intl.DateTimeFormat;
+    supportedLocalesOf(locales: string | string[], options?: Intl.DateTimeFormatOptions | undefined): string[];
+    readonly prototype: Intl.DateTimeFormat;
+} & {
+    $original: typeof Intl.DateTimeFormat;
+};
+export declare const _patchedToLocaleDateString: {
+    (this: Date, locales?: string | Array<string>, options?: Intl.DateTimeFormatOptions): string;
+    $original: {
+        (): string;
+        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+        (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+    };
+};

package/fixIcelandicLocale.privates.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._patchedToLocaleDateString = exports._PatchedDateTimeFormat = exports._patchedToLocaleString = exports._PatchedNumberFormat = exports._patchedLocaleCompare = exports._PatchedCollator = void 0;
+const _Collator = Intl.Collator;
+const _NumberFormat = Intl.NumberFormat;
+const _DateTimeFormat = Intl.DateTimeFormat;
+const mapLocales = (locales) => {
+    locales = typeof locales === 'string' ? [locales] : locales || [];
+    for (let i = 0, loc; (loc = locales[i]); i++) {
+        const isIsLocale = /^isl?(?:-|$)/i.test(loc);
+        if (isIsLocale) {
+            // 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"
+            // or "accent" then `ð` is consiered a variant of `d` and the letters
+            // á, é, í, ó, ú, and ý are not treated as separate letters but simply
+            // variants of a, e, i, o, u, and y.
+            return ['da'];
+        }
+        if (_Collator.supportedLocalesOf(loc).length) {
+            return; // no mapping needed. YOLO!
+        }
+    }
+};
+const combineParts = (parts) => parts.map(({ value }) => value).join('');
+// ===========================================================================
+// Collator
+// ===========================================================================
+const PatchedCollator = function Collator(locales, options) {
+    locales = mapLocales(locales) || locales;
+    const instance = new _Collator(locales, options);
+    Object.setPrototypeOf(instance, PatchedCollator.prototype);
+    return instance;
+};
+PatchedCollator.prototype = Object.create(_Collator.prototype);
+PatchedCollator.prototype.constructor = PatchedCollator;
+// Static methods (not patched since "is" is not ACTUALLY supported.)
+PatchedCollator.supportedLocalesOf = _Collator.supportedLocalesOf;
+PatchedCollator.$original = _Collator;
+exports._PatchedCollator = PatchedCollator;
+// ---------------------------------------------------------------------------
+const _localeCompare = String.prototype.localeCompare;
+const _patchedLocaleCompare = function localeCompare(that, locales, options) {
+    return (0, exports._PatchedCollator)(locales, options).compare(this, that);
+};
+exports._patchedLocaleCompare = _patchedLocaleCompare;
+exports._patchedLocaleCompare.$original = _localeCompare;
+// ===========================================================================
+// NumberFormat
+// ===========================================================================
+const reformatNumberParts = function (parts) {
+    if (!this.mapped) {
+        return parts;
+    }
+    const options = this.super.resolvedOptions();
+    if (options.style === 'currency' && options.currencyDisplay === 'symbol') {
+        const currency = options.currency;
+        if (currency === 'DKK' || currency === 'ISK') {
+            parts.forEach((part) => {
+                if (part.type === 'currency') {
+                    part.value = currency === 'DKK' ? 'DKK' : 'kr.';
+                }
+            });
+        }
+    }
+    return parts;
+};
+const PatchedNumberFormat = function NumberFormat(locales, options) {
+    if (!(this instanceof PatchedNumberFormat)) {
+        // @ts-expect-error  (YOLO! Can't be arsed)
+        return new PatchedNumberFormat(locales, options);
+    }
+    const mappedLocales = mapLocales(locales);
+    this.super = _NumberFormat(mappedLocales || locales, options);
+    this.mapped = !!mappedLocales;
+};
+// This is all very hacky, but extending the class *AND* preseving the
+// ability to instantiate without `new` is a bit of a pain.
+// Eagerly interested in finding a better way to do this.
+const numberFormatProto = {
+    constructor: PatchedNumberFormat,
+    format(value) {
+        return combineParts(this.formatToParts(value));
+    },
+    formatRange(value1, value2) {
+        return combineParts(this.formatRangeToParts(value1, value2));
+    },
+    formatToParts(value) {
+        return reformatNumberParts.call(this, this.super.formatToParts(value));
+    },
+    formatRangeToParts(value1, value2) {
+        return reformatNumberParts.call(this, this.super.formatRangeToParts(value1, value2));
+    },
+    resolvedOptions() {
+        return this.super.resolvedOptions();
+    },
+};
+PatchedNumberFormat.prototype = numberFormatProto;
+// Static methods (not patched since "is" is not ACTUALLY supported.)
+PatchedNumberFormat.supportedLocalesOf = _NumberFormat.supportedLocalesOf;
+PatchedNumberFormat.$original = _NumberFormat;
+exports._PatchedNumberFormat = PatchedNumberFormat;
+// ---------------------------------------------------------------------------
+const _toLocaleString = Number.prototype.toLocaleString;
+const _patchedToLocaleString = function toLocaleString(locales, options) {
+    return (0, exports._PatchedNumberFormat)(locales, options).format(this);
+};
+exports._patchedToLocaleString = _patchedToLocaleString;
+exports._patchedToLocaleString.$original = _toLocaleString;
+// ===========================================================================
+// DateTimeFormat
+// ===========================================================================
+const months = {
+    jan: 'janúar',
+    feb: 'febrúar',
+    mar: 'mars',
+    apr: 'apríl',
+    maj: 'maí',
+    jun: 'júní',
+    jul: 'júlí',
+    aug: 'ágúst',
+    // sep: 'september', // is the same
+    okt: 'október',
+    nov: 'nóvember',
+    dec: 'desember',
+};
+const weekdays = {
+    man: 'mánudagur',
+    tir: 'þriðjudagur',
+    ons: 'miðvikudagur',
+    tor: 'fimmtudagur',
+    fre: 'föstudagur',
+    lør: 'laugardagur',
+    søn: 'sunnudagur',
+};
+const partMappers = {
+    month: (value) => {
+        const islMonth = months[value.slice(0, 3)];
+        if (islMonth) {
+            return value.endsWith('.') ? `${islMonth.slice(0, 3)}.` : islMonth;
+        }
+    },
+    weekday: (value) => {
+        const isl = weekdays[value.slice(0, 3)];
+        if (isl) {
+            return value.endsWith('.') ? `${isl.slice(0, 3)}.` : isl;
+        }
+    },
+    era: (value) => {
+        if (!value.endsWith('.')) {
+            return value.length === 3
+                ? `${value[0]}.k.`
+                : value[0] === 'f'
+                    ? 'fyrir Krist'
+                    : 'eftir Krist';
+        }
+    },
+    dayPeriod: (value) => {
+        return { AM: 'f.h.', PM: 'e.h.' }[value] || value;
+    },
+    literal: (value, lastType) => {
+        if (value === ' den ') {
+            return 'inn ';
+        }
+        else if (value === '.' && (lastType === 'hour' || lastType === 'minute')) {
+            return ':';
+        }
+    },
+};
+const reformatDateTimeParts = function (parts) {
+    if (!this.mapped) {
+        return parts;
+    }
+    parts.forEach((part, idx) => {
+        var _a;
+        const mapper = partMappers[part.type];
+        const newValue = mapper && mapper(part.value, (_a = parts[idx - 1]) === null || _a === void 0 ? void 0 : _a.type);
+        if (newValue != null) {
+            part.value = newValue;
+        }
+    });
+    return parts;
+};
+const PatchedDateTimeFormat = function DateTimeFormat(locales, options) {
+    if (!(this instanceof PatchedDateTimeFormat)) {
+        // @ts-expect-error  (YOLO! Can't be arsed)
+        return new PatchedDateTimeFormat(locales, options);
+    }
+    const mappedLocales = mapLocales(locales);
+    if (options === null || options === void 0 ? void 0 : options.hour12) {
+        options = {
+            ...options,
+            hour12: undefined,
+            hourCycle: 'h11',
+        };
+    }
+    this.super = _DateTimeFormat(mappedLocales || locales, options);
+    this.mapped = !!mappedLocales;
+};
+// This is all very hacky, but extending the class *AND* preseving the
+// ability to instantiate without `new` is a bit of a pain.
+// Eagerly interested in finding a better way to do this.
+const dateTimeFormatProto = {
+    constructor: PatchedDateTimeFormat,
+    format(value) {
+        return combineParts(this.formatToParts(value));
+    },
+    formatRange(value1, value2) {
+        return combineParts(this.formatRangeToParts(value1, value2));
+    },
+    formatToParts(value) {
+        return reformatDateTimeParts.call(this, this.super.formatToParts(value));
+    },
+    formatRangeToParts(value1, value2) {
+        return reformatDateTimeParts.call(this, this.super.formatRangeToParts(value1, value2));
+    },
+    resolvedOptions() {
+        return this.super.resolvedOptions();
+    },
+};
+PatchedDateTimeFormat.prototype = dateTimeFormatProto;
+// Static methods (not patched since "is" is not ACTUALLY supported.)
+PatchedDateTimeFormat.supportedLocalesOf = _DateTimeFormat.supportedLocalesOf;
+PatchedDateTimeFormat.$original = _DateTimeFormat;
+exports._PatchedDateTimeFormat = PatchedDateTimeFormat;
+// ---------------------------------------------------------------------------
+const _toLocaleDateString = Date.prototype.toLocaleDateString;
+const _patchedToLocaleDateString = function toLocaleDateString(locales, options) {
+    return (0, exports._PatchedDateTimeFormat)(locales, options).format(this);
+};
+exports._patchedToLocaleDateString = _patchedToLocaleDateString;
+exports._patchedToLocaleDateString.$original = _toLocaleDateString;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@reykjavik/webtools",
-	"version": "0.1.14",
+	"version": "0.1.16",
 	"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",