/**
 * The `open` and `state` entrance triggers (Spec 38A §5.2, §8, §9, §12; FR-38A-51 and FR-38A-53 enablers).
 *
 * Loaded after `motion.css` (its keyframes, registered properties and channel formulas) and only on a page whose
 * rendered blocks print an entrance with trigger `open` or `state` (`Sgs_Motion_Trigger_Open_State`). Every rule
 * keys on ONE attribute, `data-sgs-motion-state`, which a block's script sets through `@sgs/motion-state`
 * (`src/shared/effects/motion-state.js`) on a state host: the target itself or an ancestor.
 *
 *   data-sgs-me="open <channels>"      a part a disclosure opens (renderer)
 *   data-sgs-me="state <channels>"     a part that plays on a named block state (renderer)
 *   --sgs-me-close-to-<x>              the close to-values (renderer, per device; each falls back to the from-value)
 *   --sgs-me-to-bg, --sgs-me-to-fg, --sgs-me-to-bd
 *                                      the colour to-values (renderer, once for every device): the background, text and
 *                                      border colour an open or state entrance changes to. The renderer's per-instance
 *                                      rules read them into background-color, color and border-color while the state is
 *                                      on (Sgs_Motion_Trigger_Open_State); the colour changes at once.
 *   --sgs-me-close-dur, --sgs-me-close-delay, --sgs-me-close-ease
 *                                      the close timing (renderer, per device; the close delay is per item)
 *   --sgs-me-loop-close-delay          a loop item's close delay, inheriting, for the entrances inside the item
 *   --sgs-mt-on                        1 while a named state is on, set by the renderer's per-instance rule
 *                                      `<target>:is([data-sgs-motion-state~="<name>"], [data-sgs-motion-state~="<name>"] *)`
 *   data-sgs-dir="forward|back"        the direction of a step change, set by the owning block's script on the state
 *                                      host next to the `step-changed` state. Under `back` a two-value `state`
 *                                      entrance plays its horizontal from-value mirrored (a step slides in from the
 *                                      other side). A multi-keyframe entrance (the WAAPI module) is never mirrored.
 *
 * Open plays the entrance from its from-values to its to-values and holds the to-values while open (a caret stays
 * turned). Close plays from the to-values to the close to-values on the close duration, easing and per-item delay,
 * and holds them. A nested host that is neither open nor closing shields its subtree, so a closed submenu inside an
 * open drawer does not play. Under reduced motion nothing plays and every delay is zero: each state shows its final
 * values at once.
 */

/* ── Per-element inputs (Spec 38A §10): the close values and timing, the named-state flag and the held values belong to
   the element that carries them and never inherit, the same rule as motion.css's entrance inputs; the universal syntax
   with no initial value keeps each var() fallback below. A loop item's close delay reaches the entrances inside the item
   through the inheriting carrier --sgs-me-loop-close-delay. ── */
@property --sgs-me-close-to-tx { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-ty { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-rot { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-rx { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-ry { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-s { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-sx { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-sy { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-op { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-blur { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-clip { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-clip-t { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-clip-r { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-clip-b { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-clip-l { syntax: '*'; inherits: false; }
@property --sgs-me-close-to-clip-round { syntax: '*'; inherits: false; }
@property --sgs-me-to-bg { syntax: '*'; inherits: false; }
@property --sgs-me-to-fg { syntax: '*'; inherits: false; }
@property --sgs-me-to-bd { syntax: '*'; inherits: false; }
@property --sgs-me-close-dur { syntax: '*'; inherits: false; }
@property --sgs-me-close-delay { syntax: '*'; inherits: false; }
@property --sgs-me-close-ease { syntax: '*'; inherits: false; }
@property --sgs-mt-on { syntax: '*'; inherits: false; }
@property --sgs-mt-op-tx { syntax: '*'; inherits: false; }
@property --sgs-mt-op-ty { syntax: '*'; inherits: false; }
@property --sgs-mt-op-rot { syntax: '*'; inherits: false; }
@property --sgs-mt-op-rx { syntax: '*'; inherits: false; }
@property --sgs-mt-op-ry { syntax: '*'; inherits: false; }
@property --sgs-mt-op-s { syntax: '*'; inherits: false; }
@property --sgs-mt-op-sx { syntax: '*'; inherits: false; }
@property --sgs-mt-op-sy { syntax: '*'; inherits: false; }
@property --sgs-mt-op-op { syntax: '*'; inherits: false; }
@property --sgs-mt-op-blur { syntax: '*'; inherits: false; }
@property --sgs-mt-op-clip-t { syntax: '*'; inherits: false; }
@property --sgs-mt-op-clip-r { syntax: '*'; inherits: false; }
@property --sgs-mt-op-clip-b { syntax: '*'; inherits: false; }
@property --sgs-mt-op-clip-l { syntax: '*'; inherits: false; }
@property --sgs-mt-op-clip-round { syntax: '*'; inherits: false; }

/* ── Keyframes: close, from the open to-values to the close to-values (each falling back to the from-value). Every
   keyframe declares its channel with the full §10 composite formula, as the entrance keyframes in motion.css do. ── */
@keyframes sgs-me-close-translate {
	from {
		--sgs-me-tx: var(--sgs-me-to-tx, 0px);
		--sgs-me-ty: var(--sgs-me-to-ty, 0px);
		translate: calc(var(--sgs-me-tx) + var(--sgs-mh-tx) + var(--sgs-mag-x) + var(--sgs-plx-x) + var(--sgs-float-x) + var(--sgs-kb-x)) calc(var(--sgs-me-ty) + var(--sgs-mh-ty) + var(--sgs-mag-y) + var(--sgs-plx-y) + var(--sgs-float-y) + var(--sgs-kb-y));
	}
	to {
		--sgs-me-tx: var(--sgs-me-close-to-tx, var(--sgs-me-from-tx, 0px));
		--sgs-me-ty: var(--sgs-me-close-to-ty, var(--sgs-me-from-ty, 0px));
		translate: calc(var(--sgs-me-tx) + var(--sgs-mh-tx) + var(--sgs-mag-x) + var(--sgs-plx-x) + var(--sgs-float-x) + var(--sgs-kb-x)) calc(var(--sgs-me-ty) + var(--sgs-mh-ty) + var(--sgs-mag-y) + var(--sgs-plx-y) + var(--sgs-float-y) + var(--sgs-kb-y));
	}
}
@keyframes sgs-me-close-rotate {
	from {
		--sgs-me-rot: var(--sgs-me-to-rot, 0deg);
		rotate: calc(var(--sgs-rot-rest) + var(--sgs-me-rot) + var(--sgs-mh-rot) + var(--sgs-svl-rot));
	}
	to {
		--sgs-me-rot: var(--sgs-me-close-to-rot, var(--sgs-me-from-rot, 0deg));
		rotate: calc(var(--sgs-rot-rest) + var(--sgs-me-rot) + var(--sgs-mh-rot) + var(--sgs-svl-rot));
	}
}
@keyframes sgs-me-close-transform {
	from {
		--sgs-me-rx: var(--sgs-me-to-rx, 0deg);
		--sgs-me-ry: var(--sgs-me-to-ry, 0deg);
		transform: perspective(var(--sgs-persp-self)) rotateX(calc(var(--sgs-rx-rest) + var(--sgs-me-rx) + var(--sgs-mh-rx) + var(--sgs-tilt-x))) rotateY(calc(var(--sgs-ry-rest) + var(--sgs-me-ry) + var(--sgs-mh-ry) + var(--sgs-tilt-y)));
	}
	to {
		--sgs-me-rx: var(--sgs-me-from-rx, 0deg);
		--sgs-me-ry: var(--sgs-me-from-ry, 0deg);
		transform: perspective(var(--sgs-persp-self)) rotateX(calc(var(--sgs-rx-rest) + var(--sgs-me-rx) + var(--sgs-mh-rx) + var(--sgs-tilt-x))) rotateY(calc(var(--sgs-ry-rest) + var(--sgs-me-ry) + var(--sgs-mh-ry) + var(--sgs-tilt-y)));
	}
}
@keyframes sgs-me-close-scale {
	from {
		--sgs-me-s: var(--sgs-me-to-s, 1);
		--sgs-me-sx: var(--sgs-me-to-sx, 1);
		--sgs-me-sy: var(--sgs-me-to-sy, 1);
		scale: calc(var(--sgs-me-s) * var(--sgs-mh-s) * var(--sgs-focus-s) * var(--sgs-kb-s) * var(--sgs-float-s) * var(--sgs-svl-s) * var(--sgs-sp-x) * var(--sgs-me-sx)) calc(var(--sgs-me-s) * var(--sgs-mh-s) * var(--sgs-focus-s) * var(--sgs-kb-s) * var(--sgs-float-s) * var(--sgs-svl-s) * var(--sgs-sp-y) * var(--sgs-me-sy));
	}
	to {
		--sgs-me-s: var(--sgs-me-close-to-s, var(--sgs-me-from-s, 1));
		--sgs-me-sx: var(--sgs-me-close-to-sx, var(--sgs-me-from-sx, 1));
		--sgs-me-sy: var(--sgs-me-close-to-sy, var(--sgs-me-from-sy, 1));
		scale: calc(var(--sgs-me-s) * var(--sgs-mh-s) * var(--sgs-focus-s) * var(--sgs-kb-s) * var(--sgs-float-s) * var(--sgs-svl-s) * var(--sgs-sp-x) * var(--sgs-me-sx)) calc(var(--sgs-me-s) * var(--sgs-mh-s) * var(--sgs-focus-s) * var(--sgs-kb-s) * var(--sgs-float-s) * var(--sgs-svl-s) * var(--sgs-sp-y) * var(--sgs-me-sy));
	}
}
@keyframes sgs-me-close-opacity {
	from {
		--sgs-me-op: var(--sgs-me-to-op, 1);
		opacity: calc(var(--sgs-me-op) * var(--sgs-mh-op) * var(--sgs-focus-op) * var(--sgs-svl-op));
	}
	to {
		--sgs-me-op: var(--sgs-me-close-to-op, var(--sgs-me-from-op, 1));
		opacity: calc(var(--sgs-me-op) * var(--sgs-mh-op) * var(--sgs-focus-op) * var(--sgs-svl-op));
	}
}
@keyframes sgs-me-close-filter {
	from {
		--sgs-me-blur: var(--sgs-me-to-blur, 0px);
		filter: blur(calc(var(--sgs-me-blur) + var(--sgs-mh-blur))) grayscale(calc(var(--sgs-gray-rest) + var(--sgs-mh-gray))) brightness(var(--sgs-mh-bright));
	}
	to {
		--sgs-me-blur: var(--sgs-me-close-to-blur, var(--sgs-me-from-blur, 0px));
		filter: blur(calc(var(--sgs-me-blur) + var(--sgs-mh-blur))) grayscale(calc(var(--sgs-gray-rest) + var(--sgs-mh-gray))) brightness(var(--sgs-mh-bright));
	}
}
/* The clip reveal closes per edge: from each edge's open to-value to that edge's close amount (a one-edge wipe's
   `--sgs-me-close-to-clip-<t|r|b|l>`, written by Sgs_Motion_Clip_Edge::close), else the uniform close amount, else that
   edge's from-value (a wipe with no close value closes back the way it opened). */
@keyframes sgs-me-close-clip-path {
	from {
		--sgs-me-clip-t: var(--sgs-me-to-clip-t, var(--sgs-me-to-clip, 0%));
		--sgs-me-clip-r: var(--sgs-me-to-clip-r, var(--sgs-me-to-clip, 0%));
		--sgs-me-clip-b: var(--sgs-me-to-clip-b, var(--sgs-me-to-clip, 0%));
		--sgs-me-clip-l: var(--sgs-me-to-clip-l, var(--sgs-me-to-clip, 0%));
		--sgs-me-clip-round: var(--sgs-me-to-clip-round, 0px);
		clip-path: inset(var(--sgs-me-clip-t) var(--sgs-me-clip-r) var(--sgs-me-clip-b) var(--sgs-me-clip-l) round var(--sgs-me-clip-round));
	}
	to {
		--sgs-me-clip-t: var(--sgs-me-close-to-clip-t, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-t, var(--sgs-me-from-clip, 0%))));
		--sgs-me-clip-r: var(--sgs-me-close-to-clip-r, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-r, var(--sgs-me-from-clip, 0%))));
		--sgs-me-clip-b: var(--sgs-me-close-to-clip-b, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-b, var(--sgs-me-from-clip, 0%))));
		--sgs-me-clip-l: var(--sgs-me-close-to-clip-l, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-l, var(--sgs-me-from-clip, 0%))));
		--sgs-me-clip-round: var(--sgs-me-close-to-clip-round, var(--sgs-me-from-clip-round, 0px));
		clip-path: inset(var(--sgs-me-clip-t) var(--sgs-me-clip-r) var(--sgs-me-clip-b) var(--sgs-me-clip-l) round var(--sgs-me-clip-round));
	}
}

/* ── Keyframes: a state entrance under a `back` step direction, the horizontal from-value mirrored. ── */
@keyframes sgs-mt-translate-back {
	from {
		--sgs-me-tx: calc(var(--sgs-me-from-tx, 0px) * -1);
		--sgs-me-ty: var(--sgs-me-from-ty, 0px);
		translate: calc(var(--sgs-me-tx) + var(--sgs-mh-tx) + var(--sgs-mag-x) + var(--sgs-plx-x) + var(--sgs-float-x) + var(--sgs-kb-x)) calc(var(--sgs-me-ty) + var(--sgs-mh-ty) + var(--sgs-mag-y) + var(--sgs-plx-y) + var(--sgs-float-y) + var(--sgs-kb-y));
	}
	to {
		--sgs-me-tx: var(--sgs-me-to-tx, 0px);
		--sgs-me-ty: var(--sgs-me-to-ty, 0px);
		translate: calc(var(--sgs-me-tx) + var(--sgs-mh-tx) + var(--sgs-mag-x) + var(--sgs-plx-x) + var(--sgs-float-x) + var(--sgs-kb-x)) calc(var(--sgs-me-ty) + var(--sgs-mh-ty) + var(--sgs-mag-y) + var(--sgs-plx-y) + var(--sgs-float-y) + var(--sgs-kb-y));
	}
}

@media (prefers-reduced-motion: no-preference) {
	/* The name lists: the opening list reuses motion.css's per-channel entrance names; the close list is its twin. An `open`
	   entrance plays it when its host closes; a `state` entrance with stored close values plays it under `<name>-out`
	   (the per-instance rule `Sgs_Motion_Trigger_Open_State` prints). */
	:is([data-sgs-me~="open"], [data-sgs-me~="state"]) {
		--sgs-mt-c-translate: none;
		--sgs-mt-c-rotate: none;
		--sgs-mt-c-transform: none;
		--sgs-mt-c-scale: none;
		--sgs-mt-c-opacity: none;
		--sgs-mt-c-filter: none;
		--sgs-mt-c-clip-path: none;
		--sgs-mt-in: var(--sgs-me-a-list-name);
		--sgs-mt-out: var(--sgs-base-animation-name, none), var(--sgs-mt-c-translate), var(--sgs-mt-c-rotate), var(--sgs-mt-c-transform), var(--sgs-mt-c-scale), var(--sgs-mt-c-opacity), var(--sgs-mt-c-filter), var(--sgs-mt-c-clip-path);
		--sgs-me-a-fill: both;
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="translate"] { --sgs-mt-c-translate: sgs-me-close-translate; }
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="rotate"] { --sgs-mt-c-rotate: sgs-me-close-rotate; }
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="transform"] { --sgs-mt-c-transform: sgs-me-close-transform; }
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="scale"] { --sgs-mt-c-scale: sgs-me-close-scale; }
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="opacity"] { --sgs-mt-c-opacity: sgs-me-close-opacity; }
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="filter"] { --sgs-mt-c-filter: sgs-me-close-filter; }
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="clip-path"] { --sgs-mt-c-clip-path: sgs-me-close-clip-path; }

	/* A step change backwards: the state entrance's translate plays mirrored (on the host or inside it). */
	[data-sgs-me~="state"][data-sgs-me~="translate"]:not([data-sgs-me-keyframes]):is([data-sgs-dir="back"], [data-sgs-dir="back"] *) {
		--sgs-me-a-translate: sgs-mt-translate-back;
	}

	/* Open: inside (or on) an open host, and inside no host that is not open. A multi-keyframe entrance belongs to the
	   WAAPI module, as in motion.css. */
	[data-sgs-me~="open"]:not([data-sgs-me-keyframes]):is([data-sgs-motion-state~="open"], [data-sgs-motion-state~="open"] *):not([data-sgs-motion-state]:not([data-sgs-motion-state~="open"]), [data-sgs-motion-state]:not([data-sgs-motion-state~="open"]) *) {
		animation-name: var(--sgs-mt-in, none);
		animation-duration: var(--sgs-me-a-list-duration);
		animation-timing-function: var(--sgs-me-a-list-timing-function);
		animation-delay: var(--sgs-me-a-list-delay);
		animation-iteration-count: var(--sgs-me-a-list-iteration-count);
		animation-direction: var(--sgs-me-a-list-direction);
		animation-fill-mode: var(--sgs-me-a-list-fill-mode);
		animation-timeline: var(--sgs-me-a-list-timeline);
	}

	/* Close: inside (or on) a closing host, and inside no host that is neither open nor closing. */
	[data-sgs-me~="open"]:not([data-sgs-me-keyframes]):is([data-sgs-motion-state~="close"], [data-sgs-motion-state~="close"] *):not([data-sgs-motion-state]:not([data-sgs-motion-state~="open"]):not([data-sgs-motion-state~="close"]), [data-sgs-motion-state]:not([data-sgs-motion-state~="open"]):not([data-sgs-motion-state~="close"]) *) {
		--sgs-me-a-dur: var(--sgs-me-close-dur, var(--sgs-me-dur, var(--wp--custom--duration--slow, 450ms)));
		--sgs-me-a-ease: var(--sgs-me-close-ease, var(--sgs-me-ease, var(--wp--custom--entrance--easing, ease-out)));
		--sgs-me-a-delay: var(--sgs-me-close-delay, var(--sgs-me-loop-close-delay, 0ms));
		animation-name: var(--sgs-mt-out, none);
		animation-duration: var(--sgs-me-a-list-duration);
		animation-timing-function: var(--sgs-me-a-list-timing-function);
		animation-delay: var(--sgs-me-a-list-delay);
		animation-iteration-count: var(--sgs-me-a-list-iteration-count);
		animation-direction: var(--sgs-me-a-list-direction);
		animation-fill-mode: var(--sgs-me-a-list-fill-mode);
		animation-timeline: var(--sgs-me-a-list-timeline);
	}

	/* State: the per-instance rule (Sgs_Motion_Trigger_Open_State, and the canvas twin) writes only the animation name
	   while its named state is on; the longhands sit here, under any state host, so the entrance's own timing wins over
	   any class the element carries. Outside its named state the name list is the base animation alone, and these
	   lists start with the base animation's own positions, so it runs unchanged. */
	[data-sgs-me~="state"]:not([data-sgs-me-keyframes]):is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		animation-duration: var(--sgs-me-a-list-duration);
		animation-timing-function: var(--sgs-me-a-list-timing-function);
		animation-delay: var(--sgs-me-a-list-delay);
		animation-iteration-count: var(--sgs-me-a-list-iteration-count);
		animation-direction: var(--sgs-me-a-list-direction);
		animation-fill-mode: var(--sgs-me-a-list-fill-mode);
		animation-timeline: var(--sgs-me-a-list-timeline);
	}
}

/* ── Reduced motion (§12, FR-38A-27): no animation, no delay; each state shows its final values at once. ── */
@media (prefers-reduced-motion: reduce) {
	[data-sgs-me~="open"]:is([data-sgs-motion-state~="open"], [data-sgs-motion-state~="open"] *):not([data-sgs-motion-state]:not([data-sgs-motion-state~="open"]), [data-sgs-motion-state]:not([data-sgs-motion-state~="open"]) *) {
		--sgs-mt-op-tx: var(--sgs-me-to-tx, 0px);
		--sgs-mt-op-ty: var(--sgs-me-to-ty, 0px);
		--sgs-mt-op-rot: var(--sgs-me-to-rot, 0deg);
		--sgs-mt-op-rx: var(--sgs-me-to-rx, 0deg);
		--sgs-mt-op-ry: var(--sgs-me-to-ry, 0deg);
		--sgs-mt-op-s: var(--sgs-me-to-s, 1);
		--sgs-mt-op-sx: var(--sgs-me-to-sx, 1);
		--sgs-mt-op-sy: var(--sgs-me-to-sy, 1);
		--sgs-mt-op-op: var(--sgs-me-to-op, 1);
		--sgs-mt-op-blur: var(--sgs-me-to-blur, 0px);
		--sgs-mt-op-clip-t: var(--sgs-me-to-clip-t, var(--sgs-me-to-clip, 0%));
		--sgs-mt-op-clip-r: var(--sgs-me-to-clip-r, var(--sgs-me-to-clip, 0%));
		--sgs-mt-op-clip-b: var(--sgs-me-to-clip-b, var(--sgs-me-to-clip, 0%));
		--sgs-mt-op-clip-l: var(--sgs-me-to-clip-l, var(--sgs-me-to-clip, 0%));
		--sgs-mt-op-clip-round: var(--sgs-me-to-clip-round, 0px);
	}
	[data-sgs-me~="open"]:is([data-sgs-motion-state~="close"], [data-sgs-motion-state~="close"] *):not([data-sgs-motion-state]:not([data-sgs-motion-state~="open"]):not([data-sgs-motion-state~="close"]), [data-sgs-motion-state]:not([data-sgs-motion-state~="open"]):not([data-sgs-motion-state~="close"]) *) {
		--sgs-mt-op-tx: var(--sgs-me-close-to-tx, var(--sgs-me-from-tx, 0px));
		--sgs-mt-op-ty: var(--sgs-me-close-to-ty, var(--sgs-me-from-ty, 0px));
		--sgs-mt-op-rot: var(--sgs-me-close-to-rot, var(--sgs-me-from-rot, 0deg));
		--sgs-mt-op-rx: var(--sgs-me-from-rx, 0deg);
		--sgs-mt-op-ry: var(--sgs-me-from-ry, 0deg);
		--sgs-mt-op-s: var(--sgs-me-close-to-s, var(--sgs-me-from-s, 1));
		--sgs-mt-op-sx: var(--sgs-me-close-to-sx, var(--sgs-me-from-sx, 1));
		--sgs-mt-op-sy: var(--sgs-me-close-to-sy, var(--sgs-me-from-sy, 1));
		--sgs-mt-op-op: var(--sgs-me-close-to-op, var(--sgs-me-from-op, 1));
		--sgs-mt-op-blur: var(--sgs-me-close-to-blur, var(--sgs-me-from-blur, 0px));
		--sgs-mt-op-clip-t: var(--sgs-me-close-to-clip-t, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-t, var(--sgs-me-from-clip, 0%))));
		--sgs-mt-op-clip-r: var(--sgs-me-close-to-clip-r, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-r, var(--sgs-me-from-clip, 0%))));
		--sgs-mt-op-clip-b: var(--sgs-me-close-to-clip-b, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-b, var(--sgs-me-from-clip, 0%))));
		--sgs-mt-op-clip-l: var(--sgs-me-close-to-clip-l, var(--sgs-me-close-to-clip, var(--sgs-me-from-clip-l, var(--sgs-me-from-clip, 0%))));
		--sgs-mt-op-clip-round: var(--sgs-me-close-to-clip-round, var(--sgs-me-from-clip-round, 0px));
	}
	/* A named state: the to-values times the per-instance on flag, so the declaration is the identity while off. */
	[data-sgs-me~="state"] {
		--sgs-mt-op-tx: calc(var(--sgs-me-to-tx, 0px) * var(--sgs-mt-on, 0));
		--sgs-mt-op-ty: calc(var(--sgs-me-to-ty, 0px) * var(--sgs-mt-on, 0));
		--sgs-mt-op-rot: calc(var(--sgs-me-to-rot, 0deg) * var(--sgs-mt-on, 0));
		--sgs-mt-op-rx: calc(var(--sgs-me-to-rx, 0deg) * var(--sgs-mt-on, 0));
		--sgs-mt-op-ry: calc(var(--sgs-me-to-ry, 0deg) * var(--sgs-mt-on, 0));
		--sgs-mt-op-s: calc(1 + (var(--sgs-me-to-s, 1) - 1) * var(--sgs-mt-on, 0));
		--sgs-mt-op-sx: calc(1 + (var(--sgs-me-to-sx, 1) - 1) * var(--sgs-mt-on, 0));
		--sgs-mt-op-sy: calc(1 + (var(--sgs-me-to-sy, 1) - 1) * var(--sgs-mt-on, 0));
		--sgs-mt-op-op: calc(1 + (var(--sgs-me-to-op, 1) - 1) * var(--sgs-mt-on, 0));
		--sgs-mt-op-blur: calc(var(--sgs-me-to-blur, 0px) * var(--sgs-mt-on, 0));
		--sgs-mt-op-clip-t: calc(var(--sgs-me-to-clip-t, var(--sgs-me-to-clip, 0%)) * var(--sgs-mt-on, 0));
		--sgs-mt-op-clip-r: calc(var(--sgs-me-to-clip-r, var(--sgs-me-to-clip, 0%)) * var(--sgs-mt-on, 0));
		--sgs-mt-op-clip-b: calc(var(--sgs-me-to-clip-b, var(--sgs-me-to-clip, 0%)) * var(--sgs-mt-on, 0));
		--sgs-mt-op-clip-l: calc(var(--sgs-me-to-clip-l, var(--sgs-me-to-clip, 0%)) * var(--sgs-mt-on, 0));
		--sgs-mt-op-clip-round: calc(var(--sgs-me-to-clip-round, 0px) * var(--sgs-mt-on, 0));
	}

	/* The held values feed each touched channel's composite formula only where an open, closing or state value
	   applies (the --sgs-mt-op-* holders exist only there). */
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="translate"] {
		--sgs-me-tx: var(--sgs-mt-op-tx, 0px);
		--sgs-me-ty: var(--sgs-mt-op-ty, 0px);
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="rotate"] {
		--sgs-me-rot: var(--sgs-mt-op-rot, 0deg);
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="transform"] {
		--sgs-me-rx: var(--sgs-mt-op-rx, 0deg);
		--sgs-me-ry: var(--sgs-mt-op-ry, 0deg);
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="scale"] {
		--sgs-me-s: var(--sgs-mt-op-s, 1);
		--sgs-me-sx: var(--sgs-mt-op-sx, 1);
		--sgs-me-sy: var(--sgs-mt-op-sy, 1);
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="opacity"] {
		--sgs-me-op: var(--sgs-mt-op-op, 1);
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="filter"] {
		--sgs-me-blur: var(--sgs-mt-op-blur, 0px);
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="clip-path"] {
		--sgs-me-clip-t: var(--sgs-mt-op-clip-t, 0%);
		--sgs-me-clip-r: var(--sgs-mt-op-clip-r, 0%);
		--sgs-me-clip-b: var(--sgs-mt-op-clip-b, 0%);
		--sgs-me-clip-l: var(--sgs-mt-op-clip-l, 0%);
		--sgs-me-clip-round: var(--sgs-mt-op-clip-round, 0px);
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="translate"]:is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		translate: calc(var(--sgs-me-tx) + var(--sgs-mh-tx) + var(--sgs-mag-x) + var(--sgs-plx-x) + var(--sgs-float-x) + var(--sgs-kb-x)) calc(var(--sgs-me-ty) + var(--sgs-mh-ty) + var(--sgs-mag-y) + var(--sgs-plx-y) + var(--sgs-float-y) + var(--sgs-kb-y));
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="rotate"]:is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		rotate: calc(var(--sgs-rot-rest) + var(--sgs-me-rot) + var(--sgs-mh-rot) + var(--sgs-svl-rot));
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="transform"]:is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		transform: perspective(var(--sgs-persp-self)) rotateX(calc(var(--sgs-rx-rest) + var(--sgs-me-rx) + var(--sgs-mh-rx) + var(--sgs-tilt-x))) rotateY(calc(var(--sgs-ry-rest) + var(--sgs-me-ry) + var(--sgs-mh-ry) + var(--sgs-tilt-y)));
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="scale"]:is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		scale: calc(var(--sgs-me-s) * var(--sgs-mh-s) * var(--sgs-focus-s) * var(--sgs-kb-s) * var(--sgs-float-s) * var(--sgs-svl-s) * var(--sgs-sp-x) * var(--sgs-me-sx)) calc(var(--sgs-me-s) * var(--sgs-mh-s) * var(--sgs-focus-s) * var(--sgs-kb-s) * var(--sgs-float-s) * var(--sgs-svl-s) * var(--sgs-sp-y) * var(--sgs-me-sy));
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="opacity"]:is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		opacity: calc(var(--sgs-me-op) * var(--sgs-mh-op) * var(--sgs-focus-op) * var(--sgs-svl-op));
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="filter"]:is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		filter: blur(calc(var(--sgs-me-blur) + var(--sgs-mh-blur))) grayscale(calc(var(--sgs-gray-rest) + var(--sgs-mh-gray))) brightness(var(--sgs-mh-bright));
	}
	:is([data-sgs-me~="open"], [data-sgs-me~="state"])[data-sgs-me~="clip-path"]:is([data-sgs-motion-state], [data-sgs-motion-state] *) {
		clip-path: inset(var(--sgs-me-clip-t) var(--sgs-me-clip-r) var(--sgs-me-clip-b) var(--sgs-me-clip-l) round var(--sgs-me-clip-round));
	}
}