@moku-labs/game 0.0.1 → 0.0.2

package/dist/visual-BDUHSRvf.mjs

@@ -0,0 +1,734 @@
+//#region src/plugins/world/ecs/define.ts
+/**
+* Declares a component type. The defaults give the TypeScript type, the JSON shape and the
+* inspector schema; the name is the storage key and the key of `motion.change`.
+*
+* @param name - Storage name, unique per world.
+* @param defaults - Every field with its default value. Plain JSON only.
+* @param options - The fields a plugin owns: a projection view neither writes nor corrects them.
+* @param options.owned - Names of the owned fields.
+* @returns A callable component type.
+* @example
+* ```ts
+* const Item = component("Item", { kind: "", level: 1 });
+* Item({ level: 2 }); // { type: Item, value: { kind: "", level: 2 } }
+* Item({ level: 2 }).type.componentName; // "Item", the storage key
+*
+* // A caption whose drawn string is written by the plugin that draws it.
+* const Caption = component("Caption", { text: "", shown: "" }, { owned: ["shown"] });
+* Caption.owned; // ["shown"]
+* ```
+*/
+function component(name, defaults, options = {}) {
+	const frozenDefaults = Object.freeze({ ...defaults });
+	const make = (patch) => Object.freeze({
+		type: componentType,
+		value: Object.freeze({
+			...frozenDefaults,
+			...patch
+		})
+	});
+	const componentType = Object.assign(make, {
+		componentName: name,
+		defaults: frozenDefaults,
+		kind: "component",
+		owned: Object.freeze([...options.owned ?? []])
+	});
+	return componentType;
+}
+/**
+* Declares a tag: a component with no data, stored as `true`.
+*
+* @param name - Storage name, unique per world.
+* @returns A callable tag type.
+* @example
+* ```ts
+* const Held = tag("Held");
+* Held(); // { type: Held, value: true }
+* Held().type.componentName; // "Held"
+* ```
+*/
+function tag(name) {
+	const make = () => Object.freeze({
+		type: tagType,
+		value: true
+	});
+	const tagType = Object.assign(make, {
+		componentName: name,
+		kind: "tag"
+	});
+	return tagType;
+}
+/**
+* Declares a resource: one mutable object per world, created from a deep clone of the defaults
+* on first read.
+*
+* @param name - Storage name, unique per world.
+* @param defaults - The value a fresh world starts with.
+* @returns The resource type.
+* @example
+* ```ts
+* const Pointer = resource("Pointer", { x: 0, y: 0, down: false });
+* Pointer.defaults; // { x: 0, y: 0, down: false }
+* ```
+*/
+function resource(name, defaults) {
+	return {
+		resourceName: name,
+		defaults: Object.freeze({ ...defaults })
+	};
+}
+/**
+* Marks a query term as written. The only effect is change detection: every entity the query
+* yields is marked changed for this component.
+*
+* @param componentType - The component the system writes.
+* @returns The marked term.
+* @example
+* ```ts
+* const Transform = component("Transform", { x: 0, y: 0 });
+* mut(Transform).kind; // "mut"
+* ```
+*/
+function mut(componentType) {
+	return {
+		kind: "mut",
+		of: componentType
+	};
+}
+/**
+* Types a system definition. It returns the same plain object; the work is the type, which reads
+* the query tuple and types the first argument of `run`.
+*
+* @param definition - Name, phase, query and the run function.
+* @returns The same definition, typed.
+* @example
+* ```ts
+* const Transform = component("Transform", { x: 0, y: 0 });
+* const drift = system({
+*   name: "drift",
+*   phase: "animate",
+*   query: [mut(Transform)],
+*   run: entities => {
+*     for (const [, transform] of entities) transform.x += 1;
+*   }
+* });
+* drift.phase; // "animate"
+* ```
+*/
+function system(definition) {
+	return definition;
+}
+/**
+* The layer a view is drawn in. Written only by the projection; a `view` that returns it is
+* logged and the value ignored.
+*/
+const Layer = /*#__PURE__*/ component("Layer", { name: "" });
+/**
+* Explicit draw order inside a layer sorted by `"order"`.
+*/
+const Order = /*#__PURE__*/ component("Order", { value: 0 });
+/**
+* The view is in the despawn queue: still drawn, never hit-tested.
+*/
+const Exiting = /*#__PURE__*/ tag("Exiting");
+/**
+* The element description of a screen: a projection whose `view` returns one node gets it wrapped
+* as this component, and `ui` reconciles the node into child entities. The node is a foreign
+* object, so the world diffs it by identity and `snapshot()` leaves it out.
+*/
+const Tree = /*#__PURE__*/ component("Tree", { node: {
+	type: "",
+	props: {},
+	children: []
+} });
+//#endregion
+//#region src/plugins/renderer/components.ts
+/**
+* @file renderer plugin — the five components a game writes and the `sprite()` bundle helper.
+* Pure: no ctx, no state, no Pixi. Made with the `component()` helper of `world`, so nothing has
+* to be registered.
+*/
+const displayDefaults = { object: void 0 };
+const shapeDefaults = {
+	kind: "rect",
+	w: 0,
+	h: 0,
+	fill: 16777215,
+	fillAlpha: 1,
+	alpha: 1,
+	radius: 0,
+	stroke: 0,
+	strokeWidth: 0,
+	dash: 0,
+	clip: false
+};
+const transformDefaults = {
+	x: 0,
+	y: 0,
+	rotation: 0,
+	scale: 1,
+	pivot: {
+		x: 0,
+		y: 0
+	}
+};
+const spriteDefaults = {
+	texture: "",
+	tint: 16777215,
+	alpha: 1,
+	anchor: {
+		x: .5,
+		y: .5
+	},
+	width: 0,
+	height: 0,
+	fit: "fill"
+};
+/**
+* Where a view sits: reference units, radians, uniform scale, and the local point it turns
+* around.
+*/
+const Transform = /*#__PURE__*/ component("Transform", transformDefaults);
+/**
+* One textured quad. `texture` is an asset key, resolved through the texture providers; a size
+* and a `fit` draw it into a box.
+*/
+const Sprite = /*#__PURE__*/ component("Sprite", spriteDefaults);
+/**
+* A stretchable panel, sized in reference units, with its own alpha and tint. `debug: true` draws
+* the slice outline over it.
+*/
+const NineSlice = /*#__PURE__*/ component("NineSlice", {
+	texture: "",
+	width: 0,
+	height: 0,
+	alpha: 1,
+	tint: 16777215,
+	debug: false
+});
+/**
+* The entity this view moves with. `0` means no parent.
+*/
+const Parent = /*#__PURE__*/ component("Parent", { entity: 0 });
+/**
+* A display object the game owns. Never pooled, never destroyed by `sync`.
+*/
+const Display = /*#__PURE__*/ component("Display", displayDefaults);
+/**
+* A filled rounded rectangle or a right-pointing triangle, drawn with Pixi `Graphics` and redrawn
+* only when a field changed. `fillAlpha: 0` draws only the stroke, `dash` above 0 dashes it.
+* `clip: true` masks the children of the entity to the shape.
+*/
+const Shape = /*#__PURE__*/ component("Shape", shapeDefaults);
+/**
+* Bundles the two components every visual needs, so a projection `view` reads as one line.
+*
+* @param options - Texture key, position, and the four values that have defaults.
+* @returns The `Sprite` and the `Transform` value, in that order.
+* @example
+* ```ts
+* sprite({ texture: "board.cell", at: { x: 540, y: 300 } });
+* // [Sprite({ texture: "board.cell", tint: 0xffffff, alpha: 1, anchor: { x: 0.5, y: 0.5 },
+* //   width: 0, height: 0, fit: "fill" }),
+* //  Transform({ x: 540, y: 300, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } })]
+* ```
+*/
+function sprite(options) {
+	return [Sprite({
+		texture: options.texture,
+		tint: options.tint ?? Sprite.defaults.tint,
+		alpha: options.alpha ?? Sprite.defaults.alpha,
+		anchor: options.anchor ?? Sprite.defaults.anchor
+	}), Transform({
+		x: options.at.x,
+		y: options.at.y,
+		rotation: Transform.defaults.rotation,
+		scale: options.scale ?? Transform.defaults.scale
+	})];
+}
+/**
+* Binds `sprite`, `Sprite` and `NineSlice` to one game's asset keys. Type-only: the same objects.
+*
+* @returns The three helpers with `texture` narrowed to `Asset`.
+* @example
+* ```ts
+* const { Sprite } = componentsFor<"board.cell" | "board.item-wood-1">();
+* Sprite({ texture: "board.cell" }).value.texture; // "board.cell"
+* ```
+*/
+function componentsFor() {
+	return {
+		sprite,
+		Sprite,
+		NineSlice
+	};
+}
+/**
+* Words on the screen: a string or a message, the style it is drawn in, and the string `text`
+* resolved out of it. A game writes `content`, `style`, `bind` and `anchor`; `resolved` is
+* engine-owned and `ui` and the tests read it.
+*/
+const Text = /*#__PURE__*/ component("Text", {
+	content: "",
+	style: "body",
+	bind: void 0,
+	anchor: {
+		x: .5,
+		y: .5
+	},
+	resolved: ""
+}, { owned: ["resolved"] });
+/**
+* Bundles the two components a label needs, so a projection `view` reads as one line. The anchor
+* is the point of the block that sits on the transform.
+*
+* @param options - The text, its style, where it sits, and which point of it sits there.
+* @returns The `Text` and the `Transform` value, in that order.
+* @example
+* ```ts
+* label({ text: "+5", style: "board.float", at: { x: 90, y: 180 } });
+* // [Text({ content: "+5", style: "board.float", bind: undefined,
+* //   anchor: { x: 0.5, y: 0.5 }, resolved: "" }),
+* //  Transform({ x: 90, y: 180, rotation: 0, scale: 1 })]
+* ```
+*/
+function label(options) {
+	return [Text({
+		content: options.text,
+		style: options.style,
+		anchor: options.anchor ?? Text.defaults.anchor
+	}), Transform({
+		x: options.at.x,
+		y: options.at.y
+	})];
+}
+/**
+* Fills the alpha of a shadow a game wrote. Its own function, so the stored shadow carries the
+* four fields and nothing else.
+*
+* @param input - The shadow of a style, when it has one.
+* @returns The shadow to draw with, or `undefined`.
+* @example
+* ```ts
+* shadowOf({ color: 0, dx: 0, dy: 4 }); // { color: 0, dx: 0, dy: 4, alpha: 1 }
+* ```
+*/
+function shadowOf(input) {
+	if (input === void 0) return void 0;
+	return {
+		color: input.color,
+		dx: input.dx,
+		dy: input.dy,
+		alpha: input.alpha ?? 1
+	};
+}
+/**
+* Fills the defaults of one style and refuses a wrap that is neither a width nor `"none"`.
+*
+* @param name - The style name, for the error.
+* @param input - What the game wrote.
+* @returns The style with every field filled.
+* @throws {Error} When `wrap` is a number that is not greater than zero.
+*/
+function normalizeStyle(name, input) {
+	const wrap = input.wrap ?? "none";
+	if (wrap !== "none" && wrap <= 0) throw new Error(`[game] Text style "${name}" has wrap ${wrap}.\n  Use a width in reference px or "none".`);
+	return {
+		font: input.font,
+		bold: input.bold,
+		italic: input.italic,
+		size: input.size,
+		fill: input.fill,
+		stroke: input.stroke ?? 0,
+		strokeWidth: input.strokeWidth ?? 0,
+		letterSpacing: input.letterSpacing ?? 0,
+		align: input.align ?? "left",
+		wrap,
+		digits: input.digits ?? false,
+		shadow: shadowOf(input.shadow)
+	};
+}
+/**
+* Declares the text styles of a feature. The result goes under the `textStyles` key of the
+* feature description, and `text` reads it in `onStart`.
+*
+* @param map - Style name to what that style looks like.
+* @returns The registration a feature carries.
+* @throws {Error} When a style names a wrap that is not a width and not `"none"`.
+* @example
+* ```ts
+* defineTextStyles({ "hud.digits": { font: "ui.font-digits", size: 40, fill: 0xffe082 } });
+* // { kind: "textStyles", map: { "hud.digits": { font: "ui.font-digits", bold: undefined,
+* //   italic: undefined, size: 40, fill: 0xffe082, stroke: 0x000000, strokeWidth: 0,
+* //   letterSpacing: 0, align: "left", wrap: "none", digits: false, shadow: undefined } } }
+* ```
+*/
+function defineTextStyles(map) {
+	const styles = {};
+	for (const [name, input] of Object.entries(map)) styles[name] = normalizeStyle(name, input);
+	return {
+		kind: "textStyles",
+		map: styles
+	};
+}
+/**
+* Tells whether a value is a plain record, so its fields can be read one by one.
+*
+* @param value - What a feature put in its description.
+* @returns True for a plain object.
+* @example
+* ```ts
+* isRecord({ font: "ui.font-body" }); // true
+* ```
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Reads one entry of a registered style map back into a full style. A feature carries the map as
+* plain objects, so this is where it becomes a style again.
+*
+* @param name - The style name, for the error message.
+* @param value - One entry of a feature's `textStyles` map.
+* @returns The style, or `undefined` when the entry is not one.
+* @example
+* ```ts
+* readStyle("hud.body", { font: "ui.font-body", size: 32, fill: 0 })?.align; // "left"
+* ```
+*/
+function readStyle(name, value) {
+	if (!isRecord(value)) return void 0;
+	if (typeof value.font !== "string" || typeof value.size !== "number") return void 0;
+	if (typeof value.fill !== "number") return void 0;
+	const input = {
+		font: value.font,
+		size: value.size,
+		fill: value.fill
+	};
+	const optional = {
+		bold: value.bold,
+		italic: value.italic,
+		stroke: value.stroke,
+		strokeWidth: value.strokeWidth,
+		letterSpacing: value.letterSpacing,
+		align: value.align,
+		wrap: value.wrap,
+		digits: value.digits,
+		shadow: readShadow(value.shadow)
+	};
+	return normalizeStyle(name, {
+		...input,
+		...pruned(optional)
+	});
+}
+/**
+* Reads the shadow of a registered style back. One that lacks a numeric colour or offset is not
+* a shadow and is left out, so the style still draws.
+*
+* @param value - The `shadow` field of a stored style.
+* @returns The shadow as a game writes it, or `undefined`.
+* @example
+* ```ts
+* readShadow({ color: 0, dx: 0, dy: 4, alpha: 1 }); // { color: 0, dx: 0, dy: 4, alpha: 1 }
+* ```
+*/
+function readShadow(value) {
+	if (!isRecord(value)) return void 0;
+	const { color, dx, dy, alpha } = value;
+	if (typeof color !== "number" || typeof dx !== "number" || typeof dy !== "number") return;
+	return typeof alpha === "number" ? {
+		color,
+		dx,
+		dy,
+		alpha
+	} : {
+		color,
+		dx,
+		dy
+	};
+}
+/**
+* Drops the fields a style did not name, so the defaults win over an explicit `undefined`.
+*
+* @param fields - The optional fields of a style, as they were stored.
+* @returns The fields that carry a value.
+* @example
+* ```ts
+* pruned({ bold: undefined, wrap: 480 }); // { wrap: 480 }
+* ```
+*/
+function pruned(fields) {
+	const kept = {};
+	for (const [name, value] of Object.entries(fields)) if (value !== void 0) kept[name] = value;
+	return kept;
+}
+/**
+* The two styles every game has, built from the fonts of the plugin config. A feature may
+* override either by name.
+*
+* @param fonts - The body and digits font keys of the config.
+* @param fonts.body - Font key of the built-in `body` style.
+* @param fonts.digits - Font key of the built-in `digits` style.
+* @returns The built-in styles, `body` first.
+* @example
+* ```ts
+* builtInStyles({ body: "ui.font-body", digits: "ui.font-digits" }).digits.digits; // true
+* ```
+*/
+function builtInStyles(fonts) {
+	return {
+		body: normalizeStyle("body", {
+			font: fonts.body,
+			size: 32,
+			fill: 16777215
+		}),
+		digits: normalizeStyle("digits", {
+			font: fonts.digits,
+			size: 32,
+			fill: 16777215,
+			digits: true
+		})
+	};
+}
+/**
+* Binds `label` and `defineTextStyles` to one game's style names and font keys. Type-only: the
+* same two functions.
+*
+* @returns The two helpers, with the style and font arguments narrowed.
+* @example
+* ```ts
+* const { label } = textFor<"body", "ui.font-body">();
+* label({ text: "+5", style: "body", at: { x: 90, y: 180 } })[1].value.x; // 90
+* ```
+*/
+function textFor() {
+	return {
+		label,
+		defineTextStyles
+	};
+}
+//#endregion
+//#region src/plugins/ui/visual.ts
+/**
+* @file ui plugin — the look of an element: the visual component it is drawn with, and where a
+* `fit: "contain"` ancestor really draws it. Pure: no ctx, no state. Shared by `jsx` (the
+* components of an entity, `lint`) and `layout` (the rest pose, the guide hole), which may not
+* import each other's run-time code.
+*/
+/** The tag of the one child a scroll container holds: everything inside it moves as one. */
+const CONTENT = "content";
+/** The three ways a sized sprite fills its box, as the `fit` prop of `image` and `icon` names them. */
+const FITS = [
+	"contain",
+	"cover",
+	"fill"
+];
+/**
+* Tells whether a tag draws nothing of its own, so its `Shape` is invisible unless its style fills.
+*
+* @param type - The intrinsic tag.
+* @returns True for the six container tags and the content of a scroll.
+* @example
+* ```ts
+* isContainer("row"); // true
+* ```
+*/
+function isContainer(type) {
+	return [
+		"screen",
+		"layer",
+		"row",
+		"column",
+		"stack",
+		"spacer",
+		CONTENT
+	].includes(type);
+}
+/**
+* Reads the asset key of an image or an icon out of its props.
+*
+* @param props - The props of the element.
+* @returns The texture key, empty when the markup named none.
+* @example
+* ```ts
+* textureOf({ name: "ui.gear" }); // "ui.gear"
+* ```
+*/
+function textureOf(props) {
+	const key = props.texture ?? props.name;
+	return typeof key === "string" ? key : "";
+}
+/**
+* Reads the `fit` prop of an image or an icon.
+*
+* @param props - The props of the element.
+* @returns The fit, `"contain"` when the markup named none.
+* @example
+* ```ts
+* spriteFitOf({ fit: "cover" }); // "cover"
+* ```
+*/
+function spriteFitOf(props) {
+	return FITS.find((fit) => fit === props.fit) ?? "contain";
+}
+/**
+* Reads the content of a text out of its props.
+*
+* @param props - The props of the element.
+* @returns The string or message, empty when the markup named none.
+*/
+function contentOf(props) {
+	return props.content ?? "";
+}
+/**
+* The visual component of an element: a sprite for an image or an icon, the text for a text, the
+* nine-slice of its style (outlined when the style sets `debug`), or a rounded rectangle, a
+* triangle with `shape: "triangle"`, its stroke dashed with `dash`. A clipping element (`scroll`,
+* `overflow: "hidden"`) keeps the rectangle, which carries the clip. A style with a stroke and no fill draws
+* only the stroke, a ring. A container with no fill and no stroke gets an invisible rectangle:
+* the renderer hangs children under the display object of their parent, so every parent needs
+* one.
+*
+* @param element - The element to draw, with its rect known.
+* @returns The component values: one visual.
+*/
+function visualOf(element) {
+	const { style, type, node, rect } = element;
+	const alpha = style.alpha ?? 1;
+	const tint = style.tint ?? Sprite.defaults.tint;
+	if (type === "image" || type === "icon") return [Sprite({
+		texture: textureOf(node.props),
+		tint,
+		alpha,
+		anchor: {
+			x: 0,
+			y: 0
+		},
+		width: rect.w,
+		height: rect.h,
+		fit: spriteFitOf(node.props)
+	})];
+	if (type === "text") {
+		const styleKey = typeof node.props.style === "string" ? node.props.style : "body";
+		return [Text({
+			content: contentOf(node.props),
+			style: styleKey,
+			bind: node.props.bind,
+			anchor: {
+				x: 0,
+				y: 0
+			}
+		})];
+	}
+	const clip = type === "scroll" || style.overflow === "hidden";
+	if (style.nineSlice !== void 0 && !clip) return [NineSlice({
+		texture: style.nineSlice,
+		width: rect.w,
+		height: rect.h,
+		alpha,
+		tint,
+		debug: style.debug ?? false
+	})];
+	const filled = style.fill !== void 0 || style.stroke !== void 0;
+	const invisible = isContainer(type) && !filled;
+	return [Shape({
+		kind: style.shape ?? "rect",
+		w: rect.w,
+		h: rect.h,
+		fill: style.fill ?? Shape.defaults.fill,
+		fillAlpha: style.fill === void 0 ? 0 : Shape.defaults.fillAlpha,
+		alpha: invisible ? 0 : alpha,
+		radius: style.radius ?? 0,
+		stroke: style.stroke ?? Shape.defaults.stroke,
+		strokeWidth: style.strokeWidth ?? 0,
+		dash: style.dash ?? 0,
+		clip
+	})];
+}
+/**
+* The element itself and every element above it, nearest first.
+*
+* @param element - Where the walk starts.
+* @param lookup - How a parent entity becomes its element.
+* @returns The chain up to the root element.
+*/
+function chainOf(element, lookup) {
+	const chain = [];
+	let current = element;
+	while (current !== void 0) {
+		chain.push(current);
+		current = current.parent === void 0 ? void 0 : lookup(current.parent);
+	}
+	return chain;
+}
+/**
+* The scale an element is drawn at by the `fit: "contain"` of itself and its ancestors.
+*
+* @param element - The element to ask about.
+* @param lookup - How a parent entity becomes its element.
+* @returns The product of the fit scales, 1 when nothing on the way up fits.
+*/
+function fitScaleOf(element, lookup) {
+	return chainOf(element, lookup).reduce((scale, above) => scale * above.fit, 1);
+}
+/**
+* Scales a rect about the centre of every fitted link of a chain, in order: the way ui draws a
+* `fit: "contain"`. A link with fit 1 leaves the rect alone.
+*
+* @param rect - The natural rect.
+* @param chain - The element and its ancestors, nearest first, each with its rect and fit scale.
+* @returns The drawn rect, a new object.
+* @example
+* ```ts
+* scaleByFits({ x: 0, y: 0, w: 100, h: 100 }, [{ rect: { x: 0, y: 0, w: 100, h: 100 }, fit: 0.5 }]); // { x: 25, y: 25, w: 50, h: 50 }
+* ```
+*/
+function scaleByFits(rect, chain) {
+	let drawn = { ...rect };
+	for (const above of chain) {
+		if (above.fit === 1) continue;
+		const centre = {
+			x: above.rect.x + above.rect.w / 2,
+			y: above.rect.y + above.rect.h / 2
+		};
+		drawn = {
+			x: centre.x + above.fit * (drawn.x - centre.x),
+			y: centre.y + above.fit * (drawn.y - centre.y),
+			w: drawn.w * above.fit,
+			h: drawn.h * above.fit
+		};
+	}
+	return drawn;
+}
+/**
+* Where an element is drawn at rest, in root coordinates: its natural rect, scaled about the
+* centre of every fitted element on the way up, the element itself included. The visual
+* transform styles (offset, scale) are left out: they are a state look, never a place.
+*
+* @param element - The element to place.
+* @param lookup - How a parent entity becomes its element.
+* @returns The drawn rect.
+*/
+function visualRectOf(element, lookup) {
+	return scaleByFits(element.rect, chainOf(element, lookup));
+}
+/**
+* Tells whether two transforms put a view in the same place.
+*
+* @param first - One pose.
+* @param second - The other.
+* @returns True when every field and the pivot are equal.
+* @example
+* ```ts
+* samePose(
+*   { x: 1, y: 2, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } },
+*   { x: 1, y: 2, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
+* ); // true
+* ```
+*/
+function samePose(first, second) {
+	return first.x === second.x && first.y === second.y && first.rotation === second.rotation && first.scale === second.scale && first.pivot.x === second.pivot.x && first.pivot.y === second.pivot.y;
+}
+//#endregion
+export { Order as C, resource as D, mut as E, system as O, Layer as S, component as T, Sprite as _, visualOf as a, sprite as b, builtInStyles as c, readStyle as d, textFor as f, Shape as g, Parent as h, scaleByFits as i, tag as k, defineTextStyles as l, NineSlice as m, fitScaleOf as n, visualRectOf as o, Display as p, samePose as r, Text as s, CONTENT as t, label as u, Transform as v, Tree as w, Exiting as x, componentsFor as y };