@prezly/theme-kit-intl 7.1.0 → 8.2.0

package/build/formatting/messages/lib.test.mjs

@@ -0,0 +1,84 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import { formatMessageFragment, formatMessageString } from "./lib.mjs";
+var I18N = {
+  ["hello.world"]: [{
+    type: 0,
+    value: '¡Hola, '
+  }, {
+    type: 1,
+    value: 'name'
+  }, {
+    type: 0,
+    value: '!'
+  }]
+};
+describe('formatMessageString', () => {
+  it('should format intl-generated message intl object using the given values', () => {
+    var formatted = formatMessageString({
+      id: 'hello.world',
+      defaultMessage: 'Hello, {name}!'
+    }, I18N, {
+      name: 'Julio'
+    });
+    expect(formatted).toBe('¡Hola, Julio!');
+  });
+  it('should leave placeholders if the given values object does not have enough data', () => {
+    var formatted = formatMessageString({
+      id: 'hello.world',
+      defaultMessage: 'Hello, {name}!'
+    }, I18N, {});
+    expect(formatted).toBe('¡Hola, {name}!');
+  });
+  it('should fallback to the default message if the dictionary does not have it', () => {
+    var formatted = formatMessageString({
+      id: 'hello.world',
+      defaultMessage: 'Hello, {name}!'
+    }, {}, {
+      name: 'Julio'
+    });
+    expect(formatted).toBe('Hello, Julio!');
+  });
+});
+describe('formatMessageFragment', () => {
+  it('should format intl-generated message intl object using the given values', () => {
+    var formatted = formatMessageFragment({
+      id: 'hello.world',
+      defaultMessage: 'Hello, {name}!'
+    }, I18N, {
+      name: createElement('strong', ['Julio'])
+    });
+    expect(formatted).toEqual(['¡Hola, ', {
+      type: 'strong',
+      children: ['Julio']
+    }, '!']);
+  });
+  it('should leave placeholders if the given values object does not have enough data', () => {
+    var formatted = formatMessageFragment({
+      id: 'hello.world',
+      defaultMessage: 'Hello, {name}!'
+    }, I18N, {});
+    expect(formatted).toEqual(['¡Hola, ', '{name}', '!']);
+  });
+  it('should fallback to the default message if the dictionary does not have it', () => {
+    var formatted = formatMessageFragment({
+      id: 'hello.world',
+      defaultMessage: 'Hello, {name}!'
+    }, {}, {
+      name: createElement('strong', ['Julio'])
+    });
+    expect(formatted).toEqual(['Hello, ', {
+      type: 'strong',
+      children: ['Julio']
+    }, '!']);
+  });
+});
+
+/**
+ * Emulating React.createElement for test purposes.
+ */
+function createElement(type, children) {
+  return {
+    type,
+    children
+  };
+}

package/build/formatting/messages/types.cjs

@@ -0,0 +1 @@
+"use strict";

package/build/formatting/messages/types.d.ts

@@ -0,0 +1,10 @@
+export type IntlDictionary = Partial<Record<string, IntlMessageFormat>>;
+export type IntlMessageFormat = {
+    type: 0 | 1;
+    value: string;
+}[];
+export interface IntlMessageDescriptor {
+    id: string;
+    defaultMessage?: string;
+}
+export type IntlMessageValues<T> = Record<string, T>;

package/build/formatting/messages/types.mjs

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

package/build/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  translations: true
+};
+exports.translations = void 0;
+var _index = require("./formatting/index.cjs");
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _index[key];
+    }
+  });
+});
+var _index2 = require("./locales/index.cjs");
+Object.keys(_index2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _index2[key];
+    }
+  });
+});
+var _translations = _interopRequireWildcard(require("./messages/index.cjs"));
+exports.translations = _translations;
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export * from './formatting';
+export * from './locales';
+export * as translations from './messages';

package/build/index.mjs

@@ -0,0 +1,4 @@
+export * from "./formatting/index.mjs";
+export * from "./locales/index.mjs";
+import * as _translations from "./messages/index.mjs";
+export { _translations as translations };

package/build/locales/Locale.cjs

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Locale = void 0;
+var _isNotUndefined = require("@technically/is-not-undefined");
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+var KNOWN_SCRIPTS = ['hant', 'hans'];
+var KNOWN_RTL_LANGUAGES = ['ar', 'he', 'ur'];
+var LANG_CODE_REGEX = /^[a-z]{2,3}$/;
+var CACHE = new Map();
+var Locale;
+(function (_Locale) {
+  /**
+   * Shortest possible slug that can identify a locale for the given newsroom.
+   * This can be full language code or lowercase region code if they're unanbiguously identify a locale
+   * or full locale slug if nothing else applies.
+   */
+
+  function from(locale) {
+    if (typeof locale === 'object') {
+      return locale;
+    }
+    var cached = CACHE.get(locale);
+    if (cached) {
+      return cached;
+    }
+    var [lang, ...rest] = locale.toLowerCase().split(/[_-]/g);
+    if (!lang.match(LANG_CODE_REGEX)) {
+      throw new Error("Invalid locale code provided: \"".concat(locale, "\"."));
+    }
+    var scripts = rest.filter(s => KNOWN_SCRIPTS.includes(s));
+    var regions = rest.filter(s => !KNOWN_SCRIPTS.includes(s)).map(region => region.toUpperCase());
+    if (scripts.length > 1) {
+      throw new Error("Unable to parse the provided locale code: \"".concat(locale, "\". Multiple script codes detected."));
+    }
+    if (regions.length > 1) {
+      throw new Error("Unable to parse the provided locale code: \"".concat(locale, "\". Multiple region codes detected."));
+    }
+    var scriptCode = scripts[0];
+    var regionCode = regions[0];
+    var code = [lang.toLowerCase(), regionCode, scriptCode ? toPascalCase(scriptCode) : undefined].filter(_isNotUndefined.isNotUndefined).join('_');
+    var isoCode = code.replace('_', '-');
+    var obj = {
+      code,
+      isoCode,
+      slug: isoCode.toLowerCase(),
+      direction: KNOWN_RTL_LANGUAGES.includes(lang) ? 'rtl' : 'ltr',
+      lang,
+      region: regionCode,
+      script: scriptCode ? toPascalCase(scriptCode) : undefined
+    };
+    CACHE.set(obj.code, obj);
+    CACHE.set(obj.isoCode, obj);
+    CACHE.set(obj.slug, obj);
+    return obj;
+  }
+  _Locale.from = from;
+  function isValid(locale) {
+    try {
+      Locale.from(locale);
+    } catch (_unused) {
+      return false;
+    }
+    return true;
+  }
+  _Locale.isValid = isValid;
+  function isLanguageCode(locale, langCode) {
+    return Locale.from(locale).lang === langCode.toLowerCase();
+  }
+  _Locale.isLanguageCode = isLanguageCode;
+  function isRegionCode(locale, regionCode) {
+    return Locale.from(locale).region === regionCode.toUpperCase();
+  }
+  _Locale.isRegionCode = isRegionCode;
+  function isRegionIndependent(locale) {
+    return !Locale.from(locale).region;
+  }
+  _Locale.isRegionIndependent = isRegionIndependent;
+  function isEqual(a, b) {
+    var al = Locale.from(a);
+    var bl = Locale.from(b);
+    return al.lang === bl.lang && al.region === bl.region && al.script === bl.script;
+  }
+  _Locale.isEqual = isEqual;
+  function isSameLang(a, b) {
+    return Locale.from(a).lang === Locale.from(b).lang;
+  }
+  _Locale.isSameLang = isSameLang;
+  function isSameRegion(a, b) {
+    var al = Locale.from(a);
+    var bl = Locale.from(b);
+    if (!al.region || !bl.region) {
+      // It's never the same region, if it's not defined.
+      return false;
+    }
+    return al.region === bl.region;
+  }
+  _Locale.isSameRegion = isSameRegion;
+})(Locale || (exports.Locale = Locale = {}));
+function toPascalCase(input) {
+  return "".concat(input.substring(0, 1).toUpperCase()).concat(input.substring(1).toLowerCase());
+}

package/build/locales/Locale.d.ts

@@ -0,0 +1,61 @@
+export interface Locale {
+    /**
+     * Full locale code with underscores.
+     * Example: 'nl_BE'
+     */
+    code: Locale.Code;
+    /**
+     * Full locale code in ISO format (with dashes instead of underscores)
+     * Example: 'nl-BE'
+     */
+    isoCode: Locale.IsoCode;
+    /**
+     * URL-friendly case-insensitive locale code.
+     * Example: 'nl-be'
+     */
+    slug: Locale.UrlSlug;
+    /**
+     * Language code.
+     * Examples: `nl`, `en`, `fr`.
+     */
+    lang: Locale.LangCode;
+    /**
+     * Text direction for the locale.
+     */
+    direction: 'ltr' | 'rtl';
+    /**
+     * Locale region code.
+     * E.g. `en-US` has `US` as region, while `en` is region independent and does not have a `regionCode`.
+     */
+    region: Locale.RegionCode | undefined;
+    /**
+     * Locale script code.
+     * E.g. `zh-Hant` has `Hant` as script code (this is not a region).
+     */
+    script: Locale.ScriptCode | undefined;
+}
+export declare namespace Locale {
+    export type AnyCode = Code | IsoCode | UrlSlug;
+    /**
+     * Shortest possible slug that can identify a locale for the given newsroom.
+     * This can be full language code or lowercase region code if they're unanbiguously identify a locale
+     * or full locale slug if nothing else applies.
+     */
+    export type AnySlug = UrlSlug | LangCode | LowercaseRegionCode;
+    type LowercaseRegionCode = `${Lowercase<string>}`;
+    export type Code = `${LangCode}` | `${LangCode}_${RegionCode}` | `${LangCode}_${ScriptCode}` | `${LangCode}_${ScriptCode}_${RegionCode}`;
+    export type IsoCode = `${LangCode}` | `${LangCode}-${RegionCode}` | `${LangCode}-${ScriptCode}` | `${LangCode}-${ScriptCode}-${RegionCode}`;
+    export type UrlSlug = string;
+    export type LangCode = `${Lowercase<string>}`;
+    export type RegionCode = `${Uppercase<string>}`;
+    export type ScriptCode = string;
+    export function from(locale: AnyCode | Locale): Locale;
+    export function isValid(locale: AnyCode | string): boolean;
+    export function isLanguageCode(locale: AnyCode | Locale, langCode: LangCode): boolean;
+    export function isRegionCode(locale: AnyCode | Locale, regionCode: Locale.RegionCode | LowercaseRegionCode): boolean;
+    export function isRegionIndependent(locale: AnyCode | Locale): boolean;
+    export function isEqual(a: Locale | AnyCode, b: Locale | AnyCode): boolean;
+    export function isSameLang(a: Locale | AnyCode, b: Locale | AnyCode): boolean;
+    export function isSameRegion(a: Locale | AnyCode, b: Locale | AnyCode): boolean;
+    export {};
+}

package/build/locales/Locale.mjs

@@ -0,0 +1,99 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+import { isNotUndefined } from '@technically/is-not-undefined';
+var KNOWN_SCRIPTS = ['hant', 'hans'];
+var KNOWN_RTL_LANGUAGES = ['ar', 'he', 'ur'];
+var LANG_CODE_REGEX = /^[a-z]{2,3}$/;
+var CACHE = new Map();
+export var Locale;
+(function (_Locale) {
+  /**
+   * Shortest possible slug that can identify a locale for the given newsroom.
+   * This can be full language code or lowercase region code if they're unanbiguously identify a locale
+   * or full locale slug if nothing else applies.
+   */
+
+  function from(locale) {
+    if (typeof locale === 'object') {
+      return locale;
+    }
+    var cached = CACHE.get(locale);
+    if (cached) {
+      return cached;
+    }
+    var [lang, ...rest] = locale.toLowerCase().split(/[_-]/g);
+    if (!lang.match(LANG_CODE_REGEX)) {
+      throw new Error("Invalid locale code provided: \"".concat(locale, "\"."));
+    }
+    var scripts = rest.filter(s => KNOWN_SCRIPTS.includes(s));
+    var regions = rest.filter(s => !KNOWN_SCRIPTS.includes(s)).map(region => region.toUpperCase());
+    if (scripts.length > 1) {
+      throw new Error("Unable to parse the provided locale code: \"".concat(locale, "\". Multiple script codes detected."));
+    }
+    if (regions.length > 1) {
+      throw new Error("Unable to parse the provided locale code: \"".concat(locale, "\". Multiple region codes detected."));
+    }
+    var scriptCode = scripts[0];
+    var regionCode = regions[0];
+    var code = [lang.toLowerCase(), regionCode, scriptCode ? toPascalCase(scriptCode) : undefined].filter(isNotUndefined).join('_');
+    var isoCode = code.replace('_', '-');
+    var obj = {
+      code,
+      isoCode,
+      slug: isoCode.toLowerCase(),
+      direction: KNOWN_RTL_LANGUAGES.includes(lang) ? 'rtl' : 'ltr',
+      lang,
+      region: regionCode,
+      script: scriptCode ? toPascalCase(scriptCode) : undefined
+    };
+    CACHE.set(obj.code, obj);
+    CACHE.set(obj.isoCode, obj);
+    CACHE.set(obj.slug, obj);
+    return obj;
+  }
+  _Locale.from = from;
+  function isValid(locale) {
+    try {
+      Locale.from(locale);
+    } catch (_unused) {
+      return false;
+    }
+    return true;
+  }
+  _Locale.isValid = isValid;
+  function isLanguageCode(locale, langCode) {
+    return Locale.from(locale).lang === langCode.toLowerCase();
+  }
+  _Locale.isLanguageCode = isLanguageCode;
+  function isRegionCode(locale, regionCode) {
+    return Locale.from(locale).region === regionCode.toUpperCase();
+  }
+  _Locale.isRegionCode = isRegionCode;
+  function isRegionIndependent(locale) {
+    return !Locale.from(locale).region;
+  }
+  _Locale.isRegionIndependent = isRegionIndependent;
+  function isEqual(a, b) {
+    var al = Locale.from(a);
+    var bl = Locale.from(b);
+    return al.lang === bl.lang && al.region === bl.region && al.script === bl.script;
+  }
+  _Locale.isEqual = isEqual;
+  function isSameLang(a, b) {
+    return Locale.from(a).lang === Locale.from(b).lang;
+  }
+  _Locale.isSameLang = isSameLang;
+  function isSameRegion(a, b) {
+    var al = Locale.from(a);
+    var bl = Locale.from(b);
+    if (!al.region || !bl.region) {
+      // It's never the same region, if it's not defined.
+      return false;
+    }
+    return al.region === bl.region;
+  }
+  _Locale.isSameRegion = isSameRegion;
+})(Locale || (Locale = {}));
+function toPascalCase(input) {
+  return "".concat(input.substring(0, 1).toUpperCase()).concat(input.substring(1).toLowerCase());
+}

package/build/locales/Locale.test.cjs

@@ -0,0 +1,120 @@
+"use strict";
+
+var _Locale = require("./Locale.cjs");
+var _supportedLocales = require("./supportedLocales.cjs");
+describe('Locale', () => {
+  it('should throw when created from invalid code', () => {
+    expect(() => _Locale.Locale.from('1234')).toThrow('Invalid locale code provided: "1234".');
+    expect(() => _Locale.Locale.from('*!en-US')).toThrow('Invalid locale code provided: "*!en-US".');
+    expect(() => _Locale.Locale.from('zh-Hant-Hans')).toThrow('Unable to parse the provided locale code: "zh-Hant-Hans". Multiple script codes detected.');
+    expect(() => _Locale.Locale.from('en_US_GB')).toThrow('Unable to parse the provided locale code: "en_US_GB". Multiple region codes detected.');
+  });
+  it('should accept valid codes', () => {
+    expect(() => _Locale.Locale.from('en')).not.toThrow();
+    expect(() => _Locale.Locale.from('en-us')).not.toThrow();
+    expect(() => _Locale.Locale.from('en-US')).not.toThrow();
+    expect(() => _Locale.Locale.from('EN-US')).not.toThrow();
+    expect(() => _Locale.Locale.from('en_us')).not.toThrow();
+    expect(() => _Locale.Locale.from('en_US')).not.toThrow();
+    expect(() => _Locale.Locale.from('EN_US')).not.toThrow();
+    expect(() => _Locale.Locale.from('zh-Hant')).not.toThrow();
+    expect(() => _Locale.Locale.from('zh-Hans')).not.toThrow();
+    expect(() => _Locale.Locale.from('es-419')).not.toThrow();
+    expect(() => _Locale.Locale.from('es_419')).not.toThrow();
+  });
+  it('should cache created locale objects', () => {
+    expect(_Locale.Locale.from('en_US')).toBe(_Locale.Locale.from('en-us'));
+  });
+  it('should provide underscore code', () => {
+    expect(_Locale.Locale.from('en').code).toBe('en');
+    expect(_Locale.Locale.from('en-us').code).toBe('en_US');
+    expect(_Locale.Locale.from('en-US').code).toBe('en_US');
+    expect(_Locale.Locale.from('EN-US').code).toBe('en_US');
+    expect(_Locale.Locale.from('en_us').code).toBe('en_US');
+    expect(_Locale.Locale.from('en_US').code).toBe('en_US');
+    expect(_Locale.Locale.from('EN_US').code).toBe('en_US');
+  });
+  it('should provide ISO code', () => {
+    expect(_Locale.Locale.from('en').isoCode).toBe('en');
+    expect(_Locale.Locale.from('en-us').isoCode).toBe('en-US');
+    expect(_Locale.Locale.from('en-US').isoCode).toBe('en-US');
+    expect(_Locale.Locale.from('EN-US').isoCode).toBe('en-US');
+    expect(_Locale.Locale.from('en_us').isoCode).toBe('en-US');
+    expect(_Locale.Locale.from('en_US').isoCode).toBe('en-US');
+    expect(_Locale.Locale.from('EN_US').isoCode).toBe('en-US');
+  });
+  it('should provide URL slug', () => {
+    expect(_Locale.Locale.from('en').slug).toBe('en');
+    expect(_Locale.Locale.from('en-us').slug).toBe('en-us');
+    expect(_Locale.Locale.from('en-US').slug).toBe('en-us');
+    expect(_Locale.Locale.from('EN-US').slug).toBe('en-us');
+    expect(_Locale.Locale.from('en_us').slug).toBe('en-us');
+    expect(_Locale.Locale.from('en_US').slug).toBe('en-us');
+    expect(_Locale.Locale.from('EN_US').slug).toBe('en-us');
+  });
+  it('should provide language code', () => {
+    expect(_Locale.Locale.from('en').lang).toBe('en');
+    expect(_Locale.Locale.from('en-us').lang).toBe('en');
+    expect(_Locale.Locale.from('en-US').lang).toBe('en');
+    expect(_Locale.Locale.from('EN-US').lang).toBe('en');
+    expect(_Locale.Locale.from('en_us').lang).toBe('en');
+    expect(_Locale.Locale.from('en_US').lang).toBe('en');
+    expect(_Locale.Locale.from('EN_US').lang).toBe('en');
+  });
+  it('should provide region code', () => {
+    expect(_Locale.Locale.from('en').region).toBe(undefined);
+    expect(_Locale.Locale.from('en-us').region).toBe('US');
+    expect(_Locale.Locale.from('en-US').region).toBe('US');
+    expect(_Locale.Locale.from('EN-US').region).toBe('US');
+    expect(_Locale.Locale.from('en_us').region).toBe('US');
+    expect(_Locale.Locale.from('en_US').region).toBe('US');
+    expect(_Locale.Locale.from('EN_US').region).toBe('US');
+  });
+  it('should check if two locales are equal', () => {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    var en_US = _Locale.Locale.from('en-US');
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    var en_US2 = _Locale.Locale.from('en-US');
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    var de_DE = _Locale.Locale.from('de-DE');
+    expect(_Locale.Locale.isEqual(en_US, en_US2)).toBe(true);
+    expect(_Locale.Locale.isEqual(en_US2, en_US)).toBe(true);
+    expect(_Locale.Locale.isEqual(en_US, de_DE)).toBe(false);
+    expect(_Locale.Locale.isEqual(de_DE, en_US)).toBe(false);
+    expect(_Locale.Locale.isEqual('en_US', 'en-us')).toBe(true);
+    expect(_Locale.Locale.isEqual('en_US', _Locale.Locale.from('en_US'))).toBe(true);
+  });
+  it('should check if two locales are of the same language', () => {
+    expect(_Locale.Locale.isSameLang(_Locale.Locale.from('en-US'), _Locale.Locale.from('en-GB'))).toBe(true);
+    expect(_Locale.Locale.isSameLang('en-US', _Locale.Locale.from('en-GB'))).toBe(true);
+    expect(_Locale.Locale.isSameLang('en-us', 'en_GB')).toBe(true);
+    expect(_Locale.Locale.isSameLang('en-FR', 'en')).toBe(true);
+    expect(_Locale.Locale.isSameLang('zh_Hant', 'zh_Hans')).toBe(true);
+    expect(_Locale.Locale.isSameLang('en_US', 'de_DE')).toBe(false);
+    expect(_Locale.Locale.isSameLang('en_US', 'fr')).toBe(false);
+  });
+  it('should check if two locales are of the same region', () => {
+    expect(_Locale.Locale.isSameRegion(_Locale.Locale.from('en-US'), _Locale.Locale.from('es-US'))).toBe(true);
+    expect(_Locale.Locale.isSameRegion('en-US', _Locale.Locale.from('es-US'))).toBe(true);
+    expect(_Locale.Locale.isSameRegion('en-us', 'es_US')).toBe(true);
+
+    // Region-independent locales (with no region) are never considered of the same region.
+    expect(_Locale.Locale.isSameRegion('en', 'en')).toBe(false);
+    expect(_Locale.Locale.isSameRegion('en-US', 'es_ES')).toBe(false);
+    expect(_Locale.Locale.isSameRegion('en_US', 'de_DE')).toBe(false);
+    expect(_Locale.Locale.isSameRegion('en_US', 'fr')).toBe(false);
+  });
+  it('should tell language direction', () => {
+    expect(_Locale.Locale.from('ar_AR').direction).toBe('rtl');
+    expect(_Locale.Locale.from('he').direction).toBe('rtl');
+    expect(_Locale.Locale.from('ur-pk').direction).toBe('rtl');
+    expect(_Locale.Locale.from('en_GB').direction).toBe('ltr');
+    expect(_Locale.Locale.from('fr').direction).toBe('ltr');
+    expect(_Locale.Locale.from('zh_Hant').direction).toBe('ltr');
+  });
+  it('should work for all supported locales', () => {
+    _supportedLocales.supportedLocales.forEach(code => {
+      expect(() => _Locale.Locale.from(code)).not.toThrow();
+    });
+  });
+});

package/build/locales/Locale.test.d.ts

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

package/build/locales/Locale.test.mjs

@@ -0,0 +1,118 @@
+import { Locale } from "./Locale.mjs";
+import { supportedLocales } from "./supportedLocales.mjs";
+describe('Locale', () => {
+  it('should throw when created from invalid code', () => {
+    expect(() => Locale.from('1234')).toThrow('Invalid locale code provided: "1234".');
+    expect(() => Locale.from('*!en-US')).toThrow('Invalid locale code provided: "*!en-US".');
+    expect(() => Locale.from('zh-Hant-Hans')).toThrow('Unable to parse the provided locale code: "zh-Hant-Hans". Multiple script codes detected.');
+    expect(() => Locale.from('en_US_GB')).toThrow('Unable to parse the provided locale code: "en_US_GB". Multiple region codes detected.');
+  });
+  it('should accept valid codes', () => {
+    expect(() => Locale.from('en')).not.toThrow();
+    expect(() => Locale.from('en-us')).not.toThrow();
+    expect(() => Locale.from('en-US')).not.toThrow();
+    expect(() => Locale.from('EN-US')).not.toThrow();
+    expect(() => Locale.from('en_us')).not.toThrow();
+    expect(() => Locale.from('en_US')).not.toThrow();
+    expect(() => Locale.from('EN_US')).not.toThrow();
+    expect(() => Locale.from('zh-Hant')).not.toThrow();
+    expect(() => Locale.from('zh-Hans')).not.toThrow();
+    expect(() => Locale.from('es-419')).not.toThrow();
+    expect(() => Locale.from('es_419')).not.toThrow();
+  });
+  it('should cache created locale objects', () => {
+    expect(Locale.from('en_US')).toBe(Locale.from('en-us'));
+  });
+  it('should provide underscore code', () => {
+    expect(Locale.from('en').code).toBe('en');
+    expect(Locale.from('en-us').code).toBe('en_US');
+    expect(Locale.from('en-US').code).toBe('en_US');
+    expect(Locale.from('EN-US').code).toBe('en_US');
+    expect(Locale.from('en_us').code).toBe('en_US');
+    expect(Locale.from('en_US').code).toBe('en_US');
+    expect(Locale.from('EN_US').code).toBe('en_US');
+  });
+  it('should provide ISO code', () => {
+    expect(Locale.from('en').isoCode).toBe('en');
+    expect(Locale.from('en-us').isoCode).toBe('en-US');
+    expect(Locale.from('en-US').isoCode).toBe('en-US');
+    expect(Locale.from('EN-US').isoCode).toBe('en-US');
+    expect(Locale.from('en_us').isoCode).toBe('en-US');
+    expect(Locale.from('en_US').isoCode).toBe('en-US');
+    expect(Locale.from('EN_US').isoCode).toBe('en-US');
+  });
+  it('should provide URL slug', () => {
+    expect(Locale.from('en').slug).toBe('en');
+    expect(Locale.from('en-us').slug).toBe('en-us');
+    expect(Locale.from('en-US').slug).toBe('en-us');
+    expect(Locale.from('EN-US').slug).toBe('en-us');
+    expect(Locale.from('en_us').slug).toBe('en-us');
+    expect(Locale.from('en_US').slug).toBe('en-us');
+    expect(Locale.from('EN_US').slug).toBe('en-us');
+  });
+  it('should provide language code', () => {
+    expect(Locale.from('en').lang).toBe('en');
+    expect(Locale.from('en-us').lang).toBe('en');
+    expect(Locale.from('en-US').lang).toBe('en');
+    expect(Locale.from('EN-US').lang).toBe('en');
+    expect(Locale.from('en_us').lang).toBe('en');
+    expect(Locale.from('en_US').lang).toBe('en');
+    expect(Locale.from('EN_US').lang).toBe('en');
+  });
+  it('should provide region code', () => {
+    expect(Locale.from('en').region).toBe(undefined);
+    expect(Locale.from('en-us').region).toBe('US');
+    expect(Locale.from('en-US').region).toBe('US');
+    expect(Locale.from('EN-US').region).toBe('US');
+    expect(Locale.from('en_us').region).toBe('US');
+    expect(Locale.from('en_US').region).toBe('US');
+    expect(Locale.from('EN_US').region).toBe('US');
+  });
+  it('should check if two locales are equal', () => {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    var en_US = Locale.from('en-US');
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    var en_US2 = Locale.from('en-US');
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    var de_DE = Locale.from('de-DE');
+    expect(Locale.isEqual(en_US, en_US2)).toBe(true);
+    expect(Locale.isEqual(en_US2, en_US)).toBe(true);
+    expect(Locale.isEqual(en_US, de_DE)).toBe(false);
+    expect(Locale.isEqual(de_DE, en_US)).toBe(false);
+    expect(Locale.isEqual('en_US', 'en-us')).toBe(true);
+    expect(Locale.isEqual('en_US', Locale.from('en_US'))).toBe(true);
+  });
+  it('should check if two locales are of the same language', () => {
+    expect(Locale.isSameLang(Locale.from('en-US'), Locale.from('en-GB'))).toBe(true);
+    expect(Locale.isSameLang('en-US', Locale.from('en-GB'))).toBe(true);
+    expect(Locale.isSameLang('en-us', 'en_GB')).toBe(true);
+    expect(Locale.isSameLang('en-FR', 'en')).toBe(true);
+    expect(Locale.isSameLang('zh_Hant', 'zh_Hans')).toBe(true);
+    expect(Locale.isSameLang('en_US', 'de_DE')).toBe(false);
+    expect(Locale.isSameLang('en_US', 'fr')).toBe(false);
+  });
+  it('should check if two locales are of the same region', () => {
+    expect(Locale.isSameRegion(Locale.from('en-US'), Locale.from('es-US'))).toBe(true);
+    expect(Locale.isSameRegion('en-US', Locale.from('es-US'))).toBe(true);
+    expect(Locale.isSameRegion('en-us', 'es_US')).toBe(true);
+
+    // Region-independent locales (with no region) are never considered of the same region.
+    expect(Locale.isSameRegion('en', 'en')).toBe(false);
+    expect(Locale.isSameRegion('en-US', 'es_ES')).toBe(false);
+    expect(Locale.isSameRegion('en_US', 'de_DE')).toBe(false);
+    expect(Locale.isSameRegion('en_US', 'fr')).toBe(false);
+  });
+  it('should tell language direction', () => {
+    expect(Locale.from('ar_AR').direction).toBe('rtl');
+    expect(Locale.from('he').direction).toBe('rtl');
+    expect(Locale.from('ur-pk').direction).toBe('rtl');
+    expect(Locale.from('en_GB').direction).toBe('ltr');
+    expect(Locale.from('fr').direction).toBe('ltr');
+    expect(Locale.from('zh_Hant').direction).toBe('ltr');
+  });
+  it('should work for all supported locales', () => {
+    supportedLocales.forEach(code => {
+      expect(() => Locale.from(code)).not.toThrow();
+    });
+  });
+});

package/build/locales/constants.cjs

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_LOCALE = void 0;
+var DEFAULT_LOCALE = exports.DEFAULT_LOCALE = 'en';