@reykjavik/webtools 0.1.13 → 0.1.15

package/CHANGELOG.md

@@ -4,11 +4,20 @@
 
 - ... <!-- Add new lines here. -->
 
-## 0.1.13
+## 0.1.15
+
+_2024-03-08_
+
+- `@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.14
 
 _2024-03-06_
 
-- feat: Add `@reykjavik/webtools/fixIcelandicLocale` polyfill module
+- feat: Add `@reykjavik/webtools/fixIcelandicLocale` Chrome paching module
 
 ## 0.1.12
 
@@ -28,7 +37,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
@@ -37,7 +46,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,60 @@ 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.NumzberFormat` 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 timezone will appear in Danish
+- The `dayPeriod` option is not supported and prints the day-period in Danish.
+- Custom formatted `DD.MM.YY` (2-digit year) dates turn into time-like
+  `DD:MM:YY` strings.
 
 ---
 

package/esm/fixIcelandicLocale.js

@@ -1,21 +1,14 @@
-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 ( /*#__PURE__*/'ö'.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);
-    };
+import { _PatchedCollator, _PatchedDateTimeFormat, _patchedLocaleCompare, _PatchedNumberFormat, _patchedToLocaleDateString, _patchedToLocaleString, } 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) {
+    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,248 @@
+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!
+        }
+    }
+};
+// ===========================================================================
+// 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 reformatNumber = function (result) {
+    if (!this.mapped) {
+        return result;
+    }
+    const options = this.super.resolvedOptions();
+    if (options.style === 'currency' && options.currencyDisplay === 'symbol') {
+        if (options.currency === 'DKK') {
+            return result.replace(/kr\./g, 'DKK');
+        }
+        if (options.currency === 'ISK') {
+            return result.replace(/ISK/g, 'kr.');
+        }
+    }
+    return result;
+};
+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 reformatNumber.call(this, this.super.format(value));
+    },
+    formatRange(value1, value2) {
+        return reformatNumber.call(this, this.super.formatRange(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 = [
+    ['januar', 'janúar', true],
+    ['februar', 'febrúar'],
+    ['marts', 'mars'],
+    ['april', 'apríl'],
+    ['maj', 'maí'],
+    ['juni', 'júní', true],
+    ['juli', 'júlí', true],
+    ['august', 'ágúst', true],
+    // ['september', 'september'],
+    ['oktober', 'október'],
+    ['november', 'nóvember', true],
+    ['december', 'desember', true],
+];
+const weekdays = [
+    ['mandag', 'mánudagur'],
+    ['tirsdag', 'þriðjudagur', 4],
+    ['onsdag', 'miðvikudagur'],
+    ['torsdag', 'fimmtudagur', 4],
+    ['fredag', 'föstudagur'],
+    ['lørdag', 'laugardagur'],
+    ['søndag', 'sunnudagur'],
+];
+const reformatDateTime = function (result) {
+    if (!this.mapped) {
+        return result;
+    }
+    const options = this.super.resolvedOptions();
+    let mappedResult = result;
+    let monthMatches = 0;
+    for (let i = 0, month; (month = months[i]); i++) {
+        const [da, is, checkShort] = month;
+        mappedResult = mappedResult.replace(da, is);
+        if (checkShort && mappedResult === result) {
+            mappedResult = mappedResult.replace(da.slice(0, 3), is.slice(0, 3));
+        }
+        if (mappedResult !== result) {
+            monthMatches++;
+            if (monthMatches >= 2) {
+                break;
+            }
+        }
+    }
+    result = mappedResult; // reset result
+    let weekdayMatches = 0;
+    for (let i = 0, weekday; (weekday = weekdays[i]); i++) {
+        const [da, is, shortLength] = weekday;
+        mappedResult = mappedResult.replace(da, is);
+        if (mappedResult === result) {
+            mappedResult = mappedResult.replace(da.slice(0, shortLength || 3), is.slice(0, 3));
+        }
+        if (mappedResult !== result) {
+            weekdayMatches++;
+            if (weekdayMatches >= 2) {
+                break;
+            }
+        }
+    }
+    result = mappedResult;
+    if (/Kristus/.test(result)) {
+        result = result.replace(/før Kristus/g, 'fyrir Krist');
+        result = result.replace(/efter Kristus/g, 'eftir Krist');
+    }
+    result = result.replace(/(f|e)Kr/g, '$1.k.');
+    result = result.replace(/AM/g, 'f.h.');
+    result = result.replace(/PM/g, 'e.h.');
+    // convert timestamps from `00.00` to `00:00`
+    result = result.replace(/(?:^|\s)\d\d\.\d\d(?:\.\d\d)?(?:,|\s|$)/g, (match) => match.replace(/\./g, ':'));
+    result = result.replace(/ den/g, 'inn');
+    return result;
+};
+const reformatDateTimeParts = function (parts) {
+    if (!this.mapped) {
+        return parts;
+    }
+    const options = this.super.resolvedOptions();
+    // reformat
+    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 reformatDateTime.call(this, this.super.format(value));
+    },
+    formatRange(value1, value2) {
+        return reformatDateTime.call(this, this.super.formatRange(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,21 +1,16 @@
 "use strict";
-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 ( /*#__PURE__*/'ö'.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);
-    };
+Object.defineProperty(exports, "__esModule", { value: true });
+const fixIcelandicLocale_privates_js_1 = require("./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) {
+    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,254 @@
+"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!
+        }
+    }
+};
+// ===========================================================================
+// 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 reformatNumber = function (result) {
+    if (!this.mapped) {
+        return result;
+    }
+    const options = this.super.resolvedOptions();
+    if (options.style === 'currency' && options.currencyDisplay === 'symbol') {
+        if (options.currency === 'DKK') {
+            return result.replace(/kr\./g, 'DKK');
+        }
+        if (options.currency === 'ISK') {
+            return result.replace(/ISK/g, 'kr.');
+        }
+    }
+    return result;
+};
+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 reformatNumber.call(this, this.super.format(value));
+    },
+    formatRange(value1, value2) {
+        return reformatNumber.call(this, this.super.formatRange(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 = [
+    ['januar', 'janúar', true],
+    ['februar', 'febrúar'],
+    ['marts', 'mars'],
+    ['april', 'apríl'],
+    ['maj', 'maí'],
+    ['juni', 'júní', true],
+    ['juli', 'júlí', true],
+    ['august', 'ágúst', true],
+    // ['september', 'september'],
+    ['oktober', 'október'],
+    ['november', 'nóvember', true],
+    ['december', 'desember', true],
+];
+const weekdays = [
+    ['mandag', 'mánudagur'],
+    ['tirsdag', 'þriðjudagur', 4],
+    ['onsdag', 'miðvikudagur'],
+    ['torsdag', 'fimmtudagur', 4],
+    ['fredag', 'föstudagur'],
+    ['lørdag', 'laugardagur'],
+    ['søndag', 'sunnudagur'],
+];
+const reformatDateTime = function (result) {
+    if (!this.mapped) {
+        return result;
+    }
+    const options = this.super.resolvedOptions();
+    let mappedResult = result;
+    let monthMatches = 0;
+    for (let i = 0, month; (month = months[i]); i++) {
+        const [da, is, checkShort] = month;
+        mappedResult = mappedResult.replace(da, is);
+        if (checkShort && mappedResult === result) {
+            mappedResult = mappedResult.replace(da.slice(0, 3), is.slice(0, 3));
+        }
+        if (mappedResult !== result) {
+            monthMatches++;
+            if (monthMatches >= 2) {
+                break;
+            }
+        }
+    }
+    result = mappedResult; // reset result
+    let weekdayMatches = 0;
+    for (let i = 0, weekday; (weekday = weekdays[i]); i++) {
+        const [da, is, shortLength] = weekday;
+        mappedResult = mappedResult.replace(da, is);
+        if (mappedResult === result) {
+            mappedResult = mappedResult.replace(da.slice(0, shortLength || 3), is.slice(0, 3));
+        }
+        if (mappedResult !== result) {
+            weekdayMatches++;
+            if (weekdayMatches >= 2) {
+                break;
+            }
+        }
+    }
+    result = mappedResult;
+    if (/Kristus/.test(result)) {
+        result = result.replace(/før Kristus/g, 'fyrir Krist');
+        result = result.replace(/efter Kristus/g, 'eftir Krist');
+    }
+    result = result.replace(/(f|e)Kr/g, '$1.k.');
+    result = result.replace(/AM/g, 'f.h.');
+    result = result.replace(/PM/g, 'e.h.');
+    // convert timestamps from `00.00` to `00:00`
+    result = result.replace(/(?:^|\s)\d\d\.\d\d(?:\.\d\d)?(?:,|\s|$)/g, (match) => match.replace(/\./g, ':'));
+    result = result.replace(/ den/g, 'inn');
+    return result;
+};
+const reformatDateTimeParts = function (parts) {
+    if (!this.mapped) {
+        return parts;
+    }
+    const options = this.super.resolvedOptions();
+    // reformat
+    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 reformatDateTime.call(this, this.super.format(value));
+    },
+    formatRange(value1, value2) {
+        return reformatDateTime.call(this, this.super.formatRange(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.13",
+	"version": "0.1.15",
 	"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",
@@ -36,7 +36,9 @@
 	"engines": {
 		"node": ">=16"
 	},
-	"sideEffects": false,
+	"sideEffects": [
+		"**/fixIcelandicLocale.js"
+	],
 	"exports": {
 		".": {
 			"import": "./esm/index.js",