@sepveneto/dao 0.0.4 → 0.1.0

package/dist/dao.js

@@ -1,541 +1,2290 @@
-var GameObject = class {
+var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __commonJSMin = (n, j) => () => (j || n((j = { exports: {} }).exports, j), j.exports), __copyProps = (n, P, I, L) => {
+	if (P && typeof P == "object" || typeof P == "function") for (var R = __getOwnPropNames(P), z = 0, B = R.length, V; z < B; z++) V = R[z], !__hasOwnProp.call(n, V) && V !== I && __defProp(n, V, {
+		get: ((n) => P[n]).bind(null, V),
+		enumerable: !(L = __getOwnPropDesc(P, V)) || L.enumerable
+	});
+	return n;
+}, __toESM = (M, N, F) => (F = M == null ? {} : __create(__getProtoOf(M)), __copyProps(N || !M || !M.__esModule ? __defProp(F, "default", {
+	value: M,
+	enumerable: !0
+}) : F, M));
+const PI_2 = Math.PI * 2;
+var Matrix = class n {
+	constructor(n = 1, j = 0, M = 0, N = 1, P = 0, F = 0) {
+		this.a = n, this.b = j, this.c = M, this.d = N, this.tx = P, this.ty = F;
+	}
+	static append(j, M) {
+		return new n(M.a * j.a + M.b * j.c, M.a * j.b + M.b * j.d, M.c * j.a + M.d * j.c, M.c * j.b + M.d * j.d, M.tx * j.a + M.ty * j.c + j.tx, M.tx * j.b + M.ty * j.d + j.ty);
+	}
+	apply(n) {
+		let { x: j, y: M } = n;
+		return new Vector2(j * this.a + M * this.c + this.tx, j * this.b + M * this.d + this.ty);
+	}
+	appendFrom(n, j) {
+		let M = n.a, N = n.b, P = n.c, F = n.d, I = n.tx, L = n.ty, R = j.a, z = j.b, B = j.c, V = j.d, H = j.tx, U = j.ty;
+		this.a = M * R + N * B, this.b = M * z + N * V, this.c = P * R + F * B, this.d = P * z + F * V, this.tx = I * R + L * B + H, this.ty = I * z + L * V + U;
+	}
+	set(n, j, M, N, P, F) {
+		this.a = n, this.b = j, this.c = M, this.d = N, this.tx = P, this.ty = F;
+	}
+	applyInverse(n, j) {
+		j = j || new Vector2();
+		let M = this.a, N = this.b, P = this.c, F = this.d, I = this.tx, L = this.ty, R = 1 / (M * F + P * -N), z = n.x, B = n.y;
+		return j.x = F * R * z + -P * R * B + (L * P - I * F) * R, j.y = M * R * B + -N * R * z + (-L * M + I * N) * R, j;
+	}
+	copyFrom(n) {
+		return this.a = n.a, this.b = n.b, this.c = n.c, this.d = n.d, this.tx = n.tx, this.ty = n.ty, this;
+	}
+	decompose(n) {
+		let j = this.a, M = this.b, N = this.c, P = this.d, F = n.pivot, I = -Math.atan2(-N, P), L = Math.atan2(M, j), R = Math.abs(I + L);
+		return R < 1e-5 || Math.abs(PI_2 - R) < 1e-5 ? (n.rotation = L, n.skew.x = n.skew.y = 0) : (n.rotation = 0, n.skew.x = I, n.skew.y = L), n.scale.x = Math.sqrt(j * j + M * M), n.scale.y = Math.sqrt(N * N + P * P), n.position.x = this.tx + F.x * j + F.y * N, n.position.y = this.ty + F.x * M + F.y * P, n;
+	}
+	clone() {
+		let j = new n();
+		return j.a = this.a, j.b = this.b, j.c = this.c, j.d = this.d, j.tx = this.tx, j.ty = this.ty, j;
+	}
+}, Rectangle = class n {
+	constructor(n = 0, j = 0, M = 0, N = 0) {
+		this.type = "rectangle", this.x = n, this.y = j, this.width = M, this.height = N;
+	}
+	getBounds() {
+		let j = new n();
+		return j.copyFrom(this), j;
+	}
+	copyFrom(n) {
+		return this.x = n.x, this.y = n.y, this.width = n.width, this.height = n.height, this;
+	}
+	contains(n, j) {
+		return this.width <= 0 || this.height <= 0 ? !1 : n >= this.x && n < this.x + this.width && j >= this.y && j < this.y + this.height;
+	}
+}, Vector2 = class {
+	constructor(n = 0, j = 0) {
+		this.x = n, this.y = j;
+	}
+	set(n, j) {
+		j == null ? this.x = this.y = n : (this.x = n, this.y = j);
+	}
+	copyFrom(n) {
+		this.set(n.x, n.y);
+	}
+};
+function nextPow2(n) {
+	return n += n === 0 ? 1 : 0, --n, n |= n >>> 1, n |= n >>> 2, n |= n >>> 4, n |= n >>> 8, n |= n >>> 16, n + 1;
+}
+const CanvasPool = new class {
 	constructor() {
-		this.x = 0, this.y = 0, this.z = 0, this.width = 0, this.height = 0, this.zIndex = 0, this.originX = 0, this.originY = 0, this.rotation = 0;
+		this._canvasPool = Object.create(null);
+	}
+	getOptimalCanvasAndContext(n, j, M = 1) {
+		let N = nextPow2(n * M - 1e-6), P = nextPow2(j * M - 1e-6), F = N << 17 + P << 1;
+		this._canvasPool[F] || (this._canvasPool[F] = []);
+		let I = this._canvasPool[F].pop();
+		if (I) return I;
+		{
+			let n = document.createElement("canvas");
+			return n.width = N, n.height = P, {
+				canvas: n,
+				context: n.getContext("2d")
+			};
+		}
 	}
-	setOrigin(r, T) {
-		this.originX = r, this.originY = T;
+}();
+var uidCache = { default: -1 };
+function uid(n = "default") {
+	return uidCache[n] === void 0 && (uidCache[n] = -1), ++uidCache[n];
+}
+var _TextStyle, TextStyle = class n {
+	constructor(j) {
+		this.uid = uid("textStyle");
+		let M = {
+			...n.defaultStyle,
+			...j
+		};
+		for (let n in M) {
+			let j = n;
+			this[j] = M[n];
+		}
 	}
-	draw(r, T) {
-		r.save(), r.rotate(this.rotation), this.render(r), r.restore();
+	get styleKey() {
+		return `${this.uid}-${this._tick}`;
 	}
-	render(r) {
-		if (!this.texture) return;
-		let T = this.width || this.texture.width, E = this.height || this.texture.height;
-		r.drawImage(this.texture, -T * this.originX, -E * this.originY, T, E);
+	get fontSize() {
+		return this._fontSize;
 	}
-	update(r) {}
-}, Container = class extends GameObject {
-	constructor(...r) {
-		super(...r), this.x = 0, this.y = 0, this.z = 0, this.rotation = 0, this.scaleX = 1, this.scaleY = 1, this.children = [];
+	set fontSize(n) {
+		this._fontSize !== n && (this._fontSize = n, this.update());
 	}
-	add(r) {
-		this.children.push(r), this.updateBounds();
+	get fill() {
+		return this._fill;
 	}
-	updateBounds() {
-		if (!this.children.length) {
-			this.width = 0, this.height = 0;
-			return;
+	set fill(n) {
+		this._fill !== n && (this._fill = n, this.update());
+	}
+	get align() {
+		return this._align;
+	}
+	set align(n) {
+		this._align !== n && (this._align = n, this.update());
+	}
+	get wordWarp() {
+		return this._wordWrap;
+	}
+	set wordWrap(n) {
+		this._wordWrap !== n && (this._wordWrap = n, this.update());
+	}
+	get fontFamily() {
+		return this._fontFamily;
+	}
+	set fontFamily(n) {
+		this._fontFamily !== n && (this._fontFamily = n, this.update());
+	}
+	get leading() {
+		return this._leading;
+	}
+	set leading(n) {
+		this._leading !== n && (this._leading = n, this.update());
+	}
+	get fontStyle() {
+		return this._fontStyle;
+	}
+	set fontStyle(n) {
+		this._fontStyle !== n && (this._fontStyle = n.toLowerCase(), this.update());
+	}
+	get textBaseline() {
+		return this._textBaseline;
+	}
+	set textBaseline(n) {
+		this._textBaseline = n, this.update();
+	}
+	get lineHeight() {
+		return this._lineHeight;
+	}
+	set lineHeight(n) {
+		this._lineHeight !== n && (this._lineHeight = n, this.update());
+	}
+	get letterSpacing() {
+		return this._letterSpacing;
+	}
+	set letterSpacing(n) {
+		this._letterSpacing !== n && (this._letterSpacing = n, this.update());
+	}
+	get fontVariant() {
+		return this._fontVariant;
+	}
+	set fontVariant(n) {
+		this._fontVariant !== n && (this._fontVariant = n, this.update());
+	}
+	get fontWeight() {
+		return this._fontWeight;
+	}
+	set fontWeight(n) {
+		this._fontWeight !== n && (this._fontWeight = n, this.update());
+	}
+	get _fontString() {
+		return this._cachedFontString === null && (this._cachedFontString = fontStringFromTextStyle(this)), this._cachedFontString;
+	}
+	update() {
+		this._tick++, this._cachedFontString = null;
+	}
+	destroy(n = !1) {
+		this._fill = null;
+	}
+};
+_TextStyle = TextStyle, _TextStyle.defaultStyle = {
+	align: "left",
+	breakWords: !1,
+	dropShadow: null,
+	fill: "black",
+	fontFamily: "Arial",
+	fontSize: 26,
+	fontStyle: "normal",
+	fontVariant: "normal",
+	fontWeight: "normal",
+	leading: 0,
+	letterSpacing: 0,
+	lineHeight: 0,
+	padding: 0,
+	stroke: null,
+	textBaseline: "alphabetic",
+	trim: !1,
+	whiteSpace: "pre",
+	wordWrap: !1,
+	wordWrapWidth: 100
+};
+var genericFontFamilies = [
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"system-ui"
+];
+function fontStringFromTextStyle(n) {
+	let j = typeof n.fontSize == "number" ? `${n.fontSize}px` : n.fontSize, M = n.fontFamily;
+	Array.isArray(n.fontFamily) || (M = n.fontFamily.split(","));
+	for (let n = M.length - 1; n >= 0; n--) {
+		let j = M[n].trim();
+		!/([\"\'])[^\'\"]+\1/.test(j) && !genericFontFamilies.includes(j) && (j = `"${j}"`), M[n] = j;
+	}
+	return `${n.fontStyle} ${n.fontVariant} ${n.fontWeight} ${j} ${M.join(",")}`;
+}
+var _TextMetrics;
+const NEWLINE_MATCH_REGEX = /(?:\r\n|\r|\n)/;
+var TextMetrics = class n {
+	constructor(n, j, M, N, P, F, I, L, R) {
+		this.text = n, this.style = j, this.width = M, this.height = N, this.lines = P, this.lineWidths = F, this.lineHeight = I, this.maxLineWidth = L, this.fontProperties = R;
+	}
+	static get canvas() {
+		if (!n._canvas) {
+			let j;
+			try {
+				let M = new OffscreenCanvas(0, 0);
+				if (M.getContext("2d", { willReadFrequently: !0 }).measureText) return n._canvas = M, M;
+				j = createCanvas(10, 10);
+			} catch (n) {
+				j = createCanvas(10, 10);
+			}
+			n._canvas = j;
+		}
+		return n._canvas;
+	}
+	static get context() {
+		return n._context || (n._context = n.canvas.getContext("2d", { willReadFrequently: !0 })), n._context;
+	}
+	static measureText(j, M) {
+		let N = `${j}-${M.styleKey}`;
+		if (n._measurementCache.has(N)) return n._measurementCache.get(N);
+		let P = M._fontString, F = n.measureFont(P);
+		F.fontSize === 0 && (F.fontSize = M.fontSize, F.ascent = M.fontSize, F.descent = 0);
+		let I = n.context;
+		I.font = P;
+		let L = j.split(NEWLINE_MATCH_REGEX), R = Array(L.length), z = 0;
+		for (let j = 0; j < L.length; ++j) {
+			let N = n._measureText(L[j], M.letterSpacing);
+			R[j] = N, z = Math.max(z, N);
+		}
+		let B = M.lineHeight || F.fontSize, V = new n(j, M, z, Math.max(B, F.fontSize + (L.length - 1) * (B + M.leading)), L, R, B, z, F);
+		return n._measurementCache.set(N, V), V;
+	}
+	static _measureText(j, M) {
+		var N, P;
+		let F = n.context;
+		F.letterSpacing = "0px", F.textLetterSpacing = M;
+		let I = F.measureText(j), L = I.width, R = 0;
+		L > 0 && (R = (n.graphemeSegmenter(j).length - 1) * M, L += R);
+		let z = -((N = I.actualBoundingBoxLeft) == null ? 0 : N), B = ((P = I.actualBoundingBoxRight) == null ? 0 : P) - z;
+		return I.width > 0 && (B += R), Math.max(L, B);
+	}
+	static measureFont(j) {
+		var M, N;
+		if (n._fonts[j]) return n._fonts[j];
+		let P = n.context;
+		P.font = j;
+		let F = P.measureText(n.METRICS_STRING + n.BASELINE_SYMBOL), I = (M = F.actualBoundingBoxAscent) == null ? 0 : M, L = (N = F.actualBoundingBoxDescent) == null ? 0 : N, R = {
+			ascent: I,
+			descent: L,
+			fontSize: I + L
+		};
+		return n._fonts[j] = R, R;
+	}
+};
+_TextMetrics = TextMetrics, _TextMetrics.METRICS_STRING = "|ÉqÅ", _TextMetrics.BASELINE_SYMBOL = "M", _TextMetrics._measurementCache = /* @__PURE__ */ new Map(), _TextMetrics._fonts = {}, _TextMetrics.graphemeSegmenter = (() => {
+	var n;
+	if (typeof ((n = Intl) == null ? void 0 : n.Segmenter) == "function") {
+		let n = new Intl.Segmenter();
+		return (j) => {
+			let M = n.segment(j), N = [], P = 0;
+			for (let n of M) N[P++] = n.segment;
+			return N;
+		};
+	}
+	return (n) => [...n];
+})();
+function createCanvas(n, j) {
+	let M = document.createElement("canvas");
+	return M.width = n, M.height = j, M;
+}
+function generateTextTexture(n) {
+	let { text: j, style: M, resolution: N = 1, padding: P = 0 } = n, F = TextMetrics.measureText(j, M), I = Math.ceil(Math.ceil(Math.max(1, F.width) + P * 2) * N), L = Math.ceil(Math.ceil(Math.max(1, F.height) + P * 2) * N), R = CanvasPool.getOptimalCanvasAndContext(I, L);
+	return renderTextToCanvas(M, N, P, R, F), {
+		canvasAndContext: R,
+		frame: new Rectangle(0, 0, I, L)
+	};
+}
+function renderTextToCanvas(n, j, M, N, P) {
+	let { context: F } = N, I = fontStringFromTextStyle(n), { lines: L, lineHeight: R, lineWidths: z, maxLineWidth: B, fontProperties: V } = P;
+	F.resetTransform(), F.scale(j, j), F.textBaseline = n.textBaseline, F.font = I;
+	let H = Math.min(0, (R - V.fontSize) / 2);
+	F.fillStyle = n.fill;
+	for (let j = 0; j < L.length; ++j) {
+		let P = getAlignmentOffset(z[j], B, n.align), F = j * R + V.ascent + H, I = 0;
+		if (n.align === "justify" && n.wordWrap && j < L.length - 1) {
+			let n = countSpaces(L[j]);
+			n > 0 && (I = (B - z[j]) / n);
+		}
+		drawLetterSpacing(L[j], n, N, P + M, F + M, !1, I);
+	}
+}
+function getAlignmentOffset(n, j, M) {
+	return M === "right" ? j - n : M === "center" ? (j - n) / 2 : 0;
+}
+function countSpaces(n) {
+	let j = 0;
+	for (let M = 0; M < n.length; M++) n.charCodeAt(M) === 32 && j++;
+	return j;
+}
+function drawLetterSpacing(n, j, M, N, P, F = !1, I = 0) {
+	let L = M.context, R = j.letterSpacing;
+	if (R === 0 && I === 0) {
+		L.fillText(n, N, P);
+		return;
+	}
+	if (I !== 0 && R === 0) {
+		let j = n.split(" "), M = N, F = L.measureText(" ").width;
+		for (let n = 0; n < j.length; ++n) L.fillText(j[n], M, P), M += L.measureText(j[n]).width + F + I;
+		return;
+	}
+	let z = N, B = TextMetrics.graphemeSegmenter(n), V = L.measureText(n).width, H = 0;
+	for (let n = 0; n < B.length; ++n) {
+		let j = B[n];
+		L.fillText(j, z, P);
+		let M = "";
+		for (let j = n + 1; j < B.length; ++j) M += B[j];
+		H = L.measureText(M).width, z += V - H + R, j === "" && (z += I), V = H;
+	}
+}
+var eventemitter3_default = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((n, j) => {
+	var M = Object.prototype.hasOwnProperty, N = "~";
+	function P() {}
+	Object.create && (P.prototype = Object.create(null), new P().__proto__ || (N = !1));
+	function F(n, j, M) {
+		this.fn = n, this.context = j, this.once = M || !1;
+	}
+	function I(n, j, M, P, I) {
+		if (typeof M != "function") throw TypeError("The listener must be a function");
+		var L = new F(M, P || n, I), R = N ? N + j : j;
+		return n._events[R] ? n._events[R].fn ? n._events[R] = [n._events[R], L] : n._events[R].push(L) : (n._events[R] = L, n._eventsCount++), n;
+	}
+	function L(n, j) {
+		--n._eventsCount === 0 ? n._events = new P() : delete n._events[j];
+	}
+	function R() {
+		this._events = new P(), this._eventsCount = 0;
+	}
+	R.prototype.eventNames = function() {
+		var n = [], j, P;
+		if (this._eventsCount === 0) return n;
+		for (P in j = this._events) M.call(j, P) && n.push(N ? P.slice(1) : P);
+		return Object.getOwnPropertySymbols ? n.concat(Object.getOwnPropertySymbols(j)) : n;
+	}, R.prototype.listeners = function(n) {
+		var j = N ? N + n : n, M = this._events[j];
+		if (!M) return [];
+		if (M.fn) return [M.fn];
+		for (var P = 0, F = M.length, I = Array(F); P < F; P++) I[P] = M[P].fn;
+		return I;
+	}, R.prototype.listenerCount = function(n) {
+		var j = N ? N + n : n, M = this._events[j];
+		return M ? M.fn ? 1 : M.length : 0;
+	}, R.prototype.emit = function(n, j, M, P, F, I) {
+		var L = N ? N + n : n;
+		if (!this._events[L]) return !1;
+		var R = this._events[L], z = arguments.length, B, V;
+		if (R.fn) {
+			switch (R.once && this.removeListener(n, R.fn, void 0, !0), z) {
+				case 1: return R.fn.call(R.context), !0;
+				case 2: return R.fn.call(R.context, j), !0;
+				case 3: return R.fn.call(R.context, j, M), !0;
+				case 4: return R.fn.call(R.context, j, M, P), !0;
+				case 5: return R.fn.call(R.context, j, M, P, F), !0;
+				case 6: return R.fn.call(R.context, j, M, P, F, I), !0;
+			}
+			for (V = 1, B = Array(z - 1); V < z; V++) B[V - 1] = arguments[V];
+			R.fn.apply(R.context, B);
+		} else {
+			var H = R.length, U;
+			for (V = 0; V < H; V++) switch (R[V].once && this.removeListener(n, R[V].fn, void 0, !0), z) {
+				case 1:
+					R[V].fn.call(R[V].context);
+					break;
+				case 2:
+					R[V].fn.call(R[V].context, j);
+					break;
+				case 3:
+					R[V].fn.call(R[V].context, j, M);
+					break;
+				case 4:
+					R[V].fn.call(R[V].context, j, M, P);
+					break;
+				default:
+					if (!B) for (U = 1, B = Array(z - 1); U < z; U++) B[U - 1] = arguments[U];
+					R[V].fn.apply(R[V].context, B);
+			}
+		}
+		return !0;
+	}, R.prototype.on = function(n, j, M) {
+		return I(this, n, j, M, !1);
+	}, R.prototype.once = function(n, j, M) {
+		return I(this, n, j, M, !0);
+	}, R.prototype.removeListener = function(n, j, M, P) {
+		var F = N ? N + n : n;
+		if (!this._events[F]) return this;
+		if (!j) return L(this, F), this;
+		var I = this._events[F];
+		if (I.fn) I.fn === j && (!P || I.once) && (!M || I.context === M) && L(this, F);
+		else {
+			for (var R = 0, z = [], B = I.length; R < B; R++) (I[R].fn !== j || P && !I[R].once || M && I[R].context !== M) && z.push(I[R]);
+			z.length ? this._events[F] = z.length === 1 ? z[0] : z : L(this, F);
+		}
+		return this;
+	}, R.prototype.removeAllListeners = function(n) {
+		var j;
+		return n ? (j = N ? N + n : n, this._events[j] && L(this, j)) : (this._events = new P(), this._eventsCount = 0), this;
+	}, R.prototype.off = R.prototype.removeListener, R.prototype.addListener = R.prototype.on, R.prefixed = N, R.EventEmitter = R, j !== void 0 && (j.exports = R);
+})))(), 1)).default, _TextureSource, TextureSource = class n extends eventemitter3_default {
+	constructor(j) {
+		super(), this._resolution = 1, this.pixelWidth = 1, this.pixelHeight = 1, this.width = 1, this.height = 1;
+		let M = {
+			...n.defaultOptions,
+			...j
+		};
+		this.label = j.label, this.resource = M.resource, this._resolution = M.resolution, M.width ? this.pixelWidth = j.width * this._resolution : this.pixelWidth = this.resource && this.resourceWidth || 1, M.height ? this.pixelHeight = j.height * this._resolution : this.pixelHeight = this.resource && this.resourceHeight || 1, this.width = this.pixelWidth / this._resolution, this.height = this.pixelHeight / this._resolution;
+	}
+	get resolution() {
+		return this._resolution;
+	}
+	set resolution(n) {
+		this._resolution !== n && (this._resolution = n, this.width = this.pixelWidth / n, this.height = this.pixelHeight / n);
+	}
+	get resourceWidth() {
+		let n = this.resource;
+		return n.naturalWidth || n.width;
+	}
+	get resourceHeight() {
+		let n = this.resource;
+		return n.naturalHeight || n.height;
+	}
+	resize(n, j, M) {
+		M || (M = this._resolution), n || (n = this.width), j || (j = this.height);
+		let N = Math.round(n * M), P = Math.round(j * M);
+		return this.width = N / M, this.height = P / M, this._resolution = M, this.pixelWidth === N && this.pixelHeight === P ? !1 : (this.pixelWidth = N, this.pixelHeight = P, this.emit("resize", this), !0);
+	}
+};
+_TextureSource = TextureSource, _TextureSource.defaultOptions = { resolution: 1 };
+var CanvasSource = class extends TextureSource {
+	constructor(n) {
+		n.resource || (n.resource = createCanvas()), n.width || (n.width = n.resource.width, n.autoDensity || (n.width /= n.resolution)), n.height || (n.height = n.resource.height, n.autoDensity || (n.height /= n.resolution)), super(n), this.autoDensity = n.autoDensity, this.resizeCanvas();
+	}
+	resizeCanvas() {
+		this.autoDensity && (this.resource.style.width = `${this.width}px`, this.resource.style.height = `${this.height}px`), (this.resource.width !== this.pixelWidth || this.resource.height !== this.pixelHeight) && (this.resource.width = this.pixelWidth, this.resource.height = this.pixelHeight);
+	}
+	resize(n = this.width, j = this.height, M = this._resolution) {
+		let N = super.resize(n, j, M);
+		return N && this.resizeCanvas(), N;
+	}
+}, Texture = class {
+	constructor({ source: n, label: j, frame: M, orig: N, rotate: P } = {}) {
+		if (this.frame = new Rectangle(), this.noFrame = !1, this.label = j, this.source = n, M) this.frame.copyFrom(M);
+		else {
+			this.noFrame = !0;
+			let { width: j, height: M } = n;
+			this.frame.width = j, this.frame.height = M;
 		}
-		let r = Infinity, T = Infinity, E = -Infinity, D = -Infinity;
-		this.children.forEach((O) => {
-			let k = O.width || 0, A = O.height || 0, j = O.x, M = O.y;
-			r = Math.min(r, j), T = Math.min(T, M), E = Math.max(E, j + k), D = Math.max(D, M + A);
-		}), this.width = E - r, this.height = D - T;
+		this.orig = N || this.frame, this.rotate = P == null ? 0 : P, this.destroyed = !1;
+	}
+	get source() {
+		return this._source;
 	}
-	remove(r) {
-		let T = this.children.indexOf(r);
-		T !== -1 && (this.children.splice(T, 1), this.updateBounds());
+	set source(n) {
+		this._source && this._source.off("resize", this.update, this), this._source = n, n.on("resize", this.update, this);
 	}
-	update(r) {
-		this.children.forEach((T) => {
-			var E;
-			return (E = T.update) == null ? void 0 : E.call(T, r);
+	get width() {
+		return this.orig.width;
+	}
+	get height() {
+		return this.orig.height;
+	}
+	update() {
+		this.noFrame && (this.frame.width = this._source.width, this.frame.height = this._source.height);
+	}
+};
+Texture.EMPTY = new Texture({
+	label: "EMPTY",
+	source: new TextureSource({ label: "EMPTY" })
+});
+var File = class {
+	constructor(n, j) {
+		this.key = n, this.url = j;
+	}
+}, ImageFile = class extends File {
+	load() {
+		return new Promise((n, j) => {
+			let M = new Image();
+			M.onload = () => n(M), M.onerror = () => j(/* @__PURE__ */ Error(`Failed to load ${this.url}`)), M.src = this.url;
 		});
 	}
-	draw(r, T) {
-		this.children.forEach((E) => {
-			this.drawChild(E, r, T);
+}, Loader = class {
+	constructor() {
+		this.queue = [], this.textures = new Cache();
+	}
+	async image(n, j) {
+		let M = await fetch(j), N = new Texture({ source: new TextureSource({ resource: await createImageBitmap(await M.blob()) }) });
+		return this.textures.add(n, N), N;
+	}
+	async load() {
+		let n = this.queue.map((n) => n.load().then((j) => {
+			n instanceof ImageFile && this.textures.add(n.key, j);
+		}));
+		this.queue.length = 0, await Promise.all(n);
+	}
+}, Cache = class {
+	constructor() {
+		this.map = /* @__PURE__ */ new Map();
+	}
+	add(n, j) {
+		this.map.has(n) || this.map.set(n, j);
+	}
+	get(n) {
+		let j = this.map.get(n);
+		if (!j) throw Error(`Asset ${n} not found`);
+		return j;
+	}
+	has(n) {
+		return this.map.has(n);
+	}
+	remove(n) {
+		this.map.delete(n);
+	}
+	clear() {
+		this.map.clear();
+	}
+}, ResourceManager = class {
+	constructor() {
+		this.textures = new Cache(), this.loader = new Loader();
+	}
+	async load(n) {
+		let j = n.map(async (n) => {
+			let j = await this.loader.image(n.alias, n.src);
+			return {
+				key: n.alias,
+				value: j
+			};
 		});
+		return (await Promise.all(j)).reduce((n, j) => (n[j.key] = j.value, n), {});
 	}
-	drawChild(r, T, E) {
-		let D = this.width * this.originX, O = this.height * this.originY, k = Math.cos(this.rotation), A = Math.sin(this.rotation), j = (r.x - D) * this.scaleX, M = (r.y - O) * this.scaleY, N = this.x + j * k - M * A, P = this.y + j * A + M * k, F = this.z + r.z, I = this.rotation + r.rotation, { px: L, py: R } = E.projection.project(N, P, F);
-		console.log(N, P, this.x, this.y), T.save(), T.translate(L, R), T.rotate(I), r.render(T), T.restore();
+};
+const Assets = new ResourceManager();
+var FederatedEvent = class {
+	constructor(n) {
+		this.system = n;
+	}
+	getLocalPosition(n, j) {
+		return n.worldTransform.applyInverse(j || this.global);
+	}
+	composedPath() {
+		return (!this.path || this.path[this.path.length - 1] !== this.target) && (this.path = this.target ? this.system.propagationPath(this.target) : []), this.path;
+	}
+}, _EventSystem, PROPAGATION_LIMIT = 2048, EventSystem = class {
+	constructor(n) {
+		this.domElement = null, this.rootTarget = null, this.resolution = 1, this._allInteractiveElements = [], this._hitElements = [], this._isPointerMoveEvent = !1, this.mappingState = { trackingData: {} }, this.renderer = n, this.resolution = n.resolution, this._onPointerDown = this._onPointerDown.bind(this), this._onPointerMove = this._onPointerMove.bind(this), this._onPointerUp = this._onPointerUp.bind(this), this._onPointerOverOut = this._onPointerOverOut.bind(this), this.init();
+	}
+	trackingData(n) {
+		return this.mappingState.trackingData[n] || (this.mappingState.trackingData[n] = {
+			pressTargetsByButton: {},
+			clicksByButton: {},
+			overTargets: null
+		}), this.mappingState.trackingData[n];
+	}
+	init() {
+		let n = this.renderer.canvas;
+		this.setTargetElement(n);
+	}
+	setTargetElement(n) {
+		this._removeEvents(), this.domElement = n, this._addEvents();
+	}
+	dispatchEvent(n, j) {
+		if (!n.target) return;
+		let M = n.composedPath();
+		for (let N = 0; N < M.length - 1; ++N) n.currentTarget = M[N], this._notifyTarget(n, j);
+		n.currentTarget = n.target, this._notifyTarget(n, j);
+	}
+	_notifyTarget(n, j) {
+		j != null || (j = n.type);
+		let M = n.currentTarget._events[j];
+		if (M) if ("fn" in M) M.once && n.target.removeListener(j, M.fn, void 0, !0), M.fn.call(M.context, n);
+		else for (let N = 0; N < M.length; ++N) {
+			let P = M[N];
+			P.once && n.target.removeListener(j, P.fn, void 0, !0), P.fn.call(P.context, n);
+		}
 	}
-}, Renderer = class {
-	constructor(r) {
-		this.ctx = r;
+	propagationPath(n) {
+		let j = [n];
+		for (let M = 0; M < PROPAGATION_LIMIT && (n !== this.rootTarget || n.parent); ++M) {
+			if (!n.parent) throw Error("Cannot find propagation path to disconnected target");
+			j.push(n.parent), n = n.parent;
+		}
+		return j.reverse(), j;
+	}
+	_removeEvents() {
+		let n = this.domElement;
+		n && (globalThis.document.removeEventListener("pointermove", this._onPointerMove, !0), n.removeEventListener("pointerdown", this._onPointerDown, !0), n.removeEventListener("pointerleave", this._onPointerOverOut, !0), n.removeEventListener("pointerover", this._onPointerOverOut, !0), globalThis.document.removeEventListener("pointerup", this._onPointerUp, !0));
+	}
+	_addEvents() {
+		let n = this.domElement;
+		if (!n) return;
+		let j = n.style;
+		j && (j.touchAction = "none"), globalThis.document.addEventListener("pointermove", this._onPointerMove, !0), n.addEventListener("pointerdown", this._onPointerDown, !0), n.addEventListener("pointerleave", this._onPointerOverOut, !0), n.addEventListener("pointerover", this._onPointerOverOut, !0), globalThis.document.addEventListener("pointerup", this._onPointerUp, !0);
+	}
+	_onPointerMove(n) {
+		var j;
+		if (this.rootTarget = this.renderer.renderedObject, !this.rootTarget) return;
+		this._isPointerMoveEvent = !0, this._allInteractiveElements.length = 0, this._hitElements.length = 0;
+		let M = this.createPointEvent(n);
+		this._isPointerMoveEvent = !1;
+		let N = this.trackingData(n.pointerId), P = findMountedTarget(N.overTargets);
+		if (((j = N.overTargets) == null ? void 0 : j.length) > 0 && P !== M.target) {
+			let j = this.createPointEvent(n, "pointerout", P);
+			this.dispatchEvent(j, "pointerout");
+			let N = M.composedPath();
+			if (!N.includes(P)) {
+				let j = this.createPointEvent(n, "pointerleave", P);
+				for (; j.target && !N.includes(j.target);) j.currentTarget = j.target, this._notifyTarget(j), j.target = j.target.parent;
+			}
+		}
+		if (P !== M.target) {
+			let n = "pointerover", j = this.clonePointEvent(M, n);
+			this.dispatchEvent(j, n);
+			let N = P == null ? void 0 : P.parent;
+			for (; N && N !== this.rootTarget.parent && N !== M.target;) N = N.parent;
+			if (!N || N === this.rootTarget.parent) {
+				let n = this.clonePointEvent(M, "pointerenter");
+				for (; n.target && n.target !== P && n.target !== this.rootTarget.parent;) n.currentTarget = n.target, this._notifyTarget(n), n.target = n.target.parent;
+			}
+		}
+		this.dispatchEvent(M, "pointermove");
+		let F = this._allInteractiveElements;
+		for (let n = F.length - 1; n >= 0; --n) M.currentTarget = F[n], this._notifyTarget(M, "globalpointermove");
+		this._allInteractiveElements.length = 0, this._hitElements.length = 0, N.overTargets = M.composedPath();
+	}
+	_onPointerDown(n) {
+		if (this.rootTarget = this.renderer.renderedObject, !this.rootTarget) return;
+		let j = this.createPointEvent(n);
+		this.dispatchEvent(j, "pointerdown");
+		let M = this.trackingData(n.pointerId);
+		M.pressTargetsByButton[n.button] = j.composedPath();
+	}
+	_onPointerOverOut(n) {
+		if (this.rootTarget = this.renderer.renderedObject, !this.rootTarget) return;
+		let j = this.createPointEvent(n);
+		this.dispatchEvent(j, "pointerout");
+	}
+	_onPointerUp(n) {
+		if (this.rootTarget = this.renderer.renderedObject, !this.rootTarget) return;
+		let j = n.target;
+		n.composedPath && n.composedPath().length > 1 && (j = n.composedPath()[0]);
+		let M = j === this.domElement ? "" : "outside", N = this.createPointEvent(n);
+		this.dispatchEvent(N, `pointerup${M}`);
+	}
+	_isInteractive(n) {
+		return n === "static";
+	}
+	createPointEvent(n, j, M) {
+		var N;
+		let P = this.mapPositionToPoint(n.clientX, n.clientY);
+		n.type === "pointerleave" && (j = "pointerout");
+		let F = new FederatedEvent(this);
+		return F.type = j, F.nativeEvent = n, F.target = (N = M == null ? this.hitTest(P.x, P.y) : M) == null ? this._hitElements[0] : N, F.global = P, F;
+	}
+	clonePointEvent(n, j) {
+		let M = new FederatedEvent(this);
+		return M.nativeEvent = n.nativeEvent, M.global = n.global, M.type = j == null ? n.type : j, M.path = n.composedPath().slice(), M.target = n.target, M;
+	}
+	mapPositionToPoint(n, j) {
+		let M = this.domElement, N = M.isConnected ? M.getBoundingClientRect() : {
+			x: 0,
+			y: 0,
+			width: M.width,
+			height: M.height,
+			left: 0,
+			top: 0
+		}, P = 1 / this.resolution, F = new Vector2();
+		return F.x = (n - N.left) * (M.width / N.width) * P, F.y = (j - N.top) * (M.height / N.height) * P, F;
+	}
+	hitTest(n, j) {
+		let M = this._isPointerMoveEvent, N = this[M ? "hitTestMoveRecursive" : "hitTestRecursive"](this.rootTarget, this.rootTarget.eventMode, new Vector2(n, j));
+		return N && N[0];
+	}
+	_interactivePrune(n) {
+		return !n || !n.visible || n.eventMode === "none";
+	}
+	hitTestMoveRecursive(n, j, M) {
+		let N = !1;
+		if (this._interactivePrune(n)) return;
+		let P = n.children;
+		if (P && P.length > 0) for (let F = P.length - 1; F >= 0; --F) {
+			let I = P[F], L = this.hitTestMoveRecursive(I, this._isInteractive(j) ? j : I.eventMode, M);
+			if (L) {
+				if (L.length > 0 && !L[L.length - 1].parent) continue;
+				let j = this._isInteractive(n.eventMode);
+				(L.length > 0 || j) && (j && this._allInteractiveElements.push(n), L.push(n)), this._hitElements.length === 0 && (this._hitElements = L), N = !0;
+			}
+		}
+		let F = this._isInteractive(j), I = this._isInteractive(n.eventMode);
+		if (I && this._allInteractiveElements.push(n), !(this._hitElements.length > 0)) {
+			if (N) return this._hitElements;
+			if (F && this.hitTestFn(n, M)) return I ? [n] : [];
+		}
 	}
-	render(r) {
-		let E = this.ctx, D = r.camera;
-		E.clearRect(0, 0, E.canvas.width, E.canvas.height), D.apply(E), r.displayList.render(E);
-		for (let O of r.world.objects) if (O instanceof Container) O.draw(E, D);
-		else {
-			let { px: r, py: T } = D.projection.project(O.x, O.y, O.z);
-			E.save(), E.translate(r, T), O.draw(E, D), E.restore();
+	hitTestRecursive(n, j, M) {
+		let N = n.children;
+		for (let P = N.length - 1; P >= 0; P--) {
+			let F = N[P], I = this.hitTestRecursive(F, this._isInteractive(j) ? j : F.eventMode, M);
+			if (I) {
+				let j = this._isInteractive(n.eventMode);
+				return (I.length > 0 || j) && I.push(n), I;
+			}
+		}
+		let P = this._isInteractive(j), F = this._isInteractive(n.eventMode);
+		return P && this.hitTestFn(n, M) ? F ? [n] : [] : null;
+	}
+	hitTestFn(n, j) {
+		if (n.hitArea) return !0;
+		if (n.containsPoint) {
+			let M = n.worldTransform.applyInverse(j);
+			return n.containsPoint(M);
 		}
-		D.restore(E);
+		return !1;
 	}
-}, EventSystem = class {
+};
+_EventSystem = EventSystem, _EventSystem.desc = { name: "events" };
+function findMountedTarget(n) {
+	if (!n) return;
+	let j = n[0];
+	for (let M = 1; M < n.length && n[M].parent === j; ++M) j = n[M];
+	return j;
+}
+var InstructionSet = class {
 	constructor() {
-		this.events = /* @__PURE__ */ new Map();
+		this.instructions = [], this.instructionSize = 0;
+	}
+	reset() {
+		this.instructionSize = 0;
 	}
-	on(r, T) {
-		this.events.has(r) || this.events.set(r, /* @__PURE__ */ new Set()), this.events.get(r).add(T);
+	add(n) {
+		this.instructions[this.instructionSize++] = n;
 	}
-	off(r, T) {
-		this.events.has(r) && this.events.get(r).delete(T);
+}, RenderGroup = class {
+	constructor(n) {
+		this.worldTransform = new Matrix(), this.localTransform = new Matrix(), this.root = null, this.instructionSet = new InstructionSet(), this.structureDidChange = !0, this.renderGroupParent = null, this.renderGroupChildren = [], this.childrenToUpdate = Object.create(null), this.init(n);
 	}
-	emit(r, ...T) {
-		if (this.events.has(r)) for (let E of this.events.get(r)) E(...T);
+	init(n) {
+		this.root = n;
+		let j = n.children;
+		for (let n = 0; n < j.length; ++n) this.addChild(j[n]);
+	}
+	addChild(n) {
+		this.structureDidChange = !0, n.parentRenderGroup = this, n.parent === this.root ? n.relativeRenderGroupDepth = 1 : n.relativeRenderGroupDepth = n.parent.relativeRenderGroupDepth + 1, n.didChange = !0, this.onChildUpdate(n);
+		let j = n.children;
+		for (let n = 0; n < j.length; ++n) this.addChild(j[n]);
+	}
+	removeChild(n) {
+		if (this.structureDidChange = !0, n.parentRenderGroup = null, n.renderGroup) {
+			this._removeRenderGroupChild(n.renderGroup);
+			return;
+		}
+		let j = n.children;
+		for (let n = 0; n < j.length; ++n) this.removeChild(j[n]);
+	}
+	removeChildren(n) {
+		for (let j = 0; j < n.length; ++j) this.removeChild(n[j]);
+	}
+	_removeRenderGroupChild(n) {
+		let j = this.renderGroupChildren.indexOf(n);
+		j > -1 && this.renderGroupChildren.splice(j, 1), n.renderGroupParent = null;
+	}
+	onChildUpdate(n) {
+		let j = this.childrenToUpdate[n.relativeRenderGroupDepth];
+		j || (j = this.childrenToUpdate[n.relativeRenderGroupDepth] = {
+			index: 0,
+			list: []
+		}), j.list[j.index++] = n;
+	}
+	destroy() {
+		this.root = null, this.instructionSet = null;
 	}
 };
-function _typeof(r) {
-	"@babel/helpers - typeof";
-	return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
-		return typeof r;
-	} : function(r) {
-		return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
-	}, _typeof(r);
+function updateBounds(n, j, M) {
+	let { width: N, height: P } = M.orig;
+	n.minX = -j.x * N, n.minY = -j.y * P, n.maxX = n.minX + N, n.maxY = n.minY + P;
 }
-function toPrimitive(r, T) {
-	if (_typeof(r) != "object" || !r) return r;
-	var E = r[Symbol.toPrimitive];
-	if (E !== void 0) {
-		var D = E.call(r, T || "default");
-		if (_typeof(D) != "object") return D;
-		throw TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return (T === "string" ? String : Number)(r);
+function applyMixins(n, ...j) {
+	for (let M of j) Object.defineProperties(n.prototype, Object.getOwnPropertyDescriptors(M));
 }
-function toPropertyKey(r) {
-	var T = toPrimitive(r, "string");
-	return _typeof(T) == "symbol" ? T : T + "";
+var ObservablePoint = class {
+	constructor(n, j, M) {
+		this._x = j || 0, this._y = M || 0, this._observer = n;
+	}
+	set(n = 0, j = n) {
+		return (this._x !== n || this._y !== j) && (this._x = n, this._y = j, this._observer._onUpdate(this)), this;
+	}
+	get x() {
+		return this._x;
+	}
+	set x(n) {
+		this._x !== n && (this._x = n, this._observer._onUpdate(this));
+	}
+	get y() {
+		return this._y;
+	}
+	set y(n) {
+		this._y !== n && (this._y = n, this._observer._onUpdate(this));
+	}
+	copyFrom(n) {
+		return (this.x !== n.x || this.y !== n.y) && (this._x = n.x, this._y = n.y, this._observer._onUpdate(this)), this;
+	}
+	toVector2() {
+		return new Vector2(this.x, this.y);
+	}
+};
+const RAD_TO_DEG = 180 / Math.PI, DEG_TO_RAD = Math.PI / 180;
+var Bounds = class n {
+	constructor(n = Infinity, j = Infinity, M = -Infinity, N = -Infinity) {
+		this.minX = Infinity, this.minY = Infinity, this.maxX = -Infinity, this.maxY = -Infinity, this.matrix = new Matrix(), this.minX = n, this.minY = j, this.maxX = M, this.maxY = N;
+	}
+	clone() {
+		return new n(this.minX, this.minY, this.maxX, this.maxY);
+	}
+	isEmpty() {
+		return this.minX >= this.maxX || this.minY >= this.maxY;
+	}
+	clear() {
+		this.minX = Infinity, this.minY = Infinity, this.maxX = -Infinity, this.maxY = -Infinity;
+	}
+	get width() {
+		return this.maxX - this.minX;
+	}
+	set width(n) {
+		this.maxX = this.minX + n;
+	}
+	get height() {
+		return this.maxY - this.minY;
+	}
+	set height(n) {
+		this.maxY = this.minY + n;
+	}
+	get left() {
+		return this.minX;
+	}
+	get right() {
+		return this.maxX;
+	}
+	get top() {
+		return this.minY;
+	}
+	get bottom() {
+		return this.maxY;
+	}
+	get isValid() {
+		return this.minX + this.minY !== Infinity;
+	}
+	set(n, j, M, N) {
+		this.minX = n, this.minY = j, this.maxX = M, this.maxY = N;
+	}
+	addBounds(n, j) {
+		this.addFrame(n.minX, n.minY, n.maxX, n.maxY, j);
+	}
+	addRect(n, j) {
+		this.addFrame(n.x, n.y, n.width + n.x, n.height + n.y, j);
+	}
+	addFrame(n, j, M, N, P) {
+		P || (P = this.matrix);
+		let F = P.a, I = P.b, L = P.c, R = P.d, z = P.tx, B = P.ty;
+		updateMinMax(F * n + L * j + z, I * n + R * j + B, this), updateMinMax(F * M + L * j + z, I * M + R * j + B, this), updateMinMax(F * n + L * N + z, I * n + R * N + B, this), updateMinMax(F * M + L * N + z, I * M + R * N + B, this);
+	}
+	get rectangle() {
+		this._rectangle || (this._rectangle = new Rectangle());
+		let n = this._rectangle;
+		return n.x = this.minX, n.y = this.minY, n.width = this.maxX - this.minX, n.height = this.maxY - this.minY, n;
+	}
+	addBoundsMask(n) {
+		this.minX = this.minX > n.minX ? this.minX : n.minX, this.minY = this.minY > n.minY ? this.minY : n.minY, this.maxX = this.maxX < n.maxX ? this.maxX : n.maxX, this.maxY = this.maxY < n.maxY ? this.maxY : n.maxY;
+	}
+};
+function updateMinMax(n, j, M) {
+	n < M.minX && (M.minX = n), n > M.maxX && (M.maxX = n), j < M.minY && (M.minY = j), j > M.maxY && (M.maxY = j);
 }
-function _defineProperty(r, T, E) {
-	return (T = toPropertyKey(T)) in r ? Object.defineProperty(r, T, {
-		value: E,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : r[T] = E, r;
+function getLocalBounds(n, j, M) {
+	return j.clear(), M || (M = new Matrix()), _getLocalBounds(n, j, M, n, !0), j.isValid || j.set(0, 0, 0, 0), j;
 }
-function ownKeys(r, T) {
-	var E = Object.keys(r);
-	if (Object.getOwnPropertySymbols) {
-		var D = Object.getOwnPropertySymbols(r);
-		T && (D = D.filter(function(T) {
-			return Object.getOwnPropertyDescriptor(r, T).enumerable;
-		})), E.push.apply(E, D);
-	}
-	return E;
+function _getLocalBounds(n, j, M, N, P) {
+	let F = new Matrix();
+	if (P) F.copyFrom(M);
+	else {
+		if (!n.visible || !n.measurable) return;
+		n.updateLocalTransform(), F.appendFrom(n.localTransform, M);
+	}
+	let I = j, L = !!n.effects.length;
+	if (L && (j = new Bounds()), n.boundsArea) j.addRect(n.boundsArea, F);
+	else {
+		n.renderPipeId && (j.matrix = F, j.addBounds(n.bounds));
+		let M = n.children;
+		for (let n = 0; n < M.length; n++) _getLocalBounds(M[n], j, F, N, !1);
+		if (L) {
+			for (let M = 0; M < n.effects.length; ++M) {
+				var R, z;
+				(R = (z = n.effects[M]).addLocalBounds) == null || R.call(z, j, N);
+			}
+			I.addBounds(j, new Matrix());
+		}
+	}
+	return j;
 }
-function _objectSpread2(r) {
-	for (var T = 1; T < arguments.length; T++) {
-		var E = arguments[T] == null ? {} : arguments[T];
-		T % 2 ? ownKeys(Object(E), !0).forEach(function(T) {
-			_defineProperty(r, T, E[T]);
-		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(E)) : ownKeys(Object(E)).forEach(function(T) {
-			Object.defineProperty(r, T, Object.getOwnPropertyDescriptor(E, T));
-		});
+var StencilMask = class {
+	constructor(n) {
+		this.pipe = "stencilMask", this.mask = n, n.includeInBuild = !1, n.measurable = !1;
 	}
-	return r;
+	addLocalBounds(n, j) {
+		let M = new Bounds();
+		this.mask.measurable = !0;
+		let N = getMatrixRelativeToParent(this.mask, j);
+		getLocalBounds(this.mask, M, N), this.mask.measurable = !1, n.addBoundsMask(M);
+	}
+};
+function getMatrixRelativeToParent(n, j, M) {
+	return M || (M = new Matrix()), n === j ? M : (M = getMatrixRelativeToParent(n.parent, j, M), n.updateLocalTransform(), Matrix.append(M, n.localTransform));
 }
-const InputEventType = {
-	KEY_DOWN: Symbol("keyDown"),
-	KEY_UP: Symbol("keyUp"),
-	POINTER_DOWN: Symbol("pointerDown"),
-	POINTER_MOVE: Symbol("pointerMove"),
-	POINTER_UP: Symbol("pointerUp")
+const effectMixin = {
+	effects: [],
+	_maskEffect: null,
+	addEffect(n) {
+		this.effects.push(n), this._updateIsSimple();
+	},
+	removeEffect(n) {
+		let j = this.effects.indexOf(n);
+		j === -1 && this.effects.splice(j, 1), this._updateIsSimple();
+	},
+	set mask(n) {
+		let j = this._maskEffect;
+		n !== (j == null ? void 0 : j.mask) && (j && (this.removeEffect(j), this._maskEffect = null), n != null && (this._maskEffect = new StencilMask(n), this.addEffect(this._maskEffect)));
+	},
+	get mask() {
+		var n;
+		return (n = this._maskEffect) == null ? void 0 : n.mask;
+	}
+}, sortMixin = {
+	_zIndex: 0,
+	sortableChildren: !1,
+	sortDirty: !1
+}, measureMixin = {
+	_localBoundsCacheData: null,
+	_localBounds: null,
+	_setWidth(n, j) {
+		let M = Math.sign(this.scale.x) || 1;
+		j === 0 ? this.scale.x = M : this.scale.x = n / j * M;
+	},
+	_setHeight(n, j) {
+		let M = Math.sign(this.scale.y) || 1;
+		j === 0 ? this.scale.y = M : this.scale.y = n / j * M;
+	},
+	getLocalBounds() {
+		return this._localBounds || (this._localBounds = new Bounds()), getLocalBounds(this, this._localBounds), this._localBounds;
+	}
 };
-var InputSystem = class {
-	constructor(r, T) {
-		this.keys = /* @__PURE__ */ new Set(), this.pointer = {
-			x: 0,
-			y: 0,
-			dx: 0,
-			dy: 0,
-			down: !1,
-			justDown: !1,
-			justUp: !1,
-			id: null
-		}, this.target = r, this.events = T, window.addEventListener("keydown", (r) => {
-			r.preventDefault(), this.keys.add(r.code), this.events.emit(InputEventType.KEY_DOWN, r);
-		}), window.addEventListener("keyup", (r) => {
-			this.keys.delete(r.code), this.events.emit(InputEventType.KEY_UP, r);
-		}), r.addEventListener("mousedown", this.onDown.bind(this)), r.addEventListener("mousemove", this.onMove.bind(this)), r.addEventListener("mouseup", this.onUp.bind(this)), r.addEventListener("touchstart", this.onDown.bind(this), { passive: !1 }), r.addEventListener("touchmove", this.onMove.bind(this), { passive: !1 }), r.addEventListener("touchend", this.onUp.bind(this));
+function clearList(n, j) {
+	j || (j = 0);
+	for (let M = j; M < n.length && n[M]; ++M) n[M] = null;
+}
+function assignWithIgnore(n, j, M = {}) {
+	for (let N in j) !M[N] && j[N] !== void 0 && (n[N] = j[N]);
+}
+const childrenHelperMixin = { removeChildren(n = 0, j) {
+	let M = j == null ? this.children.length : j, N = M - n, P = [];
+	if (N > 0 && N <= M) {
+		for (let j = M - 1; j >= n; --j) {
+			let n = this.children[j];
+			n && (P.push(n), n.parent = null);
+		}
+		removeItems(this.children, n, M);
+		let j = this.renderGroup || this.parentRenderGroup;
+		return j && j.removeChildren(P), P;
+	} else if (N === 0 && this.children.length === 0) return P;
+	throw Error("removeChildren: numeric values are outside the acceptable range.");
+} };
+function removeItems(n, j, M) {
+	let N = n.length, P;
+	if (j >= N || M === 0) return;
+	M = j + M > N ? N - j : M;
+	let F = N - M;
+	for (P = j; P < F; ++P) n[P] = n[P + M];
+	n.length = F;
+}
+const UPDATE_COLOR = 1, UPDATE_BLEND = 2, UPDATE_VISIBLE = 4, UPDATE_TRANSFORM = 8;
+var defaultSkew = new ObservablePoint(null), defaultOrigin = new ObservablePoint(null), defaultScale = new ObservablePoint(null, 1, 1), defaultPivot = new ObservablePoint(null), Container = class extends eventemitter3_default {
+	constructor(n = {}) {
+		super(), this.destroyed = !1, this.renderGroup = null, this.parentRenderGroup = null, this.parent = null, this.eventMode = "passive", this.hitArea = null, this._position = new ObservablePoint(this, 0, 0), this.includeInBuild = !0, this.didChange = !1, this.isSimple = !0, this.measurable = !0, this.relativeRenderGroupDepth = 0, this._attrUpdateTick = 0, this._localTransformUpdateTick = 0, this._updateFlags = 15, this.localDisplayStatus = 7, this.globalDisplayStatus = 7, this.children = [], this.localTransform = new Matrix(), this.relativeGroupTransform = new Matrix(), this.groupTransform = this.relativeGroupTransform, this._rotation = 0, this._cx = 1, this._sx = 0, this._cy = 0, this._sy = 1, this._skew = defaultSkew, this._scale = defaultScale, this._origin = defaultOrigin, this._pivot = defaultPivot, this.localAlpha = 1, this.groupColor = 16777215, this.localColor = 16777215, this.groupAlpha = 1, this.groupColorAlpha = 4294967295, assignWithIgnore(this, n, {
+			children: !0,
+			parent: !0,
+			effects: !0
+		}), this.effects = [];
 	}
-	update() {
-		this.pointer.justDown = !1, this.pointer.justUp = !1, this.pointer.dx = 0, this.pointer.dy = 0;
+	get renderable() {
+		return !!(this.localDisplayStatus & 1);
 	}
-	isKeyboardDown(r) {
-		return this.keys.has(r);
+	set renderable(n) {
+		let j = n ? 1 : 0;
+		(this.localDisplayStatus & 1) !== j && (this._updateFlags |= 4, this.localDisplayStatus ^= 1, this.parentRenderGroup && (this.parentRenderGroup.structureDidChange = !0), this._onUpdate());
 	}
-	onDown(r) {
-		r.preventDefault();
-		let T = this._getPoint(r);
-		if (!T) {
-			console.warn("missing point");
-			return;
-		}
-		this.pointer.down = !0, this.pointer.justDown = !0, this.pointer.x = T.x, this.pointer.y = T.y, this.pointer.id = T.id, this.events.emit(InputEventType.POINTER_DOWN, _objectSpread2({}, this.pointer));
+	get visible() {
+		return !!(this.localDisplayStatus & 2);
 	}
-	onMove(r) {
-		if (!this.pointer.down) return;
-		r.preventDefault();
-		let T = this._getPoint(r);
-		if (!T) {
-			console.warn("missing point");
-			return;
+	set visible(n) {
+		let j = n ? 2 : 0;
+		(this.localDisplayStatus & 2) !== j && (this.parentRenderGroup && (this.parentRenderGroup.structureDidChange = !0), this._updateFlags |= 4, this.localDisplayStatus ^= 2, this._onUpdate());
+	}
+	get isRenderGroup() {
+		return !!this.renderGroup;
+	}
+	set isRenderGroup(n) {
+		!!this.renderGroup !== n && (n ? this.enableRenderGroup() : this.disableRenderGroup());
+	}
+	get zIndex() {
+		return this._zIndex;
+	}
+	set zIndex(n) {
+		n !== this._zIndex && (this._zIndex = n, this.depthOfChildModified());
+	}
+	_updateIsSimple() {
+		this.isSimple = !this.renderGroup && this.effects.length == 0;
+	}
+	sortChildren() {
+		this.sortDirty && (this.sortDirty = !1, this.children.sort(sortChildren));
+	}
+	depthOfChildModified() {
+		this.parent && (this.parent.sortableChildren = !0, this.parent.sortDirty = !0), this.parentRenderGroup;
+	}
+	enableRenderGroup() {
+		this.renderGroup || (this.renderGroup = new RenderGroup(this), this.groupTransform = new Matrix(), this._updateIsSimple());
+	}
+	disableRenderGroup() {
+		if (!this.renderGroup) return;
+		let n = this.parentRenderGroup;
+		n == null || n.removeChild(this), this.renderGroup = null, this.groupTransform = this.relativeGroupTransform, n == null || n.addChild(this), this._updateIsSimple();
+	}
+	collectRenderables(n, j) {
+		this.globalDisplayStatus < 7 || !this.includeInBuild || (this.sortableChildren && this.sortChildren(), this.isSimple ? this.collectRenderableSimple(n, j) : this.renderGroup || this.collectRenderablesWithEffects(n, j));
+	}
+	collectRenderablesWithEffects(n, j) {
+		for (let M = 0; M < this.effects.length; ++M) {
+			let N = this.effects[M];
+			n[N.pipe].push(N, j);
+		}
+		this.collectRenderableSimple(n, j);
+		for (let M = 0; M < this.effects.length; ++M) {
+			let N = this.effects[M];
+			n[N.pipe].pop(N, j);
 		}
-		this.pointer.dx += T.x - this.pointer.x, this.pointer.dy += T.y - this.pointer.y, this.pointer.x = T.x, this.pointer.y = T.y, this.events.emit(InputEventType.POINTER_MOVE, _objectSpread2({}, this.pointer));
 	}
-	onUp() {
-		this.pointer.down = !1, this.pointer.justUp = !0, this.pointer.id = null, this.events.emit(InputEventType.POINTER_UP, _objectSpread2({}, this.pointer));
+	collectRenderableSimple(n, j) {
+		let M = this.children;
+		for (let N = 0; N < M.length; ++N) M[N].collectRenderables(n, j);
 	}
-	_getPoint(r) {
-		let T = this.target.getBoundingClientRect(), E, D, O = "mouse";
-		if (r instanceof TouchEvent) {
-			let T = r.touches[0] || r.changedTouches[0];
-			if (!T) return;
-			E = T.clientX, D = T.clientY, O = T.identifier;
-		} else E = r.clientX, D = r.clientY;
-		return {
-			x: E - T.left,
-			y: D - T.top,
-			id: O
-		};
+	setFromMatrix(n) {
+		n.decompose(this);
+	}
+	_updateSkew() {
+		let n = this.rotation, j = this.skew;
+		this._cx = Math.cos(n + j.y), this._sx = Math.sin(n + j.y), this._cy = -Math.sin(n - j.x), this._sy = Math.cos(n - j.x);
+	}
+	updateLocalTransform() {
+		let n = this._attrUpdateTick;
+		if (this._localTransformUpdateTick === n) return;
+		this._localTransformUpdateTick = n, this._updateSkew();
+		let j = this.position, M = this.localTransform, N = this._scale.x, P = this._scale.y, F = -this._origin.x, I = -this._origin.y, L = this._pivot.x, R = this._pivot.y;
+		M.a = this._cx * N, M.b = this._sx * N, M.c = this._cy * P, M.d = this._sy * P, M.tx = j.x - (L * M.a + R * M.c) + (F * M.a + I * M.c) - F, M.ty = j.y - (L * M.b + R * M.d) + (F * M.b + I * M.d) - I;
+	}
+	get alpha() {
+		return this.localAlpha;
+	}
+	set alpha(n) {
+		n !== this.localAlpha && (this.localAlpha = n, this._updateFlags |= 1, this._onUpdate());
+	}
+	get root() {
+		let n = this.parent, j = this.parent;
+		for (; n;) n.parent || (j = n), n = n.parent;
+		return j;
+	}
+	get worldTransform() {
+		return this._worldTransform || (this._worldTransform = new Matrix()), this.renderGroup ? this._worldTransform.copyFrom(this.renderGroup.worldTransform) : this.parentRenderGroup && this._worldTransform.appendFrom(this.relativeGroupTransform, this.parentRenderGroup.worldTransform), this._worldTransform;
+	}
+	get x() {
+		return this._position.x;
+	}
+	set x(n) {
+		this._position.x = n;
+	}
+	get position() {
+		return this._position;
+	}
+	set position(n) {
+		this._position.copyFrom(n);
+	}
+	get y() {
+		return this._position.y;
+	}
+	set y(n) {
+		this._position.y = n;
+	}
+	get rotation() {
+		return this._rotation;
+	}
+	set rotation(n) {
+		this._rotation !== n && (this._rotation = n, this._onUpdate(this._skew));
+	}
+	get angle() {
+		return this.rotation * RAD_TO_DEG;
+	}
+	set angle(n) {
+		this.rotation = n * DEG_TO_RAD;
+	}
+	get skew() {
+		return this._skew === defaultSkew && (this._skew = new ObservablePoint(this, 0, 0)), this._skew;
+	}
+	set skew(n) {
+		this._skew === defaultSkew && (this._skew = new ObservablePoint(this, 0, 0)), this._skew.copyFrom(n);
+	}
+	get scale() {
+		return this._scale === defaultScale && (this._scale = new ObservablePoint(this, 1, 1)), this._scale;
+	}
+	set scale(n) {
+		this._scale === defaultScale && (this._scale = new ObservablePoint(this, 1, 1)), this._scale.copyFrom(n);
+	}
+	get pivot() {
+		return this._pivot === defaultPivot && (this._pivot = new ObservablePoint(this, 0, 0)), this._pivot;
+	}
+	set pivot(n) {
+		this._pivot === defaultPivot && (this._pivot = new ObservablePoint(this, 0, 0)), this._pivot.copyFrom(n);
+	}
+	get origin() {
+		return this._origin === defaultOrigin && (this._origin = new ObservablePoint(this, 0, 0)), this._origin;
+	}
+	set origin(n) {
+		this._origin === defaultOrigin && (this._origin = new ObservablePoint(this, 0, 0)), this._origin.copyFrom(n);
 	}
-}, Camera = class {
 	get width() {
-		return this.viewport.width;
+		return Math.abs(this.scale.x * this.getLocalBounds().width);
 	}
+	set width(n) {}
 	get height() {
-		return this.viewport.height;
+		return Math.abs(this.scale.y * this.getLocalBounds().height);
 	}
-	constructor(r) {
-		this.viewport = {
-			x: 0,
-			y: 0,
-			width: 0,
-			height: 0
-		}, this.x = 0, this.y = 0, this.zoom = 1, this._followLerp = 1, this._offsetX = 0, this._offsetY = 0, this.originX = 0, this.originY = 0, this.projection = r;
-	}
-	setOrigin(r, T) {
-		this.originX = r, this.originY = T;
-	}
-	setViewport(r, T, E, D) {
-		this.viewport = {
-			x: r,
-			y: T,
-			width: E,
-			height: D
-		};
+	set height(n) {}
+	addChild(...n) {
+		if (n.length > 1) {
+			for (let j = 0; j < n.length; ++j) this.addChild(n[j]);
+			return n[0];
+		}
+		let j = n[0], M = this.renderGroup || this.parentRenderGroup;
+		return j.parent === this ? (this.children.splice(this.children.indexOf(j), 1), this.children.push(j), M && (M.structureDidChange = !0), j) : (this.sortableChildren && (this.sortDirty = !0), j.parent && j.parent.removeChild(j), this.children.push(j), this.sortableChildren && (this.sortDirty = !0), j.parent = this, j.didChange = !0, j._updateFlags = 7, M && M.addChild(j), j._zIndex != 0 && j.depthOfChildModified(), j);
 	}
-	apply(r) {
-		r.save(), r.translate(this.originX * this.viewport.width, this.originY * this.viewport.height), r.scale(this.zoom, this.zoom), r.translate(-Math.round(this.x), -Math.round(this.y));
+	removeChild(...n) {
+		if (n.length > 1) {
+			for (let j = 0; j < n.length; ++j) this.removeChild(n[j]);
+			return n[0];
+		}
+		let j = n[0];
+		if (!j) return j;
+		let M = this.children.indexOf(j);
+		return M > -1 && (this.children.splice(M, 1), j.parent = null), j;
+	}
+	_onUpdate(n) {
+		n && n === this._skew && this._updateSkew(), this._attrUpdateTick++, !this.didChange && (this.didChange = !0, this.parentRenderGroup && this.parentRenderGroup.onChildUpdate(this));
+	}
+	toGlobal(n, j) {
+		return this.getGlobalTransform(j).apply(n);
+	}
+	toLocal(n, j, M) {
+		let N;
+		return j && (N = j.toGlobal(n)), N = this.getGlobalTransform(M).applyInverse(n), N;
+	}
+	getGlobalTransform(n = !1) {
+		if (n) return this.worldTransform.clone();
+		this.updateLocalTransform();
+		let j = new Matrix(), M = updateTransformBackwards(this, j);
+		return j.appendFrom(this.localTransform, M), j;
+	}
+	getGlobalPosition(n = !1) {
+		return this.parent ? this.parent.toGlobal(this._position, n) : this._position.toVector2();
+	}
+	destroy(n = !1) {
+		var j, M;
+		if (this.destroyed) return;
+		this.destroyed = !0;
+		let N;
+		if (this.children.length && (N = this.removeChildren(0, this.children.length)), (j = this.parent) == null || j.removeChild(this), this.parent = null, this._maskEffect = null, this.effects = null, this._position = null, this._scale = null, this._pivot = null, this._origin = null, this._skew = null, (typeof n == "boolean" ? n : n != null && n.children) && N) for (let j = 0; j < N.length; ++j) N[j].destroy(n);
+		(M = this.renderGroup) == null || M.destroy(), this.renderGroup = null;
 	}
-	restore(r) {
-		r.restore();
+};
+function updateTransformBackwards(n, j) {
+	let M = n.parent;
+	if (M) {
+		updateTransformBackwards(M, j), M.updateLocalTransform();
+		let n = Matrix.append(j, M.localTransform);
+		j.copyFrom(n);
+	}
+	return j;
+}
+function sortChildren(n, j) {
+	return n._zIndex - j._zIndex;
+}
+applyMixins(Container, sortMixin, effectMixin, measureMixin, childrenHelperMixin);
+var UPDATE_BLEND_COLOR_VISIBLE = 7;
+function updateRenderGroupTransform(n, j = !1) {
+	let M = n.root;
+	n.worldTransform.copyFrom(M.localTransform);
+	let N = n.childrenToUpdate;
+	for (let j in N) {
+		let M = Number(j), P = N[M], F = P.list, I = P.index;
+		for (let j = 0; j < I; ++j) {
+			let N = F[j];
+			N.parentRenderGroup === n && N.relativeRenderGroupDepth === M && updateTransform(N, 0);
+		}
+		clearList(F, I), P.index = 0;
 	}
-	project(r, T, E = 0) {
-		let { px: D, py: O } = this.projection.project(r, T, E);
-		return {
-			px: D - this.x,
-			py: O - this.y
+	if (j) for (let M = 0; M < n.renderGroupChildren.length; ++M) updateRenderGroupTransform(n.renderGroupChildren[M], j);
+}
+function updateTransform(n, j) {
+	n.didChange = !1;
+	let M = n.parent, N = n.localTransform;
+	n.updateLocalTransform(), M && (j |= n._updateFlags, n.relativeGroupTransform.appendFrom(N, M.relativeGroupTransform), j & UPDATE_BLEND_COLOR_VISIBLE && updateBlendColorVisible(n, M, j));
+	let P = n.children;
+	for (let n = 0; n < P.length; n++) updateTransform(P[n], j);
+}
+function updateBlendColorVisible(n, j, M) {
+	if (M & 1) {
+		n.groupColor = j.groupColor;
+		let M = n.localAlpha * j.groupAlpha;
+		M = M < 0 ? 0 : M > 1 ? 1 : M, n.groupAlpha = M, n.groupColorAlpha = n.groupColor + ((M * 255 | 0) << 24);
+	}
+	M & 4 && (n.globalDisplayStatus = n.localDisplayStatus & j.globalDisplayStatus), n._updateFlags = 0;
+}
+var _RenderGroupSystem, RenderGroupSystem = class {
+	constructor(n) {
+		this.renderer = n;
+	}
+	_updateRenderGroup(n) {
+		let j = this.renderer, M = j.renderPipes;
+		n.instructionSet.renderPipes = M, updateRenderGroupTransform(n), n.structureDidChange && (n.structureDidChange = !1, this._buildInstructions(n, j));
+	}
+	render({ container: n, transform: j }) {
+		let M = this.renderer;
+		j && n.renderGroup.localTransform.copyFrom(j), M.canvasContext.globalTransform = j ? n.renderGroup.localTransform : n.renderGroup.worldTransform, this._updateRenderGroup(n.renderGroup), executeInstructions(n.renderGroup, M.renderPipes);
+	}
+	_buildInstructions(n, j) {
+		let M = j.renderPipes, N = n.root;
+		n.instructionSet.reset(), N.sortableChildren && N.sortChildren(), M.batch.buildStart(), N.collectRenderablesWithEffects(M, n.instructionSet), M.batch.buildEnd(n.instructionSet);
+	}
+};
+_RenderGroupSystem = RenderGroupSystem, _RenderGroupSystem.desc = { name: "renderGroup" };
+function executeInstructions(n, j) {
+	let { instructionSet: M } = n, N = M.instructions;
+	for (let n = 0; n < M.instructionSize; n++) {
+		let M = N[n];
+		j[M.renderPipeId].execute(M);
+	}
+}
+var _SpritePipe, SpritePipe = class {
+	constructor(n) {
+		this._renderer = n;
+	}
+	addRenderable(n, j) {
+		this._renderer.renderPipes.batch.addToBatch({
+			renderable: n,
+			texture: n.texture,
+			transform: n.relativeGroupTransform,
+			bounds: n.bounds,
+			roundPixels: this._renderer._roundPixels | n._roundPixels
+		}, j);
+	}
+	destroy() {
+		this._renderer = null;
+	}
+};
+_SpritePipe = SpritePipe, _SpritePipe.desc = { name: "sprite" };
+var _TextPipe, TextPipe = class {
+	constructor(n) {
+		this._renderer = n;
+	}
+	addRenderable(n, j) {
+		let M = this._getRuntimeText(n);
+		if (n._didTextUpdate) {
+			let j = n._autoResolution ? this._renderer.resolution : n.resolution;
+			(M.currentKey !== n.styleKey || n._resolution !== j) && this._updateRuntimeText(n), n._didTextUpdate = !1, updateBounds(M.bounds, n._anchor, M.texture);
+		}
+		this._renderer.renderPipes.batch.addToBatch(M, j);
+	}
+	initCacheText(n) {
+		let j = {
+			currentKey: "--",
+			transform: n.relativeGroupTransform,
+			bounds: n.bounds,
+			roundPixels: this._renderer._roundPixels | n._roundPixels,
+			renderable: n,
+			texture: null,
+			destroy: function() {
+				this.renderable = null, this.texture = null, this.bounds = null;
+			}
 		};
+		return n._runtimeData[this._renderer.uid] = j, j;
 	}
-	follow(r, T) {
-		var E, D, O;
-		this._followTarget = r, this._followLerp = (E = T == null ? void 0 : T.lerp) == null ? 1 : E, this._offsetX = (D = T == null ? void 0 : T.offsetX) == null ? 0 : D, this._offsetY = (O = T == null ? void 0 : T.offsetY) == null ? 0 : O;
+	_getRuntimeText(n) {
+		return n._runtimeData[this._renderer.uid] || this.initCacheText(n);
 	}
-	stopFollow() {
-		this._followTarget = void 0;
+	_updateRuntimeText(n) {
+		let j = this._getRuntimeText(n);
+		j.texture, n._resolution = n._autoResolution ? this._renderer.resolution : n.resolution, j.texture = this._renderer.text.getManagedTexture(n), j.currentKey = n.styleKey;
 	}
-	update() {
-		if (!this._followTarget) return;
-		let { x: r, y: T, z: E } = this._followTarget, { px: D, py: O } = this.project(r, T, E), k = D + this._offsetX, A = O + this._offsetY;
-		this.x += k * this._followLerp, this.y += A * this._followLerp;
+	destroy() {
+		this._renderer = null;
+	}
+};
+_TextPipe = TextPipe, _TextPipe.desc = { name: "text" };
+var ViewContainer = class extends Container {
+	constructor(...n) {
+		super(...n), this._runtimeData = Object.create(null), this._roundPixels = 0, this._bounds = new Bounds(0, 1, 0, 0);
 	}
-}, CameraController = class {
-	constructor(r, T) {
-		this.speed = 300, this.camera = r, this.input = T;
+	get bounds() {
+		return this.updateBounds(), this._bounds;
 	}
-	update(r) {
-		let T = this.speed * r / 1e3;
-		this.input.isKeyboardDown("ArrowUp") && (this.camera.y += T), this.input.isKeyboardDown("ArrowDown") && (this.camera.y -= T), this.input.isKeyboardDown("ArrowLeft") && (this.camera.x += T), this.input.isKeyboardDown("ArrowRight") && (this.camera.x -= T);
+	onViewUpdate() {
+		this.renderGroup || this.parentRenderGroup;
 	}
-}, DisplayObject = class {
+	collectRenderableSimple(n, j) {
+		let M = n[this.renderPipeId];
+		M && M.addRenderable && M.addRenderable(this, j);
+		let N = this.children;
+		for (let M = 0; M < N.length; ++M) N[M].collectRenderables(n, j);
+	}
+	containsPoint(n) {
+		let j = this.bounds, { x: M, y: N } = n;
+		return M > j.minX && M < j.maxX && N > j.minY && N < j.maxY;
+	}
+	get roundPixels() {
+		return !!this._roundPixels;
+	}
+	set roundPixels(n) {
+		this._roundPixels = n ? 1 : 0;
+	}
+	destroy(n = !1) {
+		for (let n in this._runtimeData) this._runtimeData[n].destroy();
+		this._runtimeData = Object.create(null), this.onViewUpdate(), super.destroy(n), this._bounds = null;
+	}
+}, Polygon = class {
 	constructor() {
-		this.x = 0, this.y = 0, this.originX = .5, this.originY = .5;
+		this.points = [], this.type = "polygon";
 	}
-}, ImageObject = class extends DisplayObject {
-	constructor(r, T, E, D = 1) {
-		super(), this.resolution = 1, this.x = r, this.y = T, this.texture = E, this.resolution = D, this.width = E.width / D, this.height = E.height / D;
+	construction() {}
+	get lastX() {
+		return this.points[this.points.length - 2];
 	}
-	render(r) {
-		r.drawImage(this.texture, this.x - this.width * this.originX, this.y - this.height * this.originY, this.width, this.height);
+	get lastY() {
+		return this.points[this.points.length - 1];
 	}
-}, DisplayList = class {
+	getBounds() {
+		let n = new Rectangle(), j = this.points, M = Infinity, N = Infinity, P = -Infinity, F = -Infinity;
+		for (let n = 0; n < j.length; n += 2) {
+			let I = j[n], L = j[n + 1];
+			M = Math.min(M, I), N = Math.min(N, L), P = Math.max(P, I), F = Math.max(F, L);
+		}
+		return n.x = M, n.width = P - M, n.y = N, n.height = F - N, n;
+	}
+}, RECURSION_LIMIT = 8, FLT_EPSILON = 1.1920929e-7, PATH_DISTANCE_EPSILON = 1, curveAngleToleranceEpsilon = .01, mAngleTolerance = 0, mCuspLimit = 0;
+function buildAdaptiveBezier(n, j, M, N, P, F, I, L, R, z) {
+	let B = (PATH_DISTANCE_EPSILON - Math.min(.99, Math.max(0, z == null ? .5 : z))) / 1;
+	return B *= B, begin(j, M, N, P, F, I, L, R, n, B), n;
+}
+function begin(n, j, M, N, P, F, I, L, R, z) {
+	recursive(n, j, M, N, P, F, I, L, R, z, 0), R.push(I, L);
+}
+function recursive(n, j, M, N, P, F, I, L, R, z, B) {
+	if (B > RECURSION_LIMIT) return;
+	let V = Math.PI, H = (n + M) / 2, U = (j + N) / 2, W = (M + P) / 2, G = (N + F) / 2, K = (P + I) / 2, q = (F + L) / 2, J = (H + W) / 2, Y = (U + G) / 2, X = (W + K) / 2, Z = (G + q) / 2, Q = (J + X) / 2, $ = (Y + Z) / 2;
+	if (B > 0) {
+		let B = I - n, H = L - j, U = Math.abs((M - I) * H - (N - L) * B), W = Math.abs((P - I) * H - (F - L) * B), G, K;
+		if (U > FLT_EPSILON && W > FLT_EPSILON) {
+			if ((U + W) * (U + W) <= z * (B * B + H * H)) {
+				if (mAngleTolerance < curveAngleToleranceEpsilon) {
+					R.push(Q, $);
+					return;
+				}
+				let z = Math.atan2(F - N, P - M);
+				if (G = Math.abs(z - Math.atan2(N - j, M - n)), K = Math.abs(Math.atan2(L - F, I - P) - z), G >= V && (G = 2 * V - G), K >= V && (K = 2 * V - K), G + K < mAngleTolerance) {
+					R.push(Q, $);
+					return;
+				}
+				if (mCuspLimit !== 0) {
+					if (G > mCuspLimit) {
+						R.push(M, N);
+						return;
+					}
+					if (K > mCuspLimit) {
+						R.push(P, F);
+						return;
+					}
+				}
+			}
+		} else if (U > FLT_EPSILON) {
+			if (U * U <= z * (B * B + H * H)) {
+				if (mAngleTolerance < curveAngleToleranceEpsilon) {
+					R.push(Q, $);
+					return;
+				}
+				if (G = Math.abs(Math.atan2(F - N, P - M) - Math.atan2(N - j, M - n)), G >= V && (G = 2 * V - G), G < mAngleTolerance) {
+					R.push(M, N), R.push(P, F);
+					return;
+				}
+				if (mCuspLimit !== 0 && G > mCuspLimit) {
+					R.push(M, N);
+					return;
+				}
+			}
+		} else if (W > FLT_EPSILON) {
+			if (W * W <= z * (B * B + H * H)) {
+				if (mAngleTolerance < curveAngleToleranceEpsilon) {
+					R.push(Q, $);
+					return;
+				}
+				if (G = Math.abs(Math.atan2(L - F, I - P) - Math.atan2(F - N, P - M)), G >= V && (G = 2 * V - G), G < mAngleTolerance) {
+					R.push(M, N), R.push(P, F);
+					return;
+				}
+				if (mCuspLimit !== 0 && G > mCuspLimit) {
+					R.push(P, F);
+					return;
+				}
+			}
+		} else if (B = Q - (n + I) / 2, H = $ - (j + L) / 2, B * B + H * H <= z) {
+			R.push(Q, $);
+			return;
+		}
+	}
+	recursive(n, j, H, U, J, Y, Q, $, R, z, B + 1), recursive(Q, $, X, Z, K, q, I, L, R, z, B + 1);
+}
+var ShapePath = class {
+	constructor(n) {
+		this.shapePrimitives = [], this._bounds = new Bounds(), this._graphicsPath = n;
+	}
+	_ensurePoly(n = !0) {
+		this._currentPoly || (this._currentPoly = new Polygon(), n && this._currentPoly.points.push(0, 0));
+	}
+	lineTo(n, j) {
+		this._ensurePoly();
+		let M = this._currentPoly.points, N = M[M.length - 2], P = M[M.length - 1];
+		return (N !== n || P !== j) && M.push(n, j), this;
+	}
+	rect(n, j, M, N) {
+		return this.drawShape(new Rectangle(n, j, M, N)), this;
+	}
+	drawShape(n) {
+		return this.endPloy(), this.shapePrimitives.push({ shape: n }), this;
+	}
+	moveTo(n, j) {
+		return this.startPoly(n, j), this;
+	}
+	bezierCurveTo(n, j, M, N, P, F, I) {
+		this._ensurePoly();
+		let L = this._currentPoly.points;
+		return buildAdaptiveBezier(L, this._currentPoly.lastX, this._currentPoly.lastY, n, j, M, N, P, F, I), this;
+	}
+	startPoly(n, j) {
+		return this._currentPoly && this.endPloy(), this._currentPoly = new Polygon(), this._currentPoly.points.push(n, j), this;
+	}
+	endPloy(n = !1) {
+		let j = this._currentPoly;
+		j && j.points.length > 2 && (j.closePath = n, this.shapePrimitives.push({ shape: j })), this._currentPoly = null;
+	}
+	closePath() {
+		return this.endPloy(!0), this;
+	}
+	buildPath() {
+		let n = this._graphicsPath;
+		for (let j = 0; j < n.instructions.length; ++j) {
+			let M = n.instructions[j];
+			this[M.action](...M.data);
+		}
+		return this;
+	}
+	get bounds() {
+		let n = this._bounds;
+		n.clear();
+		let j = this.shapePrimitives;
+		for (let M = 0; M < j.length; ++M) {
+			let N = j[M].shape.getBounds();
+			n.addRect(N);
+		}
+		return n;
+	}
+}, GraphicsPath = class n {
+	constructor() {
+		this.instructions = [], this._dirty = !0;
+	}
+	rect(n, j, M, N) {
+		return this.instructions.push({
+			action: "rect",
+			data: [
+				n,
+				j,
+				M,
+				N
+			]
+		}), this._dirty = !0, this;
+	}
+	lineTo(...n) {
+		return this.instructions.push({
+			action: "lineTo",
+			data: n
+		}), this._dirty = !0, this;
+	}
+	bezierCurveTo(...n) {
+		return this.instructions.push({
+			action: "bezierCurveTo",
+			data: n
+		}), this;
+	}
+	moveTo(...n) {
+		return this.instructions.push({
+			action: "moveTo",
+			data: n
+		}), this;
+	}
+	closePath() {
+		return this.instructions.push({
+			action: "closePath",
+			data: []
+		}), this._dirty = !0, this;
+	}
+	get shapePath() {
+		return this._shapePath || (this._shapePath = new ShapePath(this)), this._dirty && (this._dirty = !1, this._shapePath.buildPath()), this._shapePath;
+	}
+	get bounds() {
+		return this.shapePath.bounds;
+	}
+	getLastPoint() {
+		let n = this.instructions.length - 1, j = this.instructions[n];
+		if (!j) return {
+			x: 0,
+			y: 0
+		};
+		switch (j.action) {
+			case "moveTo":
+			case "lineTo": return {
+				x: j.data[0],
+				y: j.data[1]
+			};
+		}
+		return {
+			x: 0,
+			y: 0
+		};
+	}
+	clear() {
+		this.instructions.length = 0, this._dirty = !0;
+	}
+	clone() {
+		let j = new n();
+		return j.instructions = this.instructions.slice(), j;
+	}
+}, _GraphicsContext, GraphicsContext = class n {
 	constructor() {
-		this.list = [];
+		this._activePath = new GraphicsPath(), this._bounds = new Bounds(), this.instructions = [];
 	}
-	add(r) {
-		this.list.push(r);
+	setStrokeStyle(j) {
+		this._strokeStyle = toStrokeStyle(j, n.defaultStrokeStyle);
 	}
-	render(r) {
-		this.list.forEach((T) => T.render(r));
+	moveTo(n, j) {
+		return this._activePath.moveTo(n, j), this;
 	}
-}, Text = class extends GameObject {
-	constructor(r, T) {
-		super(), this.x = 0, this.y = 0, this.visible = !0, this.width = 0, this.height = 0, this.dirty = !0, this.text = r, this.style = T, this.canvas = document.createElement("canvas"), this.ctx = this.canvas.getContext("2d"), this.texture = this.canvas;
+	lineTo(n, j) {
+		return this._activePath.lineTo(n, j), this;
 	}
-	setText(r) {
-		this.text !== r && (this.text = r, this.dirty = !0);
+	bezierCurveTo(n, j, M, N, P, F, I) {
+		return this._activePath.bezierCurveTo(n, j, M, N, P, F, I), this;
 	}
-	setStyle(r) {
-		Object.assign(this.style, r), this.dirty = !0;
+	rect(n, j, M, N) {
+		return this._activePath.rect(n, j, M, N), this;
 	}
-	rebuild() {
-		var r, T, E;
-		if (!this.dirty) return;
-		let D = this.ctx, O = this.style, k = this.text.split("\n"), A = (r = O.padding) == null ? {
-			left: 0,
-			right: 0,
-			top: 0,
-			bottom: 0
-		} : r;
-		D.font = `${(T = O.fontStyle) == null ? "" : T} ${O.fontSize}px ${O.fontFamily}`;
-		let j = 0;
-		for (let r of k) j = Math.max(j, D.measureText(r).width);
-		let M = O.fontSize * 1.2;
-		this.width = j + A.left + A.right, this.height = k.length * M + A.top + A.bottom, this.canvas.width = Math.ceil(this.width), this.canvas.height = Math.ceil(this.height), D.clearRect(0, 0, this.canvas.width, this.canvas.height), D.font = `${(E = O.fontStyle) == null ? "" : E} ${O.fontSize}px ${O.fontFamily}`, D.fillStyle = O.color, D.textBaseline = "top", O.shadow && (D.shadowOffsetX = O.shadow.offsetX, D.shadowOffsetY = O.shadow.offsetY, D.shadowColor = O.shadow.color, D.shadowBlur = O.shadow.blur);
-		let N = A.top;
-		for (let r of k) {
-			let T = A.left, E = D.measureText(r).width;
-			O.align === "center" ? T += (this.width - A.left - A.right - E) / 2 : O.align === "right" && (T += this.width - A.left - A.right - E), O.stroke && O.strokeThickness && (D.lineWidth = O.strokeThickness, D.strokeStyle = O.stroke, D.strokeText(r, T, N)), D.fillText(r, T, N), N += M;
-		}
-		this.dirty = !1;
-	}
-	render(r) {
-		if (!this.texture) return;
-		this.rebuild();
-		let T = this.width || this.canvas.width, E = this.height;
-		r.drawImage(this.texture, -T * this.originX, -E * this.originY, T, E);
+	beginPath() {
+		return this._activePath = new GraphicsPath(), this;
 	}
-};
-function asyncGeneratorStep(r, T, E, D, O, k, A) {
-	try {
-		var j = r[k](A), M = j.value;
-	} catch (r) {
-		E(r);
-		return;
+	closePath() {
+		return this._activePath.closePath(), this;
 	}
-	j.done ? T(M) : Promise.resolve(M).then(D, O);
-}
-function _asyncToGenerator(r) {
-	return function() {
-		var T = this, E = arguments;
-		return new Promise(function(D, O) {
-			var k = r.apply(T, E);
-			function A(r) {
-				asyncGeneratorStep(k, D, O, A, j, "next", r);
+	fill(j) {
+		let M = {
+			...n.defaultStrokeStyle,
+			color: j
+		};
+		return this.instructions.push({
+			action: "fill",
+			data: {
+				style: M,
+				path: this._activePath.clone()
 			}
-			function j(r) {
-				asyncGeneratorStep(k, D, O, A, j, "throw", r);
+		}), this;
+	}
+	stroke() {
+		this.instructions.push({
+			action: "stroke",
+			data: {
+				style: this._strokeStyle,
+				path: this._activePath.clone()
 			}
-			A(void 0);
-		});
+		}), this._initNextPathLocation();
+	}
+	_initNextPathLocation() {
+		let { x: n, y: j } = this._activePath.getLastPoint();
+		this._activePath.clear(), this._activePath.moveTo(n, j);
+	}
+	get bounds() {
+		let n = this._bounds;
+		n.clear();
+		for (let j = 0; j < this.instructions.length; ++j) {
+			let M = this.instructions[j], N = M.action;
+			if (N === "fill") {
+				let j = M.data;
+				n.addBounds(j.path.bounds);
+			} else if (N === "stroke") {
+				let j = M.data, N = j.style.alignment, P = j.style.width * (1 - N);
+				j.style.join;
+				let F = j.path.bounds;
+				n.addFrame(F.minX - P, F.minY - P, F.maxX + P, F.maxY + P);
+			}
+		}
+		return n;
+	}
+	clone() {
+		let j = new n();
+		return j.instructions = this.instructions.slice(), j._activePath = this._activePath.clone(), j._bounds = this._bounds.clone(), j._strokeStyle = { ...this._strokeStyle }, j;
+	}
+};
+_GraphicsContext = GraphicsContext, _GraphicsContext.defaultStrokeStyle = {
+	width: 1,
+	color: "#ffffff",
+	alignment: .5,
+	miterLimit: 10,
+	cap: "butt",
+	join: "miter",
+	pixelLine: !1,
+	alpha: 1
+};
+function toStrokeStyle(n, j) {
+	return {
+		...j,
+		...n
 	};
 }
-var File = class {
-	constructor(r, T) {
-		this.key = r, this.url = T;
+var Graphics = class extends ViewContainer {
+	constructor(n) {
+		super(), this.renderPipeId = "graphics", n instanceof GraphicsContext ? this.context = n : this.context = new GraphicsContext();
+	}
+	setStrokeStyle(...n) {
+		return this._callContextMethod("setStrokeStyle", n);
+	}
+	rect(...n) {
+		return this._callContextMethod("rect", n);
+	}
+	bezierCurveTo(...n) {
+		return this._callContextMethod("bezierCurveTo", n);
+	}
+	lineTo(...n) {
+		return this._callContextMethod("lineTo", n);
+	}
+	moveTo(...n) {
+		return this._callContextMethod("moveTo", n);
+	}
+	stroke(...n) {
+		return this._callContextMethod("stroke", n);
+	}
+	beginPath() {
+		return this._callContextMethod("beginPath", []);
+	}
+	closePath() {
+		return this._callContextMethod("closePath", []);
+	}
+	fill(n) {
+		return this._callContextMethod("fill", [n]);
+	}
+	_callContextMethod(n, j) {
+		return this.context[n](...j), this;
+	}
+	updateBounds() {}
+	get bounds() {
+		return this.context.bounds;
+	}
+}, _GraphicsPipe, GraphicsPipe = class {
+	constructor(n) {
+		this._renderer = n;
+	}
+	addRenderable(n, j) {
+		this._renderer.renderPipes.batch.break(j), j.add(n);
+	}
+	execute(n) {
+		let j = this._renderer, M = j.canvasContext, N = M.activeConext, P = j.roundPixels, F = (n.groupColorAlpha >>> 24 & 255) / 255;
+		if (!(F <= 0)) {
+			N.save(), M.setContextTransform(n.relativeGroupTransform, P);
+			for (let j = 0; j < n.context.instructions.length; ++j) {
+				let M = n.context.instructions[j], P = M.data.style, I = P.alpha * F;
+				if (I <= 0) continue;
+				N.globalAlpha = I;
+				let L = M.action === "stroke";
+				if (L) {
+					let n = P.color;
+					N.lineWidth = P.width, N.lineCap = P.cap, N.lineJoin = P.join, N.miterLimit = P.miterLimit, N.strokeStyle = n;
+				} else N.fillStyle = M.data.style.color;
+				let R = M.data.path.shapePath.shapePrimitives;
+				for (let n = 0; n < R.length; ++n) {
+					let j = R[n];
+					j.shape && (N.beginPath(), buildShapePath(N, j.shape), L ? N.stroke() : N.fill());
+				}
+			}
+			N.restore();
+		}
 	}
-}, ImageFile = class extends File {
-	load() {
-		return new Promise((r, T) => {
-			let E = new Image();
-			E.onload = () => r(E), E.onerror = () => T(/* @__PURE__ */ Error(`Failed to load ${this.url}`)), E.src = this.url;
+	destroy() {
+		this._renderer = null;
+	}
+};
+_GraphicsPipe = GraphicsPipe, _GraphicsPipe.desc = { name: "graphics" };
+function buildShapePath(n, j) {
+	switch (j.type) {
+		case "rectangle": {
+			let M = j;
+			n.rect(M.x, M.y, M.width, M.height);
+			break;
+		}
+		case "polygon": {
+			let M = j, N = M.points;
+			if (!N.length) return;
+			n.moveTo(N[0], N[1]);
+			for (let j = 2; j < N.length; j += 2) n.lineTo(N[j], N[j + 1]);
+			M.closePath && n.closePath();
+			break;
+		}
+	}
+}
+var _BatchPipe, Batch = class {
+	constructor() {
+		this.renderPipeId = "batch", this.elements = [];
+	}
+}, BatchPipe = class {
+	constructor(n) {
+		this._renderer = n;
+	}
+	get batch() {
+		return this._activeBatch;
+	}
+	buildStart() {
+		this._activeBatch = new Batcher();
+	}
+	buildEnd(n) {
+		this.break(n);
+	}
+	break(n) {
+		this._activeBatch.build(n);
+	}
+	addToBatch(n, j) {
+		this._activeBatch.add({
+			...n,
+			getColor: () => n.renderable.groupColorAlpha
 		});
 	}
-}, Loader = class {
-	constructor(r) {
-		this.queue = [], this.textures = r;
+	execute(n) {
+		let j = n.elements;
+		if (!j || !j.length) return;
+		let M = this._renderer.canvasContext, N = M.activeConext;
+		for (let n = 0; n < j.length; n++) {
+			let P = j[n], F = P.roundPixels, I = (P.getColor() >>> 24 & 255) / 255;
+			if (I <= 0) continue;
+			N.globalAlpha = I, M.setContextTransform(P.transform, F === 1);
+			let L = P.bounds, R = P.texture, z = R.frame, B = R.source._resolution || 1, V = z.x * B, H = z.y * B, U = z.width * B, W = z.height * B, G = L.minX, K = L.minY, q = L.maxX - L.minX, J = L.maxY - L.minY, Y = G, X = K, Z = q, Q = J;
+			N.drawImage(R.source.resource, V, H, U, W, Y, X, Z, Q);
+		}
 	}
-	image(r, T) {
-		return this.queue.push(new ImageFile(r, T)), this;
+	destroy() {
+		var n;
+		this._renderer = null, (n = this._activeBatch) == null || n.destroy(), this._activeBatch = null;
 	}
-	load() {
-		var r = this;
-		return _asyncToGenerator(function* () {
-			let T = r.queue.map((T) => T.load().then((E) => {
-				T instanceof ImageFile && r.textures.add(T.key, E);
-			}));
-			r.queue.length = 0, yield Promise.all(T);
-		})();
-	}
-}, _ResourceManager, Cache = class {
+};
+_BatchPipe = BatchPipe, _BatchPipe.desc = { name: "batch" };
+var Batcher = class {
 	constructor() {
-		this.map = /* @__PURE__ */ new Map();
+		this.renderPipeId = "batch", this.elements = [], this.elementSize = 0;
 	}
-	add(r, T) {
-		this.map.has(r) || this.map.set(r, T);
+	add(n) {
+		this.elements[this.elementSize++] = n;
 	}
-	get(r) {
-		let T = this.map.get(r);
-		if (!T) throw Error(`Asset ${r} not found`);
-		return T;
+	build(n) {
+		let j = new Batch(), M = this.elements;
+		if (M[0]) {
+			for (let n = 0; n < M.length; n++) {
+				let N = M[n];
+				this.elements[n] = null, j.elements.push(N);
+			}
+			n.add(j);
+		}
 	}
-	has(r) {
-		return this.map.has(r);
+	destroy() {
+		this.elements = null;
+	}
+}, _TextSystem, TextSystem = class {
+	constructor(n) {
+		this._activeTexture = {}, this.renderer = n;
+	}
+	getManagedTexture(n) {
+		n._resolution = n._autoResolution ? this.renderer.resolution : n.resolution;
+		let j = n.styleKey;
+		if (this._activeTexture[j]) return this._activeTexture[j];
+		let M = this.getTexture({
+			text: n.text,
+			style: n.style,
+			resolution: n._resolution
+		});
+		return this._activeTexture[j] = M, M;
+	}
+	getTexture(n) {
+		let { text: j, style: M } = n, N = n.resolution || this.renderer.resolution, { frame: P, canvasAndContext: F } = generateTextTexture({
+			text: j,
+			style: M,
+			resolution: N
+		}), I = F.canvas, L = new Texture({ source: new TextureSource({
+			resource: I,
+			resolution: N
+		}) });
+		return L.frame.width = P.width / N, L.frame.height = P.height / N, L;
 	}
-	remove(r) {
-		this.map.delete(r);
+};
+_TextSystem = TextSystem, _TextSystem.desc = { name: "text" };
+var _StencilMaskPipe, StencilMaskPipe = class {
+	constructor(n) {
+		this._canvasMaskStack = [], this._renderer = n;
+	}
+	push(n, j) {
+		j.add({
+			renderPipeId: "stencilMask",
+			action: "pushMaskBegin",
+			mask: n
+		});
 	}
-	clear() {
-		this.map.clear();
+	pop(n, j) {
+		this._renderer.renderPipes.batch.break(j), j.add({
+			renderPipeId: "stencilMask",
+			action: "popMaskEnd",
+			mask: n
+		});
 	}
-}, ResourceManager = class {};
-_ResourceManager = ResourceManager, _ResourceManager.textures = new Cache(), _ResourceManager.loader = new Loader(_ResourceManager.textures);
-var AddFactory = class {
-	constructor(r) {
-		this.rm = ResourceManager, this.displayList = r;
+	execute(n) {
+		if (n.action !== "pushMaskBegin" && n.action !== "popMaskEnd") return;
+		let j = this._renderer.canvasContext, M = j.activeConext;
+		if (n.action === "popMaskEnd") {
+			this._canvasMaskStack.pop() && M.restore();
+			return;
+		}
+		let N = n.mask.mask, P = N.context.instructions, F = N._roundPixels === 1;
+		M.save(), j.setContextTransform(N.relativeGroupTransform, F), M.beginPath();
+		for (let n = 0; n < P.length; ++n) {
+			let j = P[n], N = j.action;
+			if (N !== "fill" && N !== "stroke") return;
+			let F = j.data.path.shapePath.shapePrimitives;
+			for (let n = 0; n < F.length; ++n) {
+				let j = F[n].shape;
+				buildShapePath(M, j);
+			}
+		}
+		M.clip(), this._canvasMaskStack.push(!0);
 	}
-	image(r, T, E, D = 1) {
-		let O = new ImageObject(r, T, this.rm.textures.get(E), D);
-		return this.displayList.add(O), O;
+	destroy() {
+		this._renderer = null;
 	}
-}, SortSystem = class {
-	constructor(r, T) {
-		this.world = r, this.strategy = T;
+};
+_StencilMaskPipe = StencilMaskPipe, _StencilMaskPipe.desc = { name: "stencilMask" };
+var RenderTexture = class n extends Texture {
+	static create(j) {
+		return new n({ source: new TextureSource(j) });
+	}
+}, Sprite = class extends ViewContainer {
+	constructor(n = Texture.EMPTY) {
+		n instanceof Texture && (n = { texture: n });
+		let { texture: j = Texture.EMPTY, width: M, height: N, ...P } = n;
+		super({
+			label: "Sprite",
+			...P
+		}), this.renderPipeId = "sprite", this.texture = j, this.anchor = new Vector2(), M != null && (this.width = M), N != null && (this.height = N);
+	}
+	set texture(n) {
+		n || (n = Texture.EMPTY), this._texture !== n && (this._texture = n, this._width && this._setWidth(this.width, this._texture.orig.width), this._height && this._setHeight(this.height, this._texture.orig.height), this.onViewUpdate());
+	}
+	get texture() {
+		return this._texture;
 	}
-	update() {
-		this.world.objects.sort((r, T) => this.strategy.getKey(r) - this.strategy.getKey(T)), this.world.objects.sort((r, T) => r.zIndex - T.zIndex);
+	get height() {
+		return Math.abs(this.scale.y) * this.texture.orig.height;
 	}
-}, TweenData = class {
-	constructor(r) {
-		this.elapsed = 0, this.target = r.target, this.key = r.key, this.start = r.target[r.key], this.end = r.to, this.duration = r.duration, this.delay = r.delay || 0;
-		let T = r.easing || "Linear";
-		typeof T == "string" ? this.easing = Easings[T] : this.easing = T;
+	set height(n) {
+		let j = this.texture.orig.height, M = Math.sign(this.scale.y) || 1;
+		j === 0 ? this.scale.y = M : this.scale.y = n / j * M, this._height = n;
 	}
-	update(r) {
-		if (this.delay > 0) return this.delay -= r, !1;
-		this.elapsed += r;
-		let T = Math.min(this.elapsed / this.duration, 1), E = this.easing(T);
-		return this.target[this.key] = this.start + (this.end - this.start) * E, T === 1 ? (this.target[this.key] = this.end, !0) : !1;
+	get width() {
+		return Math.abs(this.scale.x) * this.texture.orig.width;
 	}
-	reset() {
-		this.elapsed = 0;
+	set width(n) {
+		let j = this.texture.orig.width, M = Math.sign(this.scale.x) || 1;
+		j === 0 ? this.scale.x = M : this.scale.x = n / j * M, this._width = n;
+	}
+	updateBounds() {
+		let n = this._bounds, { width: j, height: M } = this.texture.orig;
+		n.minX = -this.anchor.x * j, n.maxX = n.minX + j, n.minY = -this.anchor.y * M, n.maxY = n.minY + M;
+	}
+}, Text = class extends ViewContainer {
+	constructor(n) {
+		var j;
+		let { text: M, resolution: N, style: P, width: F, height: I, ...L } = n;
+		super(L), this.renderPipeId = "text", this._didTextUpdate = !0, this._resolution = null, this._autoResolution = !0, this._anchor = new ObservablePoint(this, 0, 0), this.text = (j = n.text) == null ? "" : j, this.style = P, this.resolution = N == null ? null : N, F != null && (this.width = F), I != null && (this.height = I);
+	}
+	set resolution(n) {
+		this._autoResolution = n === null, this._resolution = n, this.onViewUpdate();
+	}
+	get resolution() {
+		return this._resolution;
+	}
+	get anchor() {
+		return this._anchor;
+	}
+	set anchor(n) {
+		this._anchor.copyFrom(n);
+	}
+	get text() {
+		return this._text;
+	}
+	set text(n) {
+		let j = String(n);
+		this._text !== j && (this._text = j, this.onViewUpdate());
+	}
+	get style() {
+		return this._style;
+	}
+	set style(n) {
+		n || (n = {}), n instanceof TextStyle ? this._style = n : this._style = new TextStyle(n), this.onViewUpdate();
+	}
+	get width() {
+		return Math.abs(this.scale.x) * this.bounds.width;
+	}
+	set width(n) {
+		this._setWidth(n, this.bounds.width);
+	}
+	get height() {
+		return Math.abs(this.scale.y) * this.bounds.height;
+	}
+	set height(n) {
+		this._setHeight(n, this.bounds.height);
+	}
+	onViewUpdate() {}
+	updateBounds() {
+		let n = this._bounds, j = this._anchor, M = TextMetrics.measureText(this._text, this._style), N = M.width, P = M.height;
+		n.minX = -j._x * N, n.minY = -j._y * P, n.maxX = n.minX + N, n.maxY = n.minY + P;
+	}
+	get styleKey() {
+		return `${this._text}:${this._style.styleKey}:${this._resolution}`;
+	}
+	destroy(n = !1) {
+		super.destroy(n), this._bounds = null, this._anchor = null, (typeof n == "boolean" ? n : n != null && n.style) && this._style.destroy(n), this._style = null, this._text = null;
+	}
+}, _ExtractSystem, ExtractSystem = class {
+	constructor(n) {
+		this._renderer = n;
+	}
+	texture(n) {
+		return this._generateTexture(n);
+	}
+	_generateTexture(n) {
+		n instanceof Container && (n = { target: n });
+		let j = n.resolution || this._renderer.resolution, M = n.target, N = new Bounds(), P = n.frame || getLocalBounds(M, N).rectangle;
+		P.width = Math.max(P.width, 1 / j) | 0, P.height = Math.max(P.height, 1 / j) | 0;
+		let F = RenderTexture.create({
+			width: P.width,
+			height: P.height,
+			resolution: j
+		}), I = new Matrix();
+		return I.tx = -P.x, I.ty = -P.y, this._renderer.render({
+			clearColor: "transparent",
+			container: M,
+			transform: I,
+			target: F
+		}), F;
 	}
 };
-const Easings = {
-	Linear: (r) => r,
-	EaseOutBack: (r) => {
-		let T = 3.70158, E = r - 1;
-		return 1 + E * E * ((T + 1) * E + T);
+_ExtractSystem = ExtractSystem, _ExtractSystem.desc = { name: "extract" };
+var _CanvasContextSystem, CanvasContextSystem = class {
+	constructor(n) {
+		this.activeResolution = 1, this.globalTransform = new Matrix(), this._renderer = n;
+	}
+	init() {
+		this.activeConext = this._renderer.canvas.getContext("2d"), this.rootContext = this.activeConext, this.activeResolution = this._renderer.resolution;
+	}
+	setContextTransform(n, j, M) {
+		let N = this.activeResolution, P = Matrix.append(this.globalTransform, n);
+		M || (M = this.activeResolution), j ? this.activeConext.setTransform(P.a * M, P.b * M, P.c * M, P.d * M, P.tx * N | 0, P.ty * N | 0) : this.activeConext.setTransform(P.a * M, P.b * M, P.c * M, P.d * M, P.tx * N, P.ty * N);
 	}
 };
-var Tween = class {
-	constructor(r) {
-		for (let T in this.datas = [], this.finished = !1, this.loop = !1, r.to) this.datas.push(new TweenData({
-			target: r.target,
-			key: T,
-			to: r.to[T],
-			duration: r.duration,
-			easing: r.easing,
-			delay: r.delay
-		}));
-		this.loop = r.loop || !1, this.onComplete = r.onComplete;
+_CanvasContextSystem = CanvasContextSystem, _CanvasContextSystem.desc = { name: "canvasContext" };
+var _ViewSystem, ViewSystem = class n {
+	get resolution() {
+		return this.texture.source._resolution;
+	}
+	set resolution(n) {
+		this.texture.source.resize(this.texture.source.width, this.texture.source.height, n);
+	}
+	init(j) {
+		j = {
+			...n.defaultOptions,
+			...j
+		}, this.screen = new Rectangle(0, 0, j.width, j.height), this.canvas = createCanvas(), this.texture = new Texture({ source: new CanvasSource({
+			resource: this.canvas,
+			...j
+		}) }), this.resolution = j.resolution;
+	}
+	resize(n, j, M) {
+		this.texture.source.resize(n, j, M), this.screen.width = this.texture.frame.width, this.screen.height = this.texture.frame.height;
 	}
-	update(r) {
-		if (this.finished) return;
-		let T = !0;
-		for (let E of this.datas) E.update(r) || (T = !1);
-		if (T) if (this.loop) this.datas.forEach((r) => r.reset());
-		else {
-			var E;
-			this.finished = !0, (E = this.onComplete) == null || E.call(this);
+};
+_ViewSystem = ViewSystem, _ViewSystem.desc = { name: "view" }, _ViewSystem.defaultOptions = {
+	width: 800,
+	height: 600,
+	autoDensity: !1
+};
+var systems = [
+	ViewSystem,
+	EventSystem,
+	RenderGroupSystem,
+	TextSystem,
+	ExtractSystem,
+	CanvasContextSystem
+], pipes = [
+	BatchPipe,
+	GraphicsPipe,
+	TextPipe,
+	SpritePipe,
+	StencilMaskPipe
+], CanvasRenderer = class extends eventemitter3_default {
+	constructor() {
+		super(), this.uid = uid("renderer"), this.renderedObject = null, this.renderPipes = {}, this.background = { color: "#000000" };
+	}
+	get canvas() {
+		return this.view.canvas;
+	}
+	_addPipes() {
+		pipes.forEach((n) => {
+			this.renderPipes[n.desc.name] = new n(this);
+		});
+	}
+	_addSystems() {
+		systems.forEach((n) => {
+			this[n.desc.name] = new n(this);
+		});
+	}
+	async init(n) {
+		this.resolution = n.resolution || 1, this._addSystems(), this._addPipes();
+		for (let N = 0; N < systems.length; ++N) {
+			var j, M;
+			await ((j = (M = this[systems[N].desc.name]).init) == null ? void 0 : j.call(M, n));
+		}
+		n.backgroundColor && (this.background.color = n.backgroundColor), this._roundPixels = n.roundPixels ? 1 : 0;
+	}
+	get roundPixels() {
+		return !!this._roundPixels;
+	}
+	render(n) {
+		let j = n;
+		if (j instanceof Container && (j = { container: j }), this.renderedObject = j.container, j.transform || (j.container.updateLocalTransform(), j.transform = j.container.localTransform), j.clearColor != null || (j.clearColor = this.background.color), !j.container.visible) return;
+		j.container.enableRenderGroup();
+		let M = j.container.renderGroup;
+		if (this.activeRenderGroup = M, this.canvasContext.globalTransform = M.worldTransform, this.canvasContext.activeConext = this.canvasContext.rootContext, j.target) {
+			let { context: n } = ensureCanvas(j.target.source);
+			this.canvasContext.activeConext = n;
 		}
+		this.clear(j), systems.forEach((n) => {
+			var M, N;
+			(M = (N = this[n.desc.name]).render) == null || M.call(N, j);
+		});
 	}
-}, TweenManager = class {
-	constructor() {
-		this.tweens = [];
+	clear(n) {
+		let j = this.canvasContext.activeConext;
+		j.setTransform(1, 0, 0, 1, 0, 0), j.clearRect(0, 0, this.canvas.width, this.canvas.height), j.globalAlpha = 1, j.fillStyle = n.clearColor, j.fillRect(0, 0, this.canvas.width, this.canvas.height), j.globalAlpha = 1;
+	}
+	destroy() {
+		this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas), pipes.forEach((n) => {
+			var j;
+			(j = this.renderPipes[n.desc.name]) == null || j.destroy();
+		}), this.renderPipes = null;
+	}
+	resize(n, j, M) {
+		this.view.resize(n, j, M), this.emit("resize", this.view.screen.width, this.view.screen.height, this.view.resolution);
+	}
+};
+function ensureCanvas(n) {
+	let j = n.resource;
+	return j || (j = createCanvas(n.pixelWidth, n.pixelHeight), n.resource = j), (j.width !== n.pixelWidth || j.height !== n.pixelHeight) && (j.width = n.pixelWidth, j.height = n.pixelHeight), {
+		canvas: j,
+		context: j.getContext("2d")
+	};
+}
+var TickerListener = class {
+	constructor(n, j, M = 0, N = !1) {
+		this.next = null, this.previous = null, this.priority = 0, this._destroyed = !1, this._fn = n, this._context = j, this.priority = M, this._once = N;
+	}
+	match(n, j) {
+		return this._fn === n && this._context === j;
 	}
-	add(r) {
-		let T = new Tween(r);
-		return this.tweens.push(T), T;
+	emit(n) {
+		this._fn && (this._context ? this._fn.call(this._context, n) : this._fn(n));
+		let j = this.next;
+		return this._once && this.destroy(!0), this._destroyed && (this.next = null), j;
 	}
-	update(r) {
-		for (let T of this.tweens) T.update(r);
-		this.tweens = this.tweens.filter((r) => !r.finished);
+	destroy(n) {
+		this._destroyed = !0, this._fn = null, this._context = null, this.previous && (this.previous.next = this.next), this.next && (this.next.previous = this.previous);
+		let j = this.next;
+		return this.next = n ? null : j, this.previous = null, j;
 	}
-}, World = class {
+	connect(n) {
+		this.previous = n, n.next && (n.next.previous = this), this.next = n.next, n.next = this;
+	}
+}, _Ticker, Ticker = class n {
 	constructor() {
-		this.objects = [];
+		this.autoStart = !1, this.deltaTime = 1, this.lastTime = -1, this.speed = 1, this.started = !1, this._requestId = null, this._maxElapsedMS = 100, this._minElapsedMS = 0, this._lastFrame = -1, this._head = null, this._head = new TickerListener(null, null, Infinity), this.deltaMS = 1 / n.targetFPMS, this.elapsedMS = this.deltaMS, this._tick = (n) => {
+			this._requestId = null, this.started && (this.update(n), this.started && this._requestId === null && (this._requestId = requestAnimationFrame(this._tick)));
+		};
 	}
-	add(r) {
-		this.objects.push(r);
+	update(j = performance.now()) {
+		let M;
+		if (j > this.lastTime) {
+			if (M = this.elapsedMS = j - this.lastTime, M > this._maxElapsedMS && (M = this._maxElapsedMS), M *= this.speed, this._minElapsedMS) {
+				let n = j - this._lastFrame | 0;
+				if (n < this._minElapsedMS) return;
+				this._lastFrame = j - n % this._minElapsedMS;
+			}
+			this.deltaMS = M, this.deltaTime = this.deltaMS * n.targetFPMS;
+			let N = this._head, P = N.next;
+			for (; P;) P = P.emit(this);
+			N.next || this._cancelIfNeeded();
+		} else this.deltaTime = this.deltaMS = this.elapsedMS = 0;
+		this.lastTime = j;
 	}
-	update(r) {
-		for (let T of this.objects) T.update(r);
+	get FPS() {
+		return 1e3 / this.elapsedMS;
 	}
-}, Scene = class {
-	constructor(r, T) {
-		this.world = new World(), this.system = [], this.displayList = new DisplayList(), this.add = new AddFactory(this.displayList), this.camera = new Camera(r), this.tween = new TweenManager(), this.system.push(new SortSystem(this.world, T)), this.system.push(this.tween);
+	get maxFPS() {
+		return this._minElapsedMS ? Math.round(1e3 / this._minElapsedMS) : 0;
 	}
-	_boot(r) {
-		this.input = r.input, this.events = r.events, this.config = r.config;
+	set maxFPS(n) {
+		n === 0 ? this._minElapsedMS = 0 : (n < this.minFPS && (this.minFPS = n), this._minElapsedMS = 1 / (n / 1e3));
 	}
-	registerSystem(r) {
-		this.system.push(r);
+	get minFPS() {
+		return 1e3 / this._maxElapsedMS;
 	}
-	create() {}
-	resize(r, T) {
-		this.camera.setViewport(0, 0, r, T);
+	set minFPS(j) {
+		this._maxElapsedMS = 1 / Math.min(Math.max(0, j) / 1e3, n.targetFPMS), this._minElapsedMS && j > this.maxFPS && (this.maxFPS = j);
 	}
-	update(r) {
-		for (let E of this.system) {
-			var T;
-			(T = E.update) == null || T.call(E, r);
+	add(n, j, M = 0) {
+		let N = new TickerListener(n, j, M), P = this._head.next, F = this._head;
+		if (!P) N.connect(F);
+		else {
+			for (; P;) {
+				if (N.priority > P.priority) {
+					N.connect(F);
+					break;
+				}
+				F = P, P = P.next;
+			}
+			N.previous || N.connect(F);
 		}
-		this.camera.update(), this.world.update(r);
+		return this._startIfPossible(), this;
 	}
-}, Projection2D = class {
-	constructor(r = 1, T = 1) {
-		this.scaleX = r, this.scaleY = T;
+	start() {
+		this.started || (this.started = !0, this._requestIfNeeded());
 	}
-	project(r, T) {
-		return {
-			px: r * this.scaleX,
-			py: T * this.scaleY
-		};
+	remove(n, j) {
+		let M = this._head.next;
+		for (; M;) M = M.match(n, j) ? M.destroy() : M.next;
+		return this._head.next || this._cancelIfNeeded(), this;
 	}
-}, IsoProjection = class {
-	constructor(r, T, E) {
-		this.tileWidth = r, this.tileHeight = T, this.zHeight = E;
+	_startIfPossible() {
+		this.started ? this._requestIfNeeded() : this.autoStart && this.start();
 	}
-	project(r, T, E = 0) {
-		return {
-			px: (r - T) * this.tileWidth / 2,
-			py: (r + T) * this.tileHeight / 2 - E * this.zHeight
-		};
+	_requestIfNeeded() {
+		this._requestId === null && this._head.next && (this.lastTime = performance.now(), this._lastFrame = this.lastTime, this._requestId = requestAnimationFrame(this._tick));
+	}
+	_cancelIfNeeded() {
+		this._requestId !== null && (cancelAnimationFrame(this._requestId), this._requestId = null);
+	}
+};
+_Ticker = Ticker, _Ticker.targetFPMS = .06;
+var plugins = [class {
+	static init(n) {
+		Object.defineProperty(this, "resizeTo", {
+			configurable: !0,
+			set(n) {
+				globalThis.removeEventListener("resize", this.queueResize), this._resizeTo = n, n && (globalThis.addEventListener("resize", this.queueResize), this.resize());
+			},
+			get() {
+				return this._resizeTo;
+			}
+		}), this.queueResize = () => {
+			this._resizeTo && (this._cancelResize(), this._resizeId = requestAnimationFrame(() => this.resize));
+		}, this._cancelResize = () => {
+			this._resizeId && (cancelAnimationFrame(this._resizeId), this._resizeId = null);
+		}, this.resize = () => {
+			if (!this._resizeTo) return;
+			this._cancelResize();
+			let n, j;
+			if (this._resizeTo === globalThis.window) n = globalThis.innerWidth, j = globalThis.innerHeight;
+			else {
+				let { clientWidth: M, clientHeight: N } = this._resizeTo;
+				n = M, j = N;
+			}
+			this.renderer.resize(n, j), this.render();
+		}, this._resizeId = null, this._resizeTo = null, this.resizeTo = n.resizeTo || null;
+	}
+	static destroy() {
+		globalThis.removeEventListener("resize", this.queueResize), this._cancelResize(), this._cancelResize = null, this.queueResize = null, this.resizeTo = null, this.resize = null;
+	}
+}], Application = class {
+	constructor() {
+		this.stage = new Container();
+	}
+	async init(n) {
+		n = { ...n }, this.stage || (this.stage = new Container()), this.renderer = new CanvasRenderer(), await this.renderer.init(n), plugins.forEach((j) => {
+			j.init.call(this, n);
+		}), this.ticker = new Ticker(), (n.autoStart || n.autoStart == null) && this._ticker.start();
+	}
+	get canvas() {
+		return this.renderer.canvas;
+	}
+	get screen() {
+		return this.renderer.view.screen;
+	}
+	get ticker() {
+		return this._ticker;
+	}
+	set ticker(n) {
+		this._ticker && this._ticker.remove(this.render, this), this._ticker = n, n && n.add(this.render, this);
+	}
+	render() {
+		this.renderer.render({ container: this.stage });
 	}
-}, IsoStragety = class {
-	getKey(r) {
-		return r.x + r.y + r.z;
-	}
-}, ZIndexStragety = class {
-	getKey(r) {
-		return r.zIndex;
-	}
-}, Game = class {
-	constructor(r, T) {
-		this.lastTime = 0, this.scene = null, this.config = _objectSpread2({
-			width: window.innerWidth,
-			height: window.innerHeight
-		}, T);
-		let O = window.innerWidth / this.config.width, k = window.devicePixelRatio;
-		r.width = this.config.width * O * k, r.height = this.config.height * O * k, r.style.width = `${this.config.width * O}px`, r.style.height = `${this.config.height * O}px`;
-		let A = r.getContext("2d");
-		if (!A) throw Error("Canvas 2D context not found");
-		this.events = new EventSystem(), this.input = new InputSystem(r, this.events), this.renderer = new Renderer(A), A.scale(O * k, O * k);
-	}
-	start(r) {
-		this.scene = r, r._boot(this), r.registerSystem(this.input), r.registerSystem(this.events), r.create(), r.resize(this.config.width, this.config.height), window.requestAnimationFrame(this.loop.bind(this));
-	}
-	loop(r) {
-		let T = r - this.lastTime;
-		this.lastTime = r, this.scene && (this.scene.update(T), this.renderer.render(this.scene)), window.requestAnimationFrame(this.loop.bind(this));
+	destroy() {
+		let n = plugins.slice(0);
+		n.reverse(), n.forEach((n) => {
+			n.destroy.call(this);
+		}), this.stage.destroy(), this.stage = null, this.renderer.destroy(), this.renderer = null;
 	}
 };
-export { Cache, Camera, CameraController, Container, DisplayList, Easings, Game, GameObject, ImageObject, InputEventType, InputSystem, IsoProjection, IsoStragety, Projection2D, ResourceManager, Scene, Text, TweenManager, ZIndexStragety };
+export { Application, Assets, Cache, CanvasRenderer, Container, Graphics, GraphicsContext, GraphicsPipe, ImageFile, Loader, Matrix, PI_2, Rectangle, RenderGroup, ResourceManager, Sprite, Text, TextPipe, Texture, Ticker, TickerListener, UPDATE_BLEND, UPDATE_COLOR, UPDATE_TRANSFORM, UPDATE_VISIBLE, Vector2, ViewContainer, buildShapePath, nextPow2 };
+
+//# sourceMappingURL=dao.js.map