@selimssevgi/cube-design-angular 0.8.0 → 0.9.0

package/fesm2022/selimssevgi-cube-design-angular.mjs

@@ -2800,16 +2800,20 @@ var CubeSquare = class CubeSquare {
 		});
 		let before = 0;
 		let beforeView = null;
+		let beforeCount = -1;
 		effect(() => {
 			const { cols, list } = this.layout();
 			const view = this.view();
+			const count = this.tiles().length;
+			const measured = this.room().width > 0;
 			const el = this.grid()?.nativeElement;
-			if (el && before && cols !== before && view === beforeView && !list && !reducedMotion$1() && typeof el.animate === "function") el.animate([{ transform: `scale(${cols / before})` }, { transform: "none" }], {
+			if (el && before && measured && cols !== before && count !== beforeCount && beforeCount >= 0 && view === beforeView && !list && !reducedMotion$1() && typeof el.animate === "function") el.animate([{ transform: `scale(${cols / before})` }, { transform: "none" }], {
 				duration: 420,
 				easing: "cubic-bezier(.2,.7,.2,1)"
 			});
 			before = cols;
 			beforeView = view;
+			if (measured) beforeCount = count;
 		});
 	}
 	static ɵfac = i0.ɵɵngDeclareFactory({
@@ -5676,6 +5680,702 @@ i0.ɵɵngDeclareClassMetadata({
 		args: [{ providedIn: "root" }]
 	}]
 });
-export { ART_CHOICES_KEY, CONTEXT_CUBE_SOURCE, CONTEXT_CUBE_WORDS, CONTEXT_LAST_PARTS, CONTEXT_PART_ORDER, CUBE_ARTS, CUBE_CARRY_CLASSES, CUBE_CARRY_MOVE, CUBE_DROP_OUT, CUBE_HEAD_SWIPE, CUBE_HOLD_MS, CUBE_HOLD_SLOP, CUBE_ICON_NAMES, CUBE_LOADING_COLOURS, CUBE_LOADING_LEVELS, CUBE_LOADING_STEP_MS, CUBE_LOADING_STICKERS, CUBE_LOADING_WAYS, CUBE_LOADING_WIDTH, CUBE_PINCH_APART, CUBE_PINCH_TOGETHER, CUBE_ROOM_NARROW, CUBE_WHEEL_QUIET_MS, CUBE_WHEEL_STEP, CUBE_ZOOM_OPTIONS, CubeArtChoices, CubeCarry, CubeContext, CubeHead, CubeHold, CubeIcon, CubeLoading, CubePicture, CubePinch, CubeQuiet, CubeQuietLine, CubeRoom, CubeRoomMeasure, CubeSquare, CubeSquareTile, CubeTile, CubeZoomPinch, CubeZoomService, JUST_SAVED_MINUTES, MINE_SORT, PART_ICONS, REPORT_APP, REPORT_INCIDENTS_KEPT, REPORT_INCIDENTS_MS, REPORT_KINDS, ReportClient, ReportDiagnostics, ReportDraft, ReportErrorHandler, SQUARE_LEAST_CELL, SQUARE_LEAST_TALL, SQUARE_LIST_ROW, SQUARE_MAX_SIDE, SQUARE_ROOM_BELOW, TEXT_ORDERS, TURNING_BELOW, TURNING_NUDGE_UNTIL, TURNING_SIDES, VIEW_KEYS, addLevel, artFor, artLevel, bringLevel, bringOf, chooseArt, contextArtWidth, contextIcon, contextLevelFor, contextOf, contextSquare, cubeIconCells, cubeMovesThePage, cubeTilePicture, cubeTrailHolds, directionWords, drawArt, drawCube, environmentOf, errorLine, findJustSaved, gridFor, hideLevel, insideOf, isArt, isView, loadingStickers, loadingWayFor, moveBefore, namesLevel, orderLevel, orderOf, orderParts, partsLevel, placesOf, provideCubeZoom, provideReportDiagnostics, readArtChoices, refusalOf, reportContext, reportInterceptor, reportRefusal, reportRequest, routePattern, scrubbedPath, sizeFor, sortDirectionsLevel, sortItems, sortLevel, squareCell, squareGap, squareLayout, squareLeast, squareLevelFor, squareSideAt, squareTall, startsWheelGesture, stillStep, technicalLines, tellLevel, turningFront, turningRows, viewLevel, wheelWay, whereLevel, wouldLoop };
+const NAMES = "names";
+const HIDDEN = "hidden";
+const UNKNOWN = "unknown";
+const CHOICE = "choice:";
+const LIST = "names:";
+const isToken = (s) => s === "names" || s === "hidden" || s === "unknown" || s.startsWith("choice:");
+function cubePhysics(words) {
+	const NOT_NAMED = words.notNamed;
+	const clone = (w) => structuredClone(w);
+	const live = (w) => w.ins.filter((i) => i.ended === void 0);
+	const shown = (w, id) => !!w.pieces[id] && !w.pieces[id].hidden;
+	const listWords = (w, t) => w.pieces[t]?.list?.length ? w.pieces[t].list : [words.names];
+	const nameOf = (w, id) => id.startsWith("names:") ? listWords(w, id.slice(6))[0] : w.pieces[id]?.names[0] ?? NOT_NAMED;
+	const placeOf = (w, id) => w.pieces[id]?.place ?? null;
+	function partsIn(w, holder, hidden = false) {
+		return live(w).filter((i) => i.holder === holder && (hidden || shown(w, i.piece))).sort((a, b) => a.order - b.order).map((i) => i.piece);
+	}
+	const holdersOf = (w, id) => live(w).filter((i) => i.piece === id).map((i) => i.holder);
+	const stands = (w, piece, holder) => live(w).some((i) => i.piece === piece && i.holder === holder);
+	const homeOf = (w, id) => live(w).find((i) => i.piece === id && i.home)?.holder ?? null;
+	const homeIn = (w, id, holder) => live(w).some((i) => i.piece === id && i.holder === holder && i.home);
+	function stand(w, piece, holder, home = false) {
+		if (stands(w, piece, holder)) return;
+		const order = Math.max(0, ...w.ins.filter((i) => i.holder === holder).map((i) => i.order)) + 1;
+		w.ins.push({
+			piece,
+			holder,
+			order,
+			since: ++w.clock,
+			home
+		});
+	}
+	function leave(w, piece, holder) {
+		for (const i of w.ins) if (i.piece === piece && i.holder === holder && i.ended === void 0) i.ended = ++w.clock;
+	}
+	function make(w, at, name, p, given = false) {
+		const id = "p" + (Object.keys(w.pieces).length + 1);
+		w.pieces[id] = {
+			id,
+			names: name ? [name] : [],
+			hidden: false,
+			given,
+			place: p,
+			made: ++w.clock
+		};
+		stand(w, id, at, true);
+		return id;
+	}
+	const lobbyZone = (w, id) => placeOf(w, id) === "lobby" || placeOf(w, id) === "domain";
+	const itemsOf = (w, t) => partsIn(w, t).filter((id) => placeOf(w, id) === "item" && homeIn(w, id, t));
+	const isItemOf = (w, id, t) => placeOf(w, id) === "item" && homeIn(w, id, t);
+	function tableOf(w, id) {
+		let at = id;
+		for (let k = 0; k < 30 && at; k++) {
+			if (placeOf(w, at) === "table") return at;
+			if (placeOf(w, at) === "domain" || placeOf(w, at) === "lobby") return null;
+			at = homeOf(w, at);
+		}
+		return null;
+	}
+	function domainOf(w, id) {
+		let at = id;
+		for (let k = 0; k < 30 && at; k++) {
+			if (placeOf(w, at) === "domain") return at;
+			if (placeOf(w, at) === "lobby") return null;
+			at = homeOf(w, at);
+		}
+		return null;
+	}
+	const tablesIn = (w, d, hidden = false) => partsIn(w, d, hidden).filter((id) => placeOf(w, id) === "table");
+	const waysOf = (w, t, hidden = false) => partsIn(w, t, hidden).filter((id) => !isItemOf(w, id, t));
+	function answersOf(w, way, t = tableOf(w, way), hidden = false) {
+		return partsIn(w, way, hidden).filter((id) => !(t && isItemOf(w, id, t)) && !(placeOf(w, id) === "way" && homeIn(w, id, way)));
+	}
+	function answersDeep(w, way, t) {
+		const out = [];
+		const walk = (x) => {
+			for (const a of answersOf(w, x, t)) if (!out.includes(a)) out.push(a), walk(a);
+		};
+		walk(way);
+		return out;
+	}
+	function shared(w, way) {
+		const t = tableOf(w, way);
+		if (!t || placeOf(w, way) !== "way" || !homeIn(w, way, t)) return false;
+		const answers = answersDeep(w, way, t);
+		return itemsOf(w, t).some((i) => answers.filter((a) => stands(w, i, a)).length >= 2);
+	}
+	function siblings(w, a, b) {
+		if (a === b || placeOf(w, a) !== "item" || placeOf(w, b) !== "item") return false;
+		const h = homeOf(w, a);
+		return !!h && h === homeOf(w, b);
+	}
+	const outOf = (path) => path.length > 1 ? path.slice(0, -1) : path.slice();
+	function pieceBefore(path, k) {
+		for (let i = k; i >= 0; i--) if (!isToken(path[i])) return path[i];
+		return null;
+	}
+	function roleAt(w, path) {
+		const last = path.at(-1) ?? w.top;
+		if (last === "names") return "names";
+		if (last === "hidden") return "hidden";
+		if (last === "unknown") return "unknown";
+		if (last.startsWith("choice:")) return "choice";
+		const p = placeOf(w, last);
+		const prev = path.length > 1 ? path.at(-2) : null;
+		if (p === "lobby" || p === "domain" || p === "table") return p;
+		if (prev === "names") return "item";
+		if (prev && placeOf(w, prev) === "domain") return "table";
+		const prevRole = prev && !isToken(prev) ? roleAt(w, path.slice(0, -1)) : null;
+		if (prevRole === "table") return contextTable(w, path.slice(0, -1)) && isItemOf(w, last, contextTable(w, path.slice(0, -1))) ? "item" : "way";
+		if (prevRole === "way" || prevRole === "answer") {
+			const t = contextTable(w, path.slice(0, -1));
+			return t && isItemOf(w, last, t) ? "item" : "answer";
+		}
+		if (p === "item") return "item";
+		if (p === "way") return "way";
+		return "answer";
+	}
+	function contextTable(w, path) {
+		for (let k = path.length - 1; k >= 0; k--) {
+			const s = path[k];
+			if (isToken(s)) continue;
+			if (placeOf(w, s) === "table") return s;
+			if (k > 0 && placeOf(w, path[k - 1]) === "domain") return s;
+		}
+		return null;
+	}
+	function walksThrough(_w, _path) {
+		return false;
+	}
+	function tableWays(w, t, hidden = false) {
+		if (placeOf(w, t) === "table") return waysOf(w, t, hidden);
+		return partsIn(w, t, hidden).filter((id) => placeOf(w, id) === "way" && homeIn(w, id, t));
+	}
+	function tableNames(w, t, hidden = false) {
+		if (placeOf(w, t) === "table") return partsIn(w, t, hidden).filter((id) => isItemOf(w, id, t));
+		return answersOf(w, t, tableOf(w, t), hidden);
+	}
+	function firstNames(w, ids, n = 3) {
+		const names = ids.map((id) => nameOf(w, id));
+		return names.length ? names.slice(0, n).join(words.and) + (names.length > n ? words.more : "") : "";
+	}
+	function tile(w, id, kind, line = "") {
+		const p = w.pieces[id];
+		return {
+			id,
+			kind,
+			name: nameOf(w, id),
+			line,
+			given: p?.given || void 0,
+			holds: partsIn(w, id).length
+		};
+	}
+	const add = (at) => ({
+		id: at,
+		kind: "add",
+		name: words.add,
+		line: ""
+	});
+	function choicesOf(w, item, t) {
+		const out = [];
+		for (const x of tableWays(w, t)) {
+			const answers = answersDeep(w, x, placeOf(w, t) === "table" ? t : null);
+			if (!answers.length) {
+				const yes = stands(w, item, x);
+				out.push({
+					id: x,
+					kind: "choice",
+					name: nameOf(w, x),
+					line: yes ? words.yes : words.notKnownYet,
+					ticked: yes
+				});
+			} else {
+				const a = answers.filter((o) => stands(w, item, o));
+				out.push({
+					id: x,
+					kind: "choice",
+					name: nameOf(w, x),
+					line: a.length ? firstNames(w, a, 9) : words.notKnownYet
+				});
+			}
+		}
+		for (const y of linkedTables(w, item, t)) {
+			const theirs = itemsOf(w, y).filter((i) => stands(w, i, item));
+			out.push({
+				id: "link:" + y,
+				kind: "choice",
+				name: nameOf(w, y),
+				line: theirs.length ? firstNames(w, theirs, 9) : words.notKnownYet
+			});
+		}
+		return out;
+	}
+	function linkedTables(w, _item, t) {
+		if (placeOf(w, t) !== "table") {
+			const home = tableOf(w, t);
+			return home ? [home] : [];
+		}
+		const out = [];
+		for (const i of itemsOf(w, t)) for (const h of holdersOf(w, i)) {
+			if (h === t || placeOf(w, h) === "item") continue;
+			const y = tableOf(w, h);
+			if (y && y !== t && !out.includes(y)) out.push(y);
+		}
+		return out;
+	}
+	function hiddenOf(w, path) {
+		const at = path.at(-1) ?? w.top;
+		if (isToken(at) && at !== "names") return [];
+		return listOf(w, path, true).filter((x) => w.pieces[x]?.hidden);
+	}
+	function listOf(w, path, hidden) {
+		const role = roleAt(w, path);
+		const last = path.at(-1) ?? w.top;
+		const t = contextTable(w, path);
+		switch (role) {
+			case "lobby": return partsIn(w, last, hidden);
+			case "domain": {
+				const tables = tablesIn(w, last, hidden);
+				return [...tables, ...tables.flatMap((x) => waysOf(w, x, hidden).filter((y) => homeIn(w, y, x) && shared(w, y)))];
+			}
+			case "table": return tableWays(w, last, hidden);
+			case "names": return t ? tableNames(w, t, hidden) : [];
+			case "item": return [];
+			case "way": return [...answersOf(w, last, t, hidden), ...t ? partsIn(w, last, hidden).filter((x) => isItemOf(w, x, t)) : []];
+			case "answer": return [...answersOf(w, last, t, hidden), ...t ? partsIn(w, last, hidden).filter((x) => isItemOf(w, x, t)) : []];
+			default: return [];
+		}
+	}
+	function withHidden(w, tiles, path) {
+		const n = hiddenOf(w, path).length;
+		return n ? [...tiles, {
+			id: HIDDEN,
+			kind: "hidden",
+			name: words.hidden,
+			line: "",
+			holds: n
+		}] : tiles;
+	}
+	function stepOf(t) {
+		switch (t.kind) {
+			case "add":
+			case "name": return null;
+			case "list": return NAMES;
+			case "unknown": return UNKNOWN;
+			case "hidden": return HIDDEN;
+			case "choice": return t.ticked === void 0 && !t.id.startsWith("link:") ? CHOICE + t.id : null;
+			default: return t.id;
+		}
+	}
+	function stepsInto(w, path, t) {
+		const s = stepOf(t);
+		if (!s) return null;
+		return walksThrough(w, [...path, s]) ? [s, NAMES] : [s];
+	}
+	function levelAt(w, path) {
+		const last = path.at(-1) ?? w.top;
+		const role = roleAt(w, path);
+		const level = (title, line, tiles) => ({
+			path,
+			title,
+			line,
+			lifted: false,
+			tiles
+		});
+		const t = contextTable(w, path);
+		if (role === "hidden") {
+			const on = path.slice(0, -1);
+			const at = pieceBefore(on, on.length - 1);
+			const kindIn = (x) => kindOf(w, x, on);
+			return level(words.hidden, at ? nameOf(w, at) : "", hiddenOf(w, on).map((x) => tile(w, x, kindIn(x))));
+		}
+		if (role === "unknown") {
+			const way = pieceBefore(path, path.length - 2);
+			const answers = answersDeep(w, way, t);
+			const none = t ? itemsOf(w, t).filter((i) => !stands(w, i, way) && !answers.some((a) => stands(w, i, a))) : [];
+			return level(words.notKnownYet, nameOf(w, way), none.map((i) => tile(w, i, "row")));
+		}
+		if (role === "choice") {
+			const way = last.slice(7);
+			const item = pieceBefore(path, path.length - 2);
+			const opts = answersOf(w, way, t);
+			return level(nameOf(w, way), nameOf(w, item), [...opts.map((o) => ({
+				...tile(w, o, "option"),
+				ticked: stands(w, item, o)
+			})), add("pick:" + way + ":" + item)]);
+		}
+		if (role === "names") {
+			if (!t) return level(words.notHereAnyMore, "", []);
+			const kind = placeOf(w, t) === "table" ? "item:" : "answer:";
+			return level(nameOf(w, t), placeOf(w, t) === "table" ? nameOf(w, LIST + t) : words.names, [...withHidden(w, tableNames(w, t).map((x) => tile(w, x, "row")), path), add(kind + t)]);
+		}
+		const p = w.pieces[last];
+		if (!p) return level(words.notHereAnyMore, "", []);
+		switch (role) {
+			case "lobby": {
+				const parts = partsIn(w, last);
+				const tiles = parts.map((x) => lobbyZone(w, x) ? tile(w, x, placeOf(w, x) === "domain" ? "door" : "lobby") : linkTile(w, x));
+				const feature = p.given && last !== w.top && !parts.length;
+				const hid = withHidden(w, tiles, path);
+				return level(nameOf(w, last), feature ? words.appKeepsHere : "", feature ? hid : [...hid, add(last)]);
+			}
+			case "domain": return level(nameOf(w, last), "", [...withHidden(w, listOf(w, path, false).map((x) => tile(w, x, "table")), path), add("table:" + last)]);
+			case "table": {
+				const names = {
+					id: LIST + last,
+					kind: "list",
+					name: nameOf(w, LIST + last),
+					line: "",
+					holds: tableNames(w, last).length
+				};
+				return level(nameOf(w, last), "", [
+					names,
+					...withHidden(w, tableWays(w, last).map((x) => tile(w, x, "column")), path),
+					add("way:" + last)
+				]);
+			}
+			case "item": {
+				const own = {
+					id: last,
+					kind: "name",
+					name: nameOf(w, last),
+					line: words.itsName
+				};
+				return level(nameOf(w, last), t ? nameOf(w, t) : "", [
+					own,
+					...t ? choicesOf(w, last, t) : [],
+					add("cell:" + (t ?? "") + ":" + last)
+				]);
+			}
+			case "way":
+			case "answer": {
+				const answers = answersOf(w, last, t);
+				const items = t ? partsIn(w, last).filter((x) => isItemOf(w, x, t)) : [];
+				const deep = answersDeep(w, last, t);
+				const none = role === "way" && t ? itemsOf(w, t).filter((i) => !stands(w, i, last) && !deep.some((a) => stands(w, i, a))) : [];
+				const tiles = [...answers.map((x) => tile(w, x, "option")), ...items.map((x) => tile(w, x, "row"))];
+				if (role === "way" && t) tiles.push({
+					id: last,
+					kind: "unknown",
+					name: words.notKnownYet,
+					line: "",
+					holds: none.length
+				});
+				return level(nameOf(w, last), t ? nameOf(w, t) : "", [...withHidden(w, tiles, path), add((role === "way" ? "answer:" : "in:") + last + ":" + (t ?? ""))]);
+			}
+		}
+		return level(nameOf(w, last), "", []);
+	}
+	const LINK_KIND = {
+		table: "table",
+		way: "column",
+		answer: "option",
+		item: "row"
+	};
+	function livesIn(w, id) {
+		const h = homeOf(w, id);
+		if (!h) return "";
+		return nameOf(w, placeOf(w, id) === "way" ? tableOf(w, id) ?? h : h);
+	}
+	function linkTile(w, id) {
+		return tile(w, id, LINK_KIND[placeOf(w, id)] ?? "row", livesIn(w, id));
+	}
+	function lobbyLinkable(w, holder) {
+		if (placeOf(w, holder) !== "lobby" || holder === w.top || w.pieces[holder].given) return [];
+		const out = [];
+		const deep = (x, t) => {
+			for (const a of answersOf(w, x, t)) if (!out.includes(a)) out.push(a), deep(a, t);
+		};
+		for (const d of Object.keys(w.pieces).filter((id) => placeOf(w, id) === "domain" && holdersOf(w, id).length)) {
+			for (const t of tablesIn(w, d)) {
+				out.push(t);
+				for (const x of waysOf(w, t).filter((y) => homeIn(w, y, t))) {
+					out.push(x);
+					deep(x, t);
+				}
+			}
+			for (const t of tablesIn(w, d)) out.push(...itemsOf(w, t));
+		}
+		return out;
+	}
+	function pathTo(w, id) {
+		const steps = [];
+		let at = id;
+		for (let k = 0; k < 40 && at; k++) {
+			steps.unshift(at);
+			if (at === w.top) return steps;
+			const h = homeOf(w, at);
+			if (h && placeOf(w, at) === "item" && placeOf(w, h) === "table") steps.unshift(NAMES);
+			at = h;
+		}
+		return null;
+	}
+	function pathInto(w, path, t) {
+		if (roleAt(w, path) === "lobby" && w.pieces[t.id] && !lobbyZone(w, t.id)) return pathTo(w, t.id);
+		const s = stepsInto(w, path, t);
+		return s ? [...path, ...s] : null;
+	}
+	function kindOf(w, x, path) {
+		const role = roleAt(w, path);
+		if (role === "lobby") return lobbyZone(w, x) ? placeOf(w, x) === "domain" ? "door" : "lobby" : LINK_KIND[placeOf(w, x)] ?? "row";
+		if (role === "domain") return "table";
+		if (role === "table") return "column";
+		if (role === "way" || role === "answer") return placeOf(w, x) === "item" ? "row" : "option";
+		return "row";
+	}
+	const said = (world, says, before) => ({
+		world,
+		note: {
+			says,
+			undo: before
+		}
+	});
+	const refuse = (world, says) => ({
+		world,
+		note: {
+			says,
+			refused: true
+		}
+	});
+	function insideOf(w, id, seen = /* @__PURE__ */ new Set()) {
+		for (const p of partsIn(w, id, true)) if (!seen.has(p)) seen.add(p), insideOf(w, p, seen);
+		return seen;
+	}
+	function addAt(w, at, name, given = false) {
+		const n = clone(w);
+		const [kind, a, b] = at.includes(":") ? at.split(":") : [
+			"lobby",
+			at,
+			""
+		];
+		switch (kind) {
+			case "lobby":
+				make(n, a, name, "lobby", given);
+				break;
+			case "table":
+				make(n, a, name, "table", given);
+				break;
+			case "way":
+				make(n, a, name, "way", given);
+				break;
+			case "item":
+				make(n, a, name, "item", given);
+				break;
+			case "answer":
+				make(n, a, name, "answer", given);
+				break;
+			case "cell":
+				stand(n, b, make(n, a, name, "way", given));
+				break;
+			case "in":
+				if (!b) return refuse(w, words.notHere);
+				stand(n, make(n, b, name, placeOf(n, b) === "table" ? "item" : "answer", given), a);
+				break;
+			case "pick":
+				stand(n, b, make(n, a, name, "answer", given));
+				break;
+			default: return refuse(w, words.notHere);
+		}
+		return { world: n };
+	}
+	function dropIn(w, piece, onto, path) {
+		if (piece === onto || insideOf(w, piece).has(onto)) return refuse(w, words.notInsideItself);
+		const role = roleAt(w, path);
+		const at = path.at(-1) ?? w.top;
+		const n = clone(w);
+		if (role === "lobby") {
+			if (!lobbyZone(n, onto) || placeOf(n, onto) === "domain") return refuse(w, words.standsOnItsOwn);
+			const was = n.ins.find((i) => i.piece === piece && i.holder === at && i.ended === void 0);
+			if (was) was.ended = ++n.clock;
+			stand(n, piece, onto, was ? was.home : true);
+			return { world: n };
+		}
+		if (siblings(n, piece, onto)) return refuse(w, words.eachOnItsOwn);
+		if (role === "table") {
+			if (!lobbyZone(n, piece) && placeOf(n, onto) !== "item" && stands(n, onto, at) && stands(n, piece, at)) {
+				const was = n.ins.find((i) => i.piece === piece && i.holder === at && i.ended === void 0);
+				was.ended = ++n.clock;
+				stand(n, piece, onto, was.home);
+				if (was.home && placeOf(n, piece) === "way") n.pieces[piece].place = "answer";
+				return { world: n };
+			}
+			return refuse(w, words.standsOnItsOwn);
+		}
+		if (role === "way" || role === "answer") {
+			const t = contextTable(n, path);
+			const isItem = (x) => !!t && isItemOf(n, x, t);
+			if (!isItem(piece) && !isItem(onto)) return makeOne(w, piece, onto, path);
+			if (isItem(piece) && !isItem(onto)) {
+				leave(n, piece, at);
+				stand(n, piece, onto);
+				return said(n, words.stoodIn(nameOf(n, piece), nameOf(n, onto)), clone(w));
+			}
+			return refuse(w, words.eachOnItsOwn);
+		}
+		return refuse(w, words.standsOnItsOwn);
+	}
+	function makeOne(w, a, b, path, name) {
+		if (a === b) return refuse(w, words.notWithItself);
+		const role = roleAt(w, path);
+		const at = path.at(-1) ?? w.top;
+		const n = clone(w);
+		if (role === "lobby") {
+			const g = make(n, at, name ?? null, "lobby");
+			for (const x of [a, b]) {
+				const home = homeIn(n, x, at);
+				leave(n, x, at);
+				stand(n, x, g, home);
+			}
+			return { world: n };
+		}
+		if (role === "way" || role === "answer") {
+			const one = make(n, at, name ?? null, "answer");
+			for (const x of [a, b]) {
+				const home = homeIn(n, x, at);
+				leave(n, x, at);
+				stand(n, x, one, home);
+			}
+			return said(n, words.madeOne(name || words.notNamed, nameOf(n, a), nameOf(n, b), nameOf(n, at)), clone(w));
+		}
+		return refuse(w, words.eachOnItsOwn);
+	}
+	function placeRefusal(w, piece, holder) {
+		if (stands(w, piece, holder)) return null;
+		if (piece === holder || insideOf(w, piece).has(holder)) return words.notInsideItself;
+		const pz = lobbyZone(w, piece);
+		const hz = lobbyZone(w, holder);
+		if (pz && hz) return placeOf(w, holder) === "domain" ? words.domainHoldsTables : null;
+		if (pz !== hz) return pz ? words.domainHoldsThings : lobbyLinkable(w, holder).includes(piece) ? null : words.lobbyIsTheApp;
+		const pp = placeOf(w, piece);
+		if (pp === "table") return words.tablesSideBySide;
+		if (pp === "item") {
+			if (siblings(w, piece, holder)) return words.eachOnItsOwn;
+			const t = homeOf(w, piece);
+			const hp = placeOf(w, holder);
+			if (hp === "way" && answersOf(w, holder, t).length) return words.inOneOfItsAnswers;
+			if (hp === "way" || hp === "answer") return t && tableOf(w, holder) === t ? null : words.notInThisTable;
+			return words.notInThisTable;
+		}
+		return words.staysWhereMade;
+	}
+	function placeAlso(w, piece, holder) {
+		const no = placeRefusal(w, piece, holder);
+		if (no) return refuse(w, no);
+		const n = clone(w);
+		stand(n, piece, holder);
+		return { world: n };
+	}
+	function givenAt(w, id) {
+		if (!w.pieces[id]?.given) return null;
+		return w.ins.filter((i) => i.piece === id && i.home).sort((a, b) => a.since - b.since)[0]?.holder ?? null;
+	}
+	function takeOutRefusal(w, piece, holder) {
+		if (!homeIn(w, piece, holder)) return null;
+		if (!holdersOf(w, piece).filter((h) => h !== holder).length) return words.needsOnePlace;
+		if (lobbyZone(w, piece)) return givenAt(w, piece) === holder && holder !== w.top ? words.staysWhereGiven : null;
+		return w.pieces[piece]?.given ? words.staysWhereGiven : words.neverOutOfHome;
+	}
+	function takeOut(w, piece, holder) {
+		const no = takeOutRefusal(w, piece, holder);
+		if (no) return refuse(w, no);
+		const n = clone(w);
+		if (homeIn(n, piece, holder)) {
+			leave(n, piece, holder);
+			const back = givenAt(n, piece);
+			const to = back && stands(n, piece, back) ? back : holdersOf(n, piece).at(-1);
+			n.ins.find((i) => i.piece === piece && i.holder === to && i.ended === void 0).home = true;
+			return said(n, words.movedInto(nameOf(n, piece), nameOf(n, to)), clone(w));
+		}
+		leave(n, piece, holder);
+		return { world: n };
+	}
+	function pick(w, item, _way, answer) {
+		const n = clone(w);
+		if (stands(n, item, answer)) leave(n, item, answer);
+		else stand(n, item, answer);
+		return { world: n };
+	}
+	function linkable(w, item, t) {
+		if (placeOf(w, t) !== "table") return [];
+		const d = domainOf(w, t);
+		return d ? tablesIn(w, d).filter((x) => x !== t).flatMap((x) => itemsOf(w, x)) : [];
+	}
+	const linked = (w, a, b) => stands(w, a, b) || stands(w, b, a);
+	function link(w, a, b) {
+		const ta = homeOf(w, a), tb = homeOf(w, b);
+		if (!ta || !tb || ta === tb) return refuse(w, words.eachOnItsOwn);
+		const n = clone(w);
+		const [older, newer] = n.pieces[ta].made <= n.pieces[tb].made ? [a, b] : [b, a];
+		const tOlder = older === a ? ta : tb;
+		if (linked(n, a, b)) {
+			leave(n, older, newer);
+			if (!itemsOf(n, tOlder).some((i) => stands(n, i, newer))) leave(n, newer, tOlder);
+			return { world: n };
+		}
+		stand(n, newer, tOlder);
+		stand(n, older, newer);
+		return { world: n };
+	}
+	function rename(w, piece, name) {
+		const n = clone(w);
+		if (piece.startsWith("names:")) {
+			const t = n.pieces[piece.slice(6)];
+			if (!t) return refuse(w, words.notHere);
+			t.list = [name, ...listWords(n, t.id).filter((x) => x !== name)];
+			return { world: n };
+		}
+		const p = n.pieces[piece];
+		p.names = [name, ...p.names.filter((x) => x !== name)];
+		return { world: n };
+	}
+	function hide(w, piece) {
+		const n = clone(w);
+		n.pieces[piece].hidden = true;
+		return said(n, words.hiddenKept(nameOf(n, piece)), clone(w));
+	}
+	function show(w, piece) {
+		const n = clone(w);
+		n.pieces[piece].hidden = false;
+		return said(n, words.shownAgain(nameOf(n, piece)), clone(w));
+	}
+	const undo = (note) => ({ world: note.undo });
+	function settle(_w, _left, _before) {
+		return null;
+	}
+	return {
+		listWords,
+		nameOf,
+		placeOf,
+		partsIn,
+		holdersOf,
+		stands,
+		homeOf,
+		lobbyZone,
+		itemsOf,
+		tableOf,
+		domainOf,
+		tablesIn,
+		waysOf,
+		answersOf,
+		shared,
+		siblings,
+		outOf,
+		roleAt,
+		contextTable,
+		walksThrough,
+		choicesOf,
+		linkedTables,
+		hiddenOf,
+		stepOf,
+		stepsInto,
+		levelAt,
+		livesIn,
+		lobbyLinkable,
+		pathTo,
+		pathInto,
+		addAt,
+		dropIn,
+		makeOne,
+		placeRefusal,
+		placeAlso,
+		givenAt,
+		takeOutRefusal,
+		takeOut,
+		pick,
+		linkable,
+		linked,
+		link,
+		rename,
+		hide,
+		show,
+		undo,
+		settle,
+		build: {
+			make,
+			stand
+		},
+		model: {
+			levelAt,
+			outOf,
+			add: addAt,
+			dropIn,
+			makeOne,
+			placeAlso,
+			takeOut,
+			pick,
+			link,
+			rename,
+			hide,
+			show,
+			undo,
+			settle
+		}
+	};
+}
+export { ART_CHOICES_KEY, CONTEXT_CUBE_SOURCE, CONTEXT_CUBE_WORDS, CONTEXT_LAST_PARTS, CONTEXT_PART_ORDER, CUBE_ARTS, CUBE_CARRY_CLASSES, CUBE_CARRY_MOVE, CUBE_DROP_OUT, CUBE_HEAD_SWIPE, CUBE_HOLD_MS, CUBE_HOLD_SLOP, CUBE_ICON_NAMES, CUBE_LOADING_COLOURS, CUBE_LOADING_LEVELS, CUBE_LOADING_STEP_MS, CUBE_LOADING_STICKERS, CUBE_LOADING_WAYS, CUBE_LOADING_WIDTH, CUBE_PINCH_APART, CUBE_PINCH_TOGETHER, CUBE_ROOM_NARROW, CUBE_WHEEL_QUIET_MS, CUBE_WHEEL_STEP, CUBE_ZOOM_OPTIONS, CubeArtChoices, CubeCarry, CubeContext, CubeHead, CubeHold, CubeIcon, CubeLoading, CubePicture, CubePinch, CubeQuiet, CubeQuietLine, CubeRoom, CubeRoomMeasure, CubeSquare, CubeSquareTile, CubeTile, CubeZoomPinch, CubeZoomService, JUST_SAVED_MINUTES, MINE_SORT, PART_ICONS, CHOICE as PHYSICS_CHOICE, HIDDEN as PHYSICS_HIDDEN, LIST as PHYSICS_LIST, NAMES as PHYSICS_NAMES, UNKNOWN as PHYSICS_UNKNOWN, REPORT_APP, REPORT_INCIDENTS_KEPT, REPORT_INCIDENTS_MS, REPORT_KINDS, ReportClient, ReportDiagnostics, ReportDraft, ReportErrorHandler, SQUARE_LEAST_CELL, SQUARE_LEAST_TALL, SQUARE_LIST_ROW, SQUARE_MAX_SIDE, SQUARE_ROOM_BELOW, TEXT_ORDERS, TURNING_BELOW, TURNING_NUDGE_UNTIL, TURNING_SIDES, VIEW_KEYS, addLevel, artFor, artLevel, bringLevel, bringOf, chooseArt, contextArtWidth, contextIcon, contextLevelFor, contextOf, contextSquare, cubeIconCells, cubeMovesThePage, cubePhysics, cubeTilePicture, cubeTrailHolds, directionWords, drawArt, drawCube, environmentOf, errorLine, findJustSaved, gridFor, hideLevel, insideOf, isArt, isToken as isPhysicsToken, isView, loadingStickers, loadingWayFor, moveBefore, namesLevel, orderLevel, orderOf, orderParts, partsLevel, placesOf, provideCubeZoom, provideReportDiagnostics, readArtChoices, refusalOf, reportContext, reportInterceptor, reportRefusal, reportRequest, routePattern, scrubbedPath, sizeFor, sortDirectionsLevel, sortItems, sortLevel, squareCell, squareGap, squareLayout, squareLeast, squareLevelFor, squareSideAt, squareTall, startsWheelGesture, stillStep, technicalLines, tellLevel, turningFront, turningRows, viewLevel, wheelWay, whereLevel, wouldLoop };
 
 //# sourceMappingURL=selimssevgi-cube-design-angular.mjs.map