@rohal12/spindle 0.59.13 → 0.59.14

package/dist/pkg/headless.js

@@ -9893,6 +9893,86 @@ function parseMarkup(source, options = {}) {
 function tokenizeMarkup(source, options = {}) {
 	return run$2(source, "Tokens", options);
 }
+/**
+* `tokenizeMarkup` for half-typed markup: the tokens it can read, and every
+* error, instead of throwing at the first. At a malformed tag, the tokens
+* before it are kept, its first character is read as text and tokenizing
+* resumes after it, so what follows is read as if the tag had not been
+* started. Tokens and errors have offsets in `source`; for well-formed
+* markup the tokens are those of `tokenizeMarkup` and there are no errors.
+*/
+function tokenizeMarkupTolerant(source, options = {}) {
+	const tokens = [];
+	const errors = [];
+	const lastBrace = source.lastIndexOf("}");
+	const { closeBrace } = {
+		...defaultHooks,
+		...options.hooks
+	};
+	/** `text` shifted by `base`, tokenized: the tokens or the error. */
+	const attempt = (text, base) => {
+		const hooks = {
+			...options.hooks,
+			closeBrace: (input, codeStart, lenientStart) => base + Math.min(codeStart, lenientStart) > lastBrace ? -1 : closeBrace(input, codeStart, lenientStart)
+		};
+		try {
+			return tokenizeMarkup(text, {
+				...options,
+				hooks
+			}).map((token) => shift(token, base));
+		} catch (error) {
+			if (!(error instanceof MarkupError)) throw error;
+			return error;
+		}
+	};
+	let base = 0;
+	while (base <= source.length) {
+		const rest = source.slice(base);
+		const result = attempt(rest, base);
+		if (Array.isArray(result)) {
+			tokens.push(...result);
+			break;
+		}
+		const at = base + result.offset;
+		const { line, column } = lineColumn(source, at);
+		errors.push(new MarkupError(result.reason, at, line, column));
+		let cut = result.offset;
+		let prefix = attempt(rest.slice(0, cut), base);
+		while (!Array.isArray(prefix)) {
+			cut = prefix.offset;
+			prefix = attempt(rest.slice(0, cut), base);
+		}
+		tokens.push(...prefix);
+		if (cut < rest.length) {
+			const start = base + cut;
+			tokens.push({
+				type: "text",
+				value: rest[cut],
+				start,
+				end: start + 1
+			});
+		}
+		base += cut + 1;
+	}
+	return {
+		tokens,
+		errors
+	};
+}
+/** `token` with its offsets moved `by` on. */
+function shift(token, by) {
+	if (by === 0) return token;
+	const moved = {
+		...token,
+		start: token.start + by,
+		end: token.end + by
+	};
+	if (moved.type === "link") {
+		moved.targetStart += by;
+		moved.targetEnd += by;
+	}
+	return moved;
+}
 //#endregion
 //#region src/utils/namespace.ts
 /** The variable name no namespace can hold. */
@@ -10567,28 +10647,34 @@ function parseWidgetDef(rawArgs) {
 	return widgetDef(parseMacroArgs(rawArgs, WIDGET_PARAMETERS));
 }
 /**
-* A definition: its arguments (read like a {widget} macro's, see
-* parseWidgetDef) and its body. Macro names are not case-sensitive.
-*/
-var WIDGET_DEFINITION = /\{widget\s+([^}]*)\}([\s\S]*?)\{\/widget\}/gi;
-/** `{@children}`, also with selectors such as `{.highlight @children}`. */
-var CHILDREN_PLACEHOLDER = /\{[^{}]*@children\s*\}/;
-/**
 * The names of the block widgets (those whose body renders `{@children}`)
 * that StoryInit and the passages tagged `widget` define. They must be
 * known as block macros before any passage is parsed, so that passages
 * invoking them nest their content whatever the passage order.
+*
+* The passages are read as flat tokens, which need no block macros to be
+* known, so a `{@children}` in an HTML comment or in a `{do}` body is text
+* here as it is to the parser, and does not make a block widget (#387).
 */
 function blockWidgetNames(passages) {
 	const names = [];
 	for (const passage of passages) {
 		if (passage.name !== "StoryInit" && !passage.tags?.includes("widget")) continue;
-		for (const match of passage.content.matchAll(WIDGET_DEFINITION)) {
-			if (!CHILDREN_PLACEHOLDER.test(match[2])) continue;
+		const open = [];
+		for (const token of tokenizeMarkupTolerant(passage.content).tokens) if (token.type === "macro" && token.name.toLowerCase() === "widget") {
+			if (!token.isClose) {
+				open.push({
+					rawArgs: token.rawArgs,
+					isBlock: false
+				});
+				continue;
+			}
+			const def = open.pop();
+			if (!def?.isBlock) continue;
 			try {
-				names.push(parseWidgetDef(match[1]).name);
+				names.push(parseWidgetDef(def.rawArgs).name);
 			} catch {}
-		}
+		} else if (token.type === "variable" && token.scope === "local" && token.name === "children" && open.length > 0) open[open.length - 1].isBlock = true;
 	}
 	return names;
 }
@@ -11108,6 +11194,13 @@ function wrapContent(className, id, content) {
 function hasInterpolation(s) {
 	return s.includes("{") || s.includes("}");
 }
+/** The children context for an invocation's `children`, or null if none. */
+function widgetChildrenOf(children, outer) {
+	return children?.length ? {
+		nodes: children,
+		outer: outer ?? null
+	} : null;
+}
 var parseCache = /* @__PURE__ */ new Map();
 var PARSE_CACHE_LIMIT = 2e3;
 /**
@@ -11193,7 +11286,7 @@ var TextEvaluator = class {
 				if (node.scope === "local" && node.name === "children") {
 					const children = scope.widgetChildren;
 					if (!children) return "";
-					return this.nested("children", children, scope, depth, { widgetChildren: null });
+					return this.nested("children", children.nodes, scope, depth, { widgetChildren: children.outer });
 				}
 				return this.variable(node.scope, node.name, scope);
 			case "expression": try {
@@ -11256,7 +11349,7 @@ var TextEvaluator = class {
 			}
 			return this.nested(node.name, widget.body, scope, depth, {
 				locals,
-				widgetChildren: node.children.length > 0 ? node.children : null
+				widgetChildren: widgetChildrenOf(node.children, scope.widgetChildren)
 			});
 		}
 		const text = getMacroText(node.name);
@@ -11514,7 +11607,8 @@ function WidgetInvocation(props) {
 function WidgetContent({ body, params, rawArgs, invocationChildren }) {
 	const parentValues = useRenderOptions().locals;
 	const [mergedVars, mergedTemps, mergedLocals, mergedTrans] = useMergedLocals();
-	const childrenValue = invocationChildren?.length ? invocationChildren : null;
+	const outerChildren = useContext(WidgetChildrenContext);
+	const childrenValue = useMemo(() => widgetChildrenOf(invocationChildren, outerChildren), [invocationChildren, outerChildren]);
 	const argExprs = rawArgs ? splitArgs(rawArgs) : [];
 	const values = [];
 	for (let i = 0; i < params.length; i++) {
@@ -12282,10 +12376,13 @@ function HtmlNodeRenderer({ node }) {
 	}) : element);
 }
 function ChildrenSlot() {
-	const childrenAST = useContext(WidgetChildrenContext);
+	const children = useContext(WidgetChildrenContext);
 	const renderOptions = useRenderOptions();
-	if (!childrenAST || childrenAST.length === 0) return null;
-	return /* @__PURE__ */ jsx(Fragment$1, { children: renderNodes(childrenAST, renderOptions) });
+	if (!children) return null;
+	return /* @__PURE__ */ jsx(WidgetChildrenContext.Provider, {
+		value: children.outer,
+		children: renderNodes(children.nodes, renderOptions)
+	});
 }
 /**
 * Stable per-node keys. Keying rendered children by AST node identity (not
@@ -13194,6 +13291,39 @@ function stringify_primitive(thing) {
 	return String(thing);
 }
 //#endregion
+//#region src/utils/value-kinds.ts
+var toStringTag = (value) => Object.prototype.toString.call(value).slice(8, -1);
+/** Temporal values are immutable: copies may share them. */
+var isTemporal = (value) => toStringTag(value).startsWith("Temporal.");
+/** new Number(), new String(), new Boolean(), Object(1n). */
+var isBoxed = (value) => value instanceof Number || value instanceof String || value instanceof Boolean || toStringTag(value) === "BigInt";
+/**
+* Values compared and copied as a whole, by their content: they have no
+* own keys to merge by, or their keys are not the data (a property written
+* into one would be dropped by clones and saves, and by Immer for Map and
+* Set).
+*/
+function isAtomic(value) {
+	return value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof URL || value instanceof URLSearchParams || value instanceof Error || isBoxed(value) || isTemporal(value);
+}
+/** "a Map", "an Error", ... for an atomic value (see isAtomic), else undefined. */
+function atomicName(value) {
+	if (!isAtomic(value)) return void 0;
+	const tag = value instanceof Error ? "Error" : toStringTag(value);
+	return `${/^[AEIOU]/.test(tag) ? "an" : "a"} ${tag}`;
+}
+/** Whether `key` is an index of an array element. */
+var isIndexKey = (key) => key !== "4294967295" && String(Number(key) >>> 0) === key;
+/**
+* The own enumerable string keys of a collection (an Array, Map or Set) that
+* are not its elements: what an instance of a subclass may hold besides
+* them.
+*/
+function extraKeys(collection) {
+	const keys = Object.keys(collection);
+	return Array.isArray(collection) ? keys.filter((k) => !isIndexKey(k)) : keys;
+}
+//#endregion
 //#region src/class-registry.ts
 var registry = /* @__PURE__ */ new Map();
 var ctorToName = /* @__PURE__ */ new Map();
@@ -13233,6 +13363,9 @@ var ERROR_HIDDEN_KEYS$1 = [
 	"errors"
 ];
 var isObject = (v) => typeof v === "object" && v !== null;
+/** Whether `v` is a plain object (as devalue revives one). */
+var isPlainData = (v) => isObject(v) && Object.getPrototypeOf(v) === Object.prototype;
+var malformedClass = (name) => /* @__PURE__ */ new TypeError(`spindle: Malformed data for class "${name}"`);
 var defineData = (target, key, value) => {
 	Object.defineProperty(target, key, {
 		value,
@@ -13252,15 +13385,49 @@ function refuseSymbolKeys(value) {
 * Own enumerable keys of `value`, as a plain object; for an error also its
 * message, cause and (AggregateError) errors, which are not enumerable.
 */
-function ownData(value) {
+function ownData(value, keys = Object.keys(value)) {
 	refuseSymbolKeys(value);
 	const data = {};
 	if (value instanceof Error) {
 		for (const key of ERROR_HIDDEN_KEYS$1) if (hasOwn(value, key)) defineData(data, key, value[key]);
 	}
-	for (const key of Object.keys(value)) defineData(data, key, value[key]);
+	for (const key of keys) defineData(data, key, value[key]);
 	return data;
 }
+/** The kinds of collection a registered class may extend. */
+var COLLECTION_KINDS = {
+	Array,
+	Map,
+	Set
+};
+/**
+* The saved form of a registered class instance: its own data (see
+* ownData), or for a collection its kind, elements and extra keys, read
+* with the built-in methods, which a subclass may override (#391).
+*/
+function classData(value) {
+	const extra = () => ownData(value, extraKeys(value));
+	if (Array.isArray(value)) {
+		const items = new Array(value.length);
+		for (let i = 0; i < value.length; i++) if (i in value) items[i] = value[i];
+		return [
+			"Array",
+			items,
+			extra()
+		];
+	}
+	if (value instanceof Map) return [
+		"Map",
+		Array.from(Map.prototype.entries.call(value)),
+		extra()
+	];
+	if (value instanceof Set) return [
+		"Set",
+		Array.from(Set.prototype.values.call(value)),
+		extra()
+	];
+	return ownData(value);
+}
 /** Make an error's message, cause and errors non-enumerable again. */
 function hideErrorKeys(value) {
 	for (const key of ERROR_HIDDEN_KEYS$1) if (hasOwn(value, key)) Object.defineProperty(value, key, { enumerable: false });
@@ -13269,7 +13436,7 @@ function hideErrorKeys(value) {
 var isEscapedOneCharKey = (key) => key.length === 1 && JSON.stringify(key).length > 3;
 function reducers() {
 	const out = {};
-	for (const [name, ctor] of registry) out[CLASS_PREFIX + name] = (v) => isObject(v) && Object.getPrototypeOf(v) === ctor.prototype && ownData(v);
+	for (const [name, ctor] of registry) out[CLASS_PREFIX + name] = (v) => isObject(v) && Object.getPrototypeOf(v) === ctor.prototype && classData(v);
 	for (const [proto, name] of BUILTIN_ERRORS) out[ERROR_PREFIX + name] = (v) => isObject(v) && Object.getPrototypeOf(v) === proto && ownData(v);
 	out[SYMBOL_TAG] = (v) => {
 		if (typeof v !== "symbol") return false;
@@ -13282,7 +13449,7 @@ function reducers() {
 		v.lastIndex
 	];
 	out[KEYS_TAG] = (v) => {
-		if (!isObject(v) || Object.getPrototypeOf(v) !== Object.prototype) return false;
+		if (!isPlainData(v)) return false;
 		const keys = Object.keys(v);
 		if (!keys.some(isEscapedOneCharKey)) return false;
 		refuseSymbolKeys(v);
@@ -13291,27 +13458,71 @@ function reducers() {
 	};
 	return out;
 }
+/**
+* The collection of a registered class that a `[kind, contents, keys]`
+* list holds (see classData). A cycle through the collection revives it
+* before its list is complete (devalue holds unread parts as holes), so the
+* collection is kept per list and filled with what the list holds so far.
+*/
+var collections = /* @__PURE__ */ new WeakMap();
+function reviveCollection(name, ctor, list) {
+	const [kind, contents, keys] = list;
+	const base = typeof kind === "string" && hasOwn(COLLECTION_KINDS, kind) ? COLLECTION_KINDS[kind] : void 0;
+	if (list.length !== 3 || !base || !(ctor.prototype instanceof base) || hasOwn(list, 1) && !Array.isArray(contents) || hasOwn(list, 2) && !isPlainData(keys)) throw malformedClass(name);
+	let made = collections.get(list);
+	if (!made) {
+		made = Object.setPrototypeOf(new base(), ctor.prototype);
+		collections.set(list, made);
+	}
+	if (Array.isArray(contents)) fillCollection(made, contents);
+	if (isPlainData(keys)) for (const key of Object.keys(keys)) defineData(made, key, keys[key]);
+	return made;
+}
+/** Set the elements of a revived collection, with the built-in methods. */
+function fillCollection(made, contents) {
+	if (Array.isArray(made)) {
+		made.length = contents.length;
+		for (let i = 0; i < contents.length; i++) if (hasOwn(contents, i)) made[i] = contents[i];
+		else delete made[i];
+	} else if (made instanceof Map) {
+		Map.prototype.clear.call(made);
+		for (const entry of contents) {
+			if (!Array.isArray(entry) || entry.length !== 2) throw new TypeError("spindle: Malformed map entries");
+			Map.prototype.set.call(made, entry[0], entry[1]);
+		}
+	} else {
+		Set.prototype.clear.call(made);
+		for (const member of contents) Set.prototype.add.call(made, member);
+	}
+}
 /** Restore a registered class instance in place, so cycles through it hold. */
 function reviveClass(name) {
 	return (data) => {
-		if (!isObject(data) || Object.getPrototypeOf(data) !== Object.prototype) {
+		if (Array.isArray(data)) return reviveCollection(name, registeredCtor(name), data);
+		if (!isPlainData(data)) {
 			if (isObject(data) && registeredClassName(data) === name) return data;
-			throw new TypeError(`spindle: Malformed data for class "${name}"`);
+			throw malformedClass(name);
 		}
-		const ctor = registry.get(name);
-		if (!ctor) throw new TypeError(`spindle: The save holds an instance of class "${name}", which is not registered`);
+		const ctor = registeredCtor(name);
+		if (Object.values(COLLECTION_KINDS).some((c) => ctor.prototype instanceof c)) throw malformedClass(name);
 		Object.setPrototypeOf(data, ctor.prototype);
 		if (data instanceof Error) hideErrorKeys(data);
 		return data;
 	};
 }
+/** The class registered as `name`; throws if there is none. */
+function registeredCtor(name) {
+	const ctor = registry.get(name);
+	if (!ctor) throw new TypeError(`spindle: The save holds an instance of class "${name}", which is not registered`);
+	return ctor;
+}
 /** Restore a built-in error in place, like a class instance. */
 function reviveError(name) {
 	const ctor = ERROR_CTORS.get(name);
 	if (!ctor) return void 0;
 	return (data) => {
 		if (Object.getPrototypeOf(data) === ctor.prototype) return data;
-		if (!isObject(data) || Object.getPrototypeOf(data) !== Object.prototype) throw new TypeError(`spindle: Malformed data for "${name}"`);
+		if (!isPlainData(data)) throw new TypeError(`spindle: Malformed data for "${name}"`);
 		Object.setPrototypeOf(data, ctor.prototype);
 		hideErrorKeys(data);
 		return data;
@@ -13908,28 +14119,6 @@ function getBackendType() {
 	return _backend?.type ?? "memory";
 }
 //#endregion
-//#region src/utils/value-kinds.ts
-var toStringTag = (value) => Object.prototype.toString.call(value).slice(8, -1);
-/** Temporal values are immutable: copies may share them. */
-var isTemporal = (value) => toStringTag(value).startsWith("Temporal.");
-/** new Number(), new String(), new Boolean(), Object(1n). */
-var isBoxed = (value) => value instanceof Number || value instanceof String || value instanceof Boolean || toStringTag(value) === "BigInt";
-/**
-* Values compared and copied as a whole, by their content: they have no
-* own keys to merge by, or their keys are not the data (a property written
-* into one would be dropped by clones and saves, and by Immer for Map and
-* Set).
-*/
-function isAtomic(value) {
-	return value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof URL || value instanceof URLSearchParams || value instanceof Error || isBoxed(value) || isTemporal(value);
-}
-/** "a Map", "an Error", ... for an atomic value (see isAtomic), else undefined. */
-function atomicName(value) {
-	if (!isAtomic(value)) return void 0;
-	const tag = value instanceof Error ? "Error" : toStringTag(value);
-	return `${/^[AEIOU]/.test(tag) ? "an" : "a"} ${tag}`;
-}
-//#endregion
 //#region src/utils/object-path.ts
 /**
 * Traverse dot-path segments on an object and return the nested value.
@@ -14058,6 +14247,20 @@ function isPlainObject(value) {
 	const proto = Object.getPrototypeOf(value);
 	return proto === Object.prototype || proto === null;
 }
+/**
+* `empty`, a new collection (Array, Map or Set) standing for `obj`, made
+* like it: an instance of a registered subclass keeps its class and its
+* extra keys (#391), with the values `value` gives for them; other
+* collections are plain. `made` gets it before its keys are filled, so
+* that cycles through it find it.
+*/
+function collectionLike(obj, empty, made, value) {
+	made(empty);
+	if (registeredClassName(obj) === void 0) return empty;
+	Object.setPrototypeOf(empty, Object.getPrototypeOf(obj));
+	for (const key of extraKeys(obj)) setOwn(empty, key, value(key));
+	return empty;
+}
 /** Own keys of an error that are not enumerable but are data. */
 var ERROR_HIDDEN_KEYS = [
 	"message",
@@ -14119,23 +14322,25 @@ function deepClone(value, options = {}) {
 		const settle = options.settle;
 		return settle && isObjectValue(copy) && isObjectValue(original) ? settle(copy, original) : copy;
 	}
+	/** `empty`, made the copy of the collection `obj` (see collectionLike). */
+	const collection = (obj, empty) => collectionLike(obj, empty, (copy) => keep(obj, copy), (key) => clone(obj[key]));
 	function clone(val) {
 		if (val === null || typeof val !== "object") return val;
 		const obj = val;
 		if (seen.has(obj)) return seen.get(obj);
 		if (Array.isArray(val)) {
-			const arr = keep(obj, new Array(val.length));
+			const arr = collection(obj, new Array(val.length));
 			for (let i = 0; i < val.length; i++) if (i in val) arr[i] = clone(val[i]);
 			return arr;
 		}
 		if (val instanceof Map) {
-			const copy = keep(obj, /* @__PURE__ */ new Map());
-			for (const [k, v] of val) copy.set(settled(clone(k), k), clone(v));
+			const copy = collection(obj, /* @__PURE__ */ new Map());
+			for (const [k, v] of val) Map.prototype.set.call(copy, settled(clone(k), k), clone(v));
 			return copy;
 		}
 		if (val instanceof Set) {
-			const copy = keep(obj, /* @__PURE__ */ new Set());
-			for (const v of val) copy.add(settled(clone(v), v));
+			const copy = collection(obj, /* @__PURE__ */ new Set());
+			for (const v of val) Set.prototype.add.call(copy, settled(clone(v), v));
 			return copy;
 		}
 		const builtin = cloneBuiltin(obj);
@@ -14238,23 +14443,26 @@ function shareEqual(prev, curr) {
 		if (placed !== void 0) return placed;
 		if (!isObjectValue(p)) return fresh(c);
 		if (reuse(p, c)) return p;
+		const pr = p;
+		const cr = c;
+		/** What the result holds at `key` of `c`. */
+		const shareKey = (key) => share(hasOwn(pr, key) ? pr[key] : void 0, cr[key]);
+		/** `empty`, made the result for the collection `c` (see collectionLike). */
+		const collection = (empty) => collectionLike(c, empty, (out) => done.set(c, out), shareKey);
 		if (c instanceof Map && p instanceof Map) {
-			const out = /* @__PURE__ */ new Map();
-			done.set(c, out);
-			for (const [k, v] of c) out.set(fresh(k), share(p.get(k), v));
+			const out = collection(/* @__PURE__ */ new Map());
+			for (const [k, v] of c) Map.prototype.set.call(out, fresh(k), share(p.get(k), v));
 			return out;
 		}
 		if (Array.isArray(c) && Array.isArray(p)) {
-			const out = new Array(c.length);
-			done.set(c, out);
+			const out = collection(new Array(c.length));
 			for (let i = 0; i < c.length; i++) if (i in c) out[i] = share(p[i], c[i]);
 			return out;
 		}
 		if (mergesWith(p, c, false)) {
 			const out = Object.create(Object.getPrototypeOf(c));
 			done.set(c, out);
-			const cr = c;
-			for (const key of Object.keys(cr)) setOwn(out, key, share(hasOwn(p, key) ? p[key] : void 0, cr[key]));
+			for (const key of Object.keys(cr)) setOwn(out, key, shareKey(key));
 			return out;
 		}
 		return fresh(c);
@@ -14283,14 +14491,27 @@ function equalBuiltin(a, b, assumed) {
 	if (isTemporal(a)) return String(a) === String(b);
 	if (a instanceof Error) return ERROR_HIDDEN_KEYS.every((key) => hasOwn(a, key) === hasOwn(b, key) && equal(a[key], b[key], assumed)) && equalKeys(a, b, assumed);
 }
-function equalKeys(a, b, assumed) {
+function equalKeys(a, b, assumed, keysOf = Object.keys) {
 	const ao = a;
 	const bo = b;
-	const keys = Object.keys(ao);
-	if (keys.length !== Object.keys(bo).length) return false;
+	const keys = keysOf(ao);
+	if (keys.length !== keysOf(bo).length) return false;
 	for (const key of keys) if (!hasOwn(bo, key) || !equal(ao[key], bo[key], assumed)) return false;
 	return true;
 }
+/** Built-in collection prototypes, whose instances hold no extra keys. */
+var COLLECTION_PROTOS = new Set([
+	Array.prototype,
+	Map.prototype,
+	Set.prototype
+]);
+/**
+* Equality of the extra keys (see extraKeys) of two collections of one
+* class: those of a subclass instance are part of its value.
+*/
+function equalExtraKeys(a, b, assumed) {
+	return COLLECTION_PROTOS.has(Object.getPrototypeOf(a)) || equalKeys(a, b, assumed, extraKeys);
+}
 /** `assumed` tracks the pairs of objects met (see Pairs). */
 function equal(a, b, assumed) {
 	if (Object.is(a, b) && !(assumed.strict && isObjectValue(a))) return true;
@@ -14304,7 +14525,7 @@ function equal(a, b, assumed) {
 		const ai = a.entries();
 		const bi = bc.entries();
 		for (let x = ai.next(), y = bi.next(); !x.done; x = ai.next(), y = bi.next()) if (!equal(x.value, y.value, assumed)) return false;
-		return true;
+		return equalExtraKeys(a, b, assumed);
 	}
 	const builtin = equalBuiltin(a, b, assumed);
 	if (builtin !== void 0) return builtin;
@@ -14312,7 +14533,7 @@ function equal(a, b, assumed) {
 		const bc = b;
 		if (a.length !== bc.length) return false;
 		for (let i = 0; i < a.length; i++) if (i in a !== i in bc || !equal(a[i], bc[i], assumed)) return false;
-		return true;
+		return equalExtraKeys(a, b, assumed);
 	}
 	return equalKeys(a, b, assumed);
 }
@@ -14331,7 +14552,7 @@ function isMergeable(value) {
 * one class (see isMergeable), or, with `arrays`, both are arrays.
 */
 function mergesWith(a, b, arrays) {
-	if (arrays && (Array.isArray(a) || Array.isArray(b))) return Array.isArray(a) && Array.isArray(b);
+	if (arrays && (Array.isArray(a) || Array.isArray(b))) return Array.isArray(a) && Array.isArray(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
 	return isMergeable(a) && isMergeable(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
 }
 /**
@@ -15605,6 +15826,11 @@ function deeplyFrozen(value, seen = /* @__PURE__ */ new Set()) {
 	if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return true;
 	if (!Object.isFrozen(value)) return false;
 	seen.add(value);
+	if (value instanceof Map) {
+		for (const [key, entry] of value) if (!deeplyFrozen(key, seen) || !deeplyFrozen(entry, seen)) return false;
+	} else if (value instanceof Set) {
+		for (const member of value) if (!deeplyFrozen(member, seen)) return false;
+	}
 	return Reflect.ownKeys(value).every((key) => {
 		const desc = Object.getOwnPropertyDescriptor(value, key);
 		return !desc || !("value" in desc) || deeplyFrozen(desc.value, seen);
@@ -17307,15 +17533,34 @@ var FOCUSABLE = [
 	"[tabindex]"
 ].join(",");
 /**
+* Whether `el` is in a closed `<details>`, other than in the summary that
+* toggles it: the browser renders none of that content (#389).
+*/
+function inClosedDetails(el) {
+	for (let e = el.parentElement; e; e = e.parentElement) {
+		if (e.localName !== "details" || e.hasAttribute("open")) continue;
+		if (!Array.from(e.children).find((c) => c.localName === "summary")?.contains(el)) return true;
+	}
+	return false;
+}
+/**
 * Whether CSS leaves `el` in the tab sequence: not `visibility: hidden`
-* (inherited, so the computed value covers ancestors) and not inside a
-* `display: none` element.
+* (inherited, so the computed value covers ancestors), not inside a
+* `display: none` element and not in the hidden content of a closed
+* `<details>`.
 */
 function isRendered(el) {
 	const { visibility } = getComputedStyle(el);
 	if (visibility === "hidden" || visibility === "collapse") return false;
 	for (let e = el; e; e = e.parentElement) if (getComputedStyle(e).display === "none") return false;
-	return true;
+	return !inClosedDetails(el);
+}
+/**
+* Whether `el` can be focused at all: shown, rendered, enabled (also by its
+* fieldset) and not inert.
+*/
+function isAvailable(el) {
+	return !el.hidden && !el.closest("[hidden], [inert]") && !el.matches(":disabled") && isRendered(el);
 }
 /** The `tabindex` of `el` as an integer, or null when absent or invalid. */
 function tabIndexAttr(el) {
@@ -17324,9 +17569,10 @@ function tabIndexAttr(el) {
 	return parseInt(raw, 10);
 }
 /**
-* Whether the tab key can reach `el`: a negative tabindex only allows
-* scripted focus, and of a radio group the browser tabs to the checked
-* member only (the first one when none is checked).
+* Whether the tab key can reach `el`, an available element (see
+* isAvailable): a negative tabindex only allows scripted focus, and of a
+* radio group the browser tabs to the checked member only (the first one
+* when none is checked), of the members it can reach.
 */
 function isTabStop(el) {
 	const tabIndex = tabIndexAttr(el);
@@ -17337,7 +17583,7 @@ function isTabStop(el) {
 		if (details?.localName !== "details" || Array.from(details.children).find((c) => c.localName === "summary") !== el) return tabIndex !== null;
 	}
 	if (el instanceof HTMLInputElement && el.type === "radio" && el.name) {
-		const group = Array.from((el.form ?? el.getRootNode()).querySelectorAll("input[type=\"radio\"]")).filter((r) => r.name === el.name && r.form === el.form && !r.disabled);
+		const group = Array.from((el.form ?? el.getRootNode()).querySelectorAll("input[type=\"radio\"]")).filter((r) => r.name === el.name && r.form === el.form && (tabIndexAttr(r) ?? 0) >= 0 && isAvailable(r));
 		return el === (group.find((r) => r.checked) ?? group[0]);
 	}
 	return true;
@@ -17347,7 +17593,7 @@ function isTabStop(el) {
 * first, ascending, then the others in document order.
 */
 function focusables(root) {
-	const stops = Array.from(root.querySelectorAll(FOCUSABLE)).filter((el) => !el.hidden && !el.closest("[hidden], [inert]") && !el.matches(":disabled") && isRendered(el) && isTabStop(el));
+	const stops = Array.from(root.querySelectorAll(FOCUSABLE)).filter((el) => isAvailable(el) && isTabStop(el));
 	const positive = (el) => Math.max(tabIndexAttr(el) ?? 0, 0);
 	return [...stops.filter((el) => positive(el) > 0).sort((a, b) => positive(a) - positive(b)), ...stops.filter((el) => positive(el) === 0)];
 }