@schukai/monster 4.153.0 → 4.153.1

package/package.json

@@ -1 +1 @@
-{"author":"Volker Schukai","dependencies":{"@floating-ui/dom":"^1.7.6"},"description":"Monster is a simple library for creating fast, robust and lightweight websites.","files":["source","test/cases","test/util","CHANGELOG.md"],"homepage":"https://monsterjs.org/","keywords":["framework","web","dom","css","sass","mobile-first","app","front-end","templates","schukai","core","shopcloud","alvine","monster","buildmap","stack","observer","observable","uuid","node","nodelist","css-in-js","logger","log","theme"],"license":"AGPL 3.0","main":"source/monster.mjs","module":"source/monster.mjs","name":"@schukai/monster","repository":{"type":"git","url":"https://gitlab.schukai.com/oss/libraries/javascript/monster.git"},"type":"module","version":"4.153.0"}
+{"author":"Volker Schukai","dependencies":{"@floating-ui/dom":"^1.7.6"},"description":"Monster is a simple library for creating fast, robust and lightweight websites.","files":["source","test/cases","test/util","CHANGELOG.md"],"homepage":"https://monsterjs.org/","keywords":["framework","web","dom","css","sass","mobile-first","app","front-end","templates","schukai","core","shopcloud","alvine","monster","buildmap","stack","observer","observable","uuid","node","nodelist","css-in-js","logger","log","theme"],"license":"AGPL 3.0","main":"source/monster.mjs","module":"source/monster.mjs","name":"@schukai/monster","repository":{"type":"git","url":"https://gitlab.schukai.com/oss/libraries/javascript/monster.git"},"type":"module","version":"4.153.1"}

package/source/data/buildmap.mjs

@@ -362,7 +362,8 @@ function buildFlatMap(subject, selector, key, parentMap) {
  * @return {*}
  */
 export function build(subject, definition, defaultValue) {
-	if (definition === undefined) return defaultValue ? defaultValue : subject;
+	if (definition === undefined)
+		return defaultValue !== undefined ? defaultValue : subject;
 	validateString(definition);
 
 	const regexp = /(?<placeholder>\${(?<path>[a-z\^A-Z.\-_0-9]*)})/gm;
@@ -384,7 +385,7 @@ export function build(subject, definition, defaultValue) {
 		let v = finder.getVia(path);
 		if (v === undefined) v = defaultValue;
 
-		definition = definition.replaceAll(placeholder, v);
+		definition = definition.replaceAll(placeholder, () => `${v}`);
 	});
 
 	return definition;

package/source/data/buildtree.mjs

@@ -21,12 +21,6 @@ import { extend } from "./extend.mjs";
 
 export { buildTree };
 
-/**
- * @private
- * @type {symbol}
- */
-const parentSymbol = Symbol("parent");
-
 /**
  * @private
  * @type {symbol}
@@ -171,8 +165,6 @@ function buildTree(subject, selector, idKey, parentIDKey, options) {
 			throw new Error("the object has no value for the specified id");
 		}
 
-		o[parentSymbol] = ref;
-
 		const node = new Node(o);
 		this.has(ref)
 			? this.get(ref).add(node)

package/source/data/pathfinder.mjs

@@ -217,16 +217,24 @@ function iterate(subject, path, check) {
 
 	const result = new Map();
 
-	if (isArray(path)) {
-		path = path.join(DELIMITER);
-	}
-
-	if (isObject(subject) || isArray(subject)) {
+	if (subject instanceof Map) {
+		for (const [key, value] of subject) {
+			result.set(key, getValueViaPath.call(this, value, path, check));
+		}
+	} else if (subject instanceof Set) {
+		let index = 0;
+		for (const value of subject) {
+			result.set(
+				`${index++}`,
+				getValueViaPath.call(this, value, path, check),
+			);
+		}
+	} else if (isObject(subject) || isArray(subject)) {
 		for (const [key, value] of Object.entries(subject)) {
 			result.set(key, getValueViaPath.call(this, value, path, check));
 		}
 	} else {
-		const key = path.split(DELIMITER).shift();
+		const key = isArray(path) ? path[0] : path.split(DELIMITER).shift();
 		result.set(key, getValueViaPath.call(this, subject, path, check));
 	}
 
@@ -272,7 +280,7 @@ function getValueViaPath(subject, path, check) {
 	let current = parts.shift();
 
 	if (current === this.wildCard) {
-		return iterate.call(this, subject, parts.join(DELIMITER), check);
+		return iterate.call(this, subject, parts, check);
 	}
 
 	if (isObject(subject) || isArray(subject)) {
@@ -280,23 +288,21 @@ function getValueViaPath(subject, path, check) {
 		if (subject instanceof Map || subject instanceof WeakMap) {
 			anchor = subject.get(current);
 		} else if (subject instanceof Set) {
-			current = parseInt(current);
-			validateInteger(current);
+			current = parsePathIndex(current);
 			anchor = [...subject]?.[current];
 		} else if (subject instanceof WeakSet) {
 			throw Error("unsupported action for this data type (WeakSet)");
 		} else if (typeof WeakRef === "function" && subject instanceof WeakRef) {
 			throw Error("unsupported action for this data type (WeakRef)");
 		} else if (isArray(subject)) {
-			current = parseInt(current);
-			validateInteger(current);
+			current = parsePathIndex(current);
 			anchor = subject?.[current];
 		} else {
 			anchor = subject?.[current];
 		}
 
 		if (isObject(anchor) || isArray(anchor)) {
-			return getValueViaPath.call(this, anchor, parts.join(DELIMITER), check);
+			return getValueViaPath.call(this, anchor, parts, check);
 		}
 
 		if (parts.length > 0) {
@@ -304,12 +310,18 @@ function getValueViaPath(subject, path, check) {
 		}
 
 		if (check === true) {
-			const descriptor = Object.getOwnPropertyDescriptor(
-				Object.getPrototypeOf(subject),
-				current,
-			);
+			let exists;
+			if (subject instanceof Map || subject instanceof WeakMap) {
+				exists = subject.has(current);
+			} else if (subject instanceof Set) {
+				exists = current >= 0 && current < subject.size;
+			} else if (isArray(subject)) {
+				exists = Reflect.has(subject, current);
+			} else {
+				exists = Reflect.has(subject, current);
+			}
 
-			if (!subject.hasOwnProperty(current) && descriptor === undefined) {
+			if (!exists) {
 				throw Error("unknown value " + current);
 			}
 		}
@@ -411,7 +423,7 @@ function setValueViaPath(subject, path, value) {
  * @param {*} value
  */
 function assignProperty(object, key, value) {
-	if (!object.hasOwnProperty(key)) {
+	if (!Object.hasOwn(object, key)) {
 		object[key] = value;
 		return;
 	}
@@ -423,6 +435,21 @@ function assignProperty(object, key, value) {
 	object[key] = value;
 }
 
+/**
+ * Convert a complete integer path segment without accepting trailing text.
+ * @param {*} value
+ * @return {number}
+ * @private
+ */
+function parsePathIndex(value) {
+	if (!/^-?\d+$/.test(`${value}`)) {
+		throw new TypeError("value is not an integer");
+	}
+	const index = Number(value);
+	validateInteger(index);
+	return index;
+}
+
 /**
  *
  * @param {object} subject
@@ -486,7 +513,9 @@ function deleteValueViaPath(subject, path) {
  * @private
  */
 function validateMutationPath(path) {
-	const parts = isArray(path) ? path : path.split(DELIMITER);
+	const parts = (isArray(path) ? path : [path]).flatMap((part) =>
+		`${part}`.split(DELIMITER),
+	);
 	for (const part of parts) {
 		if (UNSAFE_MUTATION_PATH_SEGMENTS.has(`${part}`)) {
 			throw new Error(`unsafe mutation path segment: ${part}`);

package/source/data/transformer.mjs

@@ -530,7 +530,7 @@ function transform(value) {
 
 			const useKey = keys?.[key];
 
-			if (value?.[useKey]) {
+			if (useKey !== undefined && Reflect.has(value, useKey)) {
 				return value?.[useKey];
 			}
 
@@ -555,7 +555,7 @@ function transform(value) {
 			}
 
 			if (isObject(value) || isArray(value)) {
-				if (value?.[key]) {
+				if (Reflect.has(value, key)) {
 					return value?.[key];
 				}
 

package/source/dom/customcontrol.mjs

@@ -377,6 +377,7 @@ function getInternal() {
 }
 
 const debounceValueSymbol = Symbol("debounceValue");
+const pendingValueAttributeSymbol = Symbol("pendingValueAttribute");
 
 /**
  *
@@ -388,7 +389,17 @@ const debounceValueSymbol = Symbol("debounceValue");
  */
 function initValueAttributeObserver() {
 	const self = this;
-	this[attributeObserverSymbol]["value"] = () => {
+	this[attributeObserverSymbol]["value"] = (newValue, oldValue) => {
+		if (!self[pendingValueAttributeSymbol]) {
+			self[pendingValueAttributeSymbol] = {
+				oldValue: normalizeAttributeValue(oldValue),
+				newValue: normalizeAttributeValue(newValue),
+			};
+		} else {
+			self[pendingValueAttributeSymbol].newValue =
+				normalizeAttributeValue(newValue);
+		}
+
 		if (self[debounceValueSymbol] instanceof DeadMansSwitch) {
 			try {
 				self[debounceValueSymbol].touch();
@@ -402,18 +413,33 @@ function initValueAttributeObserver() {
 		}
 
 		self[debounceValueSymbol] = new DeadMansSwitch(10, () => {
-			const oldValue = self.getAttribute("value");
-			const newValue = self.value;
-
-			if (oldValue !== newValue) {
-				setTimeout(() => {
-					self.value = self.getAttribute("value") ?? "";
-				}, 0);
-			}
+			const pending = self[pendingValueAttributeSymbol];
+			delete self[pendingValueAttributeSymbol];
+			delete self[debounceValueSymbol];
+			if (!pending) return;
+
+			setTimeout(() => {
+				const currentValue = normalizeAttributeValue(self.value);
+				if (
+					currentValue === pending.oldValue &&
+					currentValue !== pending.newValue
+				) {
+					self.value = pending.newValue;
+				}
+			}, 0);
 		});
 	};
 }
 
+/**
+ * @param {*} value
+ * @return {string}
+ * @private
+ */
+function normalizeAttributeValue(value) {
+	return value === null || value === undefined ? "" : String(value);
+}
+
 const disabledSyncSymbol = Symbol("disabledSync");
 const disabledAttributeSyncSymbol = Symbol("disabledAttributeSync");
 

package/source/dom/customelement.mjs

@@ -734,7 +734,10 @@ class CustomElement extends HTMLElement {
 		// Initialize the custom elements inside the shadow root and the slotted elements
 		initFromCallbackHost.call(this);
 		try {
-			nodeList = new Set([...elements, ...getSlottedElements.call(this)]);
+			nodeList = new Set([
+				...elements,
+				...getSlottedElements.call(this, undefined, undefined, getManagedShadowRoot.call(this)),
+			]);
 		} catch (e) {
 			nodeList = elements;
 		}
@@ -1133,7 +1136,12 @@ function initOptionObserver() {
 					targets.add(element);
 				}
 			}
-			for (const element of getSlottedElements.call(self, disabledQuery)) {
+			for (const element of getSlottedElements.call(
+				self,
+				disabledQuery,
+				undefined,
+				getManagedShadowRoot.call(self),
+			)) {
 				targets.add(element);
 			}
 		} catch (e) {}
@@ -1293,6 +1301,17 @@ function syncUpdaterSubject(target, source) {
 		return;
 	}
 
+	// Empty option objects are also used as refresh markers by editable
+	// datasource components. Keep their established merge behavior while
+	// allowing non-empty replacement objects to remove stale keys.
+	if (Object.keys(source).length > 0) {
+		for (const key of Object.keys(target)) {
+			if (!Object.hasOwn(source, key)) {
+				delete target[key];
+			}
+		}
+	}
+
 	for (const [key, value] of Object.entries(source)) {
 		syncUpdaterValue(target, key, value);
 	}

package/source/dom/slotted.mjs

@@ -27,37 +27,33 @@ export { getSlottedElements, getSlottedNodes };
  * @since 3.33.0
  * @throws {Error} query must be a string
  */
-function getSlottedNodes(query, name) {
+function getSlottedNodes(query, name, managedShadowRoot) {
 	const result = new Set();
+	const shadowRoot = getShadowRoot(this, managedShadowRoot);
 
-	if (!this.shadowRoot) {
+	if (!(shadowRoot instanceof ShadowRoot)) {
 		return result;
 	}
 
-	let selector = "slot";
-	if (name !== undefined) {
-		if (name === null) {
-			selector += ":not([name])";
-		} else {
-			selector += `[name=${validateString(name)}]`;
-		}
-	}
-
-	const slots = this.shadowRoot.querySelectorAll(selector);
+	const slots = getSlotsByName(shadowRoot, name);
 
-	for (const [, slot] of Object.entries(slots)) {
+	for (const slot of slots) {
 		slot.assignedNodes().forEach(function (node) {
 			if (node === null || node === undefined) {
 				return;
 			}
 
 			if (isString(query)) {
-				node.querySelectorAll(query).forEach(function (n) {
-					result.add(n);
-				});
-
-				if (node.matches(query)) {
+				if (query.length === 0) {
 					result.add(node);
+				} else if (node instanceof Element) {
+					node.querySelectorAll(query).forEach(function (n) {
+						result.add(n);
+					});
+
+					if (node.matches(query)) {
+						result.add(node);
+					}
 				}
 			} else if (query !== undefined) {
 				throw new Error("query must be a string");
@@ -80,25 +76,17 @@ function getSlottedNodes(query, name) {
  * @since 1.23.0
  * @throws {Error} query must be a string
  */
-function getSlottedElements(query, name) {
+function getSlottedElements(query, name, managedShadowRoot) {
 	const result = new Set();
+	const shadowRoot = getShadowRoot(this, managedShadowRoot);
 
-	if (!(this.shadowRoot instanceof ShadowRoot)) {
+	if (!(shadowRoot instanceof ShadowRoot)) {
 		return result;
 	}
 
-	let selector = "slot";
-	if (name !== undefined) {
-		if (name === null) {
-			selector += ":not([name])";
-		} else {
-			selector += `[name=${validateString(name)}]`;
-		}
-	}
-
-	const slots = this.shadowRoot.querySelectorAll(selector);
+	const slots = getSlotsByName(shadowRoot, name);
 
-	for (const [, slot] of Object.entries(slots)) {
+	for (const slot of slots) {
 		slot.assignedElements().forEach(function (node) {
 			if (
 				!(node instanceof HTMLElement) &&
@@ -129,3 +117,30 @@ function getSlottedElements(query, name) {
 
 	return result;
 }
+
+/**
+ * @param {*} host
+ * @param {*} managedShadowRoot
+ * @return {ShadowRoot|null}
+ * @private
+ */
+function getShadowRoot(host, managedShadowRoot) {
+	if (managedShadowRoot instanceof ShadowRoot) return managedShadowRoot;
+	return host?.shadowRoot instanceof ShadowRoot ? host.shadowRoot : null;
+}
+
+/**
+ * Filter slots by their DOM name instead of interpolating an unsafe selector.
+ * @param {ShadowRoot} shadowRoot
+ * @param {string|undefined|null} name
+ * @return {HTMLSlotElement[]}
+ * @private
+ */
+function getSlotsByName(shadowRoot, name) {
+	if (name !== undefined && name !== null) validateString(name);
+	return Array.from(shadowRoot.querySelectorAll("slot")).filter((slot) => {
+		if (name === undefined) return true;
+		if (name === null) return slot.name === "";
+		return slot.name === name;
+	});
+}

package/source/dom/template.mjs

@@ -156,7 +156,10 @@ export function findDocumentTemplate(id, currentNode) {
 		)
 	) {
 		if (currentNode instanceof Node) {
-			if (currentNode.hasAttribute(ATTRIBUTE_TEMPLATE_PREFIX)) {
+			if (
+				currentNode instanceof Element &&
+				currentNode.hasAttribute(ATTRIBUTE_TEMPLATE_PREFIX)
+			) {
 				prefixID = currentNode.getAttribute(ATTRIBUTE_TEMPLATE_PREFIX);
 			}
 

package/source/dom/updater.mjs

@@ -803,17 +803,34 @@ function parseIntArray(val) {
  * @private
  */
 function retrieveFromBindings() {
-	if (this[internalSymbol].element.matches(`[${ATTRIBUTE_UPDATER_BIND}]`)) {
+	if (
+		this[internalSymbol].element.matches(`[${ATTRIBUTE_UPDATER_BIND}]`) &&
+		!isUncheckedRadio(this[internalSymbol].element)
+	) {
 		retrieveAndSetValue.call(this, this[internalSymbol].element);
 	}
 
 	for (const [, element] of this[internalSymbol].element
 		.querySelectorAll(`[${ATTRIBUTE_UPDATER_BIND}]`)
 		.entries()) {
+		if (isUncheckedRadio(element)) continue;
 		retrieveAndSetValue.call(this, element);
 	}
 }
 
+/**
+ * @param {HTMLElement} element
+ * @return {boolean}
+ * @private
+ */
+function isUncheckedRadio(element) {
+	return (
+		element instanceof HTMLInputElement &&
+		element.type === "radio" &&
+		element.checked === false
+	);
+}
+
 /**
  * @private
  * @license AGPLv3
@@ -1201,7 +1218,10 @@ function getSlots(container, cache) {
 		return cache.get(container);
 	}
 
-	const slots = container.querySelectorAll("slot");
+	const slots = Array.from(container.querySelectorAll("slot"));
+	if (container.localName === "slot") {
+		slots.unshift(container);
+	}
 	cache.set(container, slots);
 	return slots;
 }
@@ -1565,6 +1585,9 @@ function replaceKeyedPatchedChildren(
 			const nextNode = preparePatchedNode(reused, renderedValue);
 			nextNode[patchNodeKeySymbol] = normalizedKey;
 			if (nextNode !== reused && reused.parentNode === element) {
+				if (reused instanceof HTMLElement) {
+					teardownManagedSubtree(reused);
+				}
 				element.replaceChild(nextNode, reused);
 			}
 			nextNodes.push(nextNode);
@@ -1591,15 +1614,11 @@ function replaceKeyedPatchedChildren(
 		}
 	}
 
-	for (const node of nextNodes) {
-		if (node.parentNode !== element) {
-			element.appendChild(node);
-			continue;
-		}
-
-		if (element.lastChild !== node) {
-			element.appendChild(node);
-		}
+	for (let index = 0; index < nextNodes.length; index++) {
+		const node = nextNodes[index];
+		const current = element.childNodes[index] ?? null;
+		if (current === node) continue;
+		element.insertBefore(node, current);
 	}
 }
 
@@ -1851,8 +1870,7 @@ function runUpdateAttributes(
 			if (
 				!element.hasAttribute(ATTRIBUTE_UPDATER_SELECT_THIS) &&
 				!attributes.includes(`path:${current}`) &&
-				!attributes.startsWith("static:") &&
-				!attributes.startsWith("i18n:")
+				!hasUnconditionalBinding(attributes)
 			) {
 				continue;
 			}
@@ -1933,8 +1951,7 @@ function runUpdateProperties(
 			if (
 				!element.hasAttribute(ATTRIBUTE_UPDATER_SELECT_THIS) &&
 				!properties.includes(`path:${current}`) &&
-				!properties.startsWith("static:") &&
-				!properties.startsWith("i18n:")
+				!hasUnconditionalBinding(properties)
 			) {
 				continue;
 			}
@@ -1981,6 +1998,9 @@ function runUpdateProperties(
 
 function handleInputControlAttributeUpdate(element, name, value) {
 	if (element instanceof HTMLSelectElement) {
+		if (name !== "value") {
+			return;
+		}
 		switch (element.type) {
 			case "select-multiple":
 				const selectedValues = isArray(value)
@@ -2054,6 +2074,22 @@ function handleInputControlAttributeUpdate(element, name, value) {
 	}
 }
 
+/**
+ * Check whether an attribute/property definition contains a command that is
+ * independent from the changed subject path.
+ * @param {string} definitions
+ * @return {boolean}
+ * @private
+ */
+function hasUnconditionalBinding(definitions) {
+	return definitions.split(",").some((definition) => {
+		const separator = definition.indexOf(" ");
+		if (separator < 0) return false;
+		const command = trimSpaces(definition.substring(separator + 1));
+		return command.startsWith("static:") || command.startsWith("i18n:");
+	});
+}
+
 /**
  * @private
  * @param {HTMLElement|*} element

package/source/types/node.mjs

@@ -199,8 +199,6 @@ class Node extends Base {
  * @return {setChildLevelAndParent}
  */
 function setChildLevelAndParent(node, operand, visitedNodes) {
-	const self = this;
-
 	if (visitedNodes.has(node)) {
 		throw new Error(
 			"the node has already been visited and cannot be traversed again",
@@ -217,7 +215,7 @@ function setChildLevelAndParent(node, operand, visitedNodes) {
 		child[treeStructureSymbol].parent = node;
 		child[treeStructureSymbol].level =
 			node[treeStructureSymbol].level + operand;
-		setChildLevelAndParent.call(self, child, operand, visitedNodes);
+		setChildLevelAndParent.call(node, child, operand, visitedNodes);
 	});
 	return this;
 }

package/source/types/proxyobserver.mjs

@@ -156,6 +156,15 @@ function getHandler() {
 			}
 
 			const value = Reflect.get(target, key, receiver);
+			const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+			if (
+				descriptor &&
+				descriptor.configurable === false &&
+				"value" in descriptor &&
+				descriptor.writable === false
+			) {
+				return value;
+			}
 
 			if (typeof key === "symbol") {
 				return value;
@@ -233,16 +242,12 @@ function getHandler() {
 
 		// https://262.ecma-international.org/9.0/#sec-proxy-object-internal-methods-and-internal-slots-delete-p
 		deleteProperty: function (target, key) {
-			if (key in target) {
-				delete target[key];
-
-				if (typeof key !== "symbol") {
-					proxy.observers.notify(proxy);
-				}
-
-				return true;
+			const hadOwnProperty = Object.hasOwn(target, key);
+			const result = Reflect.deleteProperty(target, key);
+			if (result && hadOwnProperty && typeof key !== "symbol") {
+				proxy.observers.notify(proxy);
 			}
-			return false;
+			return result;
 		},
 
 		// https://262.ecma-international.org/9.0/#sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc
@@ -277,5 +282,22 @@ function getHandler() {
  * @private
  */
 function isNativeObjectWithInternalSlots(value) {
-	return value instanceof Date || value instanceof Map || value instanceof Set;
+	if (
+		value instanceof Date ||
+		value instanceof RegExp ||
+		value instanceof Map ||
+		value instanceof Set ||
+		value instanceof WeakMap ||
+		value instanceof WeakSet ||
+		value instanceof Promise ||
+		value instanceof ArrayBuffer ||
+		ArrayBuffer.isView(value)
+	) {
+		return true;
+	}
+
+	return (
+		typeof SharedArrayBuffer === "function" &&
+		value instanceof SharedArrayBuffer
+	);
 }

package/test/cases/data/buildmap.mjs

@@ -6,6 +6,20 @@ import {buildMap} from "../../../source/data/buildmap.mjs";
 
 describe('buildMap', function () {
 
+    describe('falsy keys and literal replacements issue #569', function () {
+        it('should preserve a zero key returned by a selector callback', function () {
+            const value = {label: 'zero'};
+            const map = buildMap({}, () => new Map([[0, value]]), '${label}');
+            expect([...map]).to.deep.equal([[0, 'zero']]);
+        });
+
+        it('should insert replacement tokens literally', function () {
+            const value = {label: '$&-$`-$\''};
+            const map = buildMap({}, () => new Map([['key', value]]), '${label}');
+            expect(map.get('key')).to.equal('$&-$`-$\'');
+        });
+    });
+
     let convertMapResult = function (r) {
         if (r instanceof Map) {
             r = Object.fromEntries(r);

package/test/cases/data/buildtree.mjs

@@ -170,6 +170,55 @@ describe('buildTree', function () {
 
     });
 
+    describe('parent metadata issue #568', function () {
+        const createTree = (records) => buildTree(
+            records,
+            (values) => new Map(values.map((value, index) => [index, value])),
+            'id',
+            'parent',
+        );
+
+        [
+            [
+                {id: 1, parent: null},
+                {id: 2, parent: 1},
+                {id: 3, parent: 2},
+            ],
+            [
+                {id: 3, parent: 2},
+                {id: 2, parent: 1},
+                {id: 1, parent: null},
+            ],
+        ].forEach((records, index) => {
+            it(`should retain immediate parents independent of input order ${index + 1}`, function () {
+                const tree = createTree(records);
+                const root = [...tree][0];
+                const child = [...root.childNodes][0];
+                const leaf = [...child.childNodes][0];
+
+                expect(root.parent).to.equal(null);
+                expect(root.level).to.equal(0);
+                expect(child.parent).to.equal(root);
+                expect(child.level).to.equal(1);
+                expect(leaf.parent).to.equal(child);
+                expect(leaf.level).to.equal(2);
+            });
+        });
+
+        it('should preserve frozen input records and their identity', function () {
+            const rootValue = Object.freeze({id: 1, parent: null});
+            const childValue = Object.freeze({id: 2, parent: 1});
+            const tree = createTree(Object.freeze([childValue, rootValue]));
+            const root = [...tree][0];
+            const child = [...root.childNodes][0];
+
+            expect(root.value).to.equal(rootValue);
+            expect(child.value).to.equal(childValue);
+            expect(Reflect.ownKeys(rootValue)).to.deep.equal(['id', 'parent']);
+            expect(Reflect.ownKeys(childValue)).to.deep.equal(['id', 'parent']);
+        });
+    });
+
     describe('buildTree() test 2', function () {
 
         /**

package/test/cases/data/pathfinder.mjs

@@ -17,6 +17,8 @@ describe('Pathfinder', function () {
             `constructor.prototype.${probe}`,
             ['__proto__', probe],
             ['constructor', 'prototype', probe],
+            [`safe.__proto__`, probe],
+            [`safe.constructor.prototype`, probe],
         ].forEach(function (path) {
             it(`setVia(${JSON.stringify(path)}) should reject unsafe mutation paths`, function () {
                 try {
@@ -108,6 +110,38 @@ describe('Pathfinder', function () {
             expect(() => new Pathfinder({values}).setVia('values.next', {}))
                 .to.throw(Error, 'unsupported action for this data type in setValueViaPath');
         });
+
+        it('exists() should use collection membership semantics', function () {
+            expect(new Pathfinder(new Map([['entry', 0]])).exists('entry')).to.equal(true);
+            expect(new Pathfinder(new Map()).exists('entry')).to.equal(false);
+            expect(new Pathfinder(new Set([false])).exists('0')).to.equal(true);
+            expect(new Pathfinder(new Set()).exists('0')).to.equal(false);
+        });
+
+        it('wildcards should enumerate Map and Set values', function () {
+            expect([...new Pathfinder(new Map([['entry', false]])).getVia('*')])
+                .to.deep.equal([['entry', false]]);
+            expect([...new Pathfinder(new Set(['first', 'second'])).getVia('*')])
+                .to.deep.equal([['0', 'first'], ['1', 'second']]);
+        });
+
+        it('collection indices should reject trailing characters', function () {
+            expect(() => new Pathfinder(['first', 'second']).getVia('1suffix'))
+                .to.throw(TypeError);
+            expect(() => new Pathfinder(new Set(['first', 'second'])).getVia('1suffix'))
+                .to.throw(TypeError);
+        });
+
+        it('should support null-prototype objects', function () {
+            const subject = Object.assign(Object.create(null), {present: false});
+            const pathfinder = new Pathfinder(subject);
+
+            expect(pathfinder.getVia('present')).to.equal(false);
+            expect(pathfinder.exists('present')).to.equal(true);
+            expect(pathfinder.exists('missing')).to.equal(false);
+            pathfinder.setVia('next', 0);
+            expect(subject.next).to.equal(0);
+        });
     });
 
     let convertMapResult = function (r) {

package/test/cases/data/transformer.mjs

@@ -8,6 +8,32 @@ import {initJSDOM} from "../../util/jsdom.mjs";
 
 describe('Transformer', function () {
 
+    describe('falsy property values issue #569', function () {
+        [
+            ['key:value:fallback', {value: 0}, 0],
+            ['property:value:fallback', {value: false}, false],
+            ['index:0:fallback', [''], ''],
+            ['key:value:fallback', {value: null}, null],
+            ['first-key:fallback', {a: false}, false],
+            ['last-key:fallback', {a: 1, z: 0}, 0],
+        ].forEach(([definition, value, expected]) => {
+            it(`${definition} should preserve ${String(expected)}`, function () {
+                expect(new Transformer(definition).run(value)).to.equal(expected);
+            });
+        });
+
+        it('should distinguish inherited and missing properties', function () {
+            const inherited = Object.create({value: false});
+            expect(new Transformer('key:value:fallback').run(inherited)).to.equal(false);
+            expect(new Transformer('key:missing:fallback').run(inherited)).to.equal('fallback');
+        });
+
+        it('should support null-prototype objects', function () {
+            const value = Object.assign(Object.create(null), {entry: 0});
+            expect(new Transformer('key:entry:fallback').run(value)).to.equal(0);
+        });
+    });
+
     before(function (done) {
 
         let promises = []

package/test/cases/dom/customcontrol.mjs

@@ -384,6 +384,91 @@ describe('DOM', function () {
                     control.remove();
                 });
 
+                it('should not let a stale value attribute overwrite a newer property issue #566', async function () {
+                    const htmlTAG = 'monster-customcontrol-value-race-566';
+
+                    class ValueRaceComponent extends CustomControl {
+                        static getTag() {
+                            return htmlTAG;
+                        }
+
+                        get defaults() {
+                            return Object.assign({}, super.defaults, {shadowMode: false});
+                        }
+
+                        get value() {
+                            return this._value ?? '';
+                        }
+
+                        set value(value) {
+                            this._value = value;
+                        }
+                    }
+
+                    registerCustomElement(ValueRaceComponent);
+                    const control = document.createElement(htmlTAG);
+                    document.body.appendChild(control);
+
+                    control.setAttribute('value', 'attribute-value');
+                    control.value = 'newer-property-value';
+                    await new Promise((resolve) => setTimeout(resolve, 30));
+
+                    expect(control.getAttribute('value')).to.equal('attribute-value');
+                    expect(control.value).to.equal('newer-property-value');
+                    control.remove();
+                });
+
+                it('should coalesce rapid value attributes and preserve reflected setters issue #566', async function () {
+                    const htmlTAG = 'monster-customcontrol-reflected-value-566';
+
+                    class ReflectedValueComponent extends CustomControl {
+                        static getTag() {
+                            return htmlTAG;
+                        }
+
+                        get defaults() {
+                            return Object.assign({}, super.defaults, {shadowMode: false});
+                        }
+
+                        get value() {
+                            return this._value ?? '';
+                        }
+
+                        set value(value) {
+                            this._value = String(value ?? '');
+                            if (this.getAttribute('value') !== this._value) {
+                                this.setAttribute('value', this._value);
+                            }
+                        }
+                    }
+
+                    registerCustomElement(ReflectedValueComponent);
+                    const control = document.createElement(htmlTAG);
+                    document.body.appendChild(control);
+                    control.setAttribute('value', 'first');
+                    control.setAttribute('value', 'second');
+	                    await new Promise((resolve, reject) => {
+	                        const deadline = Date.now() + 500;
+	                        const check = () => {
+	                            if (control.value === 'second') {
+	                                resolve();
+	                            } else if (Date.now() >= deadline) {
+	                                reject(new Error('value attribute synchronization timed out'));
+	                            } else {
+	                                setTimeout(check, 5);
+	                            }
+	                        };
+	                        check();
+	                    });
+                    expect(control.value).to.equal('second');
+
+                    control.value = 'reflected';
+                    await new Promise((resolve) => setTimeout(resolve, 30));
+                    expect(control.value).to.equal('reflected');
+                    expect(control.getAttribute('value')).to.equal('reflected');
+                    control.remove();
+                });
+
                 it('should replay a pre-upgrade value once after assembly issue #501', async function () {
                     const htmlTAG = 'monster-customcontrol-pre-upgrade';
                     const control = document.createElement(htmlTAG);

package/test/cases/dom/customelement.mjs

@@ -587,6 +587,60 @@ describe('DOM', function () {
                     linkedUpdater[internalSymbol].subject.detachObserver(observer);
                 }
             });
+
+            it('should remove stale updater keys after replacing an option object issue #565', async function () {
+                const htmlTAG = 'monster-testclass-object-sync-565';
+
+                if (!customElements.get(htmlTAG)) {
+                    class ObjectSyncComponent extends CustomElement {
+                        static getTag() {
+                            return htmlTAG;
+                        }
+
+                        get defaults() {
+                            return Object.assign({}, super.defaults, {
+                                settings: {a: 'initial', b: 'retained'},
+                                templates: {
+                                    main: '<span data-monster-replace="path:settings.a"></span>',
+                                },
+                            });
+                        }
+                    }
+
+                    registerCustomElement(ObjectSyncComponent);
+                }
+
+                const element = document.createElement(htmlTAG);
+                document.getElementById('test1').appendChild(element);
+                await new Promise((resolve) => setTimeout(resolve, 20));
+
+                let linkedUpdater;
+                for (const group of element[customElementUpdaterLinkSymbol]) {
+                    for (const updater of group) {
+                        linkedUpdater = updater;
+                        break;
+                    }
+                    if (linkedUpdater) break;
+                }
+                expect(linkedUpdater).to.exist;
+
+                element.setOptions({settings: {a: 'merged'}});
+                await new Promise((resolve) => setTimeout(resolve, 20));
+                expect(linkedUpdater.getSubject().settings).to.deep.include({
+                    a: 'merged',
+                    b: 'retained',
+                });
+
+                const settingsProxy = linkedUpdater.getSubject().settings;
+                element.setOption('settings', {a: 'replacement'});
+                await new Promise((resolve) => setTimeout(resolve, 20));
+
+                expect(linkedUpdater.getSubject().settings).to.equal(settingsProxy);
+                expect(linkedUpdater.getSubject().settings).to.deep.equal({
+                    a: 'replacement',
+                });
+                expect(element.shadowRoot.textContent).to.equal('replacement');
+            });
         })
 
         describe('setOptions()', function () {

package/test/cases/dom/slotted-nodes.mjs

@@ -1,14 +1,61 @@
 import {expect} from 'chai';
 import {getSlottedNodes} from "../../../source/dom/slotted.mjs";
+import {getSlottedElements} from "../../../source/dom/slotted.mjs";
+import {initJSDOM} from "../../util/jsdom.mjs";
 
 
 describe('getSlottedNodes', () => {
 
+    before(async () => {
+        await initJSDOM();
+    });
+
 
     it('should return an empty Set if there is no ShadowRoot', () => {
         expect(getSlottedNodes).is.a('function');
     });
 
+    it('should ignore text nodes when applying an element query issue #567', () => {
+        const host = document.createElement('div');
+        host.append(' whitespace ');
+        const child = document.createElement('span');
+        child.className = 'match';
+        host.appendChild(child);
+        host.attachShadow({mode: 'open'}).innerHTML = '<slot></slot>';
+        document.body.appendChild(host);
+
+        expect([...getSlottedNodes.call(host, '.match')]).to.deep.equal([child]);
+        host.remove();
+    });
+
+    it('should match empty and spaced slot names without selector interpolation issue #567', () => {
+        const host = document.createElement('div');
+        const defaultChild = document.createElement('span');
+        const namedChild = document.createElement('span');
+        namedChild.slot = 'some slot';
+        host.append(defaultChild, namedChild);
+        host.attachShadow({mode: 'open'}).innerHTML =
+            '<slot name=""></slot><slot name="some slot"></slot>';
+        document.body.appendChild(host);
+
+        expect([...getSlottedElements.call(host, undefined, null)]).to.deep.equal([defaultChild]);
+        expect([...getSlottedElements.call(host, undefined, 'some slot')]).to.deep.equal([namedChild]);
+        host.remove();
+    });
+
+    it('should accept the internally managed closed shadow root issue #567', () => {
+        const host = document.createElement('div');
+        const child = document.createElement('span');
+        host.appendChild(child);
+        const root = host.attachShadow({mode: 'closed'});
+        root.innerHTML = '<slot></slot>';
+        document.body.appendChild(host);
+
+        expect(host.shadowRoot).to.equal(null);
+        expect([...getSlottedElements.call(host, undefined, undefined, root)])
+            .to.deep.equal([child]);
+        host.remove();
+    });
 
-});
 
+});

package/test/cases/dom/template.mjs

@@ -81,6 +81,17 @@ describe('Template', function () {
                 expect(t).is.instanceof(Template);
 
             })
+
+            it('should resolve from a text node context issue #567', function () {
+                const container = document.createElement('div');
+                const text = document.createTextNode('context');
+                container.appendChild(text);
+                document.body.appendChild(container);
+
+                const template = findDocumentTemplate('mytemplate', text);
+                expect(template).to.be.instanceof(Template);
+                container.remove();
+            });
         });
 
         describe('Thmened Template', function () {

package/test/cases/dom/updater.mjs

@@ -1665,6 +1665,78 @@ describe("DOM", function () {
           .catch((e) => done(new Error(e)));
       });
 
+      it("should not move unchanged keyed nodes issue #564", async function () {
+        const element = document.getElementById("test-patch");
+        const a = document.createElement("span");
+        const b = document.createElement("span");
+        a.dataset.key = "a";
+        b.dataset.key = "b";
+
+        const updater = new Updater(element, {
+          text: "",
+          contentNode: document.createElement("div"),
+          fragmentNode: document.createDocumentFragment(),
+          itemsArray: [],
+          keyedItems: [a, b],
+          keyedDataItems: [],
+          items: [],
+        });
+        updater.setCallback("getPatchKey", (value) => value?.dataset?.key);
+        await updater.run();
+
+        const target = document.getElementById("patch-keyed");
+        let moves = 0;
+        const appendChild = target.appendChild;
+        const insertBefore = target.insertBefore;
+        target.appendChild = function (...args) {
+          moves++;
+          return appendChild.apply(this, args);
+        };
+        target.insertBefore = function (...args) {
+          moves++;
+          return insertBefore.apply(this, args);
+        };
+
+        updater.getSubject().keyedItems = [a, b];
+        await new Promise((resolve) => setTimeout(resolve, 30));
+
+        expect(moves).to.equal(0);
+        expect(Array.from(target.children)).to.deep.equal([a, b]);
+      });
+
+      it("should dispose a keyed node replaced under the same key issue #564", async function () {
+        const element = document.getElementById("test-patch");
+        const first = document.createElement("span");
+        const replacement = document.createElement("span");
+        first.dataset.key = "same";
+        replacement.dataset.key = "same";
+        let disposeCount = 0;
+        addToObjectLink(
+          first,
+          customElementUpdaterLinkSymbol,
+          new Set([{dispose() { disposeCount++; }}]),
+        );
+
+        const updater = new Updater(element, {
+          text: "",
+          contentNode: document.createElement("div"),
+          fragmentNode: document.createDocumentFragment(),
+          itemsArray: [],
+          keyedItems: [first],
+          keyedDataItems: [],
+          items: [],
+        });
+        updater.setCallback("getPatchKey", (value) => value?.dataset?.key);
+        await updater.run();
+
+        updater.getSubject().keyedItems = [replacement];
+        await new Promise((resolve) => setTimeout(resolve, 30));
+
+        expect(disposeCount).to.equal(1);
+        expect(first.isConnected).to.equal(false);
+        expect(document.getElementById("patch-keyed").firstChild).to.equal(replacement);
+      });
+
       it("should remove stale keyed nodes and keep surviving node identity", function (done) {
         let element = document.getElementById("test-patch");
         const a = document.createElement("span");
@@ -2620,6 +2692,52 @@ describe("DOM", function () {
     });
   });
 
+  describe("Updater binding correctness issue #563", function () {
+    it("should ignore unchecked radios during retrieve", function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <input type="radio" value="selected" checked data-monster-bind="path:choice">
+        <input type="radio" value="unchecked" data-monster-bind="path:choice">
+      `;
+
+      const updater = new Updater(mocks, {choice: "initial"});
+      updater.retrieve();
+
+      expect(updater.getSubject().choice).to.equal("selected");
+    });
+
+    it("should not change select state for non-value attributes", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <select id="binding-select" data-monster-attributes="title path:title">
+          <option value="a">a</option>
+          <option value="b" selected>b</option>
+        </select>
+      `;
+
+      const updater = new Updater(mocks, {title: "label"});
+      await updater.run();
+
+      const select = document.getElementById("binding-select");
+      expect(select.title).to.equal("label");
+      expect(select.value).to.equal("b");
+    });
+
+    it("should evaluate static attribute and property commands", async function () {
+      const mocks = document.getElementById("mocks");
+      mocks.innerHTML = `
+        <div id="static-attribute" data-monster-attributes="title static:hello"></div>
+        <input id="static-property" data-monster-properties="value static:world">
+      `;
+
+      const updater = new Updater(mocks, {trigger: true});
+      await updater.run();
+
+      expect(document.getElementById("static-attribute").title).to.equal("hello");
+      expect(document.getElementById("static-property").value).to.equal("world");
+    });
+  });
+
   describe("Updater pipe failure recovery issue #498", function () {
     const waitForUpdate = () => new Promise((resolve) => setTimeout(resolve, 20));
 

package/test/cases/types/proxyobserver.mjs

@@ -241,6 +241,40 @@ describe('ProxyObserver', function () {
             proxy.attachObserver(observer);
             delete proxy.getSubject().a;
         });
+
+        it('should ignore missing and inherited deletes without notifying issue #570', async function () {
+            const prototype = {inherited: true};
+            const value = Object.create(prototype);
+            const proxy = new ProxyObserver(value);
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            expect(() => delete proxy.getSubject().missing).to.not.throw();
+            expect(() => delete proxy.getSubject().inherited).to.not.throw();
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(proxy.getSubject().inherited).to.equal(true);
+            expect(notifications).to.equal(0);
+        });
+
+        it('should report failed non-configurable deletes without notifying issue #570', async function () {
+            const value = {};
+            Object.defineProperty(value, 'fixed', {
+                configurable: false,
+                value: true,
+            });
+            const proxy = new ProxyObserver(value);
+            let notifications = 0;
+            proxy.attachObserver(new Observer(function () {
+                notifications++;
+            }));
+
+            expect(Reflect.deleteProperty(proxy.getSubject(), 'fixed')).to.equal(false);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(notifications).to.equal(0);
+        });
     });
 
     describe('symbol properties', function () {
@@ -342,6 +376,47 @@ describe('ProxyObserver', function () {
             expect(proxy.getSubject().map).to.equal(replacement);
             expect(notifications).to.equal(1);
         });
+
+        it('should obey frozen-property proxy invariants issue #570', function () {
+            const nested = {value: true};
+            const frozen = Object.freeze({nested});
+            const subject = new ProxyObserver({frozen}).getSubject();
+
+            expect(() => subject.frozen.nested).to.not.throw();
+            expect(subject.frozen.nested).to.equal(nested);
+        });
+
+        it('should preserve confirmed internal-slot native objects issue #570', async function () {
+            const weakKey = {};
+            const regexp = /monster/g;
+            const buffer = new ArrayBuffer(8);
+            const view = new DataView(buffer);
+            const typed = new Uint8Array(buffer);
+            const weakMap = new WeakMap([[weakKey, 'value']]);
+            const weakSet = new WeakSet([weakKey]);
+            const promise = Promise.resolve('resolved');
+            const subject = new ProxyObserver({
+                regexp,
+                buffer,
+                view,
+                typed,
+                weakMap,
+                weakSet,
+                promise,
+            }).getSubject();
+
+            expect(subject.regexp).to.equal(regexp);
+            expect(subject.regexp.test('monster')).to.equal(true);
+            expect(subject.buffer).to.equal(buffer);
+            expect(subject.buffer.byteLength).to.equal(8);
+            expect(subject.view).to.equal(view);
+            expect(subject.view.byteLength).to.equal(8);
+            expect(subject.typed).to.equal(typed);
+            expect(subject.typed.length).to.equal(8);
+            expect(subject.weakMap.get(weakKey)).to.equal('value');
+            expect(subject.weakSet.has(weakKey)).to.equal(true);
+            expect(await subject.promise).to.equal('resolved');
+        });
     });
 
 })