@schukai/monster 3.51.4 → 3.52.0

package/source/types/tokenlist.mjs

@@ -25,223 +25,223 @@ export { TokenList };
  * @memberOf Monster.Types
  */
 class TokenList extends Base {
-    /**
-     *
-     * @param {array|string|iteratable} init
-     */
-    constructor(init) {
-        super();
-        this.tokens = new Set();
+	/**
+	 *
+	 * @param {array|string|iteratable} init
+	 */
+	constructor(init) {
+		super();
+		this.tokens = new Set();
 
-        if (typeof init !== "undefined") {
-            this.add(init);
-        }
-    }
+		if (typeof init !== "undefined") {
+			this.add(init);
+		}
+	}
 
-    /**
-     * Iterator protocol
-     *
-     * @returns {Symbol.iterator}
-     */
-    getIterator() {
-        return this[Symbol.iterator]();
-    }
+	/**
+	 * Iterator protocol
+	 *
+	 * @returns {Symbol.iterator}
+	 */
+	getIterator() {
+		return this[Symbol.iterator]();
+	}
 
-    /**
-     * Iterator
-     *
-     * @returns {{next: ((function(): ({value: *, done: boolean}))|*)}}
-     */
-    [Symbol.iterator]() {
-        // Use a new index for each iterator. This makes multiple
-        // iterations over the iterable safe for non-trivial cases,
-        // such as use of break or nested looping over the same iterable.
-        let index = 0;
-        let entries = this.entries();
+	/**
+	 * Iterator
+	 *
+	 * @returns {{next: ((function(): ({value: *, done: boolean}))|*)}}
+	 */
+	[Symbol.iterator]() {
+		// Use a new index for each iterator. This makes multiple
+		// iterations over the iterable safe for non-trivial cases,
+		// such as use of break or nested looping over the same iterable.
+		let index = 0;
+		const entries = this.entries();
 
-        return {
-            next: () => {
-                if (index < entries.length) {
-                    return { value: entries?.[index++], done: false };
-                } else {
-                    return { done: true };
-                }
-            },
-        };
-    }
+		return {
+			next: () => {
+				if (index < entries.length) {
+					return { value: entries?.[index++], done: false };
+				} else {
+					return { done: true };
+				}
+			},
+		};
+	}
 
-    /**
-     * Returns true if it contains token, otherwise false
-     *
-     * @externalExample ../../example/types/tokenlist-2.mjs
-     * @param {array|string|iteratable} value
-     * @returns {boolean}
-     */
-    contains(value) {
-        if (isString(value)) {
-            value = value.trim();
-            let counter = 0;
-            value.split(" ").forEach((token) => {
-                if (this.tokens.has(token.trim()) === false) return false;
-                counter++;
-            });
-            return counter > 0 ? true : false;
-        }
+	/**
+	 * Returns true if it contains token, otherwise false
+	 *
+	 * @externalExample ../../example/types/tokenlist-2.mjs
+	 * @param {array|string|iteratable} value
+	 * @returns {boolean}
+	 */
+	contains(value) {
+		if (isString(value)) {
+			value = value.trim();
+			let counter = 0;
+			value.split(" ").forEach((token) => {
+				if (this.tokens.has(token.trim()) === false) return false;
+				counter++;
+			});
+			return counter > 0 ? true : false;
+		}
 
-        if (isIterable(value)) {
-            let counter = 0;
-            for (let token of value) {
-                validateString(token);
-                if (this.tokens.has(token.trim()) === false) return false;
-                counter++;
-            }
-            return counter > 0 ? true : false;
-        }
+		if (isIterable(value)) {
+			let counter = 0;
+			for (const token of value) {
+				validateString(token);
+				if (this.tokens.has(token.trim()) === false) return false;
+				counter++;
+			}
+			return counter > 0 ? true : false;
+		}
 
-        return false;
-    }
+		return false;
+	}
 
-    /**
-     * Add tokens
-     *
-     * @externalExample ../../example/types/tokenlist-3.mjs
-     * @param {array|string|iteratable} value
-     * @returns {TokenList}
-     * @throws {TypeError} unsupported value
-     */
-    add(value) {
-        if (isString(value)) {
-            value.split(" ").forEach((token) => {
-                this.tokens.add(token.trim());
-            });
-        } else if (isIterable(value)) {
-            for (let token of value) {
-                validateString(token);
-                this.tokens.add(token.trim());
-            }
-        } else if (typeof value !== "undefined") {
-            throw new TypeError("unsupported value");
-        }
+	/**
+	 * Add tokens
+	 *
+	 * @externalExample ../../example/types/tokenlist-3.mjs
+	 * @param {array|string|iteratable} value
+	 * @returns {TokenList}
+	 * @throws {TypeError} unsupported value
+	 */
+	add(value) {
+		if (isString(value)) {
+			value.split(" ").forEach((token) => {
+				this.tokens.add(token.trim());
+			});
+		} else if (isIterable(value)) {
+			for (const token of value) {
+				validateString(token);
+				this.tokens.add(token.trim());
+			}
+		} else if (typeof value !== "undefined") {
+			throw new TypeError("unsupported value");
+		}
 
-        return this;
-    }
+		return this;
+	}
 
-    /**
-     * remove all tokens
-     *
-     * @returns {TokenList}
-     */
-    clear() {
-        this.tokens.clear();
-        return this;
-    }
+	/**
+	 * remove all tokens
+	 *
+	 * @returns {TokenList}
+	 */
+	clear() {
+		this.tokens.clear();
+		return this;
+	}
 
-    /**
-     * Removes token
-     *
-     * @externalExample ../../example/types/tokenlist-4.mjs
-     * @param {array|string|iteratable} value
-     * @returns {TokenList}
-     * @throws {TypeError} unsupported value
-     */
-    remove(value) {
-        if (isString(value)) {
-            value.split(" ").forEach((token) => {
-                this.tokens.delete(token.trim());
-            });
-        } else if (isIterable(value)) {
-            for (let token of value) {
-                validateString(token);
-                this.tokens.delete(token.trim());
-            }
-        } else if (typeof value !== "undefined") {
-            throw new TypeError("unsupported value", "types/tokenlist.mjs");
-        }
+	/**
+	 * Removes token
+	 *
+	 * @externalExample ../../example/types/tokenlist-4.mjs
+	 * @param {array|string|iteratable} value
+	 * @returns {TokenList}
+	 * @throws {TypeError} unsupported value
+	 */
+	remove(value) {
+		if (isString(value)) {
+			value.split(" ").forEach((token) => {
+				this.tokens.delete(token.trim());
+			});
+		} else if (isIterable(value)) {
+			for (const token of value) {
+				validateString(token);
+				this.tokens.delete(token.trim());
+			}
+		} else if (typeof value !== "undefined") {
+			throw new TypeError("unsupported value", "types/tokenlist.mjs");
+		}
 
-        return this;
-    }
+		return this;
+	}
 
-    /**
-     * this method replaces a token with a new token.
-     *
-     * if the passed token exists, it is replaced with newToken and TokenList is returned.
-     * if the token does not exist, newToken is not set and TokenList is returned.
-     *
-     * @param {string} token
-     * @param {string} newToken
-     * @returns {TokenList}
-     */
-    replace(token, newToken) {
-        validateString(token);
-        validateString(newToken);
-        if (!this.contains(token)) {
-            return this;
-        }
+	/**
+	 * this method replaces a token with a new token.
+	 *
+	 * if the passed token exists, it is replaced with newToken and TokenList is returned.
+	 * if the token does not exist, newToken is not set and TokenList is returned.
+	 *
+	 * @param {string} token
+	 * @param {string} newToken
+	 * @returns {TokenList}
+	 */
+	replace(token, newToken) {
+		validateString(token);
+		validateString(newToken);
+		if (!this.contains(token)) {
+			return this;
+		}
 
-        let a = Array.from(this.tokens);
-        let i = a.indexOf(token);
-        if (i === -1) return this;
+		const a = Array.from(this.tokens);
+		const i = a.indexOf(token);
+		if (i === -1) return this;
 
-        a.splice(i, 1, newToken);
-        this.tokens = new Set();
-        this.add(a);
+		a.splice(i, 1, newToken);
+		this.tokens = new Set();
+		this.add(a);
 
-        return this;
-    }
+		return this;
+	}
 
-    /**
-     * Removes token from string. If token doesn't exist it's added.
-     *
-     * @externalExample ../../example/types/tokenlist-5.mjs
-     * @param {array|string|iteratable} value
-     * @returns {boolean}
-     * @throws {TypeError} unsupported value
-     */
-    toggle(value) {
-        if (isString(value)) {
-            value.split(" ").forEach((token) => {
-                toggleValue.call(this, token);
-            });
-        } else if (isIterable(value)) {
-            for (let token of value) {
-                toggleValue.call(this, token);
-            }
-        } else if (typeof value !== "undefined") {
-            throw new TypeError("unsupported value", "types/tokenlist.mjs");
-        }
+	/**
+	 * Removes token from string. If token doesn't exist it's added.
+	 *
+	 * @externalExample ../../example/types/tokenlist-5.mjs
+	 * @param {array|string|iteratable} value
+	 * @returns {boolean}
+	 * @throws {TypeError} unsupported value
+	 */
+	toggle(value) {
+		if (isString(value)) {
+			value.split(" ").forEach((token) => {
+				toggleValue.call(this, token);
+			});
+		} else if (isIterable(value)) {
+			for (const token of value) {
+				toggleValue.call(this, token);
+			}
+		} else if (typeof value !== "undefined") {
+			throw new TypeError("unsupported value", "types/tokenlist.mjs");
+		}
 
-        return this;
-    }
+		return this;
+	}
 
-    /**
-     * returns an array with all tokens
-     *
-     * @returns {array}
-     */
-    entries() {
-        return Array.from(this.tokens);
-    }
+	/**
+	 * returns an array with all tokens
+	 *
+	 * @returns {array}
+	 */
+	entries() {
+		return Array.from(this.tokens);
+	}
 
-    /**
-     * executes the provided function with each value of the set
-     *
-     * @param {function} callback
-     * @returns {TokenList}
-     */
-    forEach(callback) {
-        validateFunction(callback);
-        this.tokens.forEach(callback);
-        return this;
-    }
+	/**
+	 * executes the provided function with each value of the set
+	 *
+	 * @param {function} callback
+	 * @returns {TokenList}
+	 */
+	forEach(callback) {
+		validateFunction(callback);
+		this.tokens.forEach(callback);
+		return this;
+	}
 
-    /**
-     * returns the individual tokens separated by a blank character
-     *
-     * @returns {string}
-     */
-    toString() {
-        return this.entries().join(" ");
-    }
+	/**
+	 * returns the individual tokens separated by a blank character
+	 *
+	 * @returns {string}
+	 */
+	toString() {
+		return this.entries().join(" ");
+	}
 }
 
 /**
@@ -251,13 +251,14 @@ class TokenList extends Base {
  * @throws {Error} must be called with TokenList.call
  */
 function toggleValue(token) {
-    if (!(this instanceof TokenList)) throw Error("must be called with TokenList.call");
-    validateString(token);
-    token = token.trim();
-    if (this.contains(token)) {
-        this.remove(token);
-        return this;
-    }
-    this.add(token);
-    return this;
+	if (!(this instanceof TokenList))
+		throw Error("must be called with TokenList.call");
+	validateString(token);
+	token = token.trim();
+	if (this.contains(token)) {
+		this.remove(token);
+		return this;
+	}
+	this.add(token);
+	return this;
 }

package/source/types/typeof.mjs

@@ -20,16 +20,18 @@ export { typeOf };
  * @throws {TypeError} value is not a primitive
  */
 function typeOf(value) {
-    let type = {}.toString.call(value).match(/\s([a-zA-Z]+)/)[1];
-    if ("Object" === type) {
-        const name = value.constructor.name;
-        if (name) {
-            return name.toLowerCase();
-        }
+	let type = {}.toString.call(value).match(/\s([a-zA-Z]+)/)[1];
+	if ("Object" === type) {
+		const name = value.constructor.name;
+		if (name) {
+			return name.toLowerCase();
+		}
 
-        const results = /^(class|function)\s+(\w+)/.exec(value.constructor.toString());
-        type = results && results.length > 2 ? results[2] : "";
-    }
+		const results = /^(class|function)\s+(\w+)/.exec(
+			value.constructor.toString(),
+		);
+		type = results && results.length > 2 ? results[2] : "";
+	}
 
-    return type.toLowerCase();
+	return type.toLowerCase();
 }

package/source/types/uniquequeue.mjs

@@ -21,57 +21,57 @@ export { UniqueQueue };
  * @summary A queue for unique values
  */
 class UniqueQueue extends Queue {
-    /**
-     *
-     */
-    constructor() {
-        super();
-        this[internalSymbol] = {
-            unique: new WeakSet(),
-        };
-    }
+	/**
+	 *
+	 */
+	constructor() {
+		super();
+		this[internalSymbol] = {
+			unique: new WeakSet(),
+		};
+	}
 
-    /**
-     * Add a new element to the end of the queue.
-     *
-     * @param {object} value
-     * @returns {Queue}
-     * @throws {TypeError} value is not a object
-     */
-    add(value) {
-        validateObject(value);
+	/**
+	 * Add a new element to the end of the queue.
+	 *
+	 * @param {object} value
+	 * @returns {Queue}
+	 * @throws {TypeError} value is not a object
+	 */
+	add(value) {
+		validateObject(value);
 
-        if (!this[internalSymbol].unique.has(value)) {
-            this[internalSymbol].unique.add(value);
-            super.add(value);
-        }
+		if (!this[internalSymbol].unique.has(value)) {
+			this[internalSymbol].unique.add(value);
+			super.add(value);
+		}
 
-        return this;
-    }
+		return this;
+	}
 
-    /**
-     * remove all entries
-     *
-     * @returns {Queue}
-     */
-    clear() {
-        super.clear();
-        this[internalSymbol].unique = new WeakSet();
-        return this;
-    }
+	/**
+	 * remove all entries
+	 *
+	 * @returns {Queue}
+	 */
+	clear() {
+		super.clear();
+		this[internalSymbol].unique = new WeakSet();
+		return this;
+	}
 
-    /**
-     * Remove the element at the front of the queue
-     * If the queue is empty, return undefined.
-     *
-     * @return {object}
-     */
-    poll() {
-        if (this.isEmpty()) {
-            return undefined;
-        }
-        let value = this.data.shift();
-        this[internalSymbol].unique.delete(value);
-        return value;
-    }
+	/**
+	 * Remove the element at the front of the queue
+	 * If the queue is empty, return undefined.
+	 *
+	 * @return {object}
+	 */
+	poll() {
+		if (this.isEmpty()) {
+			return undefined;
+		}
+		const value = this.data.shift();
+		this[internalSymbol].unique.delete(value);
+		return value;
+	}
 }

package/source/types/uuid.mjs

@@ -23,34 +23,34 @@ export { UUID };
  * @throws {Error} unsupported
  */
 class UUID extends Base {
-    /**
-     *
-     */
-    constructor() {
-        super();
+	/**
+	 *
+	 */
+	constructor() {
+		super();
 
-        let uuid = createWithCrypto();
+		let uuid = createWithCrypto();
 
-        if (uuid === undefined) {
-            uuid = createWithRandom();
-        }
+		if (uuid === undefined) {
+			uuid = createWithRandom();
+		}
 
-        if (uuid === undefined) {
-            throw new Error("unsupported");
-        }
+		if (uuid === undefined) {
+			throw new Error("unsupported");
+		}
 
-        this[internalSymbol] = {
-            value: uuid,
-        };
-    }
+		this[internalSymbol] = {
+			value: uuid,
+		};
+	}
 
-    /**
-     *
-     * @return {string}
-     */
-    toString() {
-        return this[internalSymbol]["value"];
-    }
+	/**
+	 *
+	 * @return {string}
+	 */
+	toString() {
+		return this[internalSymbol]["value"];
+	}
 }
 
 /**
@@ -58,11 +58,11 @@ class UUID extends Base {
  * @return {string|undefined}
  */
 function createWithRandom() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-        const r = (random(0, 65000) * 16) | 0;
-        const v = c === "x" ? r : (r & 0x3) | 0x8;
-        return v.toString(16)[0];
-    });
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+		const r = (random(0, 65000) * 16) | 0;
+		const v = c === "x" ? r : (r & 0x3) | 0x8;
+		return v.toString(16)[0];
+	});
 }
 
 /**
@@ -70,8 +70,8 @@ function createWithRandom() {
  * @return {string|undefined}
  */
 function createWithCrypto() {
-    const crypt = getGlobalObject("crypto");
-    if (!isObject(crypt)) return;
-    if (typeof crypt?.["randomUUID"]) return;
-    return crypt.randomUUID();
+	const crypt = getGlobalObject("crypto");
+	if (!isObject(crypt)) return;
+	if (typeof crypt?.["randomUUID"]) return;
+	return crypt.randomUUID();
 }