@schukai/monster 3.51.4 → 3.52.0

package/source/types/base.mjs

@@ -36,50 +36,54 @@ export { Base };
  * @memberOf Monster.Types
  */
 class Base extends Object {
-    /**
-     *
-     * @returns {string}
-     */
-    toString() {
-        return JSON.stringify(this);
-    }
+	/**
+	 *
+	 * @returns {string}
+	 */
+	toString() {
+		return JSON.stringify(this);
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/base");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/base");
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @param that
-     * @returns {boolean}
-     * @since 2.1.0
-     */
-    static [Symbol.hasInstance](that) {
-        if (that === undefined || that === null || (typeof that !== "object" && typeof that !== "function")) {
-            return false;
-        }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @param that
+	 * @returns {boolean}
+	 * @since 2.1.0
+	 */
+	static [Symbol.hasInstance](that) {
+		if (
+			that === undefined ||
+			that === null ||
+			(typeof that !== "object" && typeof that !== "function")
+		) {
+			return false;
+		}
 
-        const thatClass = Object.getPrototypeOf(that);
-        if (
-            thatClass === undefined ||
-            thatClass === null ||
-            (typeof thatClass !== "object" && typeof thatClass !== "function")
-        ) {
-            return false;
-        }
+		const thatClass = Object.getPrototypeOf(that);
+		if (
+			thatClass === undefined ||
+			thatClass === null ||
+			(typeof thatClass !== "object" && typeof thatClass !== "function")
+		) {
+			return false;
+		}
 
-        if (checkInstanceSymbol.apply(this, [thatClass]) === true) {
-            return true;
-        }
+		if (checkInstanceSymbol.apply(this, [thatClass]) === true) {
+			return true;
+		}
 
-        // this call the static method of the super class, if there is one
-        return super[Symbol.hasInstance](that);
-    }
+		// this call the static method of the super class, if there is one
+		return super[Symbol.hasInstance](that);
+	}
 }
 
 /**
@@ -91,31 +95,35 @@ class Base extends Object {
  * @since 2.1.0
  */
 function checkInstanceSymbol(obj) {
-    if (this.hasOwnProperty(instanceSymbol) === false) {
-        return false;
-    }
+	if (this.hasOwnProperty(instanceSymbol) === false) {
+		return false;
+	}
 
-    const proto = obj?.constructor;
-    if (proto === undefined || proto === null || (typeof proto !== "object" && typeof proto !== "function")) {
-        return false;
-    }
+	const proto = obj?.constructor;
+	if (
+		proto === undefined ||
+		proto === null ||
+		(typeof proto !== "object" && typeof proto !== "function")
+	) {
+		return false;
+	}
 
-    if (proto.hasOwnProperty(instanceSymbol) !== true) {
-        return checkInstanceSymbol.apply(this, [obj.__proto__]);
-    }
+	if (proto.hasOwnProperty(instanceSymbol) !== true) {
+		return checkInstanceSymbol.apply(this, [obj.__proto__]);
+	}
 
-    const symbol = proto[instanceSymbol];
-    if (symbol === undefined) {
-        if (obj.__proto__) {
-            return checkInstanceSymbol(obj.__proto__);
-        } else {
-            return false;
-        }
-    }
+	const symbol = proto[instanceSymbol];
+	if (symbol === undefined) {
+		if (obj.__proto__) {
+			return checkInstanceSymbol(obj.__proto__);
+		} else {
+			return false;
+		}
+	}
 
-    if (symbol === this[instanceSymbol]) {
-        return true;
-    }
+	if (symbol === this[instanceSymbol]) {
+		return true;
+	}
 
-    return checkInstanceSymbol.apply(this, [obj.__proto__]);
+	return checkInstanceSymbol.apply(this, [obj.__proto__]);
 }

package/source/types/basewithoptions.mjs

@@ -29,56 +29,56 @@ export { BaseWithOptions };
  * @deprecated since 3.15.0 use {@link Monster.Types.Base} with {@link Monster.Types.equipWithInternal} instead.
  */
 class BaseWithOptions extends Base {
-    /**
-     *
-     * @param {object} options
-     */
-    constructor(options) {
-        super();
+	/**
+	 *
+	 * @param {object} options
+	 */
+	constructor(options) {
+		super();
 
-        if (options === undefined) {
-            options = {};
-        }
+		if (options === undefined) {
+			options = {};
+		}
 
-        this[internalSymbol] = extend({}, this.defaults, validateObject(options));
-    }
+		this[internalSymbol] = extend({}, this.defaults, validateObject(options));
+	}
 
-    /**
-     * This getter provides the options. Derived classes overwrite
-     * this getter with their own values. It is good karma to always include
-     * the values from the parent class.
-     *
-     * ```javascript
-     * get defaults() {
-     *     return Object.assign({}, super.defaults, {
-     *         mykey: true
-     *     });
-     * }
-     *
-     * ```
-     *
-     * @return {object}
-     */
-    get defaults() {
-        return {};
-    }
+	/**
+	 * This getter provides the options. Derived classes overwrite
+	 * this getter with their own values. It is good karma to always include
+	 * the values from the parent class.
+	 *
+	 * ```javascript
+	 * get defaults() {
+	 *     return Object.assign({}, super.defaults, {
+	 *         mykey: true
+	 *     });
+	 * }
+	 *
+	 * ```
+	 *
+	 * @return {object}
+	 */
+	get defaults() {
+		return {};
+	}
 
-    /**
-     * nested options can be specified by path `a.b.c`
-     *
-     * @param {string} path
-     * @param {*} defaultValue
-     * @return {*}
-     * @since 1.10.0
-     */
-    getOption(path, defaultValue) {
-        let value;
+	/**
+	 * nested options can be specified by path `a.b.c`
+	 *
+	 * @param {string} path
+	 * @param {*} defaultValue
+	 * @return {*}
+	 * @since 1.10.0
+	 */
+	getOption(path, defaultValue) {
+		let value;
 
-        try {
-            value = new Pathfinder(this[internalSymbol]).getVia(path);
-        } catch (e) {}
+		try {
+			value = new Pathfinder(this[internalSymbol]).getVia(path);
+		} catch (e) {}
 
-        if (value === undefined) return defaultValue;
-        return value;
-    }
+		if (value === undefined) return defaultValue;
+		return value;
+	}
 }

package/source/types/binary.mjs

@@ -20,19 +20,19 @@ export { toBinary, fromBinary };
  * @since 1.18.0
  */
 function toBinary(string) {
-    const codeUnits = new Uint16Array(validateString(string).length);
-    for (let i = 0; i < codeUnits.length; i++) {
-        codeUnits[i] = string.charCodeAt(i);
-    }
+	const codeUnits = new Uint16Array(validateString(string).length);
+	for (let i = 0; i < codeUnits.length; i++) {
+		codeUnits[i] = string.charCodeAt(i);
+	}
 
-    const charCodes = new Uint8Array(codeUnits.buffer);
-    let result = "";
+	const charCodes = new Uint8Array(codeUnits.buffer);
+	let result = "";
 
-    for (let i = 0; i < charCodes.byteLength; i++) {
-        result += String.fromCharCode(charCodes[i]);
-    }
+	for (let i = 0; i < charCodes.byteLength; i++) {
+		result += String.fromCharCode(charCodes[i]);
+	}
 
-    return result;
+	return result;
 }
 
 /**
@@ -46,14 +46,14 @@ function toBinary(string) {
  * @since 1.18.0
  */
 function fromBinary(binary) {
-    const bytes = new Uint8Array(validateString(binary).length);
-    for (let i = 0; i < bytes.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    const charCodes = new Uint16Array(bytes.buffer);
-    let result = "";
-    for (let i = 0; i < charCodes.length; i++) {
-        result += String.fromCharCode(charCodes[i]);
-    }
-    return result;
+	const bytes = new Uint8Array(validateString(binary).length);
+	for (let i = 0; i < bytes.length; i++) {
+		bytes[i] = binary.charCodeAt(i);
+	}
+	const charCodes = new Uint16Array(bytes.buffer);
+	let result = "";
+	for (let i = 0; i < charCodes.length; i++) {
+		result += String.fromCharCode(charCodes[i]);
+	}
+	return result;
 }

package/source/types/dataurl.mjs

@@ -8,7 +8,11 @@
 import { Base } from "./base.mjs";
 import { isString } from "./is.mjs";
 import { MediaType, parseMediaType } from "./mediatype.mjs";
-import { validateBoolean, validateInstance, validateString } from "./validate.mjs";
+import {
+	validateBoolean,
+	validateInstance,
+	validateString,
+} from "./validate.mjs";
 import { instanceSymbol } from "../constants.mjs";
 export { DataUrl, parseDataURL };
 
@@ -29,59 +33,61 @@ const internal = Symbol("internal");
  * @see https://datatracker.ietf.org/doc/html/rfc2397
  */
 class DataUrl extends Base {
-    /**
-     *
-     * @param {String} content
-     * @param {String|Monster.Types.MediaType} mediatype
-     * @param {boolean} base64=true
-     */
-    constructor(content, mediatype, base64) {
-        super();
-
-        if (isString(mediatype)) {
-            mediatype = parseMediaType(mediatype);
-        }
-
-        this[internal] = {
-            content: validateString(content),
-            mediatype: validateInstance(mediatype, MediaType),
-            base64: validateBoolean(base64 === undefined ? true : base64),
-        };
-    }
-
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/data-url");
-    }
-
-    get content() {
-        return this[internal].base64 ? atob(this[internal].content) : this[internal].content;
-    }
-
-    get mediatype() {
-        return this[internal].mediatype;
-    }
-
-    /**
-     *
-     * @return {string}
-     * @see https://datatracker.ietf.org/doc/html/rfc2397
-     */
-    toString() {
-        let content = this[internal].content;
-
-        if (this[internal].base64 === true) {
-            content = `;base64,${content}`;
-        } else {
-            content = `,${encodeURIComponent(content)}`;
-        }
-
-        return `data:${this[internal].mediatype.toString()}${content}`;
-    }
+	/**
+	 *
+	 * @param {String} content
+	 * @param {String|Monster.Types.MediaType} mediatype
+	 * @param {boolean} base64=true
+	 */
+	constructor(content, mediatype, base64) {
+		super();
+
+		if (isString(mediatype)) {
+			mediatype = parseMediaType(mediatype);
+		}
+
+		this[internal] = {
+			content: validateString(content),
+			mediatype: validateInstance(mediatype, MediaType),
+			base64: validateBoolean(base64 === undefined ? true : base64),
+		};
+	}
+
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/data-url");
+	}
+
+	get content() {
+		return this[internal].base64
+			? atob(this[internal].content)
+			: this[internal].content;
+	}
+
+	get mediatype() {
+		return this[internal].mediatype;
+	}
+
+	/**
+	 *
+	 * @return {string}
+	 * @see https://datatracker.ietf.org/doc/html/rfc2397
+	 */
+	toString() {
+		let content = this[internal].content;
+
+		if (this[internal].base64 === true) {
+			content = `;base64,${content}`;
+		} else {
+			content = `,${encodeURIComponent(content)}`;
+		}
+
+		return `data:${this[internal].mediatype.toString()}${content}`;
+	}
 }
 
 /**
@@ -105,40 +111,40 @@ class DataUrl extends Base {
  * @memberOf Monster.Types
  */
 function parseDataURL(dataurl) {
-    validateString(dataurl);
-
-    dataurl = dataurl.trim();
-
-    if (dataurl.substring(0, 5) !== "data:") {
-        throw new TypeError("incorrect or missing data protocol");
-    }
-
-    dataurl = dataurl.substring(5);
-
-    let p = dataurl.indexOf(",");
-    if (p === -1) {
-        throw new TypeError("malformed data url");
-    }
-
-    let content = dataurl.substring(p + 1);
-    let mediatypeAndBase64 = dataurl.substring(0, p).trim();
-    let mediatype = "text/plain;charset=US-ASCII";
-    let base64Flag = false;
-
-    if (mediatypeAndBase64 !== "") {
-        mediatype = mediatypeAndBase64;
-        if (mediatypeAndBase64.endsWith("base64")) {
-            let i = mediatypeAndBase64.lastIndexOf(";");
-            mediatype = mediatypeAndBase64.substring(0, i);
-            base64Flag = true;
-        } else {
-            content = decodeURIComponent(content);
-        }
-
-        mediatype = parseMediaType(mediatype);
-    } else {
-        content = decodeURIComponent(content);
-    }
-
-    return new DataUrl(content, mediatype, base64Flag);
+	validateString(dataurl);
+
+	dataurl = dataurl.trim();
+
+	if (dataurl.substring(0, 5) !== "data:") {
+		throw new TypeError("incorrect or missing data protocol");
+	}
+
+	dataurl = dataurl.substring(5);
+
+	const p = dataurl.indexOf(",");
+	if (p === -1) {
+		throw new TypeError("malformed data url");
+	}
+
+	let content = dataurl.substring(p + 1);
+	const mediatypeAndBase64 = dataurl.substring(0, p).trim();
+	let mediatype = "text/plain;charset=US-ASCII";
+	let base64Flag = false;
+
+	if (mediatypeAndBase64 !== "") {
+		mediatype = mediatypeAndBase64;
+		if (mediatypeAndBase64.endsWith("base64")) {
+			const i = mediatypeAndBase64.lastIndexOf(";");
+			mediatype = mediatypeAndBase64.substring(0, i);
+			base64Flag = true;
+		} else {
+			content = decodeURIComponent(content);
+		}
+
+		mediatype = parseMediaType(mediatype);
+	} else {
+		content = decodeURIComponent(content);
+	}
+
+	return new DataUrl(content, mediatype, base64Flag);
 }

package/source/types/global.mjs

@@ -5,7 +5,11 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-import { validateFunction, validateObject, validateString } from "./validate.mjs";
+import {
+	validateFunction,
+	validateObject,
+	validateString,
+} from "./validate.mjs";
 
 export { getGlobal, getGlobalObject, getGlobalFunction };
 
@@ -20,39 +24,39 @@ let globalReference;
  * @throws {Error} unsupported environment.
  */
 (function () {
-    if (typeof globalThis === "object") {
-        globalReference = globalThis;
-        return;
-    }
+	if (typeof globalThis === "object") {
+		globalReference = globalThis;
+		return;
+	}
 
-    if (typeof self !== "undefined") {
-        globalReference = self;
-        return;
-    } else if (typeof window !== "undefined") {
-        globalReference = window;
-        return;
-    }
+	if (typeof self !== "undefined") {
+		globalReference = self;
+		return;
+	} else if (typeof window !== "undefined") {
+		globalReference = window;
+		return;
+	}
 
-    Object.defineProperty(Object.prototype, "__monster__", {
-        get: function () {
-            return this;
-        },
-        configurable: true,
-    });
+	Object.defineProperty(Object.prototype, "__monster__", {
+		get: function () {
+			return this;
+		},
+		configurable: true,
+	});
 
-    if (typeof __monster__ === "object") {
-        __monster__.globalThis = __monster__;
-        delete Object.prototype.__monster__;
+	if (typeof __monster__ === "object") {
+		__monster__.globalThis = __monster__;
+		delete Object.prototype.__monster__;
 
-        globalReference = globalThis;
-        return;
-    }
+		globalReference = globalThis;
+		return;
+	}
 
-    try {
-        globalReference = Function("return this")();
-    } catch (e) {}
+	try {
+		globalReference = Function("return this")();
+	} catch (e) {}
 
-    throw new Error("unsupported environment.");
+	throw new Error("unsupported environment.");
 })();
 
 /**
@@ -66,7 +70,7 @@ let globalReference;
  * @returns {objec} globalThis
  */
 function getGlobal() {
-    return globalReference;
+	return globalReference;
 }
 
 /**
@@ -102,11 +106,12 @@ function getGlobal() {
  * @throws {TypeError} value is not a string
  */
 function getGlobalObject(name) {
-    validateString(name);
-    let o = globalReference?.[name];
-    if (typeof o === "undefined") throw new Error(`the object ${name} is not defined`);
-    validateObject(o);
-    return o;
+	validateString(name);
+	const o = globalReference?.[name];
+	if (typeof o === "undefined")
+		throw new Error(`the object ${name} is not defined`);
+	validateObject(o);
+	return o;
 }
 
 /**
@@ -140,9 +145,10 @@ function getGlobalObject(name) {
  * @throws {TypeError} value is not a string
  */
 function getGlobalFunction(name) {
-    validateString(name);
-    let f = globalReference?.[name];
-    if (typeof f === "undefined") throw new Error(`the function ${name} is not defined`);
-    validateFunction(f);
-    return f;
+	validateString(name);
+	const f = globalReference?.[name];
+	if (typeof f === "undefined")
+		throw new Error(`the function ${name} is not defined`);
+	validateFunction(f);
+	return f;
 }