@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.5

package/bundled-test-harness/assets/externals-CDQm-Lm7.js

@@ -0,0 +1,4393 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=[(globalThis.__boxelAssetsURL||"/")+"assets/src-CF8jhG38.js",(globalThis.__boxelAssetsURL||"/")+"assets/native-1qc0_0op.js",(globalThis.__boxelAssetsURL||"/")+"assets/chunk-Rp0pCe6z.js",(globalThis.__boxelAssetsURL||"/")+"assets/preload-helper-CKDH5-7N.js",(globalThis.__boxelAssetsURL||"/")+"assets/validation-manifest-DCy3vpRF.js",(globalThis.__boxelAssetsURL||"/")+"assets/common-CEvPgPYE.js",(globalThis.__boxelAssetsURL||"/")+"assets/dateSerial-BN3LbIto.js",(globalThis.__boxelAssetsURL||"/")+"assets/nativeFilter-bBeaFw3F.js",(globalThis.__boxelAssetsURL||"/")+"assets/src-DMlCi9TD.js",(globalThis.__boxelAssetsURL||"/")+"assets/mutation-Dt2VvgTF.js",(globalThis.__boxelAssetsURL||"/")+"assets/test-support-CgWmpebE.js",(globalThis.__boxelAssetsURL||"/")+"assets/test-support-BOFeeYuE.js",(globalThis.__boxelAssetsURL||"/")+"assets/dist-CSQ-y1Ft.js",(globalThis.__boxelAssetsURL||"/")+"assets/debug-Dg0TiPYl.js",(globalThis.__boxelAssetsURL||"/")+"assets/es-compat2-CZCbH4TS.js",(globalThis.__boxelAssetsURL||"/")+"assets/es-B1dO8RuH.js",(globalThis.__boxelAssetsURL||"/")+"assets/service-LFpJ8EEP.js",(globalThis.__boxelAssetsURL||"/")+"assets/cache-DtDz7X5V-Wn8jRDfL.js",(globalThis.__boxelAssetsURL||"/")+"assets/owner-CP0__uFm.js",(globalThis.__boxelAssetsURL||"/")+"assets/validator-T25d_ucg.js",(globalThis.__boxelAssetsURL||"/")+"assets/computed_cache-DmYKevAP-DyWE_fcK.js",(globalThis.__boxelAssetsURL||"/")+"assets/index-DaCZcoCY-CgzbilMy.js",(globalThis.__boxelAssetsURL||"/")+"assets/owner-BT6cj890.js",(globalThis.__boxelAssetsURL||"/")+"assets/alias-CPqbuwcg-B1_trmq0.js",(globalThis.__boxelAssetsURL||"/")+"assets/application-VoCE-EjL.js",(globalThis.__boxelAssetsURL||"/")+"assets/proxy-Br6ueHyJ.js",(globalThis.__boxelAssetsURL||"/")+"assets/destroyable-mdLYRn_o.js",(globalThis.__boxelAssetsURL||"/")+"assets/template-factory-ds9s0u8l.js",(globalThis.__boxelAssetsURL||"/")+"assets/is-equal-CgIVjIN-.js",(globalThis.__boxelAssetsURL||"/")+"assets/managers-CbMgnSoo-yzoWKLy4.js",(globalThis.__boxelAssetsURL||"/")+"assets/layout-group-BS0gklZp.js",(globalThis.__boxelAssetsURL||"/")+"assets/dist-CkA1rgqO.js",(globalThis.__boxelAssetsURL||"/")+"assets/component-BJO47HTh.js",(globalThis.__boxelAssetsURL||"/")+"assets/runtime--fcdnjmJ-BoCBNIsz.js",(globalThis.__boxelAssetsURL||"/")+"assets/dist-nMt-N14r.js",(globalThis.__boxelAssetsURL||"/")+"assets/modifier-D0EP-FQ7.js",(globalThis.__boxelAssetsURL||"/")+"assets/tracking-CNiq91Pk.js",(globalThis.__boxelAssetsURL||"/")+"assets/resolve-transition-CVjf7YAq.js",(globalThis.__boxelAssetsURL||"/")+"assets/memory-B73-H_Rp.js",(globalThis.__boxelAssetsURL||"/")+"assets/speed-bIo0tyrM.js",(globalThis.__boxelAssetsURL||"/")+"assets/src-LqENIikj.js",(globalThis.__boxelAssetsURL||"/")+"assets/steps-D0xobKkB.js",(globalThis.__boxelAssetsURL||"/")+"assets/src-a4d10Hra.js",(globalThis.__boxelAssetsURL||"/")+"assets/run-FzaqmBEl.js",(globalThis.__boxelAssetsURL||"/")+"assets/src-CbBcj3xm.js",(globalThis.__boxelAssetsURL||"/")+"assets/node-BWOLCOMI.js",(globalThis.__boxelAssetsURL||"/")+"assets/motion-config-BbHByW3a.js",(globalThis.__boxelAssetsURL||"/")+"assets/item-CBEoTOyj.js",(globalThis.__boxelAssetsURL||"/")+"assets/motion-BiMvMS08.js",(globalThis.__boxelAssetsURL||"/")+"assets/presence-BKkR2au7.js",(globalThis.__boxelAssetsURL||"/")+"assets/group-DL-b_Hzj.js",(globalThis.__boxelAssetsURL||"/")+"assets/choreo-D1K9RyjM.js",(globalThis.__boxelAssetsURL||"/")+"assets/choreo-Ci5dG5fv.js",(globalThis.__boxelAssetsURL||"/")+"assets/steps-aNa4m6PJ.js",(globalThis.__boxelAssetsURL||"/")+"assets/test-support-QTh6wGxu.js",(globalThis.__boxelAssetsURL||"/")+"assets/test-support-Tr-PYFgc.js",(globalThis.__boxelAssetsURL||"/")+"assets/film-D1E-odYG.js",(globalThis.__boxelAssetsURL||"/")+"assets/clip-CsRtHZiN.js",(globalThis.__boxelAssetsURL||"/")+"assets/helper-BHX0HLF2.js",(globalThis.__boxelAssetsURL||"/")+"assets/film-D97U-ydx.js",(globalThis.__boxelAssetsURL||"/")+"assets/host-KVk6VIHI.js",(globalThis.__boxelAssetsURL||"/")+"assets/adjust--n_OTVbP.js",(globalThis.__boxelAssetsURL||"/")+"assets/nodes-BH4FGkKK.js",(globalThis.__boxelAssetsURL||"/")+"assets/joins-D_xzMJAJ.js",(globalThis.__boxelAssetsURL||"/")+"assets/overlays-nTqcu69K.js",(globalThis.__boxelAssetsURL||"/")+"assets/plate-DAr_pvwC.js",(globalThis.__boxelAssetsURL||"/")+"assets/player-CAVQUyKk.js",(globalThis.__boxelAssetsURL||"/")+"assets/rail-CQ53Dakr.js",(globalThis.__boxelAssetsURL||"/")+"assets/titles-0a1luoTq.js",(globalThis.__boxelAssetsURL||"/")+"assets/picture-DbNWRbtX.js",(globalThis.__boxelAssetsURL||"/")+"assets/clip-CycGr0Lf.js",(globalThis.__boxelAssetsURL||"/")+"assets/film-D25Y0ED6.js",(globalThis.__boxelAssetsURL||"/")+"assets/adjust-tbcBqG-n.js",(globalThis.__boxelAssetsURL||"/")+"assets/host-DMN-E78f.js",(globalThis.__boxelAssetsURL||"/")+"assets/nodes-Cb9jGNmV.js",(globalThis.__boxelAssetsURL||"/")+"assets/joins-CFhtaZ7U.js",(globalThis.__boxelAssetsURL||"/")+"assets/overlays-COinwHCP.js",(globalThis.__boxelAssetsURL||"/")+"assets/picture-CPj4Wgsy.js",(globalThis.__boxelAssetsURL||"/")+"assets/plate-DeoQd99m.js",(globalThis.__boxelAssetsURL||"/")+"assets/player-BvXGBItd.js",(globalThis.__boxelAssetsURL||"/")+"assets/rail-CFPU0tFe.js",(globalThis.__boxelAssetsURL||"/")+"assets/titles-DKHNLVwC.js",(globalThis.__boxelAssetsURL||"/")+"assets/src-DOKnNfG8.js",(globalThis.__boxelAssetsURL||"/")+"assets/store-tDubGN_j.js",(globalThis.__boxelAssetsURL||"/")+"assets/vanilla-BA1BUPFM.js",(globalThis.__boxelAssetsURL||"/")+"assets/layout-DVAINTLP.js",(globalThis.__boxelAssetsURL||"/")+"assets/lib.esm-CdDCG-7Y.js",(globalThis.__boxelAssetsURL||"/")+"assets/lib.esm-k4KIhRQO.js",(globalThis.__boxelAssetsURL||"/")+"assets/pdfjs-tq21NQBp.js",(globalThis.__boxelAssetsURL||"/")+"assets/esm-browser-ByMIQXWT.js",(globalThis.__boxelAssetsURL||"/")+"assets/esm-browser-CIYLo70w.js",(globalThis.__boxelAssetsURL||"/")+"assets/browser-ZN0_uldJ.js",(globalThis.__boxelAssetsURL||"/")+"assets/browser-B_4zqvM9.js",(globalThis.__boxelAssetsURL||"/")+"assets/browser-BpGk2ZmZ.js",(globalThis.__boxelAssetsURL||"/")+"assets/browser-CKBrcCxN.js",(globalThis.__boxelAssetsURL||"/")+"assets/constants-WFA0gSYM.js",(globalThis.__boxelAssetsURL||"/")+"assets/constants-Icc0nFW-.js",(globalThis.__boxelAssetsURL||"/")+"assets/paths-C9-NYXnM.js",(globalThis.__boxelAssetsURL||"/")+"assets/marked-sync-BCLGl4e-.js",(globalThis.__boxelAssetsURL||"/")+"assets/marked-sync-B1trqB6L.js",(globalThis.__boxelAssetsURL||"/")+"assets/bfm-card-references-Cjos2rOp.js",(globalThis.__boxelAssetsURL||"/")+"assets/dompurify-runtime-BResfr4t.js",(globalThis.__boxelAssetsURL||"/")+"assets/purify.es-CdJGJvFA.js",(globalThis.__boxelAssetsURL||"/")+"assets/bfm-card-references-DiydFUNR.js",(globalThis.__boxelAssetsURL||"/")+"assets/ai-Cs1uTbhS.js",(globalThis.__boxelAssetsURL||"/")+"assets/ai-BFUROO-8.js",(globalThis.__boxelAssetsURL||"/")+"assets/card-directory-name-BwTPYMCb.js",(globalThis.__boxelAssetsURL||"/")+"assets/runtime-common-BTaLJEw-.js",(globalThis.__boxelAssetsURL||"/")+"assets/index-esm-CUymiD6S.js",(globalThis.__boxelAssetsURL||"/")+"assets/defineProperty-BzbzoKfB.js",(globalThis.__boxelAssetsURL||"/")+"assets/amd-transpile-DPkNHMXs.js",(globalThis.__boxelAssetsURL||"/")+"assets/browser-DBC8B1Th.js",(globalThis.__boxelAssetsURL||"/")+"assets/lodash-DHx1coJM.js",(globalThis.__boxelAssetsURL||"/")+"assets/loglevel-xo4L-Std.js",(globalThis.__boxelAssetsURL||"/")+"assets/realm-permission-checker-6Ap9zqtc.js"])))=>i.map(i=>d[i]);
+import { i as __name, r as __exportAll, s as __toESM, t as __commonJSMin } from "./chunk-Rp0pCe6z.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { bc as md5_esm_bundler_exports, eo as PACKAGES_FAKE_ORIGIN, f as runtime_common_exports, tn as esm_exports, to as fallbackShim, vc as init_md5_esm_bundler } from "./runtime-common-BTaLJEw-.js";
+import { t as lodash_exports } from "./lodash-DHx1coJM.js";
+import { t as __vitePreload } from "./preload-helper-CKDH5-7N.js";
+import { n as index_esm_exports } from "./index-esm-CUymiD6S.js";
+import { c as warn } from "./debug-Dg0TiPYl.js";
+import { Vn as guidFor, Z as setClassicDecorator, _ as addObserver, j as get, wt as setComponentTemplate, x as computed } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { _t as schedule, d as action, dt as join, f as object_exports, gt as runloop_exports, i as service_exports, lt as cancel, n as inject, r as service$4, vt as scheduleOnce } from "./service-LFpJ8EEP.js";
+import { N as validator_exports, S as tagFor, h as dirtyTagFor, u as consumeTag } from "./validator-T25d_ucg.js";
+import { a as set } from "./computed_cache-DmYKevAP-DyWE_fcK.js";
+import { Ft as getViewBounds$1, H as templateFactory, ct as A, t as Component } from "./index-DaCZcoCY-CgzbilMy.js";
+import { t as alias } from "./alias-CPqbuwcg-B1_trmq0.js";
+import { t as destroyable_exports } from "./destroyable-mdLYRn_o.js";
+import { n as macroCondition, t as isTesting } from "./runtime-9O0mNd7j.js";
+import { t as async_arrow_runtime_exports } from "./async-arrow-runtime-STsj7E8Y.js";
+import { t as rsvp_exports } from "./rsvp-BUQYrGTG.js";
+import { t as dist_exports$2 } from "./dist-qkBOmIQy.js";
+import { s as helper_exports } from "./helper-BHX0HLF2.js";
+import { t as dist_exports$3 } from "./dist-CLbqnmnm.js";
+import { t as dist_exports$4 } from "./dist-B9tGPKZz.js";
+import { t as modifier_exports } from "./modifier-D0EP-FQ7.js";
+import { t as component_exports } from "./component-BJO47HTh.js";
+import { n as dist_exports$5, t as Component$1 } from "./dist-CkA1rgqO.js";
+import "./metal-3rHwUpzF.js";
+import { r as tracking_exports } from "./tracking-800VJb8b.js";
+import { t as template_factory_exports } from "./template-factory-ds9s0u8l.js";
+import { n as template_only_exports } from "./template-only-6nVzLWF-.js";
+import { t as helpers_exports } from "./helpers-U4_dLjnS.js";
+import { Z as ElementHelper, t as components_exports, u as modifiers_exports } from "./components-Ck24ubaT.js";
+import { t as icons_exports } from "./icons-Ctk-4xDe.js";
+import { t as template_exports } from "./template-C81fYDrq.js";
+import { n as dist_exports$6, r as modifier } from "./dist-nMt-N14r.js";
+import { n as dist_exports$7 } from "./dist-D2_TiMFf.js";
+import { t as internals_exports } from "./internals-BTorg710.js";
+import { i as floating_ui_dom_exports } from "./dist-CAIttNZm.js";
+import { t as dist_exports$8 } from "./dist-DEVZvbin.js";
+import { a as hasContext, i as getContextValue, n as dist_exports$9, s as setContextMetadataOnContextProviderInstance } from "./dist-Ble0L9o7.js";
+import { t as browser_index_exports } from "./browser-index-WJHA2DY5.js";
+import { t as dist_exports$10 } from "./dist-BOAdzfkP.js";
+import "./views-B3PJv4Qn.js";
+import { i as layout_group_exports } from "./layout-group-BS0gklZp.js";
+import { t as src_exports } from "./src-CbBcj3xm.js";
+import { n as item_exports } from "./item-CBEoTOyj.js";
+import { r as motion_config_exports } from "./motion-config-BbHByW3a.js";
+import { n as presence_exports } from "./presence-BKkR2au7.js";
+import { n as group_exports } from "./group-DL-b_Hzj.js";
+import { n as pdfjs_loader_exports } from "./pdfjs-loader-ELvIpnbZ.js";
+import { n as signed_capture_exports } from "./signed-capture-wuvq_Aok.js";
+import { n as three_loader_exports } from "./three-loader-DNsH2465.js";
+import { n as shimHostTools } from "./tools-J_Knr_W6.js";
+//#region ../../node_modules/.pnpm/@cardstack+view-transitions@0.2.0_@babel+core@7.29.7_supports-color@8.1.1__ember-modifi_83ee960449b91cd91d58780597434c5f/node_modules/@cardstack/view-transitions/dist/index.js
+var dist_exports$1 = /* @__PURE__ */ __exportAll({
+	animatable: () => animatable,
+	viewTransitionName: () => viewTransitionName
+});
+function animatable(initialValue, opts) {
+	return new AnimatableImpl(initialValue, opts?.equals ?? Object.is);
+}
+var viewTransitionName = modifier(function(element, parts) {
+	element.style.viewTransitionName = parts.map((p) => String(p)).join("");
+});
+function waitForRender() {
+	return new Promise((resolve) => {
+		schedule("afterRender", () => {
+			resolve();
+		});
+	});
+}
+var AnimatableImpl = class {
+	#current;
+	#equals;
+	constructor(initial, equals) {
+		this.#current = initial;
+		this.#equals = equals;
+	}
+	get current() {
+		consumeTag(tagFor(this, "current"));
+		return this.#current;
+	}
+	#set(newValue) {
+		dirtyTagFor(this, "current");
+		this.#current = newValue;
+	}
+	set = (newValue) => {
+		if (this.#equals(this.#current, newValue)) return;
+		if (!document.startViewTransition) {
+			this.#set(newValue);
+			return;
+		}
+		document.startViewTransition(async () => {
+			this.#set(newValue);
+			await waitForRender();
+		});
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/singleton.js
+window.emberAnimatedSingleton = window.emberAnimatedSingleton || {};
+function getOrCreate$3(key, construct) {
+	const symbol = Symbol.for(key);
+	if (!(Object.getOwnPropertySymbols(window.emberAnimatedSingleton).indexOf(symbol) > -1)) window.emberAnimatedSingleton[symbol] = construct();
+	return window.emberAnimatedSingleton[symbol];
+}
+__name(getOrCreate$3, "getOrCreate");
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/concurrency-helpers.js
+function getOrCreate$2(key, construct) {
+	return getOrCreate$3(`concurrency-helpers.${key}`, construct);
+}
+__name(getOrCreate$2, "getOrCreate");
+var frameState = getOrCreate$2("frameState", () => ({
+	nextFrame: null,
+	nextFrameWaiters: [],
+	currentFrameClock: -Infinity
+}));
+var cancellation = getOrCreate$2("cancellation", () => /* @__PURE__ */ new WeakMap());
+function registerCancellation(promise, handler) {
+	cancellation.set(promise, handler);
+}
+function fireCancellation(promise) {
+	let fn = cancellation.get(promise);
+	if (fn) fn(promise);
+}
+function rAF() {
+	if (!frameState.nextFrame) frameState.nextFrame = requestAnimationFrame(rAFDidFire);
+	let resolve;
+	let promise = new Promise((r) => {
+		resolve = r;
+	});
+	frameState.nextFrameWaiters.push({
+		resolve,
+		promise
+	});
+	registerCancellation(promise, removeWaiter);
+	return promise;
+}
+function rAFDidFire(clock) {
+	frameState.nextFrame = null;
+	frameState.currentFrameClock = clock;
+	let waiters = frameState.nextFrameWaiters;
+	frameState.nextFrameWaiters = [];
+	for (const waiter of waiters) waiter.resolve();
+}
+function removeWaiter(promise) {
+	let pair = frameState.nextFrameWaiters.find((pair) => pair.promise === promise);
+	if (pair) {
+		let index = frameState.nextFrameWaiters.indexOf(pair);
+		if (index > -1) frameState.nextFrameWaiters.splice(index, 1);
+	}
+}
+function microwait() {
+	return new Promise((resolve) => resolve());
+}
+function wait(ms = 0) {
+	if (clock.now === originalClock) {
+		let ticket;
+		let promise = new Promise((resolve) => {
+			ticket = window.setTimeout(resolve, ms);
+		});
+		registerCancellation(promise, () => {
+			clearTimeout(ticket);
+		});
+		return promise;
+	} else {
+		let canceled = false;
+		let started = clock.now();
+		let promise = new Promise((resolve) => {
+			function checkIt() {
+				if (!canceled) {
+					if (clock.now() - started > ms) resolve();
+					rAF().then(checkIt);
+				}
+			}
+			checkIt();
+		});
+		registerCancellation(promise, () => {
+			canceled = true;
+		});
+		return promise;
+	}
+}
+function afterRender() {
+	let ticket;
+	let promise = new Promise((resolve) => {
+		ticket = schedule("afterRender", () => resolve());
+	});
+	registerCancellation(promise, () => {
+		cancel(ticket);
+	});
+	return promise;
+}
+var clock = getOrCreate$2("clock", () => ({ now() {
+	return (/* @__PURE__ */ new Date()).getTime();
+} }));
+var originalClock = getOrCreate$2("originalClock", () => clock.now);
+function allSettled(promises) {
+	return Promise.all(promises.map((p) => {
+		if (p) return p.catch(() => null);
+	}));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/scheduler.js
+function getOrCreate$1(key, construct) {
+	return getOrCreate$3(`scheduler.${key}`, construct);
+}
+__name(getOrCreate$1, "getOrCreate");
+function spawn(genFn) {
+	return new MicroRoutine(genFn, false).promise;
+}
+function spawnChild(genFn) {
+	return new MicroRoutine(genFn, true).promise;
+}
+function stop(microRoutinePromise) {
+	if (microRoutinePromise === current()) {
+		let e = /* @__PURE__ */ new Error("TaskCancelation");
+		e.message = "TaskCancelation";
+		throw e;
+	}
+	let microRoutine = microRoutines.get(microRoutinePromise);
+	if (microRoutine) microRoutine.stop();
+}
+function logErrors(fn) {
+	ensureCurrent("logErrors").errorLogger = fn;
+}
+function current() {
+	let cur = getCurrent();
+	if (cur) return cur.promise;
+}
+async function childrenSettled() {
+	return Promise.all(ensureCurrent("childrenSettled").linked.map((child) => child.promise.catch(() => null)));
+}
+function isTaskCancelationError(x) {
+	return x.message === "TaskCancelation";
+}
+var withCurrent;
+var getCurrent;
+var onStack;
+{
+	const routines = getOrCreate$1("routines", () => ({
+		cur: void 0,
+		prior: []
+	}));
+	withCurrent = function(routine, fn) {
+		routines.prior.unshift({
+			microroutine: routines.cur,
+			throw: void 0
+		});
+		routines.cur = routine;
+		try {
+			return fn();
+		} finally {
+			let restore = routines.prior.shift();
+			routines.cur = restore.microroutine;
+			if (restore.throw) throw restore.throw;
+		}
+	};
+	getCurrent = function() {
+		return routines.cur;
+	};
+	onStack = function(microroutine) {
+		return routines.prior.find((entry) => entry.microroutine === microroutine);
+	};
+}
+function ensureCurrent(label) {
+	let cur = getCurrent();
+	if (!cur) throw new Error(`${label}: only works inside a running microroutine`);
+	return cur;
+}
+var loggedErrors = getOrCreate$1("loggedErrors", () => /* @__PURE__ */ new WeakSet());
+var microRoutines = getOrCreate$1("microRoutines", () => /* @__PURE__ */ new WeakMap());
+var MicroRoutine = class {
+	generator;
+	resolve;
+	reject;
+	stopped = false;
+	state;
+	linked = [];
+	errorLogger;
+	promise;
+	constructor(genFn, linkToParent) {
+		this.generator = genFn();
+		this.promise = new Promise((res, rej) => {
+			this.resolve = res;
+			this.reject = rej;
+		});
+		microRoutines.set(this.promise, this);
+		registerCancellation(this.promise, this.stop.bind(this));
+		if (linkToParent) {
+			let parent = ensureCurrent("spawnChild");
+			parent.linked.push(this);
+			this.errorLogger = parent.errorLogger;
+		}
+		this.wake("fulfilled", void 0);
+	}
+	wake(state, value) {
+		if (this.stopped) return;
+		withCurrent(this, () => {
+			try {
+				if (state === "fulfilled") this.state = this.generator.next(value);
+				else this.state = this.generator.throw(value);
+				if (this.state.done) this.resolve(this.state.value);
+				else Promise.resolve(this.state.value).then((value) => this.wake("fulfilled", value), (reason) => this.wake("rejected", reason));
+			} catch (err) {
+				this.state = {
+					done: true,
+					value: void 0
+				};
+				this.linked.forEach((microRoutine) => {
+					microRoutine.stop();
+				});
+				if (!isTaskCancelationError(err)) {
+					this.reject(err);
+					if (this.errorLogger) {
+						if (!loggedErrors.has(err)) {
+							loggedErrors.add(err);
+							this.errorLogger.call(null, err);
+						}
+					}
+				}
+			}
+		});
+	}
+	stop() {
+		this.stopped = true;
+		if (this.state && isPromise(this.state.value)) fireCancellation(this.state.value);
+		this.linked.forEach((microRoutine) => {
+			microRoutine.stop();
+		});
+		let e = /* @__PURE__ */ new Error("TaskCancelation");
+		e.message = "TaskCancelation";
+		if (getCurrent() === this) throw e;
+		let s = onStack(this);
+		if (s) s.throw = e;
+		else withCurrent(this, () => cancelGenerator(this.generator));
+	}
+};
+function cancelGenerator(generator) {
+	let e = /* @__PURE__ */ new Error("TaskCancelation");
+	e.message = "TaskCancelation";
+	try {
+		generator.throw(e);
+	} catch (err) {
+		if (!isTaskCancelationError(err)) throw err;
+	}
+}
+function isPromise(thing) {
+	return thing && typeof thing.then === "function";
+}
+function parallel(...functions) {
+	return function(...args) {
+		return Promise.all(functions.map((f) => f.apply(null, args)));
+	};
+}
+function serial(...functions) {
+	return function(...args) {
+		return spawnChild(function* () {
+			for (let fn of functions) yield fn.apply(null, args);
+		});
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/ember-scheduler.js
+function getOrCreate(key, construct) {
+	return getOrCreate$3(`ember-scheduler.${key}`, construct);
+}
+function task(taskFn) {
+	let tp = _computed(function(propertyName) {
+		return new Task(this, taskFn, tp, propertyName);
+	});
+	Object.setPrototypeOf(tp, TaskProperty.prototype);
+	return tp;
+}
+function _computed(fn) {
+	let cp = function(proto, key) {
+		if (cp.setup !== void 0) cp.setup(proto, key);
+		return computed(fn)(...arguments);
+	};
+	setClassicDecorator(cp);
+	return cp;
+}
+var handlerCounter = 0;
+var BaseTaskProperty = class {};
+var TaskProperty = class extends BaseTaskProperty {
+	_bufferPolicy;
+	_observes;
+	restartable() {
+		this._bufferPolicy = cancelAllButLast;
+		return this;
+	}
+	drop() {
+		this._bufferPolicy = drop;
+		return this;
+	}
+	observes(...deps) {
+		this._observes = deps;
+		return this;
+	}
+	setup(proto, taskName) {
+		if (super.setup) super.setup(...arguments);
+		if (this._observes) {
+			let handlerName = `_ember_animated_handler_${handlerCounter++}`;
+			proto[handlerName] = function() {
+				let task = this[taskName];
+				scheduleOnce("actions", task, "_safePerform");
+			};
+			for (let i = 0; i < this._observes.length; ++i) {
+				let name = this._observes[i];
+				addObserver(proto, name, null, handlerName);
+			}
+		}
+	}
+};
+var priv = getOrCreate("priv", () => /* @__PURE__ */ new WeakMap());
+function getPriv(task) {
+	return priv.get(task);
+}
+var Task = class {
+	concurrency = 0;
+	isRunning = false;
+	constructor(context, implementation, taskProperty, name) {
+		priv.set(this, {
+			context,
+			implementation,
+			instances: [],
+			taskProperty,
+			name
+		});
+	}
+	perform(...args) {
+		let self = this;
+		let privSelf = getPriv(this);
+		let context = privSelf.context;
+		let implementation = privSelf.implementation;
+		let policy = privSelf.taskProperty._bufferPolicy;
+		if (context.isDestroyed) throw new Error(`Tried to perform task ${privSelf.name} on an already destroyed object`);
+		cleanupOnDestroy(context, this);
+		return spawn(function* () {
+			logErrors((error) => {
+				microwait().then(() => {
+					throw error;
+				});
+			});
+			try {
+				self._addInstance(current());
+				if (policy) {
+					let maybeWait = policy(self, privSelf);
+					if (maybeWait) yield maybeWait;
+				}
+				return yield* withRunLoop(implementation.call(context, ...args));
+			} finally {
+				join(() => {
+					self._removeInstance(current());
+				});
+			}
+		});
+	}
+	cancelAll() {
+		getPriv(this).instances.forEach((i) => stop(i));
+	}
+	_addInstance(i) {
+		getPriv(this).instances.push(i);
+		set(this, "isRunning", true);
+		set(this, "concurrency", this.concurrency + 1);
+	}
+	_removeInstance(i) {
+		let instances = getPriv(this).instances;
+		instances.splice(instances.indexOf(i), 1);
+		set(this, "concurrency", this.concurrency - 1);
+		set(this, "isRunning", this.concurrency > 0);
+	}
+	_safePerform() {
+		let { context } = getPriv(this);
+		if (!context.isDestroyed) this.perform();
+	}
+};
+function cleanupOnDestroy(owner, object) {
+	if (!owner.willDestroy) return;
+	if (!owner.willDestroy.__ember_processes_destroyers__) {
+		let oldWillDestroy = owner.willDestroy;
+		let disposers = [];
+		owner.willDestroy = function() {
+			for (const disposer of disposers) disposer();
+			oldWillDestroy.apply(owner, arguments);
+		};
+		owner.willDestroy.__ember_processes_destroyers__ = disposers;
+	}
+	owner.willDestroy.__ember_processes_destroyers__.push(() => {
+		try {
+			object.cancelAll();
+		} catch (err) {
+			if (err.message !== "TaskCancelation") throw err;
+		}
+	});
+}
+function cancelAllButLast(_task, privTask) {
+	const instances = privTask.instances;
+	for (const instance of instances.slice(0, -1)) stop(instance);
+}
+function drop(_task, privTask) {
+	let instances = privTask.instances;
+	for (let i = 1; i < instances.length; i++) stop(instances[i]);
+}
+function* withRunLoop(generator) {
+	let state;
+	let threw;
+	let nextValue;
+	let fulfilled = true;
+	while (true) {
+		join(() => {
+			try {
+				if (fulfilled) state = generator.next(nextValue);
+				else state = generator.throw(nextValue);
+			} catch (err) {
+				threw = err;
+			}
+		});
+		if (threw) throw threw;
+		if (state.done) return state.value;
+		try {
+			nextValue = yield state.value;
+			fulfilled = true;
+		} catch (err) {
+			nextValue = err;
+			fulfilled = false;
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/debug.js
+var printSprites = function printSprites(context, label) {
+	let isOrphan = null;
+	let prefix = label ? label + " " : "";
+	let spriteSummary = [
+		"inserted",
+		"kept",
+		"removed",
+		"sent",
+		"received"
+	].map((type) => {
+		return type + "=" + context[`_${type}Sprites`].map((s) => {
+			if (isOrphan == null) isOrphan = !s.element.parentElement || s.element.parentElement.classList.contains("animated-orphans");
+			return s.owner.id;
+		}).join(",");
+	}).join(" | ");
+	console.log(prefix + spriteSummary + (isOrphan ? " | (orphan)" : ""));
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/motion-bridge.js
+var bridges = getOrCreate$3("motion-bridges", () => /* @__PURE__ */ new WeakMap());
+function continueMotions(oldElement, newElement) {
+	bridges.set(newElement, oldElement);
+	rAF().then(() => {
+		if (bridges.get(newElement) === oldElement) bridges.delete(newElement);
+	});
+}
+function continuedFromElement(newElement) {
+	return bridges.get(newElement);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/transition-context.js
+var spriteContext = getOrCreate$3("transition-context", () => /* @__PURE__ */ new WeakMap());
+function* runToCompletion(context, transition) {
+	yield* transition(context);
+	yield childrenSettled();
+}
+var TransitionContext = class {
+	static forSprite(sprite) {
+		return spriteContext.get(sprite);
+	}
+	_prepared = /* @__PURE__ */ new Set();
+	prepareSprite;
+	constructor(_duration, _insertedSprites, _keptSprites, _removedSprites, _sentSprites, _receivedSprites, _beacons, onMotionStart, onMotionEnd) {
+		this._duration = _duration;
+		this._insertedSprites = _insertedSprites;
+		this._keptSprites = _keptSprites;
+		this._removedSprites = _removedSprites;
+		this._sentSprites = _sentSprites;
+		this._receivedSprites = _receivedSprites;
+		this._beacons = _beacons;
+		this.onMotionStart = onMotionStart;
+		this.onMotionEnd = onMotionEnd;
+	}
+	get duration() {
+		return this._duration;
+	}
+	get insertedSprites() {
+		return this._prepareSprites(this._insertedSprites);
+	}
+	get keptSprites() {
+		return this._prepareSprites(this._keptSprites);
+	}
+	get removedSprites() {
+		return this._prepareSprites(this._removedSprites);
+	}
+	get sentSprites() {
+		return this._prepareSprites(this._sentSprites);
+	}
+	get receivedSprites() {
+		return this._prepareSprites(this._receivedSprites);
+	}
+	get beacons() {
+		return this._beacons;
+	}
+	_prepareSprites(sprites) {
+		sprites.forEach((sprite) => {
+			spriteContext.set(sprite, this);
+		});
+		if (!this.prepareSprite) return sprites;
+		return sprites.map((sprite) => {
+			if (!this._prepared.has(sprite)) {
+				this._prepared.add(sprite);
+				sprite = this.prepareSprite(sprite);
+			}
+			return sprite;
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/motion.js
+var motions = getOrCreate$3("motion", () => /* @__PURE__ */ new WeakMap());
+var Motion = class {
+	_motionList;
+	_inheritedMotionList;
+	constructor(sprite, opts = {}) {
+		this.sprite = sprite;
+		this.opts = opts;
+		this.sprite = sprite;
+		this.opts = opts;
+		this._setupMotionList();
+	}
+	get duration() {
+		if (this.opts.duration != null) return this.opts.duration;
+		return TransitionContext.forSprite(this.sprite).duration;
+	}
+	run() {
+		let context = TransitionContext.forSprite(this.sprite);
+		let self = this;
+		return spawnChild(function* () {
+			context.onMotionStart(self.sprite);
+			try {
+				yield* self._run();
+			} finally {
+				context.onMotionEnd(self.sprite);
+			}
+		});
+	}
+	interrupted(_otherMotions) {}
+	*animate() {}
+	*_run() {
+		try {
+			let others = this._motionList.filter((m) => m !== this);
+			if (this._inheritedMotionList) others = others.concat(this._inheritedMotionList);
+			if (others.length > 0) this.interrupted(others);
+			yield* this.animate();
+		} finally {
+			rAF().then(() => this._clearMotionList());
+		}
+	}
+	_setupMotionList() {
+		let element = this.sprite.element;
+		let motionList = motions.get(element);
+		if (!motionList) motions.set(element, motionList = []);
+		this._motionList = motionList;
+		microwait().then(() => {
+			if (this._motionList) this._motionList.unshift(this);
+		});
+		let oldElement = continuedFromElement(element);
+		if (oldElement) {
+			let inheritedMotions = motions.get(oldElement);
+			if (inheritedMotions) this._inheritedMotionList = inheritedMotions;
+		}
+	}
+	_clearMotionList() {
+		if (this._motionList) {
+			let index = this._motionList.indexOf(this);
+			this._motionList.splice(index, 1);
+			if (this._motionList.length === 0) motions.delete(this.sprite.element);
+			this._motionList = void 0;
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/easings/cosine.js
+var cosine_exports = /* @__PURE__ */ __exportAll({
+	easeIn: () => easeIn,
+	easeInAndOut: () => easeInAndOut,
+	easeOut: () => easeOut
+});
+function easeInAndOut(t) {
+	return .5 - Math.cos(t * Math.PI) / 2;
+}
+var adjust = 1 / 2 + 1 / Math.PI;
+var cutover = 1 / (2 * adjust);
+var b = (2 - Math.PI) / 4;
+var m = Math.PI / 2 * adjust;
+function easeIn(t) {
+	if (t < cutover) return easeInAndOut(t * adjust);
+	else return m * t + b;
+}
+function easeOut(t) {
+	return 1 - easeIn(1 - t);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/tween.js
+var currentCurves = getOrCreate$3("tween", () => []);
+var Tween = class {
+	curve;
+	diff;
+	constructor(initialValue, finalValue, duration, easing = easeInAndOut) {
+		this.initialValue = initialValue;
+		this.finalValue = finalValue;
+		if (typeof easing !== "function") throw new Error("Tried to make a Tween with an invalid easing function");
+		this.curve = MotionCurve.findOrCreate(duration, easing);
+		this.diff = finalValue - initialValue;
+	}
+	get currentValue() {
+		return this.initialValue + this.diff * this.curve.spaceProgress;
+	}
+	get done() {
+		return this.curve.done;
+	}
+	plus(otherTween) {
+		return new DerivedTween([this, otherTween], (a, b) => a.currentValue + b.currentValue);
+	}
+};
+var DerivedTween = class {
+	_finalValue = null;
+	inputs;
+	constructor(inputs, combinator) {
+		this.combinator = combinator;
+		this._finalValue = null;
+		this.inputs = inputs.map((t) => {
+			if (t.done) return new Tween(t.currentValue, t.currentValue, 0);
+			else return t;
+		});
+	}
+	get finalValue() {
+		if (this._finalValue == null) {
+			let accum = 0;
+			for (const input of this.inputs) accum += input.finalValue;
+			this._finalValue = accum;
+		}
+		return this._finalValue;
+	}
+	get currentValue() {
+		return this.combinator(...this.inputs);
+	}
+	get done() {
+		return !this.inputs.find((t) => !t.done);
+	}
+};
+var MotionCurve = class {
+	static findOrCreate(duration, easing) {
+		let shared = currentCurves.find((c) => c.duration === duration && c.easing === easing);
+		if (shared) return shared;
+		let created = new this(duration, easing);
+		currentCurves.push(created);
+		rAF().then(() => {
+			currentCurves.splice(currentCurves.indexOf(created), 1);
+		});
+		return created;
+	}
+	startTime;
+	_doneFrames = 0;
+	_lastTick;
+	_runTime;
+	_timeProgress;
+	_spaceProgress;
+	constructor(duration, easing) {
+		this.duration = duration;
+		this.easing = easing;
+		this.startTime = clock.now();
+		this._tick();
+	}
+	_tick() {
+		if (this._lastTick !== frameState.currentFrameClock) {
+			this._lastTick = frameState.currentFrameClock;
+			this._runTime = clock.now() - this.startTime;
+			this._timeProgress = this.duration === 0 ? 1 : Math.min(this._runTime / this.duration, 1);
+			this._spaceProgress = this.easing(this._timeProgress);
+			if (this._timeProgress >= 1) this._doneFrames++;
+		}
+	}
+	get runTime() {
+		this._tick();
+		return this._runTime;
+	}
+	get timeProgress() {
+		this._tick();
+		return this._timeProgress;
+	}
+	get spaceProgress() {
+		this._tick();
+		return this._spaceProgress;
+	}
+	get done() {
+		this._tick();
+		return this._doneFrames > 1;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/ember-internals.js
+var getViewBounds = getViewBounds$1;
+function componentNodes(view) {
+	let bounds = getViewBounds(view);
+	return {
+		firstNode: bounds.firstNode,
+		lastNode: bounds.lastNode
+	};
+}
+function keyForArray(keyPath) {
+	switch (keyPath) {
+		case "@index": return index;
+		case "@identity":
+		case void 0:
+		case null: return identity$1;
+		default: return (item) => get(item, keyPath);
+	}
+}
+function index(_item, index) {
+	return String(index);
+}
+function identity$1(item) {
+	switch (typeof item) {
+		case "string":
+		case "number": return String(item);
+		default: return guidFor(item);
+	}
+}
+__name(identity$1, "identity");
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/transform.js
+var Transform = class Transform {
+	constructor(a, b, c, d, tx, ty) {
+		this.a = a;
+		this.b = b;
+		this.c = c;
+		this.d = d;
+		this.tx = tx;
+		this.ty = ty;
+	}
+	serialize() {
+		return `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.tx}, ${this.ty})`;
+	}
+	isIdentity() {
+		return this === identity || this.a === 1 && this.b === 0 && this.c === 0 && this.d === 1 && this.tx === 0 && this.ty === 0;
+	}
+	mult(other) {
+		if (this === identity) return other;
+		if (other === identity) return this;
+		return new Transform(this.a * other.a + this.c * other.b, this.b * other.a + this.d * other.b, this.a * other.c + this.c * other.d, this.b * other.c + this.d * other.d, this.a * other.tx + this.c * other.ty + this.tx, this.b * other.tx + this.d * other.ty + this.ty);
+	}
+};
+var identity = new Transform(1, 0, 0, 1, 0, 0);
+var matrixPattern = /matrix\((.*)\)/;
+function parseTransform(matrixString) {
+	const match = matrixPattern.exec(matrixString);
+	if (!match || !match[1]) return identity;
+	const [a, b, c, d, tx, ty] = match[1].split(",").map(parseFloat);
+	return new Transform(a, b, c, d, tx, ty);
+}
+function parseOrigin(originString) {
+	return originString.split(" ").map(parseFloat);
+}
+/**
+Returns a Transform instance representing the cumulative CSS
+transform of this element and all its ancestors.
+
+@function cumulativeTransform
+@hide
+@param {HTMLElement} elt
+@return {Transform}
+*/
+function cumulativeTransform(elt) {
+	let accumulator = null;
+	let current = elt;
+	while (current && current.nodeType === 1) {
+		let transform = ownTransform(current);
+		if (transform !== identity && !transform.isIdentity()) if (accumulator) accumulator = transform.mult(accumulator);
+		else accumulator = transform;
+		current = current.parentElement;
+	}
+	return accumulator || identity;
+}
+/**
+Returns a Transform instance representing the CSS transform of this
+element.
+
+* @function ownTransform
+* @param {HTMLElement} elt
+* @return {Transform} instance representing this element's css transform property.
+*/
+function ownTransform(elt) {
+	let eltStyles = window.getComputedStyle(elt);
+	let t = eltStyles.transform !== "" ? eltStyles.transform : elt.style.transform;
+	if (t === "none") return identity;
+	let matrix = parseTransform(t);
+	if (matrix.a !== 1 || matrix.b !== 0 || matrix.c !== 0 || matrix.d !== 1) {
+		let [originX, originY] = parseOrigin(eltStyles.getPropertyValue("transform-origin") !== "" ? eltStyles.getPropertyValue("transform-origin") : elt.style.getPropertyValue("transform-origin"));
+		if (originX === 0 && originY === 0) return matrix;
+		return new Transform(1, 0, 0, 1, originX, originY).mult(matrix).mult(new Transform(1, 0, 0, 1, -originX, -originY));
+	} else return matrix;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/margin-collapse.js
+function collapsedChildren(element, cs, which, children = []) {
+	if (isBlock(cs) && cs.getPropertyValue(`border-${which}-width`) === "0px" && cs.getPropertyValue(`padding-${which}`) === "0px") {
+		let block;
+		if (which === "top") block = firstChildBlock(element);
+		else block = lastChildBlock(element);
+		if (block) {
+			let [child, childCS] = block;
+			children.push(child);
+			collapsedChildren(child, childCS, which, children);
+		}
+	}
+	return children;
+}
+function firstChildBlock(element) {
+	for (let i = 0; i < element.children.length; i++) {
+		let child = element.children[i];
+		let childCS = getComputedStyle(child);
+		if (childCS.clear !== "none") return;
+		if (isBlock(childCS)) return [child, childCS];
+	}
+}
+function lastChildBlock(element) {
+	for (let i = element.children.length - 1; i >= 0; i--) {
+		let child = element.children[i];
+		let childCS = getComputedStyle(child);
+		if (childCS.clear !== "none") return;
+		if (isBlock(childCS)) return [child, childCS];
+	}
+}
+function isBlock(cs) {
+	return cs.display === "block" && (cs.position === "static" || cs.position === "relative") && cs.getPropertyValue("float") === "none" && cs.overflow === "visible";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/bounds.js
+function nonEnumerable(target, propertyKey) {
+	let descriptor = Object.getOwnPropertyDescriptor(target, propertyKey) || {};
+	if (descriptor.enumerable != false) {
+		descriptor.enumerable = false;
+		Object.defineProperty(target, propertyKey, descriptor);
+	}
+}
+var DOMRectPolyfill = class {
+	static fromRect(rect = {}) {
+		return new DOMRect(rect.x ?? 0, rect.y ?? 0, rect.width ?? 0, rect.height ?? 0);
+	}
+	constructor(x, y, width, height) {
+		if (x != null) this.x = x;
+		if (y != null) this.y = y;
+		if (width != null) this.width = width;
+		if (height != null) this.height = height;
+	}
+	static {
+		decorateFieldV2(this.prototype, "x", [nonEnumerable], function() {
+			return 0;
+		});
+	}
+	#x = (initializeDeferredDecorator(this, "x"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "y", [nonEnumerable], function() {
+			return 0;
+		});
+	}
+	#y = (initializeDeferredDecorator(this, "y"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "width", [nonEnumerable], function() {
+			return 0;
+		});
+	}
+	#width = (initializeDeferredDecorator(this, "width"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "height", [nonEnumerable], function() {
+			return 0;
+		});
+	}
+	#height = (initializeDeferredDecorator(this, "height"), void 0);
+	get top() {
+		return this.y;
+	}
+	get right() {
+		return this.x + this.width;
+	}
+	get bottom() {
+		return this.y + this.height;
+	}
+	get left() {
+		return this.x;
+	}
+	toJSON() {
+		return {
+			x: this.x,
+			y: this.y,
+			width: this.width,
+			height: this.height,
+			top: this.top,
+			right: this.right,
+			bottom: this.bottom,
+			left: this.left
+		};
+	}
+};
+if (typeof window !== "undefined" && !window.DOMRect) window.DOMRect = DOMRectPolyfill;
+/**
+Shifts the coordinates of the given bounds using the provided
+x and y axis offset.
+
+@private
+@function shiftedBounds
+@hide
+@param {Object} bounds The original bounds.
+@param {number} dx X axis offset.
+@param {number} dy Y axis offset.
+@return {Object} The newly calculated bounds.
+*/
+function shiftedBounds(bounds, dx, dy) {
+	return new DOMRect(bounds.x + dx, bounds.y + dy, bounds.width, bounds.height);
+}
+/**
+Resizes the coordinates of the given bounds using the provided
+width and height.
+
+@private
+@function resizedBounds
+@hide
+@param {Object} bounds The original bounds.
+@param {number} width The target width.
+@param {number} height The target height.
+@return {Object} The newly calculated bounds.
+*/
+function resizedBounds(bounds, width, height) {
+	return new DOMRect(bounds.x, bounds.y, width, height);
+}
+/**
+Shifts the coordinates of the given bounds so they are relative to
+the offset.
+
+@private
+@function relativeBounds
+@hide
+@param {Object} bounds The original bounds.
+@param {Object} offset The offset.
+@return {Object} The newly calculated bounds.
+*/
+function relativeBounds(bounds, offset) {
+	return shiftedBounds(bounds, -offset.left, -offset.top);
+}
+/**
+An empty bounds object.
+
+@private
+@hide
+@constant {Object} emptyBounds
+*/
+var emptyBounds = Object.freeze(new DOMRect(0, 0, 0, 0));
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/sprite.js
+var inFlight = getOrCreate$3("sprite", () => /* @__PURE__ */ new WeakMap());
+/**
+A Sprite is our handle to a DOM element that we want to animate.
+
+It manages locking and unlocking the element (which means taking it
+in and out of static document flow so it's readily animatable).
+
+It tracks the sprite's current transform.
+
+It tracks the sprite's initial and/or final bounds, as measured
+from the actual pre- and/or post-animation DOM.
+
+@class Sprite
+*/
+var Sprite = class {
+	static offsetParentStartingAt(element) {
+		let parent = getEffectiveOffsetParent(element);
+		if (!parent) parent = document.getElementsByTagName("body")[0];
+		return new this(parent, true, null, null);
+	}
+	static offsetParentEndingAt(element) {
+		let parent = getEffectiveOffsetParent(element);
+		if (!parent) parent = document.getElementsByTagName("body")[0];
+		return new this(parent, false, null, null);
+	}
+	static positionedStartingAt(element, offsetSprite) {
+		if (!offsetSprite.initialBounds) throw new Error("offset sprite must have initial bounds");
+		return new this(element, true, "position", offsetSprite);
+	}
+	static positionedEndingAt(element, offsetSprite) {
+		if (!offsetSprite.finalBounds) throw new Error("offset sprite must have final bounds");
+		return new this(element, false, "position", offsetSprite);
+	}
+	static sizedStartingAt(element) {
+		return new this(element, true, "size", null);
+	}
+	static sizedEndingAt(element) {
+		let sprite = new this(element, false, "size", null);
+		sprite._initialBounds = emptyBounds;
+		sprite._initialComputedStyle = sprite._finalComputedStyle;
+		sprite._initialPosition = sprite._finalPosition;
+		sprite._originalInitialBounds = sprite._initialBounds;
+		sprite._initialCumulativeTransform = sprite._finalCumulativeTransform;
+		return sprite;
+	}
+	__element;
+	owner = null;
+	_transform = null;
+	_cumulativeTransform = null;
+	_offsetSprite;
+	_lockedToInitialPosition;
+	_finalComputedStyle = null;
+	_finalBounds = null;
+	_originalFinalBounds = null;
+	_finalPosition = null;
+	_finalCumulativeTransform = null;
+	_initialComputedStyle = null;
+	_initialBounds = null;
+	_originalInitialBounds = null;
+	_initialPosition = null;
+	_initialCumulativeTransform = null;
+	_revealed;
+	_imposedStyle = null;
+	_styleCache = null;
+	_collapsingChildren = null;
+	_lockMode;
+	_inInitialPosition = false;
+	constructor(element, inInitialPosition, lockMode, offsetSprite) {
+		this.element = element;
+		this._offsetSprite = offsetSprite;
+		this._lockedToInitialPosition = inInitialPosition;
+		if (inInitialPosition) this.measureInitialBounds();
+		else this.measureFinalBounds();
+		let predecessor = inFlight.get(element);
+		if (predecessor && lockMode) {
+			this._styleCache = predecessor._styleCache;
+			this._revealed = predecessor._revealed;
+			this._imposedStyle = predecessor._imposedStyle;
+			this._collapsingChildren = predecessor._collapsingChildren;
+			this._lockMode = predecessor._lockMode;
+			if (lockMode !== predecessor._lockMode) throw new Error(`probable bug in ember-animated: can't change lock mode from ${predecessor._lockMode} to ${lockMode}`);
+		} else {
+			this._styleCache = null;
+			this._revealed = null;
+			this._lockMode = lockMode;
+			if (lockMode === "position") {
+				this._rememberPosition();
+				this._cacheOriginalStyles();
+			} else if (this._lockMode === "size") {
+				this._rememberSize();
+				this._cacheOriginalStyles();
+			}
+		}
+		if (macroCondition(isTesting())) Object.seal(this);
+	}
+	/**
+	A DOMRect representing the place where this sprite will start the
+	transition.
+	```js
+	sprite.initialBounds;
+	// { top: 0, bottom: 230, left: 0, right: 256, width: 256 }
+	```
+	Not every sprite has initialBounds (a newly inserted
+	sprite will not -- it will only have finalBounds).
+	The position is measured *relative* to our offsetParent, if we
+	have one. Most of the time we want motions to act in relative
+	terms, so that if we're inside another animator things still work
+	out correctly.
+	You can manipulate initialBounds using methods like startAtPixel.
+	Motions should look at initialBounds and finalBounds to decide
+	what to do.
+	@accessor initialBounds
+	@type {DOMRect}
+	*/
+	get initialBounds() {
+		return this._initialBounds;
+	}
+	/**
+	Like initialBounds, but relative to the screen, not the offset
+	parent. Most of the time you *don't* want this one, because your
+	motion will be more robust to ancestor motion if you do
+	everything in relative terms.
+	@accessor absoluteInitialBounds
+	@type {DOMRect}
+	*/
+	get absoluteInitialBounds() {
+		if (this._offsetSprite) return shiftedBounds(this._initialBounds, this._offsetSprite.initialBounds.left, this._offsetSprite.initialBounds.top);
+		else return this._initialBounds;
+	}
+	/**
+	A DOMRect representing the place where this sprite will end the
+	transition. Not every sprite has finalBounds (a sprite that is
+	about to be destroyed will not -- it will only have
+	initialBounds).
+	The position is measured *relative* to our offsetParent, if we
+	have one. Most of the time we want motions to act in relative
+	terms, so that if we're inside another animator things still work
+	out correctly.
+	You can manipulate finalBounds using methods like endAtPixel.
+	@accessor finalBounds
+	@type {DOMRect}
+	*/
+	get finalBounds() {
+		return this._finalBounds;
+	}
+	/**
+	Like initialBounds, but relative to the screen, not the offset
+	parent. Most of the time you *don't* want this one, because your
+	motion will be more robust to ancestor motion if you do
+	everything in relative terms.
+	@accessor absoluteFinalBounds
+	@type {DOMRect}
+	*/
+	get absoluteFinalBounds() {
+		if (this._offsetSprite) return shiftedBounds(this._finalBounds, this._offsetSprite.finalBounds.left, this._offsetSprite.finalBounds.top);
+		else return this._finalBounds;
+	}
+	/**
+	A snapshot of the sprite's computed style at the start of the
+	transition. We don't copy every possible property, see
+	CopiedCSS.
+	This is powered by getComputedStyle, so the property names and
+	values will follow those semantics.
+	Not every sprite will have an initialComputedStyle
+	(`insertedSprites` do not).
+	@accessor initialComputedStyle
+	@type {CSSStyleDeclaration}
+	*/
+	get initialComputedStyle() {
+		return this._initialComputedStyle;
+	}
+	/**
+	A snapshot of the sprite's computed style at the end of the
+	transition. We don't copy every possible property, see
+	CopiedCSS.
+	This is powered by getComputedStyle, so the property names and
+	values will follow those semantics.
+	Not every sprite will have a finalComputedStyle
+	(`removedSprites` do not).
+	@accessor finalComputedStyle
+	@type {CSSStyleDeclaration}
+	*/
+	get finalComputedStyle() {
+		return this._finalComputedStyle;
+	}
+	/**
+	Returns the attribute value from the initial position object with the
+	given `name`.
+	_This is mostly intended for use with SVG, where you can say things
+	like `getInitialDimension('x')`._
+	@method getInitialDimension
+	@param {string} name The desired attribute name.
+	@return {number|string}
+	*/
+	getInitialDimension(name) {
+		return this._initialPosition[name];
+	}
+	/**
+	Returns the attribute value from the final position object with the
+	given `name`.
+	_This is mostly intended for use with SVG, where you can say things
+	like `getFinalDimension('x')`._
+	@method getFinalDimension
+	@param {string} name The desired attribute name.
+	@return {number|string}
+	*/
+	getFinalDimension(name) {
+		return this._finalPosition[name];
+	}
+	/**
+	Analogous to initialBounds, this is a snapshot of the cumulative
+	effect of all transforms on this sprite at the start of
+	animation.
+	@method initialCumulativeTransform
+	@return {Transform}
+	*/
+	get initialCumulativeTransform() {
+		return this._initialCumulativeTransform;
+	}
+	/**
+	Analogous to finalBounds, this is a snapshot of the cumulative
+	effect of all transforms on this sprite at the end of animation.
+	@method finalCumulativeTransform
+	@return {Transform}
+	*/
+	get finalCumulativeTransform() {
+		return this._finalCumulativeTransform;
+	}
+	/**
+	Some things methods (like startAtSprite, startAtPixel, etc) can
+	set or alter the initialBounds. This gives you access to the
+	original value (which may be undefined if this sprite didn't have
+	any initial bounds, which is the case for newly inserted
+	sprites).
+	@method originalInitialBounds
+	@return {DOMRect}
+	*/
+	get originalInitialBounds() {
+		return this._originalInitialBounds;
+	}
+	/**
+	Some things (like endAtSprite) can alter the finalBounds. This
+	gives you access to the original value (which may be undefined if
+	the sprite didn't have any final bounds, which is the case for
+	removedSprites).
+	@method originalFinalBounds
+	@return {DOMRect}
+	*/
+	get originalFinalBounds() {
+		return this._originalFinalBounds;
+	}
+	getCurrentBounds() {
+		if (this._offsetSprite) return relativeBounds(this.element.getBoundingClientRect(), this._offsetSprite.getCurrentBounds());
+		else return this.element.getBoundingClientRect();
+	}
+	/**
+	Returns the current position of the element as an object.
+	_This deliberately only tracks inline styles, because it's only
+	important when the user is manipulating inline styles._
+	@private
+	@hide
+	@method _getCurrentPosition
+	@return {Object}
+	*/
+	_getCurrentPosition() {
+		let { element } = this;
+		if (isSVG(element)) return {
+			x: getSVGLength(element, "x"),
+			y: getSVGLength(element, "y"),
+			cx: getSVGLength(element, "cx"),
+			cy: getSVGLength(element, "cy"),
+			r: getSVGLength(element, "r"),
+			width: getSVGLength(element, "width"),
+			height: getSVGLength(element, "height"),
+			transform: element.getAttribute("transform")
+		};
+		else {
+			let style = this.element.style;
+			return {
+				top: style.top,
+				left: style.left,
+				bottom: style.bottom,
+				right: style.right,
+				transform: style.transform,
+				classList: Array.from(this.element.classList)
+			};
+		}
+	}
+	/**
+	Sets the position of the element.
+	@private
+	@method _reapplyPosition
+	@hide
+	@param {Object} pos The position to apply.
+	@return {void}
+	*/
+	_reapplyPosition(pos) {
+		if (!pos) return;
+		if (isSVG(this.element)) {
+			let { element } = this;
+			setSVGLength(element, "x", pos);
+			setSVGLength(element, "y", pos);
+			setSVGLength(element, "cx", pos);
+			setSVGLength(element, "cy", pos);
+			setSVGLength(element, "r", pos);
+			setSVGLength(element, "width", pos);
+			setSVGLength(element, "height", pos);
+			setAttribute(element, "transform", pos);
+		} else {
+			let style = this.element.style;
+			let p = pos;
+			style.top = p.top ?? "";
+			style.left = p.left ?? "";
+			style.right = p.right ?? "";
+			style.bottom = p.bottom ?? "";
+			style.transform = p.transform ?? "";
+			for (let cls of p.classList) this.element.classList.add(cls);
+			for (let cls of Array.from(this.element.classList)) if (!p.classList.includes(cls)) this.element.classList.remove(cls);
+		}
+	}
+	measureInitialBounds() {
+		if (this._initialBounds) throw new Error("Sprite already has initial bounds");
+		this._inInitialPosition = true;
+		if (this._offsetSprite) this._initialBounds = relativeBounds(this.element.getBoundingClientRect(), this._offsetSprite.initialBounds);
+		else this._initialBounds = this.element.getBoundingClientRect();
+		this._initialComputedStyle = copyComputedStyle(this.element);
+		this._initialPosition = this._getCurrentPosition();
+		this._originalInitialBounds = this._initialBounds;
+		this._initialCumulativeTransform = cumulativeTransform(this.element);
+	}
+	assertHasInitialBounds() {
+		if (!this._initialBounds) throw new Error(`sprite does not have initialBounds`);
+	}
+	assertHasOwner() {
+		if (!this.owner) throw new Error(`sprite does not have owner`);
+	}
+	measureFinalBounds() {
+		if (this._finalBounds) throw new Error("Sprite already has final bounds");
+		this._inInitialPosition = false;
+		if (this._offsetSprite) this._finalBounds = relativeBounds(this.element.getBoundingClientRect(), this._offsetSprite.finalBounds);
+		else this._finalBounds = this.element.getBoundingClientRect();
+		this._finalComputedStyle = copyComputedStyle(this.element);
+		this._finalPosition = this._getCurrentPosition();
+		this._originalFinalBounds = this._finalBounds;
+		this._finalCumulativeTransform = cumulativeTransform(this.element);
+	}
+	assertHasFinalBounds() {
+		if (!this._finalBounds) throw new Error(`sprite does not have finalBounds`);
+	}
+	/**
+	Returns the difference between two sprites, represented as x and y
+	coordinates.
+	_`this.difference('initialBounds', other, 'finalBounds')` is
+	interpreted as "the difference between this sprite's initial bounds
+	and the other sprite's final bounds"._
+	_It works this way because each sprite has its own local coordinate
+	system._
+	@method difference
+	@param {string} which The current sprite's comparison attribute.
+	@param {Sprite} otherSprite The other sprite.
+	@param {string} otherWhich The other sprite's comparison attribute.
+	@return {Object}
+	*/
+	difference(which, otherSprite, otherWhich) {
+		let x = this[which].left;
+		let y = this[which].top;
+		if (this._offsetSprite) {
+			x += this._offsetSprite[which].left;
+			y += this._offsetSprite[which].top;
+		}
+		if (otherSprite._offsetSprite) {
+			x -= otherSprite._offsetSprite[otherWhich].left;
+			y -= otherSprite._offsetSprite[otherWhich].top;
+		}
+		return {
+			dx: x - otherSprite[otherWhich].left,
+			dy: y - otherSprite[otherWhich].top
+		};
+	}
+	set element(value) {
+		this.__element = value;
+	}
+	get element() {
+		return this.__element;
+	}
+	/**
+	Returns the sprite's current transform, with appropriate caching
+	so that you don't trigger reflows.
+	@accessor transform
+	@type {Transform}
+	*/
+	get transform() {
+		if (!this._transform) this._transform = ownTransform(this.element);
+		return this._transform;
+	}
+	/**
+	This is different from `this.transform` because it's the product
+	of our own transform and all ancestor transforms. It's what you
+	need if you want to understand how many real screen pixels there
+	are to every local pixel in the sprite.
+	@accessor cumulativeTransform
+	@type {Object}
+	*/
+	get cumulativeTransform() {
+		if (!this._cumulativeTransform) this._cumulativeTransform = cumulativeTransform(this.element);
+		return this._cumulativeTransform;
+	}
+	/**
+	Returns wether the sprite is revealed or not.
+	@accessor revealed
+	@type {boolean}
+	*/
+	get revealed() {
+		if (this._revealed == null) this._revealed = !this.__element.classList.contains("ember-animated-hidden");
+		return this._revealed;
+	}
+	_rememberSize() {
+		let transform = this.initialCumulativeTransform || this.finalCumulativeTransform;
+		let bounds = this.initialBounds || this.finalBounds;
+		this._imposedStyle = {};
+		if (isSVG(this.element)) return;
+		if (this.element.style.width === "") {
+			this._imposedStyle["width"] = `${bounds.width / transform.a}px`;
+			this._imposedStyle["box-sizing"] = "border-box";
+		}
+		if (this.element.style.height === "") {
+			this._imposedStyle["height"] = `${bounds.height / transform.d}px`;
+			this._imposedStyle["box-sizing"] = "border-box";
+		}
+	}
+	_lazyOffsets(computedStyle) {
+		let offsets;
+		return () => {
+			if (!offsets) offsets = findOffsets(this.element, computedStyle, this.transform, this._offsetSprite);
+			return offsets;
+		};
+	}
+	_rememberPosition() {
+		let computedStyle = getComputedStyle(this.element);
+		let style = this.element.style;
+		let offsets = this._lazyOffsets(computedStyle);
+		let tx = 0;
+		let ty = 0;
+		this._rememberSize();
+		if (isSVG(this.element)) return;
+		if (computedStyle.position !== "absolute" && computedStyle.position !== "fixed") this._imposedStyle["position"] = "absolute";
+		if (style.top === "" && style.bottom === "") {
+			this._imposedStyle["top"] = `${offsets().top}px`;
+			this._imposedStyle["margin-top"] = "0px";
+		} else if (this._imposedStyle["position"]) ty = offsets().top - parseFloat(computedStyle.top || "0");
+		if (style.left === "" && style.bottom === "") {
+			this._imposedStyle["left"] = `${offsets().left}px`;
+			this._imposedStyle["margin-left"] = `0px`;
+		} else if (this._imposedStyle["position"]) tx = offsets().left - parseFloat(computedStyle.left || "0");
+		if (tx || ty) {
+			this._transform = this.transform.mult(new Transform(1, 0, 0, 1, tx, ty));
+			this._imposedStyle["transform"] = this.transform.serialize();
+		}
+		this._collapsingChildren = collapsedChildren(this.element, computedStyle, "top");
+	}
+	_cacheOriginalStyles() {
+		let cache = {};
+		let style = this.element.style;
+		Object.keys(this._imposedStyle).forEach((property) => {
+			cache[property] = style[property];
+		});
+		this._styleCache = cache;
+	}
+	lock() {
+		this._reapplyPosition(this._initialPosition);
+		this.applyStyles(this._imposedStyle);
+		this._handleMarginCollapse();
+		inFlight.set(this.element, this);
+		this._inInitialPosition = this._lockedToInitialPosition;
+	}
+	unlock() {
+		warn(`Probable bug in ember-animated: an interrupted sprite tried to unlock itself.
+       This is usually caused by a direct child of an animated component also being an
+       animated component. To fix it, wrap the child in another DOM element.
+       https://github.com/ember-animation/ember-animated/issues/178`, this.stillInFlight(), { id: "ember-animated-sprite-unlock" });
+		inFlight.delete(this.element);
+		let cache = this._styleCache;
+		Object.keys(cache).forEach((property) => {
+			setStyle(this.element, property, cache[property]);
+		});
+		this._reapplyPosition(this._finalPosition);
+		this._clearMarginCollapse();
+	}
+	/**
+	This is your general purpose hook for changing CSS properties of
+	the sprite's element. Use this when there's not a more specific
+	method like `translate()`, `scale()`, `hide()`, or `reveal()`.
+	```js
+	sprite.applyStyles({
+	'opacity': '0',
+	'z-index': '1'
+	});
+	```
+	Nothing you do to the sprite will persist after the transition is
+	finished – we clean things up when it ends.
+	@method applyStyles
+	@param {Object} styles The styles to apply to the sprite.
+	@return {void}
+	*/
+	applyStyles(styles) {
+		if (!this._lockMode) throw new Error("can't apply styles to non-lockable sprite");
+		if (styles !== this._imposedStyle) Object.keys(styles).forEach((property) => {
+			if (this._imposedStyle[property] == null) this._styleCache[property] = this.element.style.getPropertyValue(property);
+			this._imposedStyle[property] = styles[property];
+		});
+		Object.keys(styles).forEach((property) => {
+			let val = styles[property];
+			if (typeof val !== "string") throw new Error(`Sprite#applyStyles only accepts string values. Convert any numeric values to strings (with appropriate units) before calling. You passed ${property}=${val}`);
+			else setStyle(this.element, property, styles[property]);
+		});
+	}
+	stillInFlight() {
+		return inFlight.get(this.element) === this;
+	}
+	/**
+	Hides the sprite using CSS visibility property.
+	@method hide
+	@return {void}
+	*/
+	hide() {
+		this._revealed = false;
+		this.__element.classList.add("ember-animated-hidden");
+	}
+	/**
+	Reveals the sprite using CSS visibility property.
+	_Newly inserted sprites start hidden, and are revealed when you
+	start animating them. You can manually reveal them with this if
+	you want them to appear right away and you're not animating them._
+	@method reveal
+	@return {void}
+	*/
+	reveal() {
+		if (!this.revealed) {
+			this._revealed = true;
+			this.__element.classList.remove("ember-animated-hidden");
+		}
+	}
+	/**
+	Manages the application of the `ember-animated-none` CSS class on
+	the element.
+	When the flag is truthy, the class is removed and the element is
+	therefore visible.
+	When the flag is falsy, the class is applied and the element is
+	therefore hidden.
+	@method display
+	@param {boolean} flag
+	@return {void}
+	*/
+	display(flag) {
+		if (flag) this.__element.classList.remove("ember-animated-none");
+		else this.__element.classList.add("ember-animated-none");
+	}
+	/**
+	Translates the sprite by the given number of screen pixels.
+	_Disregards any pre-existing transforms._
+	@method translate
+	@param {number} dx The number of screen pixels on the x axis.
+	@param {number} dy The number of screen pixels on the y axis.
+	@return {void}
+	*/
+	translate(dx, dy) {
+		let t = this.transform;
+		t = t.mult(new Transform(1, 0, 0, 1, dx / t.a, dy / t.d));
+		this._transform = t;
+		this.applyStyles({
+			transform: t.serialize(),
+			"transform-origin": "0 0"
+		});
+	}
+	/**
+	Adjusts the sprite's scale by the given scaling factors.
+	@method scale
+	@param {number} scaleX The scaling factor to apply to the x axis.
+	@param {number} scaleY The scaling factor to apply to the y axis.
+	@return {void}
+	*/
+	scale(scaleX, scaleY) {
+		let t = this.transform.mult(new Transform(scaleX, 0, 0, scaleY, 0, 0));
+		this._transform = t;
+		this.applyStyles({
+			transform: t.serialize(),
+			"transform-origin": "0 0"
+		});
+	}
+	/**
+	Adjusts the sprite so it will still be in the same visual position
+	despite being moved into a new offset parent.
+	@method rehome
+	@param {Sprite} newOffsetSprite
+	@return {void}
+	*/
+	rehome(newOffsetSprite) {
+		let screenBounds = this.absoluteInitialBounds;
+		let newRelativeBounds = shiftedBounds(screenBounds, -newOffsetSprite.initialBounds.left, -newOffsetSprite.initialBounds.top);
+		let initialAmbientTransform = this._offsetSprite.cumulativeTransform;
+		let finalAmbientTransform = newOffsetSprite.cumulativeTransform;
+		let t = this.transform;
+		t = t.mult(new Transform(initialAmbientTransform.a / finalAmbientTransform.a, 0, 0, initialAmbientTransform.d / finalAmbientTransform.d, (newRelativeBounds.left - t.tx) / t.a, (newRelativeBounds.top - t.ty) / t.d));
+		this._transform = t;
+		this._imposedStyle["transform"] = t.serialize();
+		this._imposedStyle["transform-origin"] = "0 0";
+		this._imposedStyle["top"] = `0px`;
+		this._imposedStyle["left"] = `0px`;
+		this._offsetSprite = newOffsetSprite;
+		this._initialBounds = newRelativeBounds;
+		this._inInitialPosition = true;
+	}
+	_handleMarginCollapse() {
+		if (this._collapsingChildren) {
+			const children = this._collapsingChildren;
+			for (const child of children) child.classList.add("ember-animated-top-collapse");
+		}
+	}
+	_clearMarginCollapse() {
+		if (this._collapsingChildren) {
+			const children = this._collapsingChildren;
+			for (const child of children) child.classList.remove("ember-animated-top-collapse");
+		}
+	}
+	/**
+	Sets the sprite's `initialBounds` relative to the provided `otherSprite`.
+	@method startAtSprite
+	@param {Sprite} otherSprite
+	@return {void}
+	*/
+	startAtSprite(otherSprite) {
+		continueMotions(otherSprite.element, this.element);
+		let diff = this.difference("finalBounds", otherSprite, "initialBounds");
+		this.startTranslatedBy(-diff.dx, -diff.dy);
+		this._initialBounds = resizedBounds(this._initialBounds, otherSprite.initialBounds.width, otherSprite.initialBounds.height);
+		this._initialComputedStyle = otherSprite.initialComputedStyle;
+		this._initialCumulativeTransform = otherSprite.initialCumulativeTransform;
+	}
+	/**
+	Sets the sprite's `initialBounds` using the provided
+	x and y coordinates.
+	```js
+	sprite.startAtPixel({ x: 0, y: 0 });
+	```
+	@method startAtPixel
+	@param {Object} point The x and y coordinates.
+	@return {void}
+	*/
+	startAtPixel({ x, y }) {
+		let dx = 0;
+		let dy = 0;
+		if (x != null) {
+			dx = x - this._finalBounds.left;
+			if (this._offsetSprite) dx -= this._offsetSprite.finalBounds.left;
+		}
+		if (y != null) {
+			dy = y - this._finalBounds.top;
+			if (this._offsetSprite) dy -= this._offsetSprite.finalBounds.top;
+		}
+		this.startTranslatedBy(dx, dy);
+	}
+	/**
+	Sets the sprite's `initialBounds` relative to its `finalBounds`.
+	@method startTranslatedBy
+	@param {number} dx
+	@param {number} dy
+	@return {void}
+	*/
+	startTranslatedBy(dx, dy) {
+		let priorInitialBounds = this._initialBounds;
+		let offsetX = 0;
+		let offsetY = 0;
+		if (this._offsetSprite) {
+			offsetX = this._offsetSprite.finalBounds.left - this._offsetSprite.initialBounds.left;
+			offsetY = this._offsetSprite.finalBounds.top - this._offsetSprite.initialBounds.top;
+		}
+		this._initialBounds = shiftedBounds(this._finalBounds, dx - offsetX, dy - offsetY);
+		if (this._inInitialPosition) this.translate(this._initialBounds.left - priorInitialBounds.left, this._initialBounds.top - priorInitialBounds.top);
+		else {
+			this.translate(this._initialBounds.left - this._finalBounds.left, this._initialBounds.top - this._finalBounds.top);
+			this._inInitialPosition = true;
+		}
+	}
+	/**
+	Moves the sprite to its final position (`finalBounds`).
+	@method moveToFinalPosition
+	@return {void}
+	*/
+	moveToFinalPosition() {
+		if (this._inInitialPosition) {
+			let initial = this._initialBounds;
+			let final = this._finalBounds;
+			let dx = final.left - initial.left;
+			let dy = final.top - initial.top;
+			this.translate(dx, dy);
+			this._inInitialPosition = false;
+		}
+	}
+	/**
+	Sets the sprite's `finalBounds` using the provided `otherSprite`.
+	@method endAtSprite
+	@param {Sprite} otherSprite
+	@return {void}
+	*/
+	endAtSprite(otherSprite) {
+		let diff = otherSprite.difference("finalBounds", this, "initialBounds");
+		this.endTranslatedBy(diff.dx, diff.dy);
+		this._finalBounds = resizedBounds(this._finalBounds, otherSprite.finalBounds.width, otherSprite.finalBounds.height);
+		this._finalComputedStyle = otherSprite.finalComputedStyle;
+		this._finalCumulativeTransform = otherSprite.finalCumulativeTransform;
+	}
+	/**
+	Sets the sprite's `finalBounds` using the provided point `{ x, y }`.
+	```js
+	sprite.endAtPixel({ x: window.innerWidth });
+	```
+	@method endAtPixel
+	@param {Object} point The x and y coordinates.
+	@return {void}
+	*/
+	endAtPixel({ x, y }) {
+		let dx = 0;
+		let dy = 0;
+		if (x != null) {
+			dx = x - this._initialBounds.left;
+			if (this._offsetSprite) dx -= this._offsetSprite.initialBounds.left;
+		}
+		if (y != null) {
+			dy = y - this._initialBounds.top;
+			if (this._offsetSprite) dy -= this._offsetSprite.initialBounds.top;
+		}
+		this.endTranslatedBy(dx, dy);
+	}
+	/**
+	Sets the sprite's `finalBounds` using its `initialBounds` and
+	the provided x and y axis offset.
+	@method endTranslatedBy
+	@param {number} dx The x axis offset.
+	@param {number} dy The y axis offset.
+	@return {void}
+	*/
+	endTranslatedBy(dx, dy) {
+		this._finalBounds = shiftedBounds(this._initialBounds, dx, dy);
+	}
+	/**
+	Sets this sprite's `finalBounds` so that its position relative
+	to the `otherSprite` remains constant through the transition.
+	@method endRelativeTo
+	@param {Sprite} otherSprite Note: must have initial and final bounds
+	@return {void}
+	*/
+	endRelativeTo(otherSprite) {
+		this.endTranslatedBy(otherSprite.finalBounds.left - otherSprite.initialBounds.left, otherSprite.finalBounds.top - otherSprite.initialBounds.top);
+	}
+};
+function findOffsets(element, computedStyle, transform, offsetSprite) {
+	let ownBounds = element.getBoundingClientRect();
+	let left = ownBounds.left;
+	let top = ownBounds.top;
+	let effectiveOffsetParent;
+	if (computedStyle.position !== "fixed") effectiveOffsetParent = offsetSprite.element;
+	if (effectiveOffsetParent) {
+		if (effectiveOffsetParent.tagName === "BODY") {
+			left += window.scrollX;
+			top += window.scrollY;
+		} else {
+			left += effectiveOffsetParent.scrollLeft;
+			top += effectiveOffsetParent.scrollTop;
+		}
+		let eopComputedStyle = getComputedStyle(effectiveOffsetParent);
+		if (eopComputedStyle.position !== "static" || eopComputedStyle.transform !== "none") {
+			let eopBounds = effectiveOffsetParent.getBoundingClientRect();
+			left -= eopBounds.left + parseFloat(eopComputedStyle.borderLeftWidth || "0");
+			top -= eopBounds.top + parseFloat(eopComputedStyle.borderTopWidth || "0");
+			let eopTransform = cumulativeTransform(effectiveOffsetParent);
+			left /= eopTransform.a;
+			top /= eopTransform.d;
+		}
+	}
+	left -= transform.tx;
+	top -= transform.ty;
+	return {
+		top,
+		left
+	};
+}
+var SVGNamespace = "http://www.w3.org/2000/svg";
+function isSVG(element) {
+	return element.namespaceURI === SVGNamespace && (element.parentElement || false) && element.parentElement.namespaceURI === SVGNamespace;
+}
+function getEffectiveOffsetParent(element) {
+	if (isSVG(element)) {
+		let cursor = element.parentElement;
+		while (cursor && cursor.namespaceURI === SVGNamespace) {
+			if (cursor.tagName === "svg") return cursor;
+			cursor = cursor.parentElement;
+		}
+	}
+	let offsetParent = element.offsetParent;
+	let cursor = element.parentElement;
+	while (cursor && offsetParent && cursor !== offsetParent) {
+		let styles = window.getComputedStyle(cursor);
+		if ((styles.transform !== "" ? styles.transform : cursor.style.transform) !== "none") return cursor;
+		cursor = cursor.parentElement;
+	}
+	return offsetParent;
+}
+function getSVGLength(element, property) {
+	if (element[property]) return element[property].baseVal.value;
+	return null;
+}
+function setSVGLength(element, property, values) {
+	if (typeof values[property] === "number") element[property].baseVal.value = values[property];
+}
+function setAttribute(element, attrName, values) {
+	let value = values[attrName];
+	if (value) element.setAttribute(attrName, value);
+	else element.removeAttribute(attrName);
+}
+function setStyle(element, property, value) {
+	if (/[A-Z]/.test(property)) throw new Error(`applyStyles expects all CSS property names to be formatted as in CSS. Not camelcased. You passed ${property}.`);
+	element.style.setProperty(property, value);
+}
+function copyComputedStyle(element) {
+	let computed = getComputedStyle(element);
+	let output = new CopiedCSS();
+	for (let property of COPIED_CSS_PROPERTIES) output[property] = computed.getPropertyValue(property);
+	return output;
+}
+var CopiedCSS = class {
+	"opacity";
+	"font-size";
+	"font-family";
+	"font-weight";
+	"color";
+	"background-color";
+	"border-color";
+	"letter-spacing";
+	"line-height";
+	"text-align";
+	"text-transform";
+	"padding";
+	"padding-top";
+	"padding-bottom";
+	"padding-left";
+	"padding-right";
+	"border-radius";
+	"border-top-left-radius";
+	"border-top-right-radius";
+	"border-bottom-left-radius";
+	"border-bottom-right-radius";
+	"box-shadow";
+};
+var COPIED_CSS_PROPERTIES = [
+	"opacity",
+	"font-size",
+	"font-family",
+	"font-weight",
+	"color",
+	"background-color",
+	"border-color",
+	"letter-spacing",
+	"line-height",
+	"text-align",
+	"text-transform",
+	"padding",
+	"padding-top",
+	"padding-bottom",
+	"padding-left",
+	"padding-right",
+	"border-radius",
+	"border-top-left-radius",
+	"border-top-right-radius",
+	"border-bottom-left-radius",
+	"border-bottom-right-radius",
+	"box-shadow"
+];
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-beacon.js
+var service$3 = service$4 ?? inject;
+/**
+A component that marks a region of the page that
+can serve as a source or destination for sprites to animate to and from.
+
+```hbs
+{{#animated-beacon name="one"}}
+<button {{action "launch"}}>Launch</button>
+{{/animated-beacon}}
+
+{{#animated-if showThing use=transition}}
+<div class="message" {{action "dismiss"}}>
+Hello
+</div>
+{{/animated-if}}
+```
+
+```js
+import Component from '@ember/component';
+import move from 'ember-animated/motions/move';
+import scale from 'ember-animated/motions/scale';
+
+export default Component.extend({
+showThing: false,
+
+transition: function *({ insertedSprites, keptSprites, removedSprites, beacons }) {
+for (let sprite of insertedSprites) {
+sprite.startAtSprite(beacons.one);
+move(sprite);
+scale(sprite);
+}
+
+for (let sprite of keptSprites) {
+move(sprite);
+}
+
+for (let sprite of removedSprites) {
+sprite.endAtSprite(beacons.one);
+move(sprite);
+scale(sprite);
+}
+});
+},
+
+actions: {
+launch() {
+this.set('showThing', true);
+},
+dismiss() {
+this.set('showThing', false);
+}
+}
+});
+```
+@class animated-beacon
+@public
+*/
+var AnimatedBeacon = class extends Component {
+	name;
+	tagName = "";
+	_inserted = false;
+	static {
+		decorateFieldV2(this.prototype, "motionService", [service$3("-ea-motion")]);
+	}
+	#motionService = (initializeDeferredDecorator(this, "motionService"), void 0);
+	didInsertElement() {
+		super.didInsertElement();
+		this._inserted = true;
+		this.animationStarting = this.animationStarting.bind(this);
+		this.motionService.observeAnimations(this.animationStarting);
+	}
+	willDestroyElement() {
+		super.willDestroyElement();
+		this.motionService.unobserveAnimations(this.animationStarting);
+	}
+	animationStarting() {
+		this.participate.perform();
+	}
+	_firstChildElement() {
+		if (this._inserted) {
+			let { firstNode, lastNode } = componentNodes(this);
+			let node = firstNode;
+			while (node) {
+				if (node.nodeType === Node.ELEMENT_NODE) return node;
+				if (node === lastNode) break;
+				node = node.nextSibling;
+			}
+		}
+	}
+	static {
+		decorateFieldV2(this.prototype, "participate", [task(function* () {
+			if (!this.name) throw new Error("Beacons must have a name.");
+			if (this.motionService.hasBeacon(this.name)) return;
+			let element = this._firstChildElement();
+			if (!element) return;
+			let offsetParent = Sprite.offsetParentStartingAt(element);
+			let sprite = Sprite.positionedStartingAt(element, offsetParent);
+			yield afterRender();
+			yield microwait();
+			yield* this.motionService.staticMeasurement(() => {
+				offsetParent.measureFinalBounds();
+				sprite.measureFinalBounds();
+			});
+			yield this.motionService.addBeacon.perform(this.name, sprite);
+		})]);
+	}
+	#participate = (initializeDeferredDecorator(this, "participate"), void 0);
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "+EPWNCZI",
+			"block": "[[[1,\"\\n\"],[1,\"    \"],[18,1,null],[1,\"\\n  \"]],[\"&default\"],[\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-beacon.js",
+			"isStrictMode": true
+		}), this);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/resize.js
+var resize_exports = /* @__PURE__ */ __exportAll({
+	Resize: () => Resize,
+	default: () => resize
+});
+/**
+Smoothly resizes _sprite_ from its the initial size to its final size.
+
+_sprite_ must have both `initialBounds` and `finalBounds` set.
+
+Consider using `scale` instead because scale uses CSS transforms and will not trigger reflow.
+
+```js
+for (let sprite of insertedSprites) {
+sprite.startAtSprite(beacons['source']);
+resize(sprite)
+}
+```
+
+@function resize
+@export default
+@param {Sprite} sprite
+@return {Motion}
+*/
+function resize(sprite, opts = {}) {
+	return new Resize(sprite, opts).run();
+}
+var Resize = class extends Motion {
+	prior = null;
+	widthTween = null;
+	heightTween = null;
+	interrupted(motions) {
+		let prior = motions.find((m) => m instanceof this.constructor);
+		if (prior) this.prior = prior;
+	}
+	*animate() {
+		let sprite = this.sprite;
+		let duration = this.duration;
+		let widthTween;
+		let heightTween;
+		sprite.assertHasInitialBounds();
+		sprite.assertHasFinalBounds();
+		if (!this.prior) {
+			widthTween = this.widthTween = new Tween(sprite.initialBounds.width / sprite.initialCumulativeTransform.a, sprite.finalBounds.width / sprite.finalCumulativeTransform.a, duration, this.opts.easing);
+			heightTween = this.heightTween = new Tween(sprite.initialBounds.height / sprite.initialCumulativeTransform.d, sprite.finalBounds.height / sprite.finalCumulativeTransform.d, duration, this.opts.easing);
+		} else {
+			widthTween = this.widthTween = new Tween(0, sprite.finalBounds.width / sprite.finalCumulativeTransform.a - this.prior.sprite.finalBounds.width, duration, this.opts.easing).plus(this.prior.widthTween);
+			heightTween = this.heightTween = new Tween(0, sprite.finalBounds.height / sprite.finalCumulativeTransform.d - this.prior.sprite.finalBounds.height, duration, this.opts.easing).plus(this.prior.heightTween);
+		}
+		while (!widthTween.done || !heightTween.done) {
+			sprite.applyStyles({
+				width: `${widthTween.currentValue}px`,
+				height: `${heightTween.currentValue}px`
+			});
+			yield rAF();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-container.js
+var service$2 = service$4 ?? inject;
+/**
+Provides a boundary between animator components and the surrounding document
+which smoothly resizes as animators change. Use animated-container whenever you
+need to "hold a place for" some animated content while that content is animating.
+```hbs
+<button {{on "click" this.toggleThing}}>Toggle</button>
+<AnimatedContainer>
+{{#animated-if this.showThing use=this.transition }}
+<div class="message" {{on "click" this.toggleThing}}>
+Hello!
+</div>
+{{/animated-if}}
+</AnimatedContainer>
+<p>
+This is outside of the container.
+</p>
+```
+```js
+import Component from '@ember/component';
+import { action } from '@ember/object';
+import { tracked } from '@glimmer/tracking';
+import move from 'ember-animated/motions/move';
+import { easeOut, easeIn } from 'ember-animated/easings/cosine';
+
+export default class AnimatedContainerComponentExample extends Component {
+@tracked showThing = false;
+
+@action
+toggleThing() {
+this.showThing = !this.showThing;
+}
+
+*transition({ insertedSprites, keptSprites, removedSprites }) {
+for (let sprite of insertedSprites) {
+sprite.startAtPixel({ x: window.innerWidth });
+yield move(sprite, { easing: easeOut });
+}
+
+for (let sprite of keptSprites) {
+yield move(sprite);
+}
+
+for (let sprite of removedSprites) {
+sprite.endAtPixel({ x: window.innerWidth });
+yield move(sprite, { easing: easeIn });
+}
+}
+}
+```
+@class animated-container
+@public
+*/
+var AnimatedContainerComponent = class extends Component {
+	tagName = "";
+	static {
+		decorateFieldV2(this.prototype, "motionService", [service$2("-ea-motion")]);
+	}
+	#motionService = (initializeDeferredDecorator(this, "motionService"), void 0);
+	/**
+	* Use a custom tag for the container. Defaults to div.
+	@argument tag
+	@type String
+	*/
+	tag = "div";
+	/**
+	* Whether to animate the initial render. You will probably also need to set
+	* initialInsertion=true on a child component of animated-container.
+	* Defaults to false.
+	@argument onInitialRender
+	@type Boolean
+	*/
+	onInitialRender = false;
+	/**
+	* Use a custom motion to resize the container. Defaults to `Resize`.
+	@argument motion
+	@type String
+	*/
+	motion = Resize;
+	_inserted = false;
+	_startingUp = false;
+	sprite = null;
+	constructor(properties) {
+		super(properties);
+		this.motionService.register(this).observeDescendantAnimations(this, this.maybeAnimate);
+	}
+	didInsertElement() {
+		super.didInsertElement();
+		this._inserted = true;
+	}
+	_ownElement() {
+		if (!this._inserted) return;
+		let { firstNode, lastNode } = componentNodes(this);
+		let node = firstNode;
+		while (node) {
+			if (node.nodeType === Node.ELEMENT_NODE) return node;
+			if (node === lastNode) break;
+			node = node.nextSibling;
+		}
+	}
+	willDestroyElement() {
+		super.willDestroyElement();
+		this.motionService.unregister(this).unobserveDescendantAnimations(this, this.maybeAnimate);
+	}
+	static {
+		decorateFieldV2(this.prototype, "isAnimating", [alias("animated.isRunning")]);
+	}
+	#isAnimating = (initializeDeferredDecorator(this, "isAnimating"), void 0);
+	maybeAnimate({ duration, task }) {
+		if (!this._startingUp) this.animate.perform(duration, task);
+	}
+	static {
+		decorateMethodV2(this.prototype, "maybeAnimate", [action]);
+	}
+	beginStaticMeasurement() {
+		if (this.sprite) this.sprite.unlock();
+	}
+	endStaticMeasurement() {
+		if (this.sprite) this.sprite.lock();
+	}
+	static {
+		decorateFieldV2(this.prototype, "animate", [task(function* (duration, animationTask) {
+			this._startingUp = true;
+			let service = this.motionService;
+			let sprite;
+			let useMotion;
+			let element = this._ownElement();
+			if (element) {
+				sprite = Sprite.sizedStartingAt(element);
+				this.sprite = sprite;
+				sprite.lock();
+				useMotion = true;
+			} else useMotion = this.onInitialRender;
+			try {
+				yield afterRender();
+				yield microwait();
+			} finally {
+				this._startingUp = false;
+			}
+			yield* service.staticMeasurement(() => {
+				if (!sprite) {
+					sprite = Sprite.sizedEndingAt(this._ownElement());
+					this.sprite = sprite;
+				} else sprite.measureFinalBounds();
+			});
+			if (useMotion) yield* new this.motion(this.sprite, { duration })._run();
+			yield animationTask;
+			this.sprite.unlock();
+			this.sprite = null;
+		}).restartable()]);
+	}
+	#animate = (initializeDeferredDecorator(this, "animate"), void 0);
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "1Srm6ICt",
+			"block": "[[[1,\"\\n\"],[44,[[28,[32,0],[[30,0,[\"tag\"]]],null]],[[[1,\"      \"],[8,[30,1],[[16,0,[29,[\"animated-container \",[30,2]]]],[17,3]],null,[[\"default\"],[[[[1,\"\\n        \"],[18,4,null],[1,\"\\n      \"]],[]]]]],[1,\"\\n\"]],[1]]],[1,\"  \"]],[\"Tag\",\"@class\",\"&attrs\",\"&default\"],[\"let\",\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-container.js",
+			"scope": () => [ElementHelper],
+			"isStrictMode": true
+		}), this);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/partition.js
+var import_assert_never = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.assertNever = assertNever;
+	/**
+	* Helper function for exhaustive checks of discriminated unions.
+	* https://basarat.gitbooks.io/typescript/docs/types/discriminated-unions.html
+	*
+	* @example
+	*
+	*    type A = {type: 'a'};
+	*    type B = {type: 'b'};
+	*    type Union = A | B;
+	*
+	*    function doSomething(arg: Union) {
+	*      if (arg.type === 'a') {
+	*        return something;
+	*      }
+	*
+	*      if (arg.type === 'b') {
+	*        return somethingElse;
+	*      }
+	*
+	*      // TS will error if there are other types in the union
+	*      // Will throw an Error when called at runtime.
+	*      // Use `assertNever(arg, true)` instead to fail silently.
+	*      return assertNever(arg);
+	*    }
+	*/
+	function assertNever(value, errorMessageOrNoThrow) {
+		if (typeof errorMessageOrNoThrow === "string") throw new Error(errorMessageOrNoThrow);
+		if (typeof errorMessageOrNoThrow === "function") throw new Error(errorMessageOrNoThrow(value));
+		if (errorMessageOrNoThrow) return value;
+		throw new Error("Unhandled discriminated union member: ".concat(JSON.stringify(value)));
+	}
+	exports.default = assertNever;
+})))());
+function partition(iterator, predicate) {
+	let truthy = [];
+	let falsy = [];
+	for (let item of iterator) if (predicate(item)) truthy.push(item);
+	else falsy.push(item);
+	return [truthy, falsy];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/-private/child.js
+var Child = class Child {
+	state = "new";
+	removalBlockers = 0;
+	removalCycle = null;
+	constructor(group, id, value, index) {
+		this.group = group;
+		this.id = id;
+		this.value = value;
+		this.index = index;
+		this.removalBlockers = 0;
+		this.removalCycle = null;
+	}
+	block(cycle) {
+		if (this.removalCycle == null || this.removalCycle === cycle) {
+			this.removalCycle = cycle;
+			this.removalBlockers++;
+		}
+	}
+	unblock(cycle) {
+		if (this.removalCycle === cycle) this.removalBlockers--;
+	}
+	flagForRemoval() {
+		this.removalCycle = null;
+		this.removalBlockers = 0;
+		this.state = "removing";
+	}
+	get shouldRemove() {
+		return this.state === "removing" && this.removalBlockers < 1;
+	}
+	clone() {
+		return new Child(this.group, this.id, this.value, this.index);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/ea-list-element.js
+var EaListElement = class extends Component {
+	tagName = "";
+	isEmberAnimatedListElement = true;
+	child;
+	elementToChild;
+	didRender() {
+		super.didRender();
+		let mapping = this.elementToChild;
+		let child = this.child;
+		this._forEachElement((elt) => {
+			mapping.set(elt, child);
+		});
+	}
+	_forEachElement(fn) {
+		let { firstNode, lastNode } = componentNodes(this);
+		let node = firstNode;
+		while (node) {
+			if (node.nodeType === Node.ELEMENT_NODE) fn(node);
+			else if (!/^\s*$/.test(node.textContent)) warn("Found bare text content inside an animator", false, { id: "ember-animated-bare-text" });
+			if (node === lastNode) break;
+			node = node.nextSibling;
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-each.js
+var service$1 = service$4 ?? inject;
+/**
+A drop in replacement for `{{#each}}` that animates changes to a list.
+
+```hbs
+{{#animated-each items use=transition duration=2000 as |item|}}
+<div data-test-item={{item}} onclick={{action removeItem item}}>
+{{item}}
+</div>
+{{/animated-each}}
+```
+
+```js
+import Component from '@ember/component';
+import move from 'ember-animated/motions/move';
+import { fadeOut } from 'ember-animated/motions/opacity';
+
+export default Component.extend({
+init() {
+this._super();
+this.items = ['A', 'B', 'C', 'D', 'E'];
+},
+
+* transition({ keptSprites, removedSprites }) {
+for (let sprite of keptSprites) {
+move(sprite);
+}
+
+for (let sprite of removedSprites) {
+fadeOut(sprite);
+}
+},
+
+removeItem(item){
+this.set('items', this.items.filter(i => i !== item));
+}
+});
+```
+@class animated-each
+@public
+*/
+var AnimatedEach = class extends Component {
+	tagName = "";
+	static positionalParams = ["items"];
+	static {
+		decorateFieldV2(this.prototype, "motionService", [service$1("-ea-motion")]);
+	}
+	#motionService = (initializeDeferredDecorator(this, "motionService"), void 0);
+	/**
+	* The list of data you are trying to render.
+	@argument items
+	@type Array
+	*/
+	items;
+	/**
+	* If set, this animator will only [match](../../between) other animators that have the same group value.
+	@argument group
+	@type String
+	*/
+	group;
+	/**
+	* Represents the amount of time an animation takes in miliseconds.
+	@argument duration
+	@type Number
+	*/
+	duration;
+	/**
+	* Specifies the [Transition](../../transitions)
+	* to run when the list changes.
+	@argument use
+	@type Transition
+	*/
+	use;
+	/**
+	* Specifies data-dependent [Rules](../../rules) that choose which [Transition](../../transitions)
+	* to run when the list changes. This takes precedence over `use`.
+	@argument rules
+	@type Rules
+	*/
+	rules;
+	/**
+	* When true, all the items in the list will animate as [`insertedSprites`](../../sprites) when the `{{#animated-each}}` is first rendered. Defaults to false.
+	@argument initialInsertion
+	@type Boolean
+	*/
+	initialInsertion = false;
+	/**
+	When true, all the items in the list will animate as [`removedSprites`](../../sprites) when the `{{#animated-each}}` is destroyed. Defaults to false.
+	Note that an `<AnimatedOrphans/>` component must be actively rendered when this animator is removed for this option to have any effect.
+	@argument finalRemoval
+	@type Boolean
+	*/
+	finalRemoval = false;
+	/**
+	Serves the same purpose as the `key` in ember `{{#each}}`, and it's
+	also used to compare values when [animating between components](../../between).
+	@argument key
+	@type String
+	*/
+	key;
+	/**
+	An optional comma-separated list of properties to observe on each of the
+	objects in the items list. If any of those properties change, we will
+	trigger an animated transition. Without this, we only animate when the list
+	contents change, not when any deeper properties change.
+	@argument watch
+	@type String
+	*/
+	watch;
+	_elementToChild = /* @__PURE__ */ new WeakMap();
+	_prevItems = [];
+	_prevSignature = [];
+	_firstTime = true;
+	_inserted = false;
+	_renderedChildren = [];
+	_renderedChildrenStartedMoving = false;
+	_cycleCounter = 0;
+	_keptSprites = null;
+	_insertedSprites = null;
+	_removedSprites = null;
+	_lastTransition = null;
+	_ancestorWillDestroyUs = false;
+	init() {
+		super.init();
+		this.motionService.register(this).observeDescendantAnimations(this, this.maybeReanimate).observeAncestorAnimations(this, this.ancestorIsAnimating);
+		this._installObservers();
+	}
+	_installObservers() {
+		let key = this.key;
+		if (key != null && key !== "@index" && key !== "@identity") this.addObserver(`items.@each.${key}`, this, this._invalidateRenderedChildren);
+		let deps = this._deps;
+		if (deps) for (let dep of deps) this.addObserver(`items.@each.${dep}`, this, this._invalidateRenderedChildren);
+	}
+	get _deps() {
+		let w = this.watch;
+		if (typeof w === "string") return w.split(/\s*,\s*/);
+	}
+	static {
+		decorateMethodV2(this.prototype, "_deps", [computed("watch")]);
+	}
+	get durationWithDefault() {
+		let d = this.duration;
+		if (d == null) return 500;
+		else return d;
+	}
+	static {
+		decorateMethodV2(this.prototype, "durationWithDefault", [computed("duration")]);
+	}
+	_invalidateRenderedChildren() {
+		this.notifyPropertyChange("renderedChildren");
+	}
+	_identitySignature(items, getKey) {
+		if (!items) return [];
+		let deps = this._deps;
+		let signature = [];
+		for (let i = 0; i < items.length; i++) {
+			let item = items[i];
+			signature.push(getKey(item, i));
+			if (deps) for (const dep of deps) signature.push(get(item, dep));
+		}
+		return signature;
+	}
+	get renderedChildren() {
+		let firstTime = this._firstTime;
+		this._firstTime = false;
+		let getKey = this.keyGetter;
+		let oldChildren = this._renderedChildren;
+		let oldItems = this._prevItems;
+		let oldSignature = this._prevSignature;
+		let newItems = this.items;
+		let newSignature = this._identitySignature(newItems, getKey);
+		let group = this.group || "__default__";
+		this._prevItems = newItems ? newItems.slice() : [];
+		this._prevSignature = newSignature;
+		if (!newItems) newItems = [];
+		let oldIndices = /* @__PURE__ */ new Map();
+		oldChildren.forEach((child, index) => {
+			oldIndices.set(child.id, index);
+		});
+		let newIndices = /* @__PURE__ */ new Map();
+		newItems.forEach((item, index) => {
+			newIndices.set(getKey(item, index), index);
+		});
+		let newChildren = newItems.map((value, listIndex) => {
+			let id = getKey(value, listIndex);
+			if (oldIndices.get(id) != null) {
+				let child = new Child(group, id, value, listIndex);
+				child.state = "kept";
+				return child;
+			} else return new Child(group, id, value, listIndex);
+		}).concat(oldChildren.filter((child) => (!child.shouldRemove || !this._renderedChildrenStartedMoving) && newIndices.get(child.id) == null).map((child) => {
+			child.flagForRemoval();
+			return child;
+		}));
+		this._renderedChildren = newChildren;
+		this._renderedChildrenStartedMoving = false;
+		if (typeof FastBoot === "undefined" && !isStable(oldSignature, newSignature)) {
+			let transition = this._transitionFor(firstTime, oldItems, newItems);
+			this.animate.perform(transition, firstTime);
+		}
+		return newChildren;
+	}
+	static {
+		decorateMethodV2(this.prototype, "renderedChildren", [computed("items.[]", "group")]);
+	}
+	static {
+		decorateFieldV2(this.prototype, "isAnimating", [alias("animate.isRunning")]);
+	}
+	#isAnimating = (initializeDeferredDecorator(this, "isAnimating"), void 0);
+	get keyGetter() {
+		return keyForArray(this.key);
+	}
+	static {
+		decorateMethodV2(this.prototype, "keyGetter", [computed("key")]);
+	}
+	didInsertElement() {
+		super.didInsertElement();
+		this._inserted = true;
+	}
+	*_ownElements() {
+		if (!this._inserted) return;
+		let { firstNode, lastNode } = componentNodes(this);
+		let node = firstNode;
+		while (node) {
+			if (node.nodeType === Node.ELEMENT_NODE) yield node;
+			if (node === lastNode) break;
+			node = node.nextSibling;
+		}
+	}
+	maybeReanimate() {
+		if (this.animate.isRunning && !this.startAnimation.isRunning) this.animate.perform(this._lastTransition);
+	}
+	static {
+		decorateMethodV2(this.prototype, "maybeReanimate", [action]);
+	}
+	ancestorIsAnimating(ourState) {
+		if (ourState === "removing" && !this._ancestorWillDestroyUs) {
+			this._ancestorWillDestroyUs = true;
+			this._letSpritesEscape();
+		} else if (ourState !== "removing" && this._ancestorWillDestroyUs) {
+			this._ancestorWillDestroyUs = false;
+			let transition = this._transitionFor(this._firstTime, [], this._prevItems);
+			this.animate.perform(transition);
+		}
+	}
+	static {
+		decorateMethodV2(this.prototype, "ancestorIsAnimating", [action]);
+	}
+	_letSpritesEscape() {
+		let transition = this._transitionFor(this._firstTime, this._prevItems, []);
+		let removedSprites = [];
+		let parent;
+		for (let element of this._ownElements()) {
+			if (!parent) parent = Sprite.offsetParentStartingAt(element);
+			let sprite = Sprite.positionedStartingAt(element, parent);
+			sprite.owner = this._elementToChild.get(element);
+			removedSprites.push(sprite);
+		}
+		this.motionService.matchDestroyed(removedSprites, transition, this.durationWithDefault, this.finalRemoval);
+	}
+	willDestroyElement() {
+		super.willDestroyElement();
+		if (!this._ancestorWillDestroyUs) this._letSpritesEscape();
+		this.motionService.unregister(this).unobserveDescendantAnimations(this, this.maybeReanimate).unobserveAncestorAnimations(this, this.ancestorIsAnimating);
+	}
+	beginStaticMeasurement() {
+		if (this._keptSprites) {
+			this._keptSprites.forEach((sprite) => sprite.unlock());
+			this._insertedSprites.forEach((sprite) => sprite.unlock());
+			this._removedSprites.forEach((sprite) => sprite.display(false));
+		}
+	}
+	endStaticMeasurement() {
+		if (this._keptSprites) {
+			this._keptSprites.forEach((sprite) => sprite.lock());
+			this._insertedSprites.forEach((sprite) => sprite.lock());
+			this._removedSprites.forEach((sprite) => sprite.display(true));
+		}
+	}
+	_findCurrentSprites() {
+		let currentSprites = [];
+		let parent;
+		for (let element of this._ownElements()) {
+			if (!parent) parent = Sprite.offsetParentStartingAt(element);
+			let sprite = Sprite.positionedStartingAt(element, parent);
+			currentSprites.push(sprite);
+		}
+		return {
+			currentSprites,
+			parent
+		};
+	}
+	_partitionKeptAndRemovedSprites(currentSprites) {
+		currentSprites.forEach((sprite) => {
+			if (!sprite.element.parentElement) return;
+			let child = this._elementToChild.get(sprite.element);
+			sprite.owner = child;
+			if (this._ancestorWillDestroyUs) this._removedSprites.push(sprite);
+			else switch (child.state) {
+				case "kept":
+					this._keptSprites.push(sprite);
+					break;
+				case "removing":
+					this._removedSprites.push(sprite);
+					break;
+				case "new":
+					this._keptSprites.push(sprite);
+					break;
+				default: throw (0, import_assert_never.default)(child.state);
+			}
+		});
+	}
+	static {
+		decorateFieldV2(this.prototype, "animate", [task(function* (transition, firstTime) {
+			let { parent, currentSprites, insertedSprites, keptSprites, removedSprites } = yield this.startAnimation.perform(transition, current());
+			let { matchingAnimatorsFinished } = yield this.runAnimation.perform(transition, parent, currentSprites, insertedSprites, keptSprites, removedSprites, firstTime);
+			yield this.finalizeAnimation.perform(insertedSprites, keptSprites, removedSprites, matchingAnimatorsFinished);
+		}).restartable()]);
+	}
+	#animate = (initializeDeferredDecorator(this, "animate"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "startAnimation", [task(function* (transition, animateTask) {
+			this._lastTransition = transition;
+			let keptSprites = this._keptSprites = [];
+			let removedSprites = this._removedSprites = [];
+			let insertedSprites = this._insertedSprites = [];
+			let { currentSprites, parent } = this._findCurrentSprites();
+			this.motionService.willAnimate({
+				task: animateTask,
+				duration: this.durationWithDefault,
+				component: this,
+				children: this._renderedChildren
+			});
+			currentSprites.forEach((sprite) => sprite.lock());
+			yield afterRender();
+			return {
+				parent,
+				currentSprites,
+				insertedSprites,
+				keptSprites,
+				removedSprites
+			};
+		})]);
+	}
+	#startAnimation = (initializeDeferredDecorator(this, "startAnimation"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "runAnimation", [task(function* (transition, parent, currentSprites, insertedSprites, keptSprites, removedSprites, firstTime) {
+			this._partitionKeptAndRemovedSprites(currentSprites);
+			yield* this.motionService.staticMeasurement(() => {
+				if (parent && !parent.finalBounds) parent.measureFinalBounds();
+				for (let element of this._ownElements()) if (!currentSprites.find((sprite) => sprite.element === element)) {
+					if (!parent) parent = Sprite.offsetParentEndingAt(element);
+					let sprite = Sprite.positionedEndingAt(element, parent);
+					sprite.owner = this._elementToChild.get(element);
+					sprite.hide();
+					insertedSprites.push(sprite);
+				}
+				keptSprites.forEach((sprite) => sprite.measureFinalBounds());
+			});
+			let { farMatches, matchingAnimatorsFinished, beacons } = yield this.motionService.get("farMatch").perform(current(), insertedSprites, keptSprites, removedSprites);
+			if (parent && !parent.initialBounds) parent.measureInitialBounds();
+			let [sentSprites, unmatchedRemovedSprites] = partition(removedSprites, (sprite) => {
+				let other = farMatches.get(sprite);
+				if (other) {
+					sprite.endAtSprite(other);
+					if (other.revealed && !sprite.revealed) sprite.startAtSprite(other);
+					return true;
+				}
+				return false;
+			});
+			let [receivedSprites, unmatchedInsertedSprites] = partition(insertedSprites, (sprite) => {
+				let other = farMatches.get(sprite);
+				if (other) {
+					sprite.startAtSprite(other);
+					return true;
+				}
+				return false;
+			});
+			let [matchedKeptSprites, unmatchedKeptSprites] = partition(keptSprites, (sprite) => {
+				let other = farMatches.get(sprite);
+				if (other) {
+					if (other.revealed && !sprite.revealed) sprite.startAtSprite(other);
+					return true;
+				}
+				return false;
+			});
+			yield microwait();
+			matchedKeptSprites.forEach((s) => s.hide());
+			sentSprites.forEach((s) => s.hide());
+			if (firstTime && !this.initialInsertion) {
+				unmatchedInsertedSprites.forEach((s) => s.reveal());
+				unmatchedInsertedSprites = [];
+			}
+			this._renderedChildrenStartedMoving = true;
+			if (!transition || unmatchedInsertedSprites.length === 0 && unmatchedKeptSprites.length === 0 && unmatchedRemovedSprites.length === 0 && sentSprites.length === 0 && receivedSprites.length === 0 && matchedKeptSprites.length === 0) return { matchingAnimatorsFinished };
+			let context = new TransitionContext(this.durationWithDefault, unmatchedInsertedSprites, unmatchedKeptSprites, unmatchedRemovedSprites, sentSprites, receivedSprites.concat(matchedKeptSprites), beacons, (sprite) => this._motionStarted(sprite, cycle), (sprite) => this._motionEnded(sprite, cycle));
+			let cycle = this._cycleCounter++;
+			yield* runToCompletion(context, transition);
+			return { matchingAnimatorsFinished };
+		})]);
+	}
+	#runAnimation = (initializeDeferredDecorator(this, "runAnimation"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "finalizeAnimation", [task(function* (insertedSprites, keptSprites, removedSprites, matchingAnimatorsFinished) {
+			yield matchingAnimatorsFinished;
+			keptSprites.forEach((sprite) => {
+				sprite.unlock();
+				sprite.reveal();
+			});
+			insertedSprites.forEach((sprite) => {
+				sprite.unlock();
+				sprite.reveal();
+			});
+			this._keptSprites = null;
+			this._removedSprites = null;
+			this._insertedSprites = null;
+			if (removedSprites.length > 0) {
+				this.notifyPropertyChange("renderedChildren");
+				yield afterRender();
+			}
+		})]);
+	}
+	#finalizeAnimation = (initializeDeferredDecorator(this, "finalizeAnimation"), void 0);
+	_motionStarted(sprite, cycle) {
+		sprite.reveal();
+		sprite.owner.block(cycle);
+	}
+	_motionEnded(sprite, cycle) {
+		sprite.owner.unblock(cycle);
+	}
+	_transitionFor(firstTime, oldItems, newItems) {
+		let rules = this.rules;
+		if (rules) return rules({
+			firstTime,
+			oldItems,
+			newItems
+		});
+		else return this.use;
+	}
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "TB4qeXUr",
+			"block": "[[[42,[28,[31,1],[[28,[31,1],[[30,0,[\"renderedChildren\"]]],null]],null],\"id\",[[[8,[32,0],null,[[\"@child\",\"@elementToChild\"],[[30,1],[30,0,[\"_elementToChild\"]]]],[[\"default\"],[[[[18,2,[[30,1,[\"value\"]],[30,1,[\"index\"]]]]],[]]]]]],[1]],[[[18,3,null]],[]]],[1,\"  \"]],[\"child\",\"&default\",\"&else\"],[\"each\",\"-track-array\",\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-each.js",
+			"scope": () => [EaListElement],
+			"isStrictMode": true
+		}), this);
+	}
+};
+function isStable(before, after) {
+	if (before.length !== after.length) return false;
+	for (let i = 0; i < before.length; i++) if (before[i] !== after[i]) return false;
+	return true;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-value.js
+/**
+A component that animates when a single value changes.
+Animated-value uses the same arguments as animated-each.
+
+```hbs
+<AnimatedContainer>
+{{#animated-value this.counter rules=this.rules duration=100 as |v|}}
+<span class="numbers">{{v}}</span>
+{{/animated-value}}
+</AnimatedContainer>
+
+<button {{action "increment"}}>+</button>
+<button {{action "decrement"}}>-</button>
+```
+
+```js
+import Component from '@ember/component';
+import { toLeft, toRight } from 'ember-animated/transitions/move-over';
+
+export default Component.extend({
+rules({ oldItems, newItems }) {
+if (oldItems[0] < newItems[0]) {
+return toLeft;
+} else {
+return toRight;
+}
+},
+
+counter: 10,
+
+actions: {
+increment() {
+this.set('counter', this.get('counter') + 1);
+},
+decrement() {
+this.set('counter', this.get('counter') - 1);
+}
+}
+});
+```
+@class animated-value
+@public
+*/
+var AnimatedValueComponent = class extends Component {
+	/**
+	* The data you are trying to render.
+	@argument items
+	@type unknown
+	*/
+	value;
+	tagName = "";
+	finalRemoval;
+	initialInsertion;
+	watch;
+	key;
+	group;
+	rules;
+	use;
+	duration;
+	static positionalParams = ["value"];
+	get items() {
+		return A([this.value]);
+	}
+	static {
+		decorateMethodV2(this.prototype, "items", [computed("value")]);
+	}
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "bfeQqXYb",
+			"block": "[[[1,\"\\n\"],[6,[32,0],[[30,0,[\"items\"]]],[[\"key\",\"rules\",\"use\",\"duration\",\"group\",\"watch\",\"initialInsertion\",\"finalRemoval\"],[[30,0,[\"key\"]],[30,0,[\"rules\"]],[30,0,[\"use\"]],[30,0,[\"duration\"]],[30,0,[\"group\"]],[30,0,[\"watch\"]],[30,0,[\"initialInsertion\"]],[30,0,[\"finalRemoval\"]]]],[[\"default\"],[[[[1,\"      \"],[18,2,[[30,1]]],[1,\"\\n\"]],[1]]]]],[1,\"  \"]],[\"item\",\"&default\"],[\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-value.js",
+			"scope": () => [AnimatedEach],
+			"isStrictMode": true
+		}), this);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-if.js
+/**
+A drop in replacement for `{{#if}}` that animates changes when the predicate changes.
+Animated-if uses the same arguments as animated-each.
+
+```hbs
+<button {{on 'click' this.toggleThing}}>Toggle</button>
+
+{{#animated-if showThing use=transition}}
+<div class="message" {{on 'click' this.toggleThing}} role="button">
+myContent
+</div>
+{{/animated-if}}
+```
+
+```js
+import Component from '@glimmer/component';
+import move from 'ember-animated/motions/move';
+import { easeOut, easeIn } from 'ember-animated/easings/cosine';
+import { tracked } from '@glimmer/tracking';
+
+export default class FooComponent extends Component {
+@tracked showThing = false;
+
+toggleThing() {
+this.showThing = !this.showThing;
+}
+
+// eslint-disable-next-line require-yield
+*transition({ insertedSprites, keptSprites, removedSprites }) {
+for (let sprite of insertedSprites) {
+sprite.startAtPixel({ x: window.innerWidth });
+move(sprite, { easing: easeOut });
+}
+
+for (let sprite of keptSprites) {
+move(sprite);
+}
+
+for (let sprite of removedSprites) {
+sprite.endAtPixel({ x: window.innerWidth });
+move(sprite, { easing: easeIn });
+}
+}
+};
+```
+@class animated-if
+@public
+*/
+var AnimatedIfComponent = class extends Component {
+	tagName = "";
+	static positionalParams = ["predicate"];
+	predicate;
+	group;
+	finalRemoval;
+	initialInsertion;
+	key;
+	rules;
+	use;
+	duration;
+	get realGroup() {
+		return this.group || `animated_if_${Math.floor(Math.random() * 1e6)}`;
+	}
+	static {
+		decorateMethodV2(this.prototype, "realGroup", [computed("group")]);
+	}
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "ZsGP7Nvw",
+			"block": "[[[1,\"\\n    \"],[8,[32,0],null,[[\"@value\",\"@key\",\"@rules\",\"@use\",\"@duration\",\"@group\",\"@initialInsertion\",\"@finalRemoval\"],[[30,0,[\"predicate\"]],[30,0,[\"key\"]],[30,0,[\"rules\"]],[30,0,[\"use\"]],[30,0,[\"duration\"]],[30,0,[\"realGroup\"]],[30,0,[\"initialInsertion\"]],[30,0,[\"finalRemoval\"]]]],[[\"default\"],[[[[1,\"\\n\"],[41,[30,1],[[[1,\"        \"],[18,2,null],[1,\"\\n\"]],[]],[[[1,\"        \"],[18,3,null],[1,\"\\n\"]],[]]],[1,\"    \"]],[1]]]]],[1,\"\\n  \"]],[\"currentPredicate\",\"&default\",\"&else\"],[\"if\",\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-if.js",
+			"scope": () => [AnimatedValueComponent],
+			"isStrictMode": true
+		}), this);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/element-remove-8rRE7jKB.js
+(function(arr) {
+	arr.forEach(function(item) {
+		if (Object.prototype.hasOwnProperty.call(item, "remove")) return;
+		Object.defineProperty(item, "remove", {
+			configurable: true,
+			enumerable: true,
+			writable: true,
+			value: function remove() {
+				this.parentNode.removeChild(this);
+			}
+		});
+	});
+})([
+	window.Element,
+	window.CharacterData,
+	window.DocumentType
+].filter((klass) => klass).map((klass) => klass.prototype));
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-orphans.js
+var service = service$4 ?? inject;
+/**
+A component that adopts any orphaned sprites so they can continue animating even
+after their original parent component has been destroyed. This relies on cloning
+DOM nodes, and the cloned nodes will be inserted as children of animated-orphans.
+
+```hbs
+<AnimatedOrphans/>
+```
+@class animated-orphans
+@public
+*/
+var AnimatedOrphans = class extends Component {
+	init(...args) {
+		super.init(...args);
+		this.classNames = this.classNames.concat(["animated-orphans"]);
+	}
+	static {
+		decorateFieldV2(this.prototype, "motionService", [service("-ea-motion")]);
+	}
+	#motionService = (initializeDeferredDecorator(this, "motionService"), void 0);
+	_newOrphanTransitions = [];
+	_elementToChild = /* @__PURE__ */ new WeakMap();
+	_childToTransition = /* @__PURE__ */ new WeakMap();
+	_inserted = false;
+	_cycleCounter = 0;
+	didInsertElement() {
+		super.didInsertElement();
+		this._inserted = true;
+		this.motionService.register(this).observeOrphans(this.animateOrphans).observeAnimations(this.reanimate);
+	}
+	willDestroyElement() {
+		super.willDestroyElement();
+		this.motionService.unregister(this).unobserveOrphans(this.animateOrphans).unobserveAnimations(this.reanimate);
+	}
+	animateOrphans(removedSprites, transition, duration, shouldAnimateRemoved) {
+		this._newOrphanTransitions.push({
+			removedSprites: removedSprites.map((sprite) => {
+				sprite.assertHasOwner();
+				sprite.owner = sprite.owner.clone();
+				sprite.owner.flagForRemoval();
+				return sprite;
+			}),
+			transition,
+			duration,
+			shouldAnimateRemoved
+		});
+		this.reanimate();
+	}
+	static {
+		decorateMethodV2(this.prototype, "animateOrphans", [action]);
+	}
+	reanimate() {
+		if (!this.get("startAnimation.isRunning")) {
+			let ownSprite = new Sprite(this.element, true, null, null);
+			let activeSprites = this._findActiveSprites(ownSprite);
+			this.animate.perform({
+				ownSprite,
+				activeSprites
+			});
+		}
+	}
+	static {
+		decorateMethodV2(this.prototype, "reanimate", [action]);
+	}
+	beginStaticMeasurement() {}
+	endStaticMeasurement() {}
+	static {
+		decorateFieldV2(this.prototype, "isAnimating", [alias("animate.isRunning")]);
+	}
+	#isAnimating = (initializeDeferredDecorator(this, "isAnimating"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "animate", [task(function* ({ ownSprite, activeSprites }) {
+			yield this.startAnimation.perform(ownSprite);
+			let { matchingAnimatorsFinished } = yield this.runAnimation.perform(activeSprites, ownSprite);
+			yield this.finalizeAnimation.perform(activeSprites, matchingAnimatorsFinished);
+		}).restartable()]);
+	}
+	#animate = (initializeDeferredDecorator(this, "animate"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "startAnimation", [task(function* (ownSprite) {
+			yield afterRender();
+			ownSprite.measureFinalBounds();
+		})]);
+	}
+	#startAnimation = (initializeDeferredDecorator(this, "startAnimation"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "runAnimation", [task(function* (activeSprites, ownSprite) {
+			yield* this.motionService.staticMeasurement(() => {});
+			{
+				let activeIds = Object.create(null);
+				for (let sprite of activeSprites) activeIds[`${sprite.owner.group}/${sprite.owner.id}`] = true;
+				for (let entry of this._newOrphanTransitions) entry.removedSprites = entry.removedSprites.filter((s) => {
+					s.assertHasOwner();
+					return !activeIds[`${s.owner.group}/${s.owner.id}`];
+				});
+			}
+			let { farMatches, matchingAnimatorsFinished } = yield this.motionService.get("farMatch").perform(current(), [], [], activeSprites.concat(...this._newOrphanTransitions.map((t) => t.removedSprites)));
+			let cycle = this._cycleCounter++;
+			for (let { transition, duration, sprites } of this._groupActiveSprites(activeSprites)) {
+				let [sentSprites, removedSprites] = partition(sprites, (sprite) => {
+					let other = farMatches.get(sprite);
+					if (other) {
+						sprite.endAtSprite(other);
+						if (other.revealed && !sprite.revealed) sprite.startAtSprite(other);
+						return true;
+					}
+					return false;
+				});
+				let context = new TransitionContext(duration, [], [], removedSprites, sentSprites, [], {}, this._onMotionStart.bind(this, cycle), this._onMotionEnd.bind(this, cycle));
+				spawnChild(function* () {
+					yield microwait();
+					sentSprites.forEach((s) => s.hide());
+					yield* runToCompletion(context, transition);
+				});
+			}
+			while (this._newOrphanTransitions.length > 0) {
+				let entry = this._newOrphanTransitions.pop();
+				let { transition, duration, removedSprites, shouldAnimateRemoved } = entry;
+				if (removedSprites.length === 0) continue;
+				for (let _sprite of removedSprites) {
+					let sprite = _sprite;
+					sprite.assertHasOwner();
+					sprite.rehome(ownSprite);
+					this._childToTransition.set(sprite.owner, entry);
+				}
+				let [sentSprites, unmatchedRemovedSprites] = partition(removedSprites, (sprite) => {
+					let other = farMatches.get(sprite);
+					if (other) {
+						sprite.endAtSprite(other);
+						if (other.revealed && !sprite.revealed) sprite.startAtSprite(other);
+						return true;
+					}
+					return false;
+				});
+				let self = this;
+				spawnChild(function* () {
+					yield microwait();
+					sentSprites.forEach((s) => s.hide());
+					if (!transition) return;
+					let removedSprites;
+					if (shouldAnimateRemoved) removedSprites = unmatchedRemovedSprites;
+					else removedSprites = [];
+					if (removedSprites.length === 0 && sentSprites.length === 0) return;
+					let context = new TransitionContext(duration, [], [], removedSprites, sentSprites, [], {}, self._onFirstMotionStart.bind(self, activeSprites, cycle), self._onMotionEnd.bind(self, cycle));
+					context.prepareSprite = self._prepareSprite.bind(self);
+					yield* runToCompletion(context, transition);
+				});
+			}
+			yield childrenSettled();
+			return { matchingAnimatorsFinished };
+		})]);
+	}
+	#runAnimation = (initializeDeferredDecorator(this, "runAnimation"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "finalizeAnimation", [task(function* (activeSprites, matchingAnimatorsFinished) {
+			yield matchingAnimatorsFinished;
+			for (let sprite of activeSprites) sprite.element.remove();
+		})]);
+	}
+	#finalizeAnimation = (initializeDeferredDecorator(this, "finalizeAnimation"), void 0);
+	_findActiveSprites(ownSprite) {
+		if (!this._inserted) return [];
+		return Array.from(this.element.children).map((element) => {
+			let child = this._elementToChild.get(element);
+			if (child.shouldRemove) {
+				element.remove();
+				return;
+			} else {
+				let sprite = Sprite.positionedStartingAt(element, ownSprite);
+				sprite.owner = child;
+				child.flagForRemoval();
+				return sprite;
+			}
+		}).filter(Boolean);
+	}
+	_groupActiveSprites(activeSprites) {
+		let groups = [];
+		for (let _sprite of activeSprites) {
+			let sprite = _sprite;
+			sprite.assertHasOwner();
+			let { transition, duration } = this._childToTransition.get(sprite.owner);
+			let group = groups.find((g) => g.transition === transition);
+			if (!group) {
+				group = {
+					transition,
+					duration,
+					sprites: []
+				};
+				groups.push(group);
+			}
+			group.sprites.push(sprite);
+		}
+		return groups;
+	}
+	_prepareSprite(sprite) {
+		sprite.hide();
+		let newElement = sprite.element.cloneNode(true);
+		continueMotions(sprite.element, newElement);
+		sprite.element = newElement;
+		return sprite;
+	}
+	_onFirstMotionStart(activeSprites, cycle, sprite) {
+		if (activeSprites.indexOf(sprite) === -1) {
+			let s = Object.assign({}, sprite.initialComputedStyle);
+			delete s["line-height"];
+			sprite.applyStyles(s);
+			this.element.appendChild(sprite.element);
+			sprite.lock();
+			sprite.reveal();
+			activeSprites.push(sprite);
+			this._elementToChild.set(sprite.element, sprite.owner);
+		}
+		sprite.assertHasOwner();
+		sprite.owner.block(cycle);
+	}
+	_onMotionStart(cycle, sprite) {
+		sprite.assertHasOwner();
+		sprite.reveal();
+		sprite.owner.block(cycle);
+	}
+	_onMotionEnd(cycle, sprite) {
+		sprite.assertHasOwner();
+		sprite.owner.unblock(cycle);
+	}
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "r32EN1l0",
+			"block": "[[[1,\"\\n\"],[1,\"    \"],[18,1,null],[1,\"\\n  \"]],[\"&default\"],[\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/components/animated-orphans.js",
+			"isStrictMode": true
+		}), this);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/index.js
+var dist_exports = /* @__PURE__ */ __exportAll({
+	AnimatedBeacon: () => AnimatedBeacon,
+	AnimatedContainer: () => AnimatedContainerComponent,
+	AnimatedOrphans: () => AnimatedOrphans,
+	Motion: () => Motion,
+	Tween: () => Tween,
+	afterRender: () => afterRender,
+	allSettled: () => allSettled,
+	animatedEach: () => AnimatedEach,
+	animatedIf: () => AnimatedIfComponent,
+	animatedValue: () => AnimatedValueComponent,
+	childrenSettled: () => childrenSettled,
+	clock: () => clock,
+	continueMotions: () => continueMotions,
+	current: () => current,
+	microwait: () => microwait,
+	parallel: () => parallel,
+	printSprites: () => printSprites,
+	rAF: () => rAF,
+	serial: () => serial,
+	spawn: () => spawn,
+	spawnChild: () => spawnChild,
+	stop: () => stop,
+	task: () => task,
+	wait: () => wait
+});
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/easings/linear.js
+var linear_exports = /* @__PURE__ */ __exportAll({ default: () => linear });
+function linear(t) {
+	return t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/color-DWpDqA22.js
+var Color = class Color {
+	static fromComputedStyle(colorString) {
+		let channels = parseComputedColor(colorString);
+		return new Color(channels, channels.m[0]);
+	}
+	static fromUserProvidedColor(colorString) {
+		return new Color(parseUserProvidedColor(colorString), colorString);
+	}
+	toString() {
+		return `rgba(${this.r}, ${this.g}, ${this.b}, ${this.a})`;
+	}
+	r;
+	g;
+	b;
+	a;
+	constructor({ r, g, b, a }, sourceString) {
+		this.sourceString = sourceString;
+		this.r = r;
+		this.g = g;
+		this.b = b;
+		this.a = a;
+	}
+};
+var ColorTween = class {
+	rTween;
+	gTween;
+	bTween;
+	aTween;
+	constructor(initialColor, finalColor, duration, easing = linear) {
+		this.rTween = new Tween(initialColor.r * initialColor.a, finalColor.r * finalColor.a, duration, easing);
+		this.gTween = new Tween(initialColor.g * initialColor.a, finalColor.g * finalColor.a, duration, easing);
+		this.bTween = new Tween(initialColor.b * initialColor.a, finalColor.b * finalColor.a, duration, easing);
+		this.aTween = new Tween(initialColor.a, finalColor.a, duration, easing);
+	}
+	get currentValue() {
+		let nonZeroAlpha = this.aTween.currentValue || 1;
+		return new Color({
+			r: Math.floor(this.rTween.currentValue / nonZeroAlpha),
+			g: Math.floor(this.gTween.currentValue / nonZeroAlpha),
+			b: Math.floor(this.bTween.currentValue / nonZeroAlpha),
+			a: this.aTween.currentValue
+		}, "");
+	}
+	get done() {
+		return [
+			this.rTween,
+			this.gTween,
+			this.bTween,
+			this.aTween
+		].every((tween) => tween.done);
+	}
+};
+function parseComputedColor(c) {
+	let m = /^rgb\((\d+), (\d+), (\d+)\)/.exec(c);
+	if (m) return {
+		r: parseInt(m[1]),
+		g: parseInt(m[2]),
+		b: parseInt(m[3]),
+		a: 1,
+		m
+	};
+	m = /^rgba\((\d+), (\d+), (\d+), (\d+(?:\.\d+)?)\)/.exec(c);
+	if (m) return {
+		r: parseInt(m[1]),
+		g: parseInt(m[2]),
+		b: parseInt(m[3]),
+		a: parseFloat(m[4]),
+		m
+	};
+	throw new Error(`unable to parse color ${c}`);
+}
+function parseUserProvidedColor(c) {
+	let testElement = document.createElement("div");
+	testElement.style.display = "none";
+	testElement.style.color = c;
+	document.body.appendChild(testElement);
+	let result = parseComputedColor(getComputedStyle(testElement).color);
+	testElement.remove();
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/adjust-color.js
+var adjust_color_exports = /* @__PURE__ */ __exportAll({
+	AdjustColor: () => AdjustColor,
+	default: () => adjustColor
+});
+function adjustColor(propertyName, sprite, opts = {}) {
+	return new AdjustColor(propertyName, sprite, opts).run();
+}
+adjustColor.property = function(propertyName) {
+	return this.bind(null, propertyName);
+};
+var AdjustColor = class extends Motion {
+	colorTween = null;
+	constructor(propertyName, sprite, opts = {}) {
+		super(sprite, opts);
+		this.propertyName = propertyName;
+	}
+	*animate() {
+		let from;
+		let to;
+		if (this.opts.from != null) from = Color.fromUserProvidedColor(this.opts.from);
+		else if (this.sprite.initialComputedStyle) from = Color.fromComputedStyle(this.sprite.initialComputedStyle[this.propertyName]);
+		else {
+			this.sprite.assertHasFinalBounds();
+			from = Color.fromComputedStyle(this.sprite.finalComputedStyle[this.propertyName]);
+		}
+		if (this.opts.to != null) to = Color.fromUserProvidedColor(this.opts.to);
+		else if (this.sprite.finalComputedStyle) to = Color.fromComputedStyle(this.sprite.finalComputedStyle[this.propertyName]);
+		else {
+			this.sprite.assertHasInitialBounds();
+			to = Color.fromComputedStyle(this.sprite.initialComputedStyle[this.propertyName]);
+		}
+		this.colorTween = new ColorTween(from, to, this.duration, this.opts.easing);
+		while (!this.colorTween.done) {
+			this.sprite.applyStyles({ [this.propertyName]: this.colorTween.currentValue.toString() });
+			yield rAF();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/adjust-css.js
+var adjust_css_exports = /* @__PURE__ */ __exportAll({
+	AdjustCSS: () => AdjustCSS,
+	default: () => adjustCSS
+});
+/**
+Animates the change in style of a Sprite. Applies to CSS properties that are a unit and a number (font-size, letter spacing, etc.).
+
+@function adjustCSS
+@export default
+@param {String} propertyName The CSS property to adjust
+@param {Sprite} sprite The sprite we're adjusting
+@param {Object} options
+@return {Motion}
+*/
+function adjustCSS(propertyName, sprite, opts = {}) {
+	return new AdjustCSS(propertyName, sprite, opts).run();
+}
+adjustCSS.property = function(propertyName) {
+	return this.bind(null, propertyName);
+};
+var AdjustCSS = class AdjustCSS extends Motion {
+	prior = null;
+	tween = null;
+	constructor(propertyName, sprite, opts = {}) {
+		super(sprite, opts);
+		this.propertyName = propertyName;
+	}
+	interrupted(motions) {
+		this.prior = motions.find((m) => m instanceof AdjustCSS && m.propertyName === this.propertyName);
+	}
+	*animate() {
+		let { value: finalValue, unit } = this._splitUnit(this.sprite.finalComputedStyle[this.propertyName]);
+		if (this.prior) {
+			let prior = this.prior;
+			prior.assertHasTween();
+			this.tween = new Tween(0, finalValue - prior.tween.finalValue, this.duration, this.opts.easing).plus(prior.tween);
+		} else {
+			this.sprite.assertHasInitialBounds();
+			this.tween = new Tween(this._splitUnit(this.sprite.initialComputedStyle[this.propertyName]).value, finalValue, this.duration, this.opts.easing);
+		}
+		while (!this.tween.done) {
+			this.sprite.applyStyles({ [this.propertyName]: `${this.tween.currentValue}${unit}` });
+			yield rAF();
+		}
+	}
+	_splitUnit(s) {
+		if (this.propertyName === "letter-spacing" && s === "normal") return {
+			value: 0,
+			unit: "px"
+		};
+		let m = /(\d+(?:\.\d+)?)(\w+)/.exec(s);
+		if (!m) throw new Error(`Unable to use adjustCSS for property ${this.propertyName} which has value ${s}`);
+		return {
+			value: parseFloat(m[1]),
+			unit: m[2] || ""
+		};
+	}
+	assertHasTween() {
+		if (!this.tween) throw new Error(`motion does not have tween`);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/box-shadow.js
+var innerPattern = /^ (\d+)px (\d+)px(?: (\d+)px)?(?: (\d+)px)?( inset)?(?:, )?/;
+var BoxShadow = class BoxShadow {
+	static fromComputedStyle(string) {
+		let originalString = string;
+		let shadows = [];
+		if (!string || string === "none") return shadows;
+		while (string.length > 0) {
+			let color = Color.fromComputedStyle(string);
+			string = string.slice(color.sourceString.length);
+			let m = innerPattern.exec(string);
+			if (!m) throw new Error(`failed to parse computed shadow ${originalString}`);
+			let x = parseInt(m[1]);
+			let y = parseInt(m[2]);
+			let blur = m[3] == null ? 0 : parseInt(m[3]);
+			let spread = m[4] == null ? 0 : parseInt(m[4]);
+			let inset = m[5] != null;
+			shadows.push(new BoxShadow({
+				color,
+				x,
+				y,
+				blur,
+				spread,
+				inset
+			}));
+			string = string.slice(m[0].length);
+		}
+		return shadows;
+	}
+	static fromUserProvidedShadow(string) {
+		let testElement = document.createElement("div");
+		testElement.style.display = "none";
+		testElement.style.boxShadow = string;
+		document.body.appendChild(testElement);
+		let result = this.fromComputedStyle(getComputedStyle(testElement).boxShadow);
+		testElement.remove();
+		return result;
+	}
+	color;
+	x;
+	y;
+	blur;
+	spread;
+	inset;
+	constructor({ color, x, y, blur, spread, inset }) {
+		this.color = color;
+		this.x = x;
+		this.y = y;
+		this.blur = blur;
+		this.spread = spread;
+		this.inset = inset;
+	}
+	toString() {
+		return `${this.inset ? "inset " : ""}${this.x}px ${this.y}px ${this.blur}px ${this.spread}px ${this.color.toString()}`;
+	}
+};
+function emptyShadowOfType(otherShadow) {
+	return new BoxShadow({
+		color: Color.fromComputedStyle("rgba(0, 0, 0, 0)"),
+		blur: 0,
+		spread: 0,
+		x: 0,
+		y: 0,
+		inset: otherShadow.inset
+	});
+}
+var BoxShadowTween = class {
+	shadowTweens;
+	constructor(fromShadows, toShadows, duration, easing = linear) {
+		let shadowCount = Math.max(fromShadows.length, toShadows.length);
+		if (fromShadows.length < shadowCount) {
+			fromShadows = fromShadows.slice();
+			while (fromShadows.length < shadowCount) fromShadows.push(emptyShadowOfType(toShadows[fromShadows.length]));
+		}
+		if (toShadows.length < shadowCount) {
+			toShadows = toShadows.slice();
+			while (toShadows.length < shadowCount) toShadows.push(emptyShadowOfType(fromShadows[toShadows.length]));
+		}
+		this.shadowTweens = fromShadows.map((fromShadow, index) => new OneShadowTween(fromShadow, toShadows[index], duration, easing));
+	}
+	get currentValue() {
+		return this.shadowTweens.map((tween) => tween.currentValue);
+	}
+	get done() {
+		return this.shadowTweens.every((tween) => tween.done);
+	}
+};
+var OneShadowTween = class {
+	colorTween;
+	xTween;
+	yTween;
+	blurTween;
+	spreadTween;
+	inset;
+	constructor(fromShadow, toShadow, duration, easing) {
+		this.colorTween = new ColorTween(fromShadow.color, toShadow.color, duration, easing);
+		this.xTween = new Tween(fromShadow.x, toShadow.x, duration, easing);
+		this.yTween = new Tween(fromShadow.y, toShadow.y, duration, easing);
+		this.blurTween = new Tween(fromShadow.blur, toShadow.blur, duration, easing);
+		this.spreadTween = new Tween(fromShadow.spread, toShadow.spread, duration, easing);
+		this.inset = fromShadow.inset;
+	}
+	get currentValue() {
+		return new BoxShadow({
+			x: this.xTween.currentValue,
+			y: this.yTween.currentValue,
+			blur: this.blurTween.currentValue,
+			spread: this.spreadTween.currentValue,
+			inset: this.inset,
+			color: this.colorTween.currentValue
+		});
+	}
+	get done() {
+		return [
+			this.colorTween,
+			this.xTween,
+			this.yTween,
+			this.blurTween,
+			this.spreadTween
+		].every((tween) => tween.done);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/box-shadow.js
+var box_shadow_exports = /* @__PURE__ */ __exportAll({
+	BoxShadowMotion: () => BoxShadowMotion,
+	default: () => boxShadow
+});
+function boxShadow(sprite, opts = {}) {
+	return new BoxShadowMotion(sprite, opts).run();
+}
+var BoxShadowMotion = class extends Motion {
+	*animate() {
+		let from;
+		if (this.opts.from) from = BoxShadow.fromUserProvidedShadow(this.opts.from);
+		else {
+			this.sprite.assertHasInitialBounds();
+			from = BoxShadow.fromComputedStyle(this.sprite.initialComputedStyle["box-shadow"]);
+		}
+		let to;
+		if (this.opts.to) to = BoxShadow.fromUserProvidedShadow(this.opts.to);
+		else {
+			this.sprite.assertHasFinalBounds();
+			to = BoxShadow.fromComputedStyle(this.sprite.finalComputedStyle["box-shadow"]);
+		}
+		let shadowTween = new BoxShadowTween(from, to, this.duration, this.opts.easing);
+		while (!shadowTween.done) {
+			this.sprite.applyStyles({ "box-shadow": shadowTween.currentValue.map((shadow) => shadow.toString()).join(",") });
+			yield rAF();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/compensate-for-scale.js
+var compensate_for_scale_exports = /* @__PURE__ */ __exportAll({
+	CompensateForScale: () => CompensateForScale,
+	default: () => compensateForScale
+});
+function compensateForScale(sprite, opts = {}) {
+	return new CompensateForScale(sprite, opts).run();
+}
+var CompensateForScale = class extends Motion {
+	widthTween = null;
+	heightTween = null;
+	*animate() {
+		let duration = this.duration;
+		this.sprite.assertHasInitialBounds();
+		this.sprite.assertHasFinalBounds();
+		let sprite = this.sprite;
+		let widthFactor = sprite.finalCumulativeTransform.a / sprite.initialCumulativeTransform.a;
+		let heightFactor = sprite.finalCumulativeTransform.d / sprite.initialCumulativeTransform.d;
+		this.widthTween = new Tween(sprite.transform.a, sprite.transform.a * widthFactor, duration);
+		this.heightTween = new Tween(sprite.transform.d, sprite.transform.d * heightFactor, duration);
+		while (!this.widthTween.done || !this.heightTween.done) {
+			sprite.scale(this.widthTween.currentValue / sprite.transform.a, this.heightTween.currentValue / sprite.transform.d);
+			yield rAF();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/move.js
+var move_exports = /* @__PURE__ */ __exportAll({
+	ContinuePrior: () => ContinuePrior,
+	Move: () => Move,
+	continuePrior: () => continuePrior,
+	default: () => move
+});
+/**
+Animates _sprite_ from its initial position to its final position.
+
+_sprite_ must have both `initialBounds` and `finalBounds` set.
+
+```js
+for (let sprite of keptSprites) {
+move(sprite)
+}
+```
+
+@function move
+@export default
+@param {Sprite} sprite
+@return {Motion}
+*/
+function move(sprite, opts = {}) {
+	return new Move(sprite, opts).run();
+}
+var Move = class Move extends Motion {
+	prior = null;
+	xTween = null;
+	yTween = null;
+	interrupted(motions) {
+		this.prior = motions.find((m) => m instanceof Move);
+	}
+	*animate() {
+		let duration = this.duration;
+		this.sprite.assertHasInitialBounds();
+		this.sprite.assertHasFinalBounds();
+		let sprite = this.sprite;
+		let dx;
+		let dy;
+		{
+			let initial = sprite.initialBounds;
+			let final = sprite.finalBounds;
+			dx = final.left - initial.left;
+			dy = final.top - initial.top;
+		}
+		if (!this.prior) {
+			this.xTween = new Tween(sprite.transform.tx, sprite.transform.tx + dx, fuzzyZero(dx) ? 0 : duration, this.opts.easing);
+			this.yTween = new Tween(sprite.transform.ty, sprite.transform.ty + dy, fuzzyZero(dy) ? 0 : duration, this.opts.easing);
+		} else {
+			let prior = this.prior;
+			prior.assertHasTweens();
+			let priorXTween = prior.xTween;
+			let priorYTween = prior.yTween;
+			let transformDiffX = sprite.transform.tx - priorXTween.currentValue;
+			let transformDiffY = sprite.transform.ty - priorYTween.currentValue;
+			dx -= priorXTween.finalValue - priorXTween.currentValue;
+			dy -= priorYTween.finalValue - priorYTween.currentValue;
+			let durationX = fuzzyZero(dx) ? 0 : duration;
+			let durationY = fuzzyZero(dy) ? 0 : duration;
+			this.xTween = new Tween(transformDiffX, transformDiffX + dx, durationX, this.opts.easing).plus(prior.xTween);
+			this.yTween = new Tween(transformDiffY, transformDiffY + dy, durationY, this.opts.easing).plus(prior.yTween);
+		}
+		yield* this._moveIt();
+	}
+	*_moveIt() {
+		this.assertHasTweens();
+		let sprite = this.sprite;
+		while (!this.xTween.done || !this.yTween.done) {
+			sprite.translate(this.xTween.currentValue - sprite.transform.tx, this.yTween.currentValue - sprite.transform.ty);
+			yield rAF();
+		}
+	}
+	assertHasTweens() {
+		if (!this.xTween) throw new Error(`motion does not have xTween`);
+		if (!this.yTween) throw new Error(`motion does not have yTween`);
+	}
+};
+function fuzzyZero(number) {
+	return Math.abs(number) < 1e-5;
+}
+function continuePrior(sprite, opts = {}) {
+	return new ContinuePrior(sprite, opts).run();
+}
+var ContinuePrior = class extends Move {
+	*animate() {
+		if (!this.prior) return;
+		this.xTween = this.prior.xTween;
+		this.yTween = this.prior.yTween;
+		yield* this._moveIt();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/follow.js
+var follow_exports = /* @__PURE__ */ __exportAll({
+	Follow: () => Follow,
+	default: () => follow
+});
+function follow(sprite, opts = {}) {
+	return new Follow(sprite, opts).run();
+}
+var Follow = class extends Move {
+	source;
+	constructor(sprite, opts = {}) {
+		super(sprite, opts);
+		if (!(this.opts.source instanceof Move)) throw new Error("Follow requires a `source` Move to follow");
+		this.source = this.opts.source;
+	}
+	*animate() {
+		this.source.assertHasTweens();
+		let source = this.source;
+		let sprite = this.sprite;
+		let transformOffsetX = sprite.transform.tx - source.sprite.transform.tx;
+		let transformOffsetY = sprite.transform.ty - source.sprite.transform.ty;
+		this.xTween = new Tween(transformOffsetX, transformOffsetX, 0).plus(source.xTween);
+		this.yTween = new Tween(transformOffsetY, transformOffsetY, 0).plus(source.yTween);
+		this.sprite.endRelativeTo(source.sprite);
+		while (!this.xTween.done || !this.yTween.done) {
+			sprite.translate(this.xTween.currentValue - sprite.transform.tx, this.yTween.currentValue - sprite.transform.ty);
+			yield rAF();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/move-svg.js
+var move_svg_exports = /* @__PURE__ */ __exportAll({
+	MoveSVG: () => MoveSVG,
+	default: () => moveSVG
+});
+function moveSVG(dimension, sprite, opts = {}) {
+	return new MoveSVG(dimension, sprite, opts).run();
+}
+moveSVG.property = function(propertyName) {
+	return this.bind(null, propertyName);
+};
+var MoveSVG = class MoveSVG extends Motion {
+	prior = null;
+	tween = null;
+	constructor(dimension, sprite, opts = {}) {
+		super(sprite, opts);
+		this.dimension = dimension;
+	}
+	interrupted(motions) {
+		this.prior = motions.find((m) => m instanceof MoveSVG && m.dimension === this.dimension);
+	}
+	*animate() {
+		if (this.prior) {
+			let prior = this.prior;
+			prior.assertHasTween();
+			this.tween = new Tween(0, Number(this.sprite.getFinalDimension(this.dimension)) - prior.tween.finalValue, this.duration, this.opts.easing).plus(prior.tween);
+		} else this.tween = new Tween(Number(this.sprite.getInitialDimension(this.dimension)), Number(this.sprite.getFinalDimension(this.dimension)), this.duration, this.opts.easing);
+		while (!this.tween.done) {
+			this.sprite.element[this.dimension].baseVal.value = this.tween.currentValue;
+			yield rAF();
+		}
+	}
+	assertHasTween() {
+		if (!this.tween) throw new Error(`motion does not have tween`);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/opacity.js
+var opacity_exports = /* @__PURE__ */ __exportAll({
+	Opacity: () => Opacity,
+	default: () => opacity,
+	fadeIn: () => fadeIn,
+	fadeOut: () => fadeOut
+});
+function opacity(sprite, opts = {}) {
+	return new Opacity(sprite, opts).run();
+}
+/**
+Animates in a sprite from 0% to 100% opacity.
+
+```js
+for (let sprite of insertedSprites) {
+fadeIn(sprite)
+}
+```
+
+@function fadeIn
+@param {Sprite} sprite
+@return {Motion}
+*/
+function fadeIn(sprite, opts = {}) {
+	return opacity(sprite, Object.assign({ to: 1 }, opts));
+}
+/**
+Animates out a sprite from 100% to 0% opacity.
+
+```js
+for (let sprite of removedSprites) {
+fadeOut(sprite)
+}
+```
+
+@function fadeOut
+@param {Sprite} sprite
+@return {Motion}
+*/
+function fadeOut(sprite, opts = {}) {
+	return opacity(sprite, Object.assign({ to: 0 }, opts));
+}
+var Opacity = class extends Motion {
+	prior = null;
+	tween = null;
+	interrupted(motions) {
+		this.prior = motions.find((m) => m instanceof this.constructor);
+	}
+	*animate() {
+		let { sprite, duration, opts } = this;
+		let to = opts.to != null ? opts.to : sprite.finalComputedStyle != null ? parseFloat(sprite.finalComputedStyle.opacity) : 1;
+		let from;
+		if (this.prior) {
+			let prior = this.prior;
+			prior.assertHasTween();
+			from = prior.tween.currentValue;
+		} else from = opts.from != null ? opts.from : sprite.initialComputedStyle != null ? parseFloat(sprite.initialComputedStyle.opacity) : 0;
+		let proportionalDuration = Math.abs(from - to) * duration;
+		this.tween = new Tween(from, to, proportionalDuration, this.opts.easing !== void 0 ? this.opts.easing : linear);
+		while (!this.tween.done) {
+			sprite.applyStyles({ opacity: `${this.tween.currentValue}` });
+			yield rAF();
+		}
+	}
+	assertHasTween() {
+		if (!this.tween) throw new Error(`motion does not have tween`);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/motions/scale.js
+var scale_exports = /* @__PURE__ */ __exportAll({
+	Scale: () => Scale,
+	default: () => scale
+});
+/**
+Smoothly scales _sprite_ from its the initial size to its final size.
+
+_sprite_ must have both `initialBounds` and `finalBounds` set.
+
+```js
+for (let sprite of insertedSprites) {
+sprite.startAtSprite(beacons['source']);
+scale(sprite)
+}
+```
+
+@function scale
+@export default
+@param {Sprite} sprite
+@return {Motion}
+*/
+function scale(sprite, opts = {}) {
+	return new Scale(sprite, opts).run();
+}
+var Scale = class extends Motion {
+	widthTween = null;
+	heightTween = null;
+	*animate() {
+		this.sprite.assertHasInitialBounds();
+		this.sprite.assertHasFinalBounds();
+		let sprite = this.sprite;
+		let duration = this.duration;
+		let initialWidthFactor;
+		let initialHeightFactor;
+		if (sprite.originalInitialBounds) {
+			initialWidthFactor = sprite.initialBounds.width / sprite.originalInitialBounds.width;
+			initialHeightFactor = sprite.initialBounds.height / sprite.originalInitialBounds.height;
+		} else {
+			initialWidthFactor = sprite.initialBounds.width / sprite.originalFinalBounds.width;
+			initialHeightFactor = sprite.initialBounds.height / sprite.originalFinalBounds.height;
+		}
+		let widthFactor = sprite.finalBounds.width / sprite.initialBounds.width;
+		let heightFactor = sprite.finalBounds.height / sprite.initialBounds.height;
+		this.widthTween = new Tween(sprite.transform.a * initialWidthFactor, sprite.transform.a * initialWidthFactor * widthFactor, duration, this.opts.easing);
+		this.heightTween = new Tween(sprite.transform.d * initialHeightFactor, sprite.transform.d * initialHeightFactor * heightFactor, duration, this.opts.easing);
+		while (!this.widthTween.done || !this.heightTween.done) {
+			sprite.scale(this.widthTween.currentValue / sprite.transform.a, this.heightTween.currentValue / sprite.transform.d);
+			yield rAF();
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/transitions/fade.js
+var fade_exports = /* @__PURE__ */ __exportAll({ default: () => fade });
+/**
+Fades inserted, removed, and kept sprites.
+
+```js
+import fade from 'ember-animated/transitions/fade';
+
+export default Component.extend({
+transition: fade
+});
+```
+
+```hbs
+{{#animated-if use=transition}}
+...
+{{/animated-if}}
+```
+
+@function fade
+@export default
+*/
+function* fade({ removedSprites, insertedSprites, keptSprites, duration }) {
+	yield Promise.all(removedSprites.map((s) => {
+		if (s.revealed) return opacity(s, {
+			to: 0,
+			duration: duration / 2
+		});
+	}));
+	insertedSprites.concat(keptSprites).map((s) => opacity(s, {
+		to: 1,
+		duration: duration / 2
+	}));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-animated@2.3.0_@babel+core@7.29.7_supports-color@8.1.1__@ember+test-helpers@5.4.3_dad572efa0a5f6f0d57e7476531ff882/node_modules/ember-animated/dist/transitions/move-over.js
+var move_over_exports = /* @__PURE__ */ __exportAll({
+	default: () => moveOver,
+	toDown: () => toDown,
+	toLeft: () => toLeft,
+	toRight: () => toRight,
+	toUp: () => toUp
+});
+var toLeft = moveOver.bind(null, "x", -1);
+var toRight = moveOver.bind(null, "x", 1);
+var toUp = moveOver.bind(null, "y", -1);
+var toDown = moveOver.bind(null, "y", 1);
+function normalize(dimension, direction) {
+	let position;
+	let size;
+	let startTranslatedBy;
+	let endTranslatedBy;
+	if (dimension.toLowerCase() === "x") {
+		size = (bounds) => bounds.width;
+		if (direction > 0) {
+			position = (bounds) => bounds.left;
+			startTranslatedBy = (sprite, distance) => sprite.startTranslatedBy(distance, 0);
+			endTranslatedBy = (sprite, distance) => sprite.endTranslatedBy(distance, 0);
+		} else {
+			position = (bounds) => -bounds.right;
+			startTranslatedBy = (sprite, distance) => sprite.startTranslatedBy(-distance, 0);
+			endTranslatedBy = (sprite, distance) => sprite.endTranslatedBy(-distance, 0);
+		}
+	} else {
+		size = (bounds) => bounds.height;
+		if (direction > 0) {
+			position = (bounds) => bounds.top;
+			startTranslatedBy = (sprite, distance) => sprite.startTranslatedBy(0, distance);
+			endTranslatedBy = (sprite, distance) => sprite.endTranslatedBy(0, distance);
+		} else {
+			position = (bounds) => -bounds.bottom;
+			startTranslatedBy = (sprite, distance) => sprite.startTranslatedBy(0, -distance);
+			endTranslatedBy = (sprite, distance) => sprite.endTranslatedBy(0, -distance);
+		}
+	}
+	return {
+		position,
+		size,
+		startTranslatedBy,
+		endTranslatedBy
+	};
+}
+function* moveOver(dimension, direction, context) {
+	let { position, size, startTranslatedBy, endTranslatedBy } = normalize(dimension, direction);
+	let viewport;
+	if (context.insertedSprites[0]) viewport = context.insertedSprites[0].finalBounds;
+	else if (context.keptSprites[0]) viewport = context.keptSprites[0].finalBounds;
+	else throw new Error("Unimplemented");
+	if (context.insertedSprites[0]) {
+		let offset = 0;
+		context.removedSprites.forEach((sprite) => {
+			sprite.assertHasInitialBounds();
+			let o = position(viewport) - position(sprite.initialBounds);
+			if (o > offset) offset = o;
+		});
+		let firstInserted = context.insertedSprites[0];
+		firstInserted.assertHasFinalBounds();
+		offset += size(firstInserted.finalBounds);
+		startTranslatedBy(firstInserted, -offset);
+		if (context.removedSprites[0]) {
+			endTranslatedBy(context.removedSprites[0], offset);
+			let move = new Move(context.removedSprites[0]);
+			move.run();
+			for (const removedSprite of context.removedSprites) follow(removedSprite, { source: move });
+			follow(firstInserted, { source: move });
+		} else new Move(firstInserted).run();
+	} else if (context.keptSprites[0]) {
+		const move = new Move(context.keptSprites[0]);
+		move.run();
+		context.removedSprites.forEach((sprite) => {
+			follow(sprite, { source: move });
+		});
+	} else throw new Error("Unimplemented2");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ember-provide-consume-context@0.8.0_@ember+test-helpers@5.4.3_@babel+core@7.29.7_suppor_c983a8f2d92056376342a828259aeed4/node_modules/ember-provide-consume-context/dist/components/context-consumer.js
+var context_consumer_exports = /* @__PURE__ */ __exportAll({ default: () => ContextConsumer });
+var TEMPLATE = templateFactory({
+	"id": "+KWon0be",
+	"block": "[[[18,1,[[30,0,[\"contextValue\"]]]]],[\"&default\"],[\"yield\"]]",
+	"moduleName": "/home/runner/work/boxel/boxel/node_modules/.pnpm/ember-provide-consume-context@0.8.0_@ember+test-helpers@5.4.3_@babel+core@7.29.7_suppor_c983a8f2d92056376342a828259aeed4/node_modules/ember-provide-consume-context/dist/components/context-consumer.js",
+	"isStrictMode": false
+});
+var ContextConsumer = class extends Component$1 {
+	get contextValue() {
+		if (hasContext(this, this.args.key)) return getContextValue(this, this.args.key);
+		return this.args.defaultValue;
+	}
+};
+setComponentTemplate(TEMPLATE, ContextConsumer);
+//#endregion
+//#region ../../node_modules/.pnpm/ember-provide-consume-context@0.8.0_@ember+test-helpers@5.4.3_@babel+core@7.29.7_suppor_c983a8f2d92056376342a828259aeed4/node_modules/ember-provide-consume-context/dist/components/context-provider.js
+var context_provider_exports = /* @__PURE__ */ __exportAll({ default: () => ContextProvider });
+var ContextProvider = class extends Component$1 {
+	constructor(owner, args) {
+		super(owner, args);
+		setContextMetadataOnContextProviderInstance(this, [[args.key, "value"]]);
+	}
+	get value() {
+		return this.args.value;
+	}
+};
+//#endregion
+//#region app/lib/externals.ts
+var import_flat = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = flatten;
+	flatten.flatten = flatten;
+	flatten.unflatten = unflatten;
+	function isBuffer(obj) {
+		return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+	}
+	function keyIdentity(key) {
+		return key;
+	}
+	function flatten(target, opts) {
+		opts = opts || {};
+		const delimiter = opts.delimiter || ".";
+		const maxDepth = opts.maxDepth;
+		const transformKey = opts.transformKey || keyIdentity;
+		const output = {};
+		function step(object, prev, currentDepth) {
+			currentDepth = currentDepth || 1;
+			Object.keys(object).forEach(function(key) {
+				const value = object[key];
+				const isarray = opts.safe && Array.isArray(value);
+				const type = Object.prototype.toString.call(value);
+				const isbuffer = isBuffer(value);
+				const isobject = type === "[object Object]" || type === "[object Array]";
+				const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+				if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) return step(value, newKey, currentDepth + 1);
+				output[newKey] = value;
+			});
+		}
+		step(target);
+		return output;
+	}
+	function unflatten(target, opts) {
+		opts = opts || {};
+		const delimiter = opts.delimiter || ".";
+		const overwrite = opts.overwrite || false;
+		const transformKey = opts.transformKey || keyIdentity;
+		const result = {};
+		if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") return target;
+		function getkey(key) {
+			const parsedKey = Number(key);
+			return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+		}
+		function addKeys(keyPrefix, recipient, target) {
+			return Object.keys(target).reduce(function(result, key) {
+				result[keyPrefix + delimiter + key] = target[key];
+				return result;
+			}, recipient);
+		}
+		function isEmpty(val) {
+			const type = Object.prototype.toString.call(val);
+			const isArray = type === "[object Array]";
+			const isObject = type === "[object Object]";
+			if (!val) return true;
+			else if (isArray) return !val.length;
+			else if (isObject) return !Object.keys(val).length;
+		}
+		target = Object.keys(target).reduce(function(result, key) {
+			const type = Object.prototype.toString.call(target[key]);
+			if (!(type === "[object Object]" || type === "[object Array]") || isEmpty(target[key])) {
+				result[key] = target[key];
+				return result;
+			} else return addKeys(key, result, flatten(target[key], opts));
+		}, {});
+		Object.keys(target).forEach(function(key) {
+			const split = key.split(delimiter).map(transformKey);
+			let key1 = getkey(split.shift());
+			let key2 = getkey(split[0]);
+			let recipient = result;
+			while (key2 !== void 0) {
+				if (key1 === "__proto__") return;
+				const type = Object.prototype.toString.call(recipient[key1]);
+				const isobject = type === "[object Object]" || type === "[object Array]";
+				if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") return;
+				if (overwrite && !isobject || !overwrite && recipient[key1] == null) recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+				recipient = recipient[key1];
+				if (split.length > 0) {
+					key1 = getkey(split.shift());
+					key2 = getkey(split[0]);
+				}
+			}
+			recipient[key1] = unflatten(target[key], opts);
+		});
+		return result;
+	}
+})))());
+init_md5_esm_bundler();
+function shimExternals(virtualNetwork) {
+	const windowQUnit = globalThis.QUnit;
+	virtualNetwork.shimModule("qunit", windowQUnit || {
+		module: () => {},
+		test: () => {},
+		config: {}
+	});
+	virtualNetwork.shimModule("@cardstack/runtime-common", runtime_common_exports);
+	virtualNetwork.shimModule("@cardstack/boxel-ui/components", components_exports);
+	virtualNetwork.shimModule("@cardstack/boxel-ui/helpers", helpers_exports);
+	virtualNetwork.shimModule("@cardstack/boxel-ui/icons", icons_exports);
+	virtualNetwork.shimModule("@cardstack/boxel-ui/modifiers", modifiers_exports);
+	virtualNetwork.addPackageMapping("@cardstack/boxel-ui/", `${PACKAGES_FAKE_ORIGIN}@cardstack/boxel-ui/`);
+	virtualNetwork.shimModule("@glimmer/component", dist_exports$5);
+	virtualNetwork.shimModule("@glimmer/tracking", tracking_exports);
+	virtualNetwork.shimModule("@glimmer/validator", validator_exports);
+	virtualNetwork.shimModule("@ember/component", component_exports);
+	virtualNetwork.shimModule("@ember/component/template-only", template_only_exports);
+	virtualNetwork.shimModule("@ember/destroyable", destroyable_exports);
+	virtualNetwork.shimModule("@ember/helper", helper_exports);
+	virtualNetwork.shimModule("@ember/modifier", modifier_exports);
+	virtualNetwork.shimModule("@ember/object", object_exports);
+	virtualNetwork.shimModule("@ember/object/internals", internals_exports);
+	virtualNetwork.shimModule("@ember/runloop", runloop_exports);
+	virtualNetwork.shimModule("@ember/service", service_exports);
+	virtualNetwork.shimModule("@ember/template", template_exports);
+	virtualNetwork.shimModule("@ember/template-factory", template_factory_exports);
+	virtualNetwork.shimModule("@cardstack/view-transitions", dist_exports$1);
+	virtualNetwork.shimModule("awesome-phonenumber", index_esm_exports);
+	virtualNetwork.shimModule("date-fns", esm_exports);
+	virtualNetwork.shimModule("ember-animated", dist_exports);
+	virtualNetwork.shimModule("ember-animated/easings/cosine", cosine_exports);
+	virtualNetwork.shimModule("ember-animated/easings/linear", linear_exports);
+	virtualNetwork.shimModule("ember-animated/motions/adjust-color", adjust_color_exports);
+	virtualNetwork.shimModule("ember-animated/motions/adjust-css", adjust_css_exports);
+	virtualNetwork.shimModule("ember-animated/motions/box-shadow", box_shadow_exports);
+	virtualNetwork.shimModule("ember-animated/motions/compensate-for-scale", compensate_for_scale_exports);
+	virtualNetwork.shimModule("ember-animated/motions/follow", follow_exports);
+	virtualNetwork.shimModule("ember-animated/motions/move", move_exports);
+	virtualNetwork.shimModule("ember-animated/motions/move-svg", move_svg_exports);
+	virtualNetwork.shimModule("ember-animated/motions/opacity", opacity_exports);
+	virtualNetwork.shimModule("ember-animated/motions/resize", resize_exports);
+	virtualNetwork.shimModule("ember-animated/motions/scale", scale_exports);
+	virtualNetwork.shimModule("ember-animated/transitions/fade", fade_exports);
+	virtualNetwork.shimModule("ember-animated/transitions/move-over", move_over_exports);
+	virtualNetwork.shimModule("ember-concurrency", dist_exports$8);
+	virtualNetwork.shimModule("ember-concurrency/-private/async-arrow-runtime", async_arrow_runtime_exports);
+	virtualNetwork.shimModule("ember-css-url", dist_exports$7);
+	virtualNetwork.shimModule("ember-modifier", dist_exports$6);
+	virtualNetwork.shimModule("ember-modify-based-class-resource", dist_exports$3);
+	virtualNetwork.shimModule("ember-provide-consume-context", dist_exports$9);
+	virtualNetwork.shimModule("ember-provide-consume-context/components/context-consumer", context_consumer_exports);
+	virtualNetwork.shimModule("ember-provide-consume-context/components/context-provider", context_provider_exports);
+	virtualNetwork.shimModule("ember-resources", dist_exports$2);
+	virtualNetwork.shimModule("ember-source/types", { default: class {} });
+	virtualNetwork.shimModule("ember-source/types/preview", { default: class {} });
+	virtualNetwork.shimModule("flat", import_flat);
+	virtualNetwork.shimModule("@floating-ui/dom", floating_ui_dom_exports);
+	virtualNetwork.shimModule("lodash", lodash_exports);
+	virtualNetwork.shimModule("lodash-es", lodash_exports);
+	virtualNetwork.shimModule("matrix-js-sdk", browser_index_exports);
+	virtualNetwork.shimModule("rsvp", rsvp_exports);
+	virtualNetwork.shimModule("super-fast-md5", md5_esm_bundler_exports);
+	virtualNetwork.shimModule("tracked-built-ins", dist_exports$4);
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/bxl",
+		resolve: async () => {
+			let bxl = await __vitePreload(() => import("./src-CF8jhG38.js"), __vite__mapDeps([0,1,2,3,4,5,6,7,8,9]), import.meta.url);
+			await bxl.loadAllFormulaExtensions();
+			return bxl;
+		}
+	});
+	virtualNetwork.shimModule("glimmer-motion", src_exports);
+	virtualNetwork.shimModule("glimmer-motion/layout-group", layout_group_exports);
+	virtualNetwork.shimModule("glimmer-motion/motion-config", motion_config_exports);
+	virtualNetwork.shimModule("glimmer-motion/presence", presence_exports);
+	virtualNetwork.shimModule("glimmer-motion/reorder/group", group_exports);
+	virtualNetwork.shimModule("glimmer-motion/reorder/item", item_exports);
+	virtualNetwork.shimAsyncModule({
+		id: "glimmer-motion/test-support",
+		resolve: () => __vitePreload(() => import("./test-support-CgWmpebE.js"), __vite__mapDeps([10,11,2,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo",
+		resolve: () => __vitePreload(() => import("./src-LqENIikj.js"), __vite__mapDeps([40,41,2,31,16,17,18,13,19,20,32,21,22,23,29,26,34,24,35,27,42,33,36,43,44,45,30,37,46,39,47,48,38,49,50,51]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/choreo",
+		resolve: () => __vitePreload(() => import("./choreo-Ci5dG5fv.js"), __vite__mapDeps([52,51,2,31,16,17,18,13,19,20,32,21,22,23,29,26,33,34,24,35,27,36,44,45,30,37,46,39,47,48,38,49,50,41,43]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/steps",
+		resolve: () => __vitePreload(() => import("./steps-aNa4m6PJ.js"), __vite__mapDeps([53,41,2,31,16,17,18,13,19,20,32,21,22,23,29,26,34,24,35,27]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/test-support",
+		resolve: () => __vitePreload(() => import("./test-support-QTh6wGxu.js"), __vite__mapDeps([54,11,2,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,55,45,46,43,44,47,48,49,50]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film",
+		resolve: () => __vitePreload(() => import("./film-D1E-odYG.js"), __vite__mapDeps([56,57,2,31,16,17,18,13,19,20,32,21,22,23,29,26,58,27,44,33,34,24,35,36,45,30,37,46,39,47,48,38,49,50,51,41,43,59,60,61,62,63,64,65,66,67,68,69]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/clip",
+		resolve: () => __vitePreload(() => import("./clip-CycGr0Lf.js"), __vite__mapDeps([70,57,2,31,16,17,18,13,19,20,32,21,22,23,29,26,58,27,44,33,34,24,35,36,45,30,37,46,39,47,48,38,49,50,51,41,43]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/film",
+		resolve: () => __vitePreload(() => import("./film-D25Y0ED6.js"), __vite__mapDeps([71,59,2,31,16,17,18,13,19,20,32,21,22,23,29,26,33,34,24,35,27,36,44,45,30,37,46,39,47,48,38,49,50,41,51,43,57,58,60,61,62,63,64,65,66,67,68]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/graph/adjust",
+		resolve: () => __vitePreload(() => import("./adjust-tbcBqG-n.js"), __vite__mapDeps([72,61,2,62,31,16,17,18,13,19,20,32,21,22,23,29,26,34,24,35,27]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/graph/host",
+		resolve: () => __vitePreload(() => import("./host-DMN-E78f.js"), __vite__mapDeps([73,60,2,31,16,17,18,13,19,20,32,21,22,23,29,26,34,24,35,27,61,62]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/graph/nodes",
+		resolve: () => __vitePreload(() => import("./nodes-Cb9jGNmV.js"), __vite__mapDeps([74,62,2,31,16,17,18,13,19,20,32,21,22,23,29,26,34,24,35,27]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/joins",
+		resolve: () => __vitePreload(() => import("./joins-CFhtaZ7U.js"), __vite__mapDeps([75,63,2,31,16,17,18,13,19,20,32,21,22,23,29,26,34,24,35,27]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/overlays",
+		resolve: () => __vitePreload(() => import("./overlays-COinwHCP.js"), __vite__mapDeps([76,64,2,31,16,17,18,13,19,20,32,21,22,23,29,26,35,27,44,33,34,24,36,45,30,37,46,39,47,48,38,49,50,51,41,43]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/picture",
+		resolve: () => __vitePreload(() => import("./picture-CPj4Wgsy.js"), __vite__mapDeps([77,69,2,31,16,17,18,13,19,20,32,21,22,23,29,26,34,24,35,27,61,62]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/plate",
+		resolve: () => __vitePreload(() => import("./plate-DeoQd99m.js"), __vite__mapDeps([78,65,2,31,16,17,18,13,19,20,32,21,22,23,29,26,58,27,44,33,34,24,35,36,45,30,37,46,39,47,48,38,49,50,51,41,43]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/player",
+		resolve: () => __vitePreload(() => import("./player-BvXGBItd.js"), __vite__mapDeps([79,66,2,31,16,17,18,13,19,20,32,21,22,23,29,26,58,35,27,44,33,34,24,36,45,30,37,46,39,47,48,38,49,50,51,41,43]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/rail",
+		resolve: () => __vitePreload(() => import("./rail-CFPU0tFe.js"), __vite__mapDeps([80,67,2,31,16,17,18,13,19,20,32,21,22,23,29,26,58,35,27]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo/film/titles",
+		resolve: () => __vitePreload(() => import("./titles-DKHNLVwC.js"), __vite__mapDeps([81,68,2,31,16,17,18,13,19,20,32,21,22,23,29,26,27,44,33,34,24,35,36,45,30,37,46,39,47,48,38,49,50,51,41,43]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/choreo-player",
+		resolve: () => __vitePreload(() => import("./src-DOKnNfG8.js"), __vite__mapDeps([82,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "dialkit/store",
+		resolve: () => __vitePreload(() => import("./store-tDubGN_j.js"), __vite__mapDeps([83,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "dialkit/vanilla",
+		resolve: () => __vitePreload(() => import("./vanilla-BA1BUPFM.js"), __vite__mapDeps([84,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@chenglou/pretext",
+		resolve: () => __vitePreload(() => import("./layout-DVAINTLP.js"), __vite__mapDeps([85,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "ethers",
+		resolve: () => __vitePreload(() => import("./lib.esm-CdDCG-7Y.js"), __vite__mapDeps([86,87,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "pdfjs-dist",
+		resolve: () => __vitePreload(() => import("./pdfjs-tq21NQBp.js"), __vite__mapDeps([88,2,3]), import.meta.url)
+	});
+	virtualNetwork.shimModule("@cardstack/boxel-host/lib/pdfjs-loader", pdfjs_loader_exports);
+	virtualNetwork.shimModule("@cardstack/boxel-host/lib/signed-capture", signed_capture_exports);
+	virtualNetwork.shimModule("@cardstack/boxel-host/lib/three-loader", three_loader_exports);
+	virtualNetwork.shimAsyncModule({
+		id: "uuid",
+		resolve: () => __vitePreload(() => import("./esm-browser-ByMIQXWT.js"), __vite__mapDeps([89,90,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "yaml",
+		resolve: () => __vitePreload(() => import("./browser-ZN0_uldJ.js"), __vite__mapDeps([91,92,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "fflate",
+		resolve: () => __vitePreload(() => import("./browser-BpGk2ZmZ.js"), __vite__mapDeps([93,94,2]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/runtime-common/constants",
+		resolve: () => __vitePreload(() => import("./constants-WFA0gSYM.js"), __vite__mapDeps([95,96,2,97]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/runtime-common/marked-sync",
+		resolve: () => __vitePreload(() => import("./marked-sync-BCLGl4e-.js"), __vite__mapDeps([98,99,2,3,100,97,96,101,102]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/runtime-common/bfm-card-references",
+		resolve: () => __vitePreload(() => import("./bfm-card-references-DiydFUNR.js"), __vite__mapDeps([103,100,2,97]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/runtime-common/helpers/ai",
+		resolve: () => __vitePreload(() => import("./ai-Cs1uTbhS.js"), __vite__mapDeps([104,105,2,96,97]), import.meta.url)
+	});
+	virtualNetwork.shimAsyncModule({
+		id: "@cardstack/runtime-common/helpers/card-directory-name",
+		resolve: () => __vitePreload(() => import("./card-directory-name-BwTPYMCb.js"), __vite__mapDeps([106,107,2,3,87,108,109,110,111,112,113,90,92,100,97,96,101,102,105,114]), import.meta.url)
+	});
+	shimModulesForLiveTests(virtualNetwork);
+	virtualNetwork.shimModule("@cardstack/host/services/store", fallbackShim({ default: class {} }));
+	shimHostTools(virtualNetwork);
+}
+function shimModulesForLiveTests(virtualNetwork) {
+	virtualNetwork.shimModule("@ember/test-helpers", dist_exports$10);
+	virtualNetwork.shimModule("@cardstack/host/tests/helpers", fallbackShim());
+	virtualNetwork.shimModule("@cardstack/host/tests/helpers/mock-matrix", fallbackShim());
+	virtualNetwork.shimModule("@cardstack/host/tests/helpers/setup", fallbackShim());
+	virtualNetwork.shimModule("@cardstack/host/tests/helpers/adapter", fallbackShim());
+	virtualNetwork.shimModule("@cardstack/host/tests/helpers/render-component", fallbackShim());
+	virtualNetwork.shimModule("@cardstack/host/tests/helpers/base-realm", fallbackShim());
+	virtualNetwork.shimModule("@universal-ember/test-support", fallbackShim());
+	virtualNetwork.shimModule("@ember/owner", fallbackShim());
+	virtualNetwork.shimModule("@cardstack/host/config/environment", fallbackShim());
+}
+//#endregion
+export { microwait as a, allSettled as i, task as n, rAF as o, afterRender as r, shimExternals as t };