@schukai/monster 3.51.4 → 3.52.0

package/source/types/nodelist.mjs

@@ -21,100 +21,98 @@ export { NodeList };
  * @summary A NodeList class
  */
 class NodeList extends Set {
-    /**
-     * @throws {Error} invalid value type
-     * @param {NodeList|Node|Array<Node>}values
-     */
-    constructor(values) {
-        super();
-
-        const self = this;
-
-        if (values === undefined) return;
-
-        if (isArray(values)) {
-            values.forEach((value) => self.add(value));
-        } else if (isInstance(values, NodeList)) {
-            values.forEach((value) => self.add(value));
-        } else if (isInstance(values, Node)) {
-            self.add(values);
-        } else {
-            throw new Error("invalid value type");
-        }
-    }
-
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/node-list");
-    }
-
-    /**
-     *
-     * @param {Node} node
-     * @return {Monster.Types.NodeList}
-     */
-    add(node) {
-        super.add(validateInstance(node, Node));
-        return this;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {NodeList}
-     */
-    remove(node) {
-        super.delete(validateInstance(node, Node));
-        return this;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
-    has(node) {
-        return super.has(validateInstance(node, Node));
-    }
-
-    /**
-     * @returns {NodeList}
-     */
-    clear() {
-        super.clear();
-        return this;
-    }
-
-    /**
-     * @returns {NodeList}
-     */
-    toArray() {
-        return Array.from(this);
-    }
-
-    /**
-     * @returns {NodeList}
-     */
-    toJSON() {
-        return this.toArray();
-    }
-
-    /**
-     * @returns {NodeList}
-     */
-    toString() {
-        let parts = [];
-
-        for (const node of this.toArray()) {
-            parts.push(node.toString());
-        }
-
-        return parts.join("\n");
-    }
-
-    get length() {
-        return super.size;
-    }
+	/**
+	 * @throws {Error} invalid value type
+	 * @param {NodeList|Node|Array<Node>}values
+	 */
+	constructor(values) {
+		super();
+
+		if (values === undefined) return;
+
+		if (isArray(values)) {
+			values.forEach((value) => this.add(value));
+		} else if (isInstance(values, NodeList)) {
+			values.forEach((value) => this.add(value));
+		} else if (isInstance(values, Node)) {
+			this.add(values);
+		} else {
+			throw new Error("invalid value type");
+		}
+	}
+
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/node-list");
+	}
+
+	/**
+	 *
+	 * @param {Node} node
+	 * @return {Monster.Types.NodeList}
+	 */
+	add(node) {
+		super.add(validateInstance(node, Node));
+		return this;
+	}
+
+	/**
+	 * @param {Node} node
+	 * @returns {NodeList}
+	 */
+	remove(node) {
+		super.delete(validateInstance(node, Node));
+		return this;
+	}
+
+	/**
+	 * @param {Node} node
+	 * @returns {boolean}
+	 */
+	has(node) {
+		return super.has(validateInstance(node, Node));
+	}
+
+	/**
+	 * @returns {NodeList}
+	 */
+	clear() {
+		super.clear();
+		return this;
+	}
+
+	/**
+	 * @returns {NodeList}
+	 */
+	toArray() {
+		return Array.from(this);
+	}
+
+	/**
+	 * @returns {NodeList}
+	 */
+	toJSON() {
+		return this.toArray();
+	}
+
+	/**
+	 * @returns {NodeList}
+	 */
+	toString() {
+		const parts = [];
+
+		for (const node of this.toArray()) {
+			parts.push(node.toString());
+		}
+
+		return parts.join("\n");
+	}
+
+	get length() {
+		return super.size;
+	}
 }

package/source/types/noderecursiveiterator.mjs

@@ -32,63 +32,63 @@ const isNodeListSymbol = Symbol("isNodeList");
  * @summary An iterator to run recursively through a tree of nodes
  */
 class NodeRecursiveIterator extends Base {
-    /**
-     * @param {Node} [data]
-     */
-    constructor(node) {
-        super();
+	/**
+	 * @param {Node} [data]
+	 */
+	constructor(node) {
+		super();
 
-        this[isNodeListSymbol] = false;
+		this[isNodeListSymbol] = false;
 
-        // iterator is a nodelist
-        if (isInstance(node, NodeList)) {
-            let children = node;
-            node = new Node();
-            node.childNodes = children;
-            this[isNodeListSymbol] = true;
-        }
+		// iterator is a nodelist
+		if (isInstance(node, NodeList)) {
+			const children = node;
+			node = new Node();
+			node.childNodes = children;
+			this[isNodeListSymbol] = true;
+		}
 
-        this[internalSymbol] = validateInstance(node, Node);
-    }
+		this[internalSymbol] = validateInstance(node, Node);
+	}
 
-    /**
-     * @private
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield
-     */
-    [Symbol.iterator] = function* () {
-        /**
-         * The end of the generator function is reached. In this case, execution of the generator
-         * ends and an IteratorResult is returned to the caller in which the value is undefined and done is true.
-         * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield
-         */
-        if (this[internalSymbol] === undefined) {
-            return;
-        }
+	/**
+	 * @private
+	 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield
+	 */
+	[Symbol.iterator] = function* () {
+		/**
+		 * The end of the generator function is reached. In this case, execution of the generator
+		 * ends and an IteratorResult is returned to the caller in which the value is undefined and done is true.
+		 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield
+		 */
+		if (this[internalSymbol] === undefined) {
+			return;
+		}
 
-        // iterator is a nodelist and the main node is only a placeholder
-        if (this[isNodeListSymbol] !== true) {
-            yield this[internalSymbol];
-        }
+		// iterator is a nodelist and the main node is only a placeholder
+		if (this[isNodeListSymbol] !== true) {
+			yield this[internalSymbol];
+		}
 
-        if (this[internalSymbol].hasChildNodes()) {
-            let childNodes = this[internalSymbol].childNodes;
+		if (this[internalSymbol].hasChildNodes()) {
+			const childNodes = this[internalSymbol].childNodes;
 
-            for (let node of childNodes) {
-                yield* new NodeRecursiveIterator(node);
-            }
-        }
+			for (const node of childNodes) {
+				yield* new NodeRecursiveIterator(node);
+			}
+		}
 
-        return;
-    };
+		return;
+	};
 
-    /**
-     * @param {function} callback
-     * @return {Monster.Types.NodeRecursiveIterator}
-     */
-    forEach(callback) {
-        for (const node of this) {
-            callback(node);
-        }
-        return this;
-    }
+	/**
+	 * @param {function} callback
+	 * @return {Monster.Types.NodeRecursiveIterator}
+	 */
+	forEach(callback) {
+		for (const node of this) {
+			callback(node);
+		}
+		return this;
+	}
 }

package/source/types/observablequeue.mjs

@@ -24,84 +24,84 @@ export { ObservableQueue };
  * @summary An observable Queue (Fifo)
  */
 class ObservableQueue extends Queue {
-    /**
-     *
-     */
-    constructor() {
-        super();
-        this[internalSymbol] = {
-            observers: new ObserverList(),
-        };
-    }
+	/**
+	 *
+	 */
+	constructor() {
+		super();
+		this[internalSymbol] = {
+			observers: new ObserverList(),
+		};
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/observablequeue");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/observablequeue");
+	}
 
-    /**
-     * Add a new element to the end of the queue.
-     *
-     * @param {*} value
-     * @returns {Queue}
-     */
-    add(value) {
-        super.add(value);
-        this.notifyObservers();
-        return this;
-    }
+	/**
+	 * Add a new element to the end of the queue.
+	 *
+	 * @param {*} value
+	 * @returns {Queue}
+	 */
+	add(value) {
+		super.add(value);
+		this.notifyObservers();
+		return this;
+	}
 
-    /**
-     * remove all entries
-     *
-     * @returns {Queue}
-     */
-    clear() {
-        super.clear();
-        this.notifyObservers();
-        return this;
-    }
+	/**
+	 * remove all entries
+	 *
+	 * @returns {Queue}
+	 */
+	clear() {
+		super.clear();
+		this.notifyObservers();
+		return this;
+	}
 
-    /**
-     * Attach a new observer
-     *
-     * @param {Observer} observer
-     * @returns {ProxyObserver}
-     */
-    attachObserver(observer) {
-        this[internalSymbol].observers.attach(observer);
-        return this;
-    }
+	/**
+	 * Attach a new observer
+	 *
+	 * @param {Observer} observer
+	 * @returns {ProxyObserver}
+	 */
+	attachObserver(observer) {
+		this[internalSymbol].observers.attach(observer);
+		return this;
+	}
 
-    /**
-     * Detach a observer
-     *
-     * @param {Observer} observer
-     * @returns {ProxyObserver}
-     */
-    detachObserver(observer) {
-        this[internalSymbol].observers.detach(observer);
-        return this;
-    }
+	/**
+	 * Detach a observer
+	 *
+	 * @param {Observer} observer
+	 * @returns {ProxyObserver}
+	 */
+	detachObserver(observer) {
+		this[internalSymbol].observers.detach(observer);
+		return this;
+	}
 
-    /**
-     * Notify all observer
-     *
-     * @returns {Promise}
-     */
-    notifyObservers() {
-        return this[internalSymbol].observers.notify(this);
-    }
+	/**
+	 * Notify all observer
+	 *
+	 * @returns {Promise}
+	 */
+	notifyObservers() {
+		return this[internalSymbol].observers.notify(this);
+	}
 
-    /**
-     * @param {Observer} observer
-     * @returns {boolean}
-     */
-    containsObserver(observer) {
-        return this[internalSymbol].observers.contains(observer);
-    }
+	/**
+	 * @param {Observer} observer
+	 * @returns {boolean}
+	 */
+	containsObserver(observer) {
+		return this[internalSymbol].observers.contains(observer);
+	}
 }

package/source/types/observer.mjs

@@ -45,108 +45,108 @@ export { Observer };
  * @memberOf Monster.Types
  */
 class Observer extends Base {
-    /**
-     *
-     * @param {function} callback
-     * @param {*} args
-     */
-    constructor(callback, ...args) {
-        super();
-
-        if (typeof callback !== "function") {
-            throw new Error("observer callback must be a function");
-        }
-
-        this.callback = callback;
-        this.arguments = args;
-        this.tags = new TokenList();
-        this.queue = new UniqueQueue();
-    }
-
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/observer");
-    }
-
-    /**
-     *
-     * @param {string} tag
-     * @returns {Observer}
-     */
-    addTag(tag) {
-        this.tags.add(tag);
-        return this;
-    }
-
-    /**
-     *
-     * @param {string} tag
-     * @returns {Observer}
-     */
-    removeTag(tag) {
-        this.tags.remove(tag);
-        return this;
-    }
-
-    /**
-     *
-     * @returns {Array}
-     */
-    getTags() {
-        return this.tags.entries();
-    }
-
-    /**
-     *
-     * @param {string} tag
-     * @returns {boolean}
-     */
-    hasTag(tag) {
-        return this.tags.contains(tag);
-    }
-
-    /**
-     *
-     * @param {object} subject
-     * @returns {Promise}
-     */
-    update(subject) {
-        let self = this;
-
-        return new Promise(function (resolve, reject) {
-            if (!isObject(subject)) {
-                reject("subject must be an object");
-                return;
-            }
-
-            self.queue.add(subject);
-
-            setTimeout(() => {
-                try {
-                    // the queue and the settimeout ensure that an object is not
-                    // informed of the same change more than once.
-                    if (self.queue.isEmpty()) {
-                        resolve();
-                        return;
-                    }
-
-                    let s = self.queue.poll();
-                    let result = self.callback.apply(s, self.arguments);
-
-                    if (isObject(result) && result instanceof Promise) {
-                        result.then(resolve).catch(reject);
-                        return;
-                    }
-
-                    resolve(result);
-                } catch (e) {
-                    reject(e);
-                }
-            }, 0);
-        });
-    }
+	/**
+	 *
+	 * @param {function} callback
+	 * @param {*} args
+	 */
+	constructor(callback, ...args) {
+		super();
+
+		if (typeof callback !== "function") {
+			throw new Error("observer callback must be a function");
+		}
+
+		this.callback = callback;
+		this.arguments = args;
+		this.tags = new TokenList();
+		this.queue = new UniqueQueue();
+	}
+
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/observer");
+	}
+
+	/**
+	 *
+	 * @param {string} tag
+	 * @returns {Observer}
+	 */
+	addTag(tag) {
+		this.tags.add(tag);
+		return this;
+	}
+
+	/**
+	 *
+	 * @param {string} tag
+	 * @returns {Observer}
+	 */
+	removeTag(tag) {
+		this.tags.remove(tag);
+		return this;
+	}
+
+	/**
+	 *
+	 * @returns {Array}
+	 */
+	getTags() {
+		return this.tags.entries();
+	}
+
+	/**
+	 *
+	 * @param {string} tag
+	 * @returns {boolean}
+	 */
+	hasTag(tag) {
+		return this.tags.contains(tag);
+	}
+
+	/**
+	 *
+	 * @param {object} subject
+	 * @returns {Promise}
+	 */
+	update(subject) {
+		const self = this;
+
+		return new Promise(function (resolve, reject) {
+			if (!isObject(subject)) {
+				reject("subject must be an object");
+				return;
+			}
+
+			self.queue.add(subject);
+
+			setTimeout(() => {
+				try {
+					// the queue and the settimeout ensure that an object is not
+					// informed of the same change more than once.
+					if (self.queue.isEmpty()) {
+						resolve();
+						return;
+					}
+
+					const s = self.queue.poll();
+					const result = self.callback.apply(s, self.arguments);
+
+					if (isObject(result) && result instanceof Promise) {
+						result.then(resolve).catch(reject);
+						return;
+					}
+
+					resolve(result);
+				} catch (e) {
+					reject(e);
+				}
+			}, 0);
+		});
+	}
 }