@schukai/monster 3.51.5 → 3.52.1

package/source/i18n/formatter.mjs

@@ -30,85 +30,87 @@ const internalTranslationSymbol = Symbol("internalTranslation");
  * @memberOf Monster.I18n
  */
 class Formatter extends TextFormatter {
-    /**
-     * Default values for the markers are `${` and `}`
-     *
-     * @param {object} object
-     * @throws {TypeError} value is not a object
-     */
-    constructor(object, translation, options) {
-        super(object, options);
-        this[internalTranslationSymbol] = validateInstance(translation, Translations);
-    }
+	/**
+	 * Default values for the markers are `${` and `}`
+	 *
+	 * @param {object} object
+	 * @throws {TypeError} value is not a object
+	 */
+	constructor(object, translation, options) {
+		super(object, options);
+		this[internalTranslationSymbol] = validateInstance(
+			translation,
+			Translations,
+		);
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 3.27.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/i18n/formatter@@instance");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 3.27.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/i18n/formatter@@instance");
+	}
 
-    /**
-     * @property {object} marker
-     * @property {array} marker.open=["i18n{","${"]
-     * @property {array} marker.close=["${"]
-     * @property {object} parameter
-     * @property {string} parameter.delimiter="::"
-     * @property {string} parameter.assignment="="
-     * @property {object} callbacks
-     * @property {function} callbacks.i18n=()=>{}
-     */
-    get defaults() {
-        const self = this;
-        return extend({}, super.defaults, {
-            callbacks: {
-                i18n: (value) => {
-                    return self[internalTranslationSymbol].getText(validateString(value));
-                },
-            },
-            marker: {
-                open: ["i18n{", "${"],
-                close: ["}"],
-            },
-        });
-    }
+	/**
+	 * @property {object} marker
+	 * @property {array} marker.open=["i18n{","${"]
+	 * @property {array} marker.close=["${"]
+	 * @property {object} parameter
+	 * @property {string} parameter.delimiter="::"
+	 * @property {string} parameter.assignment="="
+	 * @property {object} callbacks
+	 * @property {function} callbacks.i18n=()=>{}
+	 */
+	get defaults() {
+		return extend({}, super.defaults, {
+			callbacks: {
+				i18n: (value) => {
+					return this[internalTranslationSymbol].getText(validateString(value));
+				},
+			},
+			marker: {
+				open: ["i18n{", "${"],
+				close: ["}"],
+			},
+		});
+	}
 
-    /**
-     *
-     * @param {string} text
-     * @return {string}
-     * @throws {TypeError} value is not a string
-     * @throws {Error} too deep nesting
-     * @throws {Error} key not found
-     * @throws {Error} the closing marker is missing
-     */
-    format(text) {
-        validateString(text);
+	/**
+	 *
+	 * @param {string} text
+	 * @return {string}
+	 * @throws {TypeError} value is not a string
+	 * @throws {Error} too deep nesting
+	 * @throws {Error} key not found
+	 * @throws {Error} the closing marker is missing
+	 */
+	format(text) {
+		validateString(text);
 
-        const openMarker = this[internalSymbol]["marker"]["open"]?.[0];
-        const closeMarker = this[internalSymbol]["marker"]["close"]?.[0];
+		const openMarker = this[internalSymbol]["marker"]["open"]?.[0];
+		const closeMarker = this[internalSymbol]["marker"]["close"]?.[0];
 
-        if (text.indexOf(openMarker) === 0) {
-            text = text.substring(openMarker.length);
+		if (text.indexOf(openMarker) === 0) {
+			text = text.substring(openMarker.length);
 
-            if (text.indexOf(closeMarker) === text.length - closeMarker.length) {
-                text = text.substring(0, text.length - closeMarker.length);
-            } else {
-                throw new Error("the closing marker is missing");
-            }
-        }
+			if (text.indexOf(closeMarker) === text.length - closeMarker.length) {
+				text = text.substring(0, text.length - closeMarker.length);
+			} else {
+				throw new Error("the closing marker is missing");
+			}
+		}
 
-        const parts = validateString(text).split("::");
-        const translationKey = parts.shift().trim(); // key value delimiter
-        const parameter = parts.join("::").trim();
+		const parts = validateString(text).split("::");
+		const translationKey = parts.shift().trim(); // key value delimiter
+		const parameter = parts.join("::").trim();
 
-        let assembledText = `${openMarker}static:${translationKey} | call:i18n`;
-        if (parameter.length > 0) {
-            assembledText += `::${parameter}`;
-        }
-        assembledText += closeMarker;
-        return super.format(assembledText);
-    }
+		let assembledText = `${openMarker}static:${translationKey} | call:i18n`;
+		if (parameter.length > 0) {
+			assembledText += `::${parameter}`;
+		}
+		assembledText += closeMarker;
+		return super.format(assembledText);
+	}
 }

package/source/i18n/locale.mjs

@@ -65,115 +65,116 @@ const localeStringSymbol = Symbol("localeString");
  * @see https://datatracker.ietf.org/doc/html/rfc3066
  */
 class Locale extends Base {
-    /**
-     * @param {string} language
-     * @param {string} [region]
-     * @param {string} [script]
-     * @param {string} [variants]
-     * @param {string} [extlang]
-     * @param {string} [privateUse]
-     * @throws {Error} unsupported locale
-     */
-    constructor(language, region, script, variants, extlang, privateUse) {
-        super();
+	/**
+	 * @param {string} language
+	 * @param {string} [region]
+	 * @param {string} [script]
+	 * @param {string} [variants]
+	 * @param {string} [extlang]
+	 * @param {string} [privateUse]
+	 * @throws {Error} unsupported locale
+	 */
+	constructor(language, region, script, variants, extlang, privateUse) {
+		super();
 
-        this[propertiesSymbol] = {
-            language: language === undefined ? undefined : validateString(language),
-            script: script === undefined ? undefined : validateString(script),
-            region: region === undefined ? undefined : validateString(region),
-            variants: variants === undefined ? undefined : validateString(variants),
-            extlang: extlang === undefined ? undefined : validateString(extlang),
-            privateUse: privateUse === undefined ? undefined : validateString(privateUse),
-        };
+		this[propertiesSymbol] = {
+			language: language === undefined ? undefined : validateString(language),
+			script: script === undefined ? undefined : validateString(script),
+			region: region === undefined ? undefined : validateString(region),
+			variants: variants === undefined ? undefined : validateString(variants),
+			extlang: extlang === undefined ? undefined : validateString(extlang),
+			privateUse:
+				privateUse === undefined ? undefined : validateString(privateUse),
+		};
 
-        let s = [];
-        if (language !== undefined) s.push(language);
-        if (script !== undefined) s.push(script);
-        if (region !== undefined) s.push(region);
-        if (variants !== undefined) s.push(variants);
-        if (extlang !== undefined) s.push(extlang);
-        if (privateUse !== undefined) s.push(privateUse);
+		const s = [];
+		if (language !== undefined) s.push(language);
+		if (script !== undefined) s.push(script);
+		if (region !== undefined) s.push(region);
+		if (variants !== undefined) s.push(variants);
+		if (extlang !== undefined) s.push(extlang);
+		if (privateUse !== undefined) s.push(privateUse);
 
-        if (s.length === 0) {
-            throw new Error("unsupported locale");
-        }
+		if (s.length === 0) {
+			throw new Error("unsupported locale");
+		}
 
-        this[localeStringSymbol] = s.join("-");
-    }
+		this[localeStringSymbol] = s.join("-");
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 3.27.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/i18n/locale@@instance");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 3.27.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/i18n/locale@@instance");
+	}
 
-    /**
-     * @return {string}
-     */
-    get localeString() {
-        return this[localeStringSymbol];
-    }
+	/**
+	 * @return {string}
+	 */
+	get localeString() {
+		return this[localeStringSymbol];
+	}
 
-    /**
-     * @return {string|undefined}
-     */
-    get language() {
-        return this[propertiesSymbol].language;
-    }
+	/**
+	 * @return {string|undefined}
+	 */
+	get language() {
+		return this[propertiesSymbol].language;
+	}
 
-    /**
-     * @return {string|undefined}
-     */
-    get region() {
-        return this[propertiesSymbol].region;
-    }
+	/**
+	 * @return {string|undefined}
+	 */
+	get region() {
+		return this[propertiesSymbol].region;
+	}
 
-    /**
-     * @return {string|undefined}
-     */
-    get script() {
-        return this[propertiesSymbol].script;
-    }
+	/**
+	 * @return {string|undefined}
+	 */
+	get script() {
+		return this[propertiesSymbol].script;
+	}
 
-    /**
-     * @return {string|undefined}
-     */
-    get variants() {
-        return this[propertiesSymbol].variants;
-    }
+	/**
+	 * @return {string|undefined}
+	 */
+	get variants() {
+		return this[propertiesSymbol].variants;
+	}
 
-    /**
-     * @return {string|undefined}
-     */
-    get extlang() {
-        return this[propertiesSymbol].extlang;
-    }
+	/**
+	 * @return {string|undefined}
+	 */
+	get extlang() {
+		return this[propertiesSymbol].extlang;
+	}
 
-    /**
-     * @return {string|undefined}
-     */
-    get privateUse() {
-        return this[propertiesSymbol].privateValue;
-    }
+	/**
+	 * @return {string|undefined}
+	 */
+	get privateUse() {
+		return this[propertiesSymbol].privateValue;
+	}
 
-    /**
-     * @return {string}
-     */
-    toString() {
-        return `${this.localeString}`;
-    }
+	/**
+	 * @return {string}
+	 */
+	toString() {
+		return `${this.localeString}`;
+	}
 
-    /**
-     * The structure has the following: language, script, region, variants, extlang, privateUse
-     *
-     * @return {Monster.I18n.LocaleMap}
-     */
-    getMap() {
-        return clone(this[propertiesSymbol]);
-    }
+	/**
+	 * The structure has the following: language, script, region, variants, extlang, privateUse
+	 *
+	 * @return {Monster.I18n.LocaleMap}
+	 */
+	getMap() {
+		return clone(this[propertiesSymbol]);
+	}
 }
 
 /**
@@ -257,62 +258,63 @@ class Locale extends Base {
  * @throws {Error} unsupported locale
  */
 function parseLocale(locale) {
-    locale = validateString(locale).replace(/_/g, "-");
+	locale = validateString(locale).replace(/_/g, "-");
 
-    let language;
-    let region;
-    let variants;
-    let parts;
-    let script;
-    let extlang;
-    let regexRegular = "(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)";
-    let regexIrregular =
-        "(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)";
-    let regexGrandfathered = `(${regexIrregular}|${regexRegular})`;
-    let regexPrivateUse = "(x(-[A-Za-z0-9]{1,8})+)";
-    let regexSingleton = "[0-9A-WY-Za-wy-z]";
-    let regexExtension = `(${regexSingleton}(-[A-Za-z0-9]{2,8})+)`;
-    let regexVariant = "([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})";
-    let regexRegion = "([A-Za-z]{2}|[0-9]{3})";
-    let regexScript = "([A-Za-z]{4})";
-    let regexExtlang = "([A-Za-z]{3}(-[A-Za-z]{3}){0,2})";
-    let regexLanguage = `(([A-Za-z]{2,3}(-${regexExtlang})?)|[A-Za-z]{4}|[A-Za-z]{5,8})`;
-    let regexLangtag = `(${regexLanguage}(-${regexScript})?(-${regexRegion})?(-${regexVariant})*(-${regexExtension})*(-${regexPrivateUse})?)`;
-    let regexLanguageTag = `^(${regexGrandfathered}|${regexLangtag}|${regexPrivateUse})$`;
-    let regex = new RegExp(regexLanguageTag);
-    let match;
+	let language;
+	let region;
+	let variants;
+	let parts;
+	let script;
+	let extlang;
+	const regexRegular =
+		"(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)";
+	const regexIrregular =
+		"(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)";
+	const regexGrandfathered = `(${regexIrregular}|${regexRegular})`;
+	const regexPrivateUse = "(x(-[A-Za-z0-9]{1,8})+)";
+	const regexSingleton = "[0-9A-WY-Za-wy-z]";
+	const regexExtension = `(${regexSingleton}(-[A-Za-z0-9]{2,8})+)`;
+	const regexVariant = "([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})";
+	const regexRegion = "([A-Za-z]{2}|[0-9]{3})";
+	const regexScript = "([A-Za-z]{4})";
+	const regexExtlang = "([A-Za-z]{3}(-[A-Za-z]{3}){0,2})";
+	const regexLanguage = `(([A-Za-z]{2,3}(-${regexExtlang})?)|[A-Za-z]{4}|[A-Za-z]{5,8})`;
+	const regexLangtag = `(${regexLanguage}(-${regexScript})?(-${regexRegion})?(-${regexVariant})*(-${regexExtension})*(-${regexPrivateUse})?)`;
+	const regexLanguageTag = `^(${regexGrandfathered}|${regexLangtag}|${regexPrivateUse})$`;
+	const regex = new RegExp(regexLanguageTag);
+	let match;
 
-    if ((match = regex.exec(locale)) !== null) {
-        if (match.index === regex.lastIndex) {
-            regex.lastIndex++;
-        }
-    }
+	if ((match = regex.exec(locale)) !== null) {
+		if (match.index === regex.lastIndex) {
+			regex.lastIndex++;
+		}
+	}
 
-    if (match === undefined || match === null) {
-        throw new Error("unsupported locale");
-    }
+	if (match === undefined || match === null) {
+		throw new Error("unsupported locale");
+	}
 
-    if (match[6] !== undefined) {
-        language = match[6];
+	if (match[6] !== undefined) {
+		language = match[6];
 
-        parts = language.split("-");
-        if (parts.length > 1) {
-            language = parts[0];
-            extlang = parts[1];
-        }
-    }
+		parts = language.split("-");
+		if (parts.length > 1) {
+			language = parts[0];
+			extlang = parts[1];
+		}
+	}
 
-    if (match[14] !== undefined) {
-        region = match[14];
-    }
+	if (match[14] !== undefined) {
+		region = match[14];
+	}
 
-    if (match[12] !== undefined) {
-        script = match[12];
-    }
+	if (match[12] !== undefined) {
+		script = match[12];
+	}
 
-    if (match[16] !== undefined) {
-        variants = match[16];
-    }
+	if (match[16] !== undefined) {
+		variants = match[16];
+	}
 
-    return new Locale(language, region, script, variants, extlang);
+	return new Locale(language, region, script, variants, extlang);
 }

package/source/i18n/provider.mjs

@@ -6,7 +6,11 @@
  */
 
 import { instanceSymbol } from "../constants.mjs";
-import { hasObjectLink, getLinkedObjects, addToObjectLink } from "../dom/attributes.mjs";
+import {
+	hasObjectLink,
+	getLinkedObjects,
+	addToObjectLink,
+} from "../dom/attributes.mjs";
 import { getLocaleOfDocument } from "../dom/locale.mjs";
 import { BaseWithOptions } from "../types/basewithoptions.mjs";
 import { Locale } from "./locale.mjs";
@@ -21,7 +25,9 @@ export { Provider, translationsLinkSymbol };
  * @since 3.9.0
  * @private
  */
-const translationsLinkSymbol = Symbol.for("@schukai/monster/i18n/translations@@link");
+const translationsLinkSymbol = Symbol.for(
+	"@schukai/monster/i18n/translations@@link",
+);
 
 /**
  * A provider makes a translation object available.
@@ -33,76 +39,76 @@ const translationsLinkSymbol = Symbol.for("@schukai/monster/i18n/translations@@l
  * @see {@link https://datatracker.ietf.org/doc/html/rfc3066}
  */
 class Provider extends BaseWithOptions {
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 3.27.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/i18n/provider@@instance");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 3.27.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/i18n/provider@@instance");
+	}
 
-    /**
-     * @param {Locale|string} locale
-     * @return {Promise}
-     */
-    getTranslations(locale) {
-        if (locale === undefined) {
-            locale = getLocaleOfDocument();
-        }
+	/**
+	 * @param {Locale|string} locale
+	 * @return {Promise}
+	 */
+	getTranslations(locale) {
+		if (locale === undefined) {
+			locale = getLocaleOfDocument();
+		}
 
-        return new Promise((resolve, reject) => {
-            try {
-                resolve(new Translations(locale));
-            } catch (e) {
-                reject(e);
-            }
-        });
-    }
+		return new Promise((resolve, reject) => {
+			try {
+				resolve(new Translations(locale));
+			} catch (e) {
+				reject(e);
+			}
+		});
+	}
 
-    /**
-     * @param {Locale|string} locale
-     * @param {HTMLElement} element
-     * @return {Provider}
-     */
-    assignToElement(locale, element) {
-        if (locale === undefined) {
-            locale = getLocaleOfDocument();
-        }
+	/**
+	 * @param {Locale|string} locale
+	 * @param {HTMLElement} element
+	 * @return {Provider}
+	 */
+	assignToElement(locale, element) {
+		if (locale === undefined) {
+			locale = getLocaleOfDocument();
+		}
 
-        if (!(locale instanceof Locale)) {
-            throw new Error("Locale is not an instance of Locale");
-        }
+		if (!(locale instanceof Locale)) {
+			throw new Error("Locale is not an instance of Locale");
+		}
 
-        if (!(element instanceof HTMLElement)) {
-            element = document.querySelector("body");
-        }
+		if (!(element instanceof HTMLElement)) {
+			element = document.querySelector("body");
+		}
 
-        if (!(element instanceof HTMLElement)) {
-            throw new Error("Element is not an HTMLElement");
-        }
+		if (!(element instanceof HTMLElement)) {
+			throw new Error("Element is not an HTMLElement");
+		}
 
-        return this.getTranslations(locale).then((obj) => {
-            let translations = null;
-            if (hasObjectLink(element, translationsLinkSymbol)) {
-                const objects = getLinkedObjects(element, translationsLinkSymbol);
-                for (const o of objects) {
-                    if (o instanceof Translations) {
-                        translations = o;
-                        break;
-                    }
-                }
+		return this.getTranslations(locale).then((obj) => {
+			let translations = null;
+			if (hasObjectLink(element, translationsLinkSymbol)) {
+				const objects = getLinkedObjects(element, translationsLinkSymbol);
+				for (const o of objects) {
+					if (o instanceof Translations) {
+						translations = o;
+						break;
+					}
+				}
 
-                if (!(translations instanceof Translations)) {
-                    throw new Error("Object is not an instance of Translations");
-                }
+				if (!(translations instanceof Translations)) {
+					throw new Error("Object is not an instance of Translations");
+				}
 
-                translations.assignTranslations(obj);
-            } else {
-                addToObjectLink(element, translationsLinkSymbol, obj);
-            }
+				translations.assignTranslations(obj);
+			} else {
+				addToObjectLink(element, translationsLinkSymbol, obj);
+			}
 
-            return obj;
-        });
-    }
+			return obj;
+		});
+	}
 }