insomni 0.2.0-alpha.0

package/dist/text-ttf.mjs

@@ -0,0 +1,298 @@
+import { n as resolveRoot } from "./root-CHradZKM.mjs";
+import { r as shapeText, t as measureBlockWidth } from "./shape-DfZP9Jdk.mjs";
+import { r as Texture } from "./texture-dABoqFoP.mjs";
+import { Font, MsdfGlyphAtlas as MsdfGlyphAtlas$1, loadFont, parseFont, parseFont as parseFont$1 } from "insomni-msdf-text";
+//#region src/text/msdf-adapter.ts
+var MsdfGlyphAtlas = class {
+	font;
+	_atlas;
+	_texture;
+	measureCache = /* @__PURE__ */ new Map();
+	measureCacheVersion = 0;
+	constructor(owner, font, options = {}) {
+		const device = resolveRoot(owner).device;
+		this.font = font;
+		this._atlas = new MsdfGlyphAtlas$1({
+			device,
+			font,
+			atlasSize: options.atlasSize,
+			atlasFontSize: options.atlasFontSize,
+			pxRange: options.pxRange,
+			label: options.label ?? `text-atlas:${font.family}`
+		});
+		this._texture = new Texture(this._atlas.texture, this._atlas.atlasSize, this._atlas.atlasSize);
+	}
+	get pxRange() {
+		return this._atlas.pxRange;
+	}
+	get atlasFontSize() {
+		return this._atlas.atlasFontSize;
+	}
+	get atlasSize() {
+		return this._atlas.atlasSize;
+	}
+	get texture() {
+		return this._texture;
+	}
+	get glyphCount() {
+		return this._atlas.glyphCount;
+	}
+	get destroyed() {
+		return this._atlas.destroyed;
+	}
+	get fillPercent() {
+		return this._atlas.fillPercent;
+	}
+	get version() {
+		return this._atlas.version;
+	}
+	getGlyph(codepoint) {
+		return this._atlas.getGlyph(codepoint);
+	}
+	getGlyphById(id) {
+		return this._atlas.getGlyphById(id);
+	}
+	measureText(text, options) {
+		const v = this._atlas.version;
+		if (this.measureCacheVersion !== v) {
+			this.measureCache.clear();
+			this.measureCacheVersion = v;
+		}
+		const simple = options.simple === true;
+		const lineHeight = options.lineHeight ?? options.fontSize * 1.2;
+		const key = `${options.fontSize}|${simple ? 1 : 0}|${options.maxWidth ?? -1}|${lineHeight}|${text}`;
+		const cached = this.measureCache.get(key);
+		if (cached !== void 0) return cached;
+		let metrics;
+		if (options.maxWidth === void 0) {
+			const width = measureBlockWidth(text, this.font, this, options.fontSize, simple);
+			let lineCount = 1;
+			if (!simple) {
+				for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) lineCount++;
+			}
+			metrics = {
+				width: Math.max(0, width),
+				height: lineCount * lineHeight
+			};
+		} else {
+			const block = shapeText(text, this.font, this, 0, 0, {
+				fontSize: options.fontSize,
+				maxWidth: options.maxWidth,
+				lineHeight: options.lineHeight,
+				simple
+			});
+			const width = Number.isFinite(block.bbox.maxX) ? block.bbox.maxX - block.bbox.minX : 0;
+			metrics = {
+				width: Math.max(0, width),
+				height: block.height
+			};
+		}
+		this.measureCache.set(key, metrics);
+		return metrics;
+	}
+	preload(text) {
+		this._atlas.preload(text);
+	}
+	destroy() {
+		this._atlas.destroy();
+		this._texture.destroy();
+	}
+};
+//#endregion
+//#region src/text/embedded-font.ts
+/** Family name for the embedded subset (its `name` table was dropped by subsetting). */
+const EMBEDDED_FONT_FAMILY = "Lato";
+/** Base64-encoded Lato Regular subset TTF (Latin-1 + common punctuation). */
+const EMBEDDED_FONT_B64 = "AAEAAAANAIAAAwBQR1BPU6KLh18AAE/sAAAPpEdTVUIh9CaFAABfkAAAAF5PUy8yeEOgZgAATMwAAABgY21hcAGRALkAAE0sAAAAPGdhc3AAEgAYAABP4AAAAAxnbHlmUfzPBgAAANwAAEauaGVhZPyc8iMAAElIAAAANmhoZWEPtgdjAABMqAAAACRobXR4Na5I/QAASYAAAAMmbG9jYfuc6tQAAEesAAABmm1heHAA2gDmAABHjAAAACBuYW1lNKdK1QAATWgAAAJYcG9zdP93AHgAAE/AAAAAIAACANr/8QHTBZkADQAhAAABERQOAgcjLgM1EQM0PgIzMh4CFRQOAiMiLgIBrgMGCQZ5BgkGAysTIS4aGi4iExMiLhoaLiETBZn9xC1WV1s0NFtXVi0CPPrVGi4iFBQiLhobLSITEyItAAIAmAOZAoAFmQAKABUAAAERBw4BIyImLwERIREHDgEjIiYvAREBMxADHB8aHQYQAegQAxwfGh0GEAWZ/t6bICMjIJsBIv7emyAjIyCbASIAAgA2AAAEUQWZAD4AQgAAAQMjIiY1NDY3EyMDDgErARMjIiY1NDY/ATMTIzc+ATsBEz4BOwEDMxMzMhYVFAcDMwcOASsBAzMyFhUUBg8BJTMTIwMWVFEXIAEBR/dHCC0dT1WSFxoBAQjMQegNBSQnnkgGKx5QVPdUTxkhAUnUDQUlJopBsxgaAQEJ/Zz3QfcBp/5ZIhsEBwUBWv6dJR8BpxccBQwGOQFGSh0cAWYeIv5aAaYeGAgF/p1LHRv+uhcdBQsGOYMBRgADAGr/EgQkBmcAOABDAE4AAAUuASc3PgEzMh4CFxMuAzU0PgI/AT4BOwEHHgEXBwYjIi4CJwMeAxUUDgIPAQ4BKwEBNC4CJwM+AwEUHgIXEw4DAfJ5x0g1BxoOEzBGYUQlRodrQTltoGgKAhoWQg5pmDwrFBoOKTpMMSFIjHBFPHOnawwCGxVCAZglQFYxIkFlRSP91SI8UC8eQV89HgwLYUtSCw4mMS4IAhMVNVWBYUmLbEUEkBMexg1SOkIeGSEhB/4cFjRSe1xannhLBrATHQKFMkg0JhD+DgYtRl0C0DBHNigQAcMGKDxLAAUASP/vBdsFpwATACcAMQBFAFkAAAEUDgIjIi4CNTQ+AjMyHgIHNC4CIyIOAhUUHgIzMj4CAT4BOwEBDgErAQEUDgIjIi4CNTQ+AjMyHgIHNC4CIyIOAhUUHgIzMj4CAsM0V3Q/RHNWMDBWc0RDdVUxixwxQSUlQTAbGzBBJSVBMRwCgA0dGID76QocE4QFNTRXcz9Ec1YwMFZzREN0VjCKHDFBJSVBMBsbMEElJUExHAQ/VIVbMDBbhVRWhlwwMFyGVkJcOxoaO1xCQVs5GRk5WwF3ERP6hA0QAVJUhFswMFuEVFaHXDAwXIdWQl06Gho6XUJBWjkZGTlaAAIAUv/wBXgFqQA/AEsAAAEyHgIXBwYjIiYnLgMjIg4CFRQeAhcBPgE3PgE7AQ4BBwEjIiYvAQ4BIyIuAjU0PgI3LgE1ND4CARQeAjMyNjcBDgEClE+CXzcEbwUEDRcFBx8xRS4yUDkfESI2JgGcJi0IAhQSbgJGQgEsrB0kFpBe9ZNQmnlKL1NyRD06NWSP/swwTmQ0cLJE/llqawWpM1RvPBYBDhIaOC4eIDlNLSNAQUUm/l1Dk0oTFnPeYf7QDhaRW2o2Z5RdRn1qVB5Nkk5JgF83++NBY0QjUkQBqzmfAAABAJgDmQEzBZkACgAAAREHDgEjIiYvAREBMxADHB8aHQYQBZn+3psgIyMgmwEiAAABAIb+2wIBBg8AHAAAARQSFx4BFRQGDwEuAzU0PgI3Fx4BFRQHBgIBIW5oBgQOC09LaUEeHkFpS08LDgppbQJ11v5ttwsQCA4SBzBz4uTnenno4+J0MQcSDg8Ttv5sAAABAEr+2wHFBg8AHAAAATQCJyY1NDY/AR4DFRQOAgcnLgE1NDY3NhIBKm1pCg4LT0tpQR4eQWlLTwsOBAZobgJ11gGUthMPDhIHMXTi4+h5eufk4nMwBxIOCBALtwGTAAABAGADXwK8BeIAMAAAATU0NjcGDwEnNzY3LgEvATcXFhcuAT0BMxUUBz4BPwEXBw4BBx4BHwEHJy4BJxYdAQFiBQcUIawsrCQlFCMSrSytIxYJB1gOCxsRrCysESESEiERrSytEhwLEANfxRMiEBkUY0tkFQMCCwxlS2QUIBIlFMbFKR8PFgtjS2QLDAICCwtlS2QLFhAhJ8YAAQBkAK4EIgSOAAsAAAERIRUhESMRITUhEQKLAZf+aZL+awGVBI7+VYf+UgGuhwGrAAABAF7+8QFQAOwAHgAANzQ+AjMyHgIVFA4CBycmNTQ3PgM3IyIuAl4RHywaHi8fEBowRy0eDQ4KHyAbBg0aKh8RexcpHxIWJzMeLWFfWiYdDBANDgslMDohEiEtAAEAZAIMAlICowADAAATIRUhZAHu/hICo5cAAQBY//EBUQDsABMAADc0PgIzMh4CFRQOAiMiLgJYEyEuGhouIhMTIi4aGi4hE24aLiIUFCIuGhstIhMTIi0AAAH/9P+mAvYFwQAJAAAXDgErAQE+ATsBoQ43HUsCWQ0wIUsVIyIF2SAiAAIAPP/xBEwFqQATACcAAAEUAg4BIyIuAQI1NBI+ATMyHgESBzQuAiMiDgIVFB4CMzI+AgRMUYy/bW69jFBQjL1ubb+MUbk3XXpCQnpcNzdcekJCel03Asy8/u20WFi0ARO8vAEUtVhYtf7svKTfiDs7iN+kpN6IOzuI3gABAMoAAAQfBZwAEgAAJSERNDcFDgEjIiYvAQEzESEVIQEfATQD/wAKFAkPGAY4AaqRARr9AIgD0Swt2wgHDQlNAXH67IgAAQBoAAAEJAWpADMAAAEyHgIVFA4CBwE+ATMhMhYdASE1NDY3AT4DNTQuAiMiDgIHDgEjIiYvAT4DAllbnnNCMFJrPP6HKFImAeAdIvxEDxEByzleQyQoRl42NlxHMQoIIBoFCwddDlB7nwWpNmeUXlCIfXU9/n4LDSIbbD0TKBEBzTprbG8/P18+HyA5Ti8dGgEBEGKXZjUAAAEAbP/wBC4FqQBKAAABMh4CFRQOAgceARUUDgIjIi4CJzc2MzIWFx4BFx4DMzI+AjU0LgIjNT4DNTQuAiMiDgIHDgEjIiYvAT4DAmxbmm8+I0FcOYyNS4KtY3KicEgZTBUVFB8IAgQCDihEZUtLcUsmH1GPcFuBUiUnRF02NlxHMAwIIBkFCwddDlB7nwWpNGCIU0RrUTgRJa6DY55vOzlkiVAgCRESBAkFHUlALDFOYC86YEYogQEmQlw4Plw8HiA5Ty4dGgEBEGKXZjUAAgAoAAAEYAWZABAAFgAAATMVFAYrAREjESEiJi8BATMDNDY3ASEDh9kTFLKd/YUUHQQSArmmnQMF/fcCAQIFZhAW/ocBeRcRWwOd/rsaPCD9OwAAAQBs//AD/gWZAC4AAAEUBiMhAzYzMh4CFRQOAiMiLgInNzYzMh4CMzI+AjU0LgIjIgYHJxMhA9IwOf4+QnBfcKt0O1CLvG0/dGRWITYSHhMzSGFDS3hVLidPdk82dD5wdAKnBUsmMf6IGEJ0nl1yuINGGSo2HkwaHyYfMFl8TUNsTCoSFCECngAAAgBs//AEMgWZABoALgAAATIeAhUUDgIjIi4CNTQ2NwE+ATsBAT4BARQeAjMyPgI1NC4CIyIOAgKKVpp0REiBtm1sr3xDVFsBaw4yIJ7+DzN8/tYoTW9HSHRTLSxQcENIdFErA245bZ9mY6p+SEV/tXBe1HoB6RIZ/YsjJ/5MRXJSLS5ScEJGcU8qMVNtAAEAbgAABDwFmQASAAABFRQGBwEOASsBAT4BNyEiJj0BBDwPCP2vDS4nfwJaDRsR/RQRGwWZUCIsD/tTGiUEnhkqExsReQADAGD/8AQmBakAHwAzAEcAAAUiLgI1NDY3LgE1ND4CMzIeAhUUBgceARUUDgInMj4CNTQuAiMiDgIVFB4CEzI+AjU0LgIjIg4CFRQeAgJDa7KARpCGcXM+cp9iYaByPnRwhpBHf7JrRm9NKTFTbDs7bFMxKU1vRkZjPhwhQWFAQGFBIRw+YxA5apdeirMmKqd0T4pmOjpmik90pyoms4pel2o5jidHYzxKaUIfH0JpSjxjRycCsCtHXDEyWEImJkJYMjFcRysAAAIAlAAABDYFqQAfADMAAAEiLgI1ND4CMzIeAhUUDgIHAQ4BKwEBPgE3DgEBNC4CIyIOAhUUHgIzMj4CAiVRkW5BRn6uaGeoeEEXLD0n/qMNMB+kAbQWJhE3igEZK0xpP0JtTSonSWlBSG9MKAJMNmmZY16kekZEeqpnPm9qaTj+CBMXAjsdNBosLgGjQ21MKStMaj9Ea0omL05mAAIAgP/xAXkD2gATACcAADc0PgIzMh4CFRQOAiMiLgIRND4CMzIeAhUUDgIjIi4CgBMhLhoaLiITEyIuGhouIRMTIS4aGi4iExMiLhoaLiETbhouIhQUIi4aGy0iExMiLQMJGi4iFBQiLhobLSITEyItAAIAgP7xAXkD2gAeADIAADc0PgIzMh4CFRQOAgcnJjU0Nz4DNyMiLgIDND4CMzIeAhUUDgIjIi4ChhEfLBoeLx8QGjBHLR4NDgofIBsGDRoqHxEGEyEuGhouIhMTIi4aGi4hE3sXKR8SFiczHi1hX1omHQwQDQ4LJTA6IRIhLQL8Gi4iFBQiLhobLSITEyItAAEAlADqA5oEVwASAAATARUUBgcFDgEHHgEXBR4BHQEBlAMGEBT+PxQtGRktFAHBFBD8+gLGAZF/ERkK5AsPBgUQCuMKGhCAAZIAAgCWAbcD8QONAAMABwAAEyEVIREhFSGWA1v8pQNb/KUCPocB1ocAAAEA7gDqA/MEVwASAAA3NTQ2NyU+ATcuASclLgE9AQEV7hAUAcEUKxkZKxT+PxQQAwXqgBAaCuMKEAUGDwvkChkRf/5vSgACACL/8QL4BakAKAA8AAATPgMzMh4CFRQOBA8BIyc1ND4ENTQuAiMiDgIjIicTND4CMzIeAhUUDgIjIi4CIh9LWWc8T4diOC1FUkczBBJ6DC1FT0UtIjpPLT1XPCUMGQ6VEyEuGhouIhMTIi4aGi4hEwUZHTQoFy5UeEtMblM9NjYhmaYLKkE5OUVYPCtGMRoeJB4X+6AaLiIUFCIuGhstIhMTIi0AAgBW/xEGHAVPAFEAYQAAJSImJw4BIyIuAjU0PgIzMhYXAwYVFB4CMzI+AjU0LgIjIg4CFRQSHgEzMjY3NjMyHwEGBCMiJCYCNTQ+BDMyHgQVFA4CJTI+AjcTJiMiDgIVFBYEj05iDTqITjxYOx1BgL99Q2UtXRMSHykXMVhDJ1mb03qG6q5ka7n5j5jpVQ8MFQoZa/7vra3+1tt9N2SMrMZsXLCdhF81PWuR/gIfPzsxEUwnLkt9WjNCuktOUUYpSWQ6Va2LWBUU/pdLMSQvGwo4Zo9XitCLRWa09pGq/v+uWEIzCRhCSFJuzwEsvm3Kr5FnOShOc5W3a2y3hkx4FDJWQQEnCT9mhEVIVwAAAgAKAAAFSQWZAA0AFQAAISMiJicDIQMOASsBATMBIQMmJw4BBwVJlhogCIb9fYYHIhmWAj3F/pICF+EWFQsVChoUAVr+phIcBZn8ewJHNlEpRRoAAwCuAAAEoAWZABQAHwAqAAAzESEyHgIVFA4CBx4BFRQOAiMBESEyPgI1NCYjJSEyPgI1NCYjIa4ByYS/ezshQ2VEnaBDgbt4/scBNlN3TSSdn/7LAQBSeE8mmKD++QWZNGCLVzViVEIVH6SGW5ZsOwKN/g0mRV85b4GKJEBbNn52AAEAWv/wBQkFqQAuAAABMh8BDgEjIi4BAjU0EjYkMzIWFwcOASMiLgQjIg4CFRQeAjMyPgI3NgSgEA1MWPuxm/yyYmm+AQmgnuVZPwcSEQ0dKDZKYkBzv4pNTYW2aUBmV0smEQEoDVNmcmvBAQ6iogEOwmtiVFkKDRMcIBwTT5LSgobSkUwPIDEiDwAAAgCuAAAFiAWZAAwAGQAAARQCBgQjIREhMgQWEgc0LgIjIREhMj4CBYhmuv78nv3oAhieAQS6ZsdIhLxz/qsBVXO8hEgCzKH++LxnBZlnvf74oYTQkEz7oUyP0AABAK4AAAQhBZkACwAAARUhESEVIREhFSERBCH9UAIt/dMCsPyNBZme/iSY/heeBZkAAAEArgAABCEFmQAJAAABFSERIRUhESMRBCH9UAJM/bTDBZme/gue/ZgFmQAAAQBa//AFQAWpADQAACUyPgI3ESMiJj0BIREOAyMiJCYCNTQSNiQzMh4CFwcGIyInLgMjIg4CFRQeAgMtOmFWTCbeExcBuDZ1hZhZnP78vGlnvwEPqFWSfWouNxEbEBMZPll5U3nEikpNjMCNCxYfFAE8FhBu/donOicTa8EBDqKkAQ7BahkvQypYGwsOKCUaT5PRgojVlE4AAAEArgAABTgFmQALAAAhIxEhESMRMxEhETMFOMP8/MPDAwTDAoz9dAWZ/YECfwABANIAAAGUBZkAAwAAISMRMwGUwsIFmQABADz/8ALJBZkAFwAAARQOAiMiJz4BNz4BMzIWMzI+AjURMwLJO3OobWFpAgYDAhUVEjwyQmdHJcEB73i+g0YcHTkcERUSKFSDWgOuAAABAMIAAAU6BZkAIgAAATMyNjcBPgE7AQEOAQceARcBIyIuAicBLgMrAREjETMBg0kmLRQB3RYpIKX93hUlFRwqFwI6qBMaExAI/hELExkhGFjBwQMlExcCHBkV/ZcXIAoJJBv9WQYKEAkCOQwRDAX9cAWZAAEArgAAA9wFmQAFAAAlIRUhETMBcAJs/NLCo6MFmQAAAQCuAAAGgQWZACMAAAEeARc+ATcBPgE7AREjETQ2NwEGKwEiJwEeARURIxEzMhYXAQNvDhUKChYOAeUNHBqPqgIC/hUZLRwtGf4KAwOqjxocDQHvAgYYNRscMxoDcRcK+mcEHRUwGfyALS0DgxoyFfvjBZkKF/yOAAABAK4AAAU4BZkAFgAAATIWFwEuATURMxEjIiYnAR4BFREjETMBEhoZEAM+AwKqYhcfD/zDAgKqZAWZDRT7yBoxFwP3+mcQEwQ3GTAU/AMFmQAAAgBc//EF4QWpABMAJwAAARQCBgQjIiQmAjU0EjYkMzIEFhIHNC4CIyIOAhUUHgIzMj4CBeFmuv77np7+/LpmZroBBJ6eAQW6ZsdIhLx0c7yFSEiFvHN0vIRIAsyh/vPCa2vCAQ2hoQENw2xsw/7zoYTSkU5OkdKEhNGRTU2R0QACAMIAAAR/BZkADgAZAAABESMRITIeAhUUDgIjJzMyPgI1NCYrAQGDwQGniMmEQUaHyIHm5lN/Viypq+YCGP3oBZk/dKRlZKZ4Q5osT25CiZoAAgBc/tgGJAWpABwAMAAAARQOAgcBIyImJwMOASMiJCYCNTQSNiQzMgQWEgc0LgIjIg4CFRQeAjMyPgIF4SlOcEYBcKAkOBf8OXtDnv78umZmugEEnp4BBbpmx0iEvHRzvIVISIW8c3S8hEgCzGW2nYAv/nMUGQESEhRrwgENoaEBDcNsbMP+86GE0pFOTpHShITRkU1NkdEAAAIAwgAABOUFmQAYACMAAAERIxEhMh4CFRQOAgcWFwEjIicBLgEjJzMyPgI1NCYrAQGDwQGViMaBPjBbg1MkHAGirDUZ/owRKCiTy1WBVyypp9QCVv2qBZk3aJNbTIRpShMVKP3HKQIAGBWNKUtoP4CCAAEAOv/wA9sFqQA9AAABDgEjIi4CIyIOAhUUHgYVFA4CIyImJzc+ATMyHgIzMj4CNTQuBjU0PgIzMhYXA4wJFBARLUVhRUFkQyI7YXuBe2E7QHuzcovlUTgIFw4VNlFzU0VsSyg7YHuBe2A7O3Cla3jGSgS5Dw8iKSIjPFEvPE84KSw3VHpZXqV6RmVWXAsPLTYtJkVgO0FTOCcpNlaBX0yObkJMSAABABwAAAR+BZkABwAAARUhESMRITUEfv4xwv4vBZmj+woE9qMAAAEAoP/vBRUFmQAZAAAlMj4CNREzERQOAiMiLgI1ETMRFB4CAttZjGEzwU+T1ISE1JRPwTNhjZo8bJZaA2f8mXzUm1hYm9R8A2f8mlqWbD0AAQAIAAAFRwWZABIAABMzMhYXAR4BFz4BNwE+ATsBASMImxogCAGVDhcLCRUOAZMHIhmc/bivBZkaFPwNIlArK1AiA/MRHfpnAAABAA4AAAfnBZkAKAAAEzMyFhcBHgEXPgE3AT4BOwEyFhcBFhc+ATcBPgE7AQEjASYnDgEHASMOoRoiBgEoCA0GBw4JAVEGIxk4GiEHAU8SDgYKCAEpBSMZl/5Brv6VCwkFCQX+k64FmRoU/BwbPiIiPxoD5BEdGhT8HDRDITwaA+QSHPpnBEUfKRQlD/u7AAABAA4AAAT2BZkAGwAACQEzMhYXATY3AT4BOwEJASMiJicBBgcBDgErAQH7/ifBFRQIAXYHDgFhCRUPuf4lAevAFhkI/oAHC/6KCRcVtALgArkODf3CFRkCDA4R/VD9FxcOAlkVE/3PDhcAAQAIAAAE5AWZABQAAAERIxEBMzIWFwEeARc+ATcBPgE7AQLWwf3zqhoeCwFIFBsLCxoUAUcJHxmsAjr9xgI6A18aE/3TIz4eHz4iAi0QHQABAFYAAASUBZkADQAAARUUBwEhFSE1NDcBITUElBX81QMy+9ATAyz85wWZSCIe+42eTB4bBHaeAAEAjv7fAf4F/QANAAATESEVFAYrAREzMhYdAY4BcBsWqakWG/7fBx5GFhn5zRkXRgAAAf/s/6YC7wXBAAkAAAMzMhYXASMiJicUTCEwDQJZSx04DQXBIiD6JyIjAAABAFr+3wHKBf0ADQAAFzQ2OwERIyImPQEhESFaGxapqRYbAXD+kNsUHAYzGxRG+OIAAAEAngMTA90FmQARAAABMwEjIiYnAy4BJwYHAw4BKwECBHMBZoERGAjEDRMHDhfCCBcUiAWZ/XoUDgFgFysVLCv+oA4UAAABAAD+4wMU/1sAAwAABRUhNQMU/OyleHgAAAEAJgSLAbMFqQAJAAATMhYfASMiJicDzyEgDpVmFRoO6gWpFRfyDQ8BAgAAAgBc//ADegQHACkAOQAAISMiJi8BDgMjIi4CNTQ+Ajc1NCYjIg4CIyImLwE+ATMyHgIVATI+Ajc1DgMVFB4CA3pPGiAFFChMVF86O2dMLUKT7qxlY0FZQS8XEhsIIFTCdlWEWi7+Mi9ORT8ee6xsMRosPBAaXiQ5JxQhQmVFPG9WNwRPdnkhKSETDjlRUDhkjlX95RMjMiDTBB8yRCooOiURAAACAJj/8gQWBcEAFgAlAAAzETMRPgEzMh4CFRQOAiMiJicHBiMBIgYHER4BMzI2NTQuApizP6NpWI5kNjxxo2ZiiTMJCCYBUVeDNzB1SI6YI0JgBcH9oklZQoPBfnDBjVFMRFwmA3dQSf4WQjbKu2OOWyoAAAEASv/yA38EBQAqAAABDgEjIi4CIyIOAhUUHgIzMj4CMzIfAQ4BIyIuAjU0PgIzMhYXA0UIEA8PIzZNOEpyTScqTG1EQVQ4JBIXCzJCxm5fo3hFP3myc2qkPwNBCwwZHhk1ZI5YXI9hMx8mHxFBUUtGhcJ8ccCLTkU/AAACAEj/8gPFBcEAFgAlAAAhIi8BDgEjIi4CNTQ+AjMyFhcRMxElMjY3ES4BIyIGFRQeAgNbJgoQQadsV45kNjxxomddhDSy/j1XgzcxdUeOmCJCYCV7T19DgsJ+cMGOUT85AjL6P4JQSQHqQjXKu2ONWyoAAAIASv/yA8cEBQAkAC0AAAEyHgIVFAYjIR4DMzI+AjMyHwEOAyMiLgI1ND4CFyIGByE0LgICI1uacD8SGf1eAjBUdEhDYUYvERYMMiFcaXA3abGBSEF6sHKBlBICJyJCXwQFPXOpbCocYI5fLx8kHxFBKDsmE0eJyoNquIdNg5WEPmdLKQAAAQAaAAAClAWuAB4AADMRJy4BPQEzNTQ+AjMyFwcOASsBIg4CHQEhFSERunAVG6AxW4BQRDoEASAdHy5LNh0BJf7hA10NBRUUSWJXh10wFFkUCBg2WEFdgfygAAADADL+kwPeBAYAOQBNAF0AAAEyFhchFRQPARYVFA4CIyInDgEVFB4GFRQOAiMiLgI1NDY3LgE1ND4CNy4BNTQ+AgE0LgQnDgEVFB4CMzI+AgEyPgI1NCYjIgYVFB4CAedCcy8BEypzIjlli1NHPyAhOmB6f3pgOkF6sG9vp243X1MrMxAhMCBLVTlmjQGQKkheaGwxOUcjSG1KSHJPKv7ENlM4HHFsa3EdOFIEBh0cQiEJEEFQSnlWLhEULhYkJRAECRYyWEZBel85LEphNUtpHxRDOBYvLioQKotdSnlVLvvDJi4ZDAUGCBtONiI7KxkaMEICTh42Sy1dbm5dLUs2HgABAJIAAAPdBcEAFQAAMxEzET4BMzIeAhURIxE0JiMiBgcRkrJBnmdTf1UssmlsT4k6BcH9rEVTN2WOVv17AoVzf0xB/RYAAgCCAAABgAWzAAMAFwAAAREjERMUDgIjIi4CNTQ+AjMyHgIBWLLaFSMuGhotIxQUIy0aGi4jFQP1/AsD9QE+Gi0jFBQjLRoaLyMUFCMvAAAC/8j+lAGABbMAFAAoAAABERQOAiMiJic3PgEzMhYzMjY1ERMUDgIjIi4CNTQ+AjMyHgIBWCBFbUwhNhsIAg4PCBINTkLaFSMuGhotIxQUIy0aGi4jFQP1+8A9aU4tCgpgDQcBSVEEQAE+Gi0jFBQjLRoaLyMUFCMvAAEAmAAAA/gFwQAeAAABETMyNjcBPgE7AQEOAQceARcBIyImJwEuASsBESMRAUsuFBoQAUAPHhmi/osOGxESHQ0BjKAWHw7+sw8eHjKzBcH8nQsRAVcQFP5zERoKDB8U/gwREgGfFQ3+HAXBAAEApgAAAVgFwQADAAABESMRAViyBcH6PwXBAAABAJIAAAXvBAUAKgAAMxEzMh8BPgEzMhYXPgMzMh4CFREjETQmIyIOAhURIxE0JiMiBgcRkmomCg04i1xnfxwVRVZhMlB9Vy6yaGMsTzwjsmJeQnEvA/UlaEVYcmE3UDQYM2KPXP17AoV3ex88Wzz9ewKFenhHPf0NAAEAkgAAA90EBQAXAAAzETMyHwE+ATMyHgIVESMRNCYjIgYHEZJqJgoOQqNrU39VLLJpbE+JOgP1JW5JWjdljlb9ewKFc39MQf0WAAACAEj/8gQOBAUAEwAjAAABMh4CFRQOAiMiLgI1ND4CEzI2NTQmIyIOAhUUHgICLG+zfUNDfbNvb7N+RER+s2+WlJSWTHBLJSVLcAQFSojBd3jAiElJiMB4d8GISvx4ybS1yjRij1pajmE0AAACAJL+qQQPBAcAFgAlAAATETMyHwE+ATMyHgIVFA4CIyImJxEBIgYHER4BMzI2NTQuApJqJgoPQadtV45kNjxwo2ZehTMBEVeDNzF1SI2YI0Jg/qkFTCV4T2BDg8J+cMGNUT45/kAEzlBJ/hZCNsq7Y45bKgAAAgBI/qkDxQQHABYAJQAAAREjEQ4BIyIuAjU0PgIzMhYXNzYzATI2NxEuASMiBhUUHgIDxbJAo2lXjmQ2PHGiZ2KJNgwKJv6nV4M3MHZHjpgiQmAD9fq0Ae1KWkOCwn5wwY5RRkBPJfyNUEkB6kA3yrtjjVsqAAEAkgAAAvoEBwAWAAAzETMyFh8BPgEzMhYXBwYjIiYjIgYHEZJmHRYEDDSZZypEHRcHGA46NF19KgP1FhueancTEYUZE2xn/XsAAQA+//ADDwQFADwAAAEGIyIuAiMiDgIVFB4GFRQOAiMiJic3PgEzMh4CMzI+AjU0LgY1ND4CMzIWFwLWDBkPJjdMNC1IMxstSl5jXkotMmKOXWqsPCoIFhISKDlRPTRONBktSl9jX0otMFyGVmSfOgNOFhYbFxcoNR8nNCYdISg8Vz1Gd1cyRTZEDQ4cIhwbLjwiKjcnHSApPltBOmtRMD83AAABACz/8AK6BT4AIQAABSImNREjIiY9ATcTPgE7AREhFSERFBYzMj4CMzIfAQ4BAcV4gXoQFqYpAhYRWgEi/t4+MRwpHhUIDgs0LoIQhn4CbBMURxUBOQ8T/qOB/aBAPg8SDxFVKzEAAAEAev/wA8UD9QAXAAABERQWMzI2NxEzESMiLwEOASMiLgI1EQEsamtOijqyaiYKDkKkalN/VisD9f16c35KQgLr/AslbUlZN2SOVgKGAAEAEgAAA+0D9QASAAATMzIWFwEeARc+ATcBPgE7AQEjEpIVHAYBAQ4QBwgSDgEEBhsUi/5joQP1Fg/9dCRIIyNIJAKMEBX8CwAAAQAOAAAF7wP3AC4AABMzMhYXEx4BFz4BNxM+ATsBMhYXEx4BFz4BNxM+ATsBASMiJwMuAScOAQcDBisBDowWHAXCCA4FCBQL1gUZE00UGgXRCxEIBRAJxgUcE4b+uI0aCuAICgUFCgjjCx6GA/UWD/10JEMiIkMkApAPFBQP/XAjRCEhSB8CjBAV/AsiAq8XLxcXMBf9UiIAAAEAHAAAA9ID9QAbAAAJATMyFhcTNjcTPgE7AQkBIyImJwMGBwMOASsBAX/+q6sWFAj4CRHaChQPpP6rAWOrFhkI/wcO7AoXFJ8CBwHuDg3+hBwcAUAOEf4c/e8XDgGNHRf+pw4XAAEADv6pA/AD9QAWAAABDgErARMBMzIWFwEeARc+ATcBPgE7AQG7CRschLn+XpoXGgYBDwkNBQcOCQEHBh0Rjv7VFBgBkgO6Fw79ghYsFxcsFwJ9EBUAAQBGAAADVQP1AA8AAAEUBgcBIRUhNTQ2NwEhNSEDVQ4L/dwCKf0FDQwCJ/3fAvADqRMjDv0mi0oNIxAC34wAAAEALP7fAgAF/QBAAAATNCYjNTI2NTQuAjU0PgI7ARUUBisBIgYVFB4CFRQOAgceAxUUDgIVFBY7ATIWHQEjIi4CNTQ+ArVGQ0NGEBMQKVN7UjUcDBRNWQ4SDhYpNyEhNykWDhIOWU0UDBw1UntTKRATEAGpP1FrUEAyYmJkNEV0VC5PFBJlVjhoY2IyJkEzJQkJJTRAJTJiY2g4V2QSFFAvVHRFNGNjYgAAAQDm/qkBcAX9AAMAABMzESPmiooF/fisAAABAFj+3wIsBf0AQAAAARQeAhUUDgIrATU0NjsBMjY1NC4CNTQ+AjcuAzU0PgI1NCYrASImPQEzMh4CFRQOAhUUFjMVIgYBoxATECpSe1I1HAwUTVkOEg4WKTchITcpFg4SDllNFAwcNVJ7UioQExBGQ0NGAakyYmNjNEV0VC9QFBJkVzhoY2IyJUA0JQkJJTNBJjJiY2g4VmUSFE8uVHRFNGRiYjJAUGtRAAEAdAGeBBIDAAAbAAABMjY3MxQOAiMiLgIjIgYHIzQ+AjMyHgIC90FJAZAlRWZANGZfViRBSQGQJUVlQTRmX1YCZVVGQ3BQLCAnIVRHQ3BQLSEnIQAAAgDa/qkB1AQFAA0AIQAAARE0PgI3Mx4DFREDND4CMzIeAhUUDgIjIi4CAQYDBgkGeQYJBgPVEyItGxotIhQUIi0aGy0iE/6pAh0tVVdcNDRcV1Ut/eME3xstIhMTIi0bGi4iFBQiLgACAIr/FQQCBOYALgA3AAAFLgM1ND4CPwE+ATsBBx4BFwcOASMiLgInAz4DMzIWHwEOAQ8BDgErAQMUFhcTDgMCMVybcT9Cfrh3DAIbFUIQUoQ2LggPDgwhLT8qND9VOyYQCxIFMDy5awwCGxVC54d5NExzTicLCk+EtnJvu4pRA7MUHekMPzE+CwsRGBgH/QYEHyIcCQc/SEoHrxMdAuWiwBcC+AY5Y4gAAAEANAAABFsFqAA+AAATNDY7ARE0PgIzMh4CFwcOASMiJicuAyMiDgIVESEVFAYjIRUUBgc+ATMhFRQOAiMhNT4DNREjNCAdhjZupG5OeV5FGEgKFQoOGQsUKTNCLT9gQCABuR4W/ns5Mh05HgKkCxQcEvw8Ij4wHcMCoBokAQVepXtHJ0RaNC4GBQsOGS8jFSpObkT++UgSHvNLbS0FB0wOGxcOcwoiM0UuASEAAAIAhADgBAQEYAAjADcAABM0NjcnNxc+ATMyFhc3FwceARUUBgcXBycOASMiJicHJzcuATcUHgIzMj4CNTQuAiMiDgLfIR2ZW5csaDo5ZiuZWZcfIiEdmFuYLGg5OWUsmVmXHiKEIz5RLy9TPSQkPVMvL1E+IwKgOWUsmVqYHyIhHplbmCxnOjlmK5dcmB4iIR2ZW5gsZzouUT0kJD1RLi9SPiMjPlIAAAEALAAABFMFmQAiAAATIQEzMhYXAR4BFz4BNwE+ATsBASEVIRUhFSERIxEhNSE1IZIBMv5olRofCgEUDhQHBxIOARMIIRmW/mcBM/6sAVT+rLP+rAFU/qwCcQMoGRT9yiM6HR07IgI2ERz82GZpZ/7FATtnaQACAOb+qQFwBf0AAwAHAAATMxEjETMRI+aKioqKBf385v7h/OUAAAIAcv+DA4cFpwBIAFoAAAEGIyIuAiMiDgIVFB4GFRQGBx4BFRQOAiMiJic3PgEzMh4CMzI+AjU0LgY1NDY3LgE1ND4CMzIWFwEUHgIXPgE1NC4EJw4BAzEMGQ8mN0w0ME01HDFPZmlmTzFOVDE+MmGPXGqsPCkIFxESKDpVPzJPNhwyUmhuaFIyVl0yPzBchlZknzr9t0ZthD42MB40Rk9UKEI2BPEWFhsXGSo4HyY5LysuN0dcPVF/JiViRUZ3VzJFNkQNDhwjHBktPiYtQjMqLDNGXUBOfSMmaUs6a1AwPjf9pDNHOTUfGksvJDguJiMjFB5JAAIADgSaAlYFewATACcAABMUDgIjIi4CNTQ+AjMyHgIFFA4CIyIuAjU0PgIzMh4C7xIgKRcWKB8SEh8oFhcpIBIBZxIfKRcXKR4SEh4pFxcpHxIFCRcoHhISHigXFyofEhIfKhcXKB4SEh4oFxcqHxISHyoAAwBE//IF+QWoAC4ASgBiAAABPgEzMhYfAQ4BIyIuAjU0PgIzMhYXBw4BIyIuAiMiDgIVFB4CMzI+AgE0PgQzMh4EFRQOBCMiLgQ3FB4EMzI+AjU0LgQjIg4CBAYICwYLCAY9OaZ0YqFzP0V6p2JsmDkuBRAMDh8yTDtGcU8rK0xqPjBCMCX8UjRfhqK6ZWW7ooZfNDRfhqK7ZWW6ooZfNGQsUnKMoliE56tjLVJzjKNYhOaqYgHPBQcGBkBCSUR6qGRlqXlDRDdBBgwWGxctVHhLTXlSKwwUGAEJZbujhWA0NGCFo7tlZLuihWA0NGCForplWaSPdFMtZK3phlmmj3ZTLmWv6wAAAgBcAz8CVAWqACkANQAAASMiJi8BDgMjIi4CNTQ+Ajc1NCYjIg4CIyImLwE+ATMyHgIVATI2NzUOAxUUFgJUPBISCAwYLjI4IiZBMBsmWJFrOjkmMiUdEA4UBRY0eUk2VDoe/uEzSiRGYTwaNANICxIxFSAXCxQpPCkiQzUjAiU/PBIVEQ8KKjEuIjxUM/7WJiNpAhEbIxUqIgAAAgCKAIEDAQOiABQAKQAAEzUTFx4BFRQHAwYHFhcTHgEVFA8BEzUTFx4BFRQHAwYHFhcTHgEVFA8Bivk6Dg4Knw4ODw2fBQUcOi/5Og4OCp8ODg8NnwUFHDoCBhcBhRwHFg0REP77GA0OFv77CBIIHA0cAYUXAYUcBxYNERD++xgNDhb++wgSCBwNHAABAJQBOwPwAuMABQAAEyERIxEhlANcl/07AuP+WAEhAAEAZAIMAlICowADAAATIRUhZAHu/hICo5cABABE//IF+QWoABsAMwBJAFYAABM0PgQzMh4EFRQOBCMiLgQ3FB4EMzI+AjU0LgQjIg4CBREjESEyFhUUBgceARcTIyInAy4BIyczMj4CNTQuAisBRDRfhqK6ZWW7ooZfNDRfhqK7ZWW6ooZfNGQsUnKMoliE56tjLVJzjKNYhOaqYgHmnAEgrKZrahEZC+SUIRDJCRkaUHQ3TS8VEytGNIQCzGW7o4VgNDRghaO7ZWS7ooVgNDRghaK6ZVmkj3RTLWSt6YZZpo92Uy5lr+vg/p4DfH16XoQZCh4U/rIZAS4NDnIVKDomJTgkEgABABQEzwJSBUQAAwAAEyEVIRQCPv3CBUR1AAIARgMnAtIFqgATACcAABM0PgIzMh4CFRQOAiMiLgI3FB4CMzI+AjU0LgIjIg4CRjJYd0VFd1gyMlh3RUV3WDJ/HjZJKipINh4eNkgqKkk2HgRoQ3ZXMjJXdkNCdVczM1d1QSpJNh8fNkkqKko3Hx83SgAAAgBkAFAEIgSyAAsADwAAAREhFSERIxEhNSERASEVIQKLAZf+aZL+awGV/msDvvxCBLL+iIj+kAFwiAF4/CWHAAEAUgOEAlEGZQAtAAABMh4CFRQOAg8BPgE7ATIWHQEhNTQ2PwE+AzU0JiMiBgcOASMiJi8BPgEBWjRVPCEZKjYeohcvFcMVF/4BCgzdGSwgEzwtLjkOCBMRBAkFRw+KBmUeNk0vKEU+Oh6lBggWFE0rDRwM2xk0NTUbMzcwKg4QAQEMamoAAQBUA3wCUgZlAD0AAAEyHgIVFAceARUUDgIjIi4CJzc2MzIXHgMzMj4CNTQuAiM1PgE1NCYjIgYHDgEjIiYvAT4DAWIzUjsgd0JFKkVbMDlUPSsPNw8OHQsGEh4rIB8vIBARJ0EvV0c6MDA5DAgRDwQJBUMHLEFUBmUdM0QogC0TTj43VDkdGTFILxgGFw0gHBMUHygVHiscDlcBPDQyNC8oEA8BAQw1TzUbAAEAxASLAlUFqQAJAAABAw4BKwE3PgEzAlXpDhsVapQOISAFqf7+Dw3yFxUAAQB6/qkDxQP1AB0AAAERFBYzMjY3ETMRIyIvAQ4BIyImJx4BFREjIiY1EQEsbGlOijqyaiYKDkONV0pwJwcGWSYpA/X9bm14SkIC6/wLJW1IRDMuKlcm/ukoJAUAAAEAKv83BRYFmQATAAABFSMRIxEhESMRIi4CNTQ+AjMFFtud/uudaKZ1Pz91pmgFmZn6NwXJ+jcDXT1pjlFWjWU4AAEAfAG9AacC6AATAAATND4CMzIeAhUUDgIjIi4CfBcpNh4fOCgYGCg4Hx42KRcCUR84KBgYKDgfHjYpFxcpNgABAIT+oQHvAAoAHQAAFzIeAjMyNjU0LgInNzMHHgEVFA4CIyImJzc2rAYQFiAVKisWKTwmK3AYWlEgOVAwKUofEQb3BwkHIRoTGhIMBY1QFEU2IDMkExEONxIAAAEAeAOEAkQGXwAPAAATMxE3BwYjIi8BNzMRMxUhrZMEawwOFwkn3myC/mkD2QG4K1gJDji+/XpVAAACAEgDPAKxBakAEwAfAAABMh4CFRQOAiMiLgI1ND4CEzI2NTQmIyIGFRQWAX5GcVAsLFBxRkdyUSwsUXJHVFNTVFdTUwWpK1BzR0h0USsrUXRIR3NQK/39aWRkaGhkZGkAAAIAlgCBAw0DogASACUAADcnJjU0NxM2NyYnAyY1ND8BExUlFQMnJjU0NxM2NyYnAyY1ND8B7DocCp8NDgwPnwocOvkBKPk6HAqfDQ4MD58KHDqBHA0cEREBBRgMCxoBBRERHA0c/nsXFxf+exwNHBERAQUYDAsaAQURERwNHAAABABmAAAFfAWaABAAIAAmADAAAAEzFRQGKwEVIzUhIiYvAQEzJTMRNwcGIyIvATczETMVIQU0NjcDMwUOASsBAT4BOwEFD20ODVJt/s4SFQIKAVZ8+4yTBGsMDhcJJ95sgv5pBAcCA/Hs/RATLB1MAzISLiBNAQtBCw+wsBAMOQHUOwG4K1gJDji+/XpVwxMsF/651h8WBVwdIAAAAwBmAAAFXQWaAC0APQBHAAABMh4CFRQOAg8BPgE7ATIWHQEhNTQ2PwE+AzU0JiMiBgcOASMiJi8BPgElMxE3BwYjIi8BNzMRMxUhEw4BKwEBPgE7AQRmNFU8IRkqNh6iFy8VwxUX/gEKDN0ZLCATPC0uOQ4IExEECQVHD4r8nJMEawwOFwkn3myC/mnrEywdTAMyEi4gTQLhHjZNLyhFPjoepQYIFhRNKw0cDNsZNDU1GzM3MCoOEAEBDGpqMwG4K1gJDji+/XpV/XYfFgVcHSAABABEAAAFfQWgABAATgBUAF4AAAEzFRQGKwEVIzUhIiYvAQEzATIeAhUUBx4BFRQOAiMiLgInNzYzMhceAzMyPgI1NC4CIzU+ATU0JiMiBgcOASMiJi8BPgMBNDY3AzMFDgErAQE+ATsBBRBtDg1Sbf7OEhUCCgFWfPxCM1I7IHdCRSpFWzA5VD0rDzcPDh0LBhIeKyAfLyAQESdBL1dHOjAwOQwIEQ8ECQVDByxBVAOCAgPx7P0UEywdTAMyEi4gTQELQQsPsLAQDDkB1ALHHTNEKIAtE04+N1Q5HRkxSC8YBhcNIBwTFB8oFR4rHA5XATw0MjQvKBAPAQEMNU81G/xcEywX/rnWHxYFXB0gAAACACz+nAMCBAUAKQA9AAAFDgMjIi4CNTQ+BD8BMxcVFA4EFRQeAjMyPgIzMhYXATQ+AjMyHgIVFA4CIyIuAgMCH0tYaDxPh2I4LUVSRzMEEnoMLUVPRS0iOk8tPVc8JgwOEQf+cRMhLhoaLiITEyIuGhouIRPUHTQoFyxSdktMakw2MDEhmqcMLD4yLzxQOyxFMRoeJB4MCwQQGi4iFBQiLhobLSITEyIt//8ACgAABUkG9gImACIAAAAHAMYBawAA//8ACgAABUkG9gImACIAAAAHAMgBawAA//8ACgAABUkG3AImACIAAAAHAMkBdgAA//8ACgAABUkG0gImACIAAAAHAMsBdgAA//8ACgAABUkG8gImACIAAAAHAMcBdgAA//8ACgAABUkHLQImACIAAAAHAMoBcwAAAAL/6AAABtoFmQASABgAAAEhFSETIRUhEyEVIQMhAw4BKwEBIQMOAQcC3QP9/RM8Ai/95D0CYfz8Mf3UswslGpQB2gHRXgwdDgWZnv4kmP4XngGI/qUUGQIUAvEpRR8AAAEAWv6hBQkFqQBLAAAFMh4CMzI2NTQuAic3LgICNTQSNiQzMhYXBw4BIyIuBCMiDgIVFB4CMzI+Ajc2MzIfAQ4BDwEeARUUDgIjIiYnNzYCgwYQFiAVKisWKTwmJIvin1ZpvgEJoJ7lWT8HEhENHSg2SmJAc7+KTU2FtmlAZldLJhEQEA1MU+miEFpRIDlQMClKHxEG9wcJByEaExoSDAV2DHW/AQCZogEOwmtiVFkKDRMcIBwTT5LSgobSkUwPIDEiDw1TYXAGNxRFNiAzJBMRDjcSAP//AK4AAAQhBvYCJgAmAAAABwDGATcAAP//AK4AAAQhBvYCJgAmAAAABwDIATcAAP//AK4AAAQhBtwCJgAmAAAABwDJAUIAAP//AK4AAAQhBvICJgAmAAAABwDHAUIAAP///8wAAAG8BvYCJgAqAAAABgDG+AD//wCaAAACigb2AiYAKgAAAAYAyPgA////7wAAAnsG3AImACoAAAAGAMkDAP////IAAAJ4BvICJgAqAAAABgDHAgAAAgAyAAAF0QWZABAAIQAAEzMRITIEFhIVFAIGBCMhESMlNC4CIyERIRUhESEyPgIyxQIXngEFumZmuv77nv3pxQTYSIS8dP6rAX3+gwFVdLyESAMMAo1nvf74oaH++LxnApoyhNCQTP4Qcv4DTI/Q//8ArgAABTgG0gImAC8AAAAHAMsB2gAA//8AXP/xBeEG9gImADAAAAAHAMYB4wAA//8AXP/xBeEG9gImADAAAAAHAMgB4wAA//8AXP/xBeEG3AImADAAAAAHAMkB7gAA//8AXP/xBeEG0gImADAAAAAHAMsB7gAA//8AXP/xBeEG8gImADAAAAAHAMcB7gAAAAEAfgDbBAMEWAALAAAJAgcJAScJATcJAQP5/qgBYl/+nv6bXwFk/qdfAVkBWAP2/qj+n2ABYv6cYAFkAVlg/qYBWAAAAwBc/5MF4QXaACEALQA4AAABFAIGBCMiJicHDgErARMmAjU0EjYkMzIWFzc+ATsBBxYSBRQWFwEuASMiDgIFNCYnARYzMj4CBeFmuv77nmy8T2QWOh1Ov3B7ZroBBJ5zyFNSFCAgZKxncPtBS0UCkzyUV3O8hUgD+EE8/XF0nHS8hEgCzKH+88JrMTCIHRoBBGIBILOhAQ3DbDo2bxsX62L+6quH00kDgyorTpHShH7JSPyERk2R0QD//wCg/+8FFQb2AiYANgAAAAcAxgGdAAD//wCg/+8FFQb2AiYANgAAAAcAyAGdAAD//wCg/+8FFQbcAiYANgAAAAcAyQGoAAD//wCg/+8FFQbyAiYANgAAAAcAxwGoAAD//wAIAAAE5Ab2AiYAOgAAAAcAyAE5AAAAAgDCAAAEfwWZABAAGwAAAREjETMRMzIeAhUUDgIjJzMyPgI1NCYrAQGDwcHmiMmEQUaHyIHm5lN/Viypq+YBEP7wBZn++D90pGVkpnhDmixPbkKJmgABALr/8AR2Ba4ASAAAATIeAhUUDgQVFB4EFRQOAiMiJic3PgEzMh4CMzI+AjU0LgQ1ND4ENTQuAiMiDgIVESMRND4CAqFnl2IvK0BLQCs1UF1QNTlkh09hnjwpCBcREig3SzUsRjEaOFRiVDgtQ05DLRk4WT9Eb08rs0WAtAWuPF1uMzxWQjIwMyAnNC0vRmZOTnpVLUU2RA0OHCIcGy5AJThGMyo6U0I1Tz82PEcwIEE0ISpUflT8JgPgaKp6Qv//AFz/8AN6BakCJgBCAAAABwBBAN0AAP//AFz/8AN6BakCJgBCAAAABwB0AN0AAP//AFz/8AN6BZkCJgBCAAAABwDBAN0AAP//AFz/8AN6BYkCJgBCAAAABwDDAN0AAP//AFz/8AN6BXsCJgBCAAAABwBoAN0AAP//AFz/8AN6Bd4CJgBCAAAABwDCAN4AAAADAFz/8AYPBAcAQwBRAFwAAAEyHgIVFAYjIR4DMzI+AjMyFh8BDgMjIiYnDgMjIi4CNTQ+Ajc1NCYjIg4CIyImLwE+ATMyFhc+AQEOAxUUFjMyPgI1ASIOAgchNC4CBI5SjWc7EBn9jQQuTWlBRVw9JhAOEgYvIVdjajR1vzcbV2p3O0VyUy1Ck+6sZWNBWUEvFxIbCCBUtXF4kiE2rf62e6xsMWRROWNJKgG8PWBFKQcB/B88VwQFQHqvcCkdW4daLB0kHQkIPSg7JhNxdD5YOBkjRmpIPHRcOwQydn4jKiMTDjlRUGZbWGf94QUjOEgqV1AkSm5KAe8pTnBGQW9QLQABAEr+oQN/BAUASAAABTIeAjMyNjU0LgInNy4DNTQ+AjMyFhcHDgEjIi4CIyIOAhUUHgIzMj4CMzIWHwEOAQ8BHgEVFA4CIyImJzc2AZAGEBYgFSorFik8JiVTjWY6P3myc2qkPy8IEA8PIzZNOEpyTScqTG1EQVQ4JBILEQYyO6phEVpRIDlQMClKHxEG9wcJByEaExoSDAV5C0+EtnFxwItORT9ACwwZHhk1ZI5YXI9hMx8mHwkIQUhKCDoURTYgMyQTEQ43EgD//wBK//IDxwWpAiYARgAAAAcAQQD0AAD//wBK//IDxwWpAiYARgAAAAcAdAD0AAD//wBK//IDxwWZAiYARgAAAAcAwQD0AAD//wBK//IDxwV7AiYARgAAAAcAaAD0AAD////5AAABhgWpAiYAwAAAAAYAQdMA//8AlwAAAigFqQImAMAAAAAGAHTTAP///9IAAAI2BZkCJgDAAAAABgDB0gD////hAAACKQV7AiYAwAAAAAYAaNMAAAIATP/zBAUFhgA0AEgAAAEuATU0PwEuAScuATU0PwEeARc3FxYVFA8BHgMVFA4CIyIuAjU0PgIzMhYXLgEnBxMyPgI3LgMjIg4CFRQeAgGhBAUXZy1lORIZBRRgtFGnIwgWYTxjRic+e7d4Yqp9SD50pWhksUEUdV64X0dzUS4DEDRLYz5LcUwnLlBpBCkHDQYWD0gUIg4FGxcPDj4QPDB6OQ0LFRBDMXybuW6P5KBWQnuycF6nfkpWV4i+QIf8jDZtpW8rUT8lMld3RFF/Vi0A//8AkgAAA90FiQImAE8AAAAHAMMBAgAA//8ASP/yBA4FqQImAFAAAAAHAEEA+wAA//8ASP/yBA4FqQImAFAAAAAHAHQA+wAA//8ASP/yBA4FmQImAFAAAAAHAMEA+wAA//8ASP/yBA4FiQImAFAAAAAHAMMA+wAA//8ASP/yBA4FewImAFAAAAAHAGgA+wAAAAMAZAC9BCIEgAADABcAKwAAEyEVIQE0PgIzMh4CFRQOAiMiLgIRND4CMzIeAhUUDgIjIi4CZAO+/EIBYhMhLRsaLSIUFCItGhstIRMTIS0bGi0iFBQiLRobLSETAuOHAaYaLiIUFCIuGhstIhMTIi39UxouIhQUIi4aGy0iExMiLQADAED/tAQtBEkAIQArADUAAAEeARUUDgIjIiYnBw4BKwE3LgE1ND4CMzIWFzc+ATsBARQXASYjIg4CATI+AjU0JwEWA5A9QkN9s29MgzY3FjsdQ5FCRkR+s29PhzhEFCAgWvzJOwG0SW9MdE8oATdLc08oNP5PRgN0RL92eMCISSIgSh0ZxEXCfHfBiEomI1sbF/2xoGECTjg2ZJH+JDVkj1qXYP23MP//AHr/8APFBakCJgBWAAAABwBBAPUAAP//AHr/8APFBakCJgBWAAAABwB0APUAAP//AHr/8APFBZkCJgBWAAAABwDBAPUAAP//AHr/8APFBXsCJgBWAAAABwBoAPUAAP//AA7+qQPwBakCJgBaAAAABwB0AOQAAAACAJL+qQQPBcEAFAAjAAATETMRPgEzMh4CFRQOAiMiJicRASIGBxEeATMyNjU0LgKSsj+kaVeOZDY8cKNmX4QzARFXgzcxdUiNmCNCYP6pBxj9oUpZQoPBfnDBjVFFP/4zBM5QSf4WQjbKu2OOWyr//wAO/qkD8AV7AiYAWgAAAAcAaADkAAAAAQCmAAABWAP1AAMAAAERIxEBWLID9fwLA/UAAAEAAASRAmQFmQANAAABIyIvAg8BDgErARMzAmR3FROAERCBBhYMe9+mBJEOfhERfgUJAQgAAAIAagRrAfsF3gATAB8AABM0PgIzMh4CFRQOAiMiLgI3FBYzMjY1NCYjIgZqIDdIKClJOCAgOEkpKEg3IGQ2Ly03Ny0vNgUjKkQyGxsyRCopRDAbGzBEKSw4OCwtODgAAAEAEgSuAlkFiQAaAAABMjY3MxQOAiMiLgIjIgcjND4CMzIeAgGhJCcBbBkvQSgjPTYwF0gCbxowQicjPTYvBS0qLC9POB8dIh1YME85Hx0iHQABABoAAAPLBb8AIQAAMxEnLgE9ATM1ND4CMzIWFwcOASMiJiMiBh0BIREjESERunAVG6A6dK1zJk8dBgIUEwsYD7GhAmSy/lQDXQ0FFRRJOF2bcD4KCl0NBwGTlDP8HwNg/KAAAQAaAAAD8gW0AB8AADMRJy4BPQEzNTQ+AjMyFjsBESMRLgEjIgYdASEVIRG6cBUboDRonGhTmUhksjZtKIKMAQj+/gNdDQUVFEk2VJdwQg36WQUqAgaVhjaB/KAAAAH/1AYKAcQG9gAJAAATMhYfASMiJiclnSAgFNOLFRgR/tkG9g0UywcM2QAAAv/wBhYCdgbyABMAJwAAExQOAiMiLgI1ND4CMzIeAgUUDgIjIi4CNTQ+AjMyHgLMEh4pFxUnHhISHicVFykeEgGqEh4oFhcoHhERHigXFigeEgaCFiceEREeJxYXKR4SEh4pFxYnHhERHicWFykeEhIeKQABAKIGCgKSBvYACwAAAQUOASsBNz4DMwKS/toRGhWK0woREhYRBvbYDAjLCgwIAwAB/+wGCgJ4BtwAEAAAASMiJi8BJicGDwEOASsBNzMCeIcMHAmCCAQIBIIJHAyH7rAGCgcGXwQEBgJfBgfSAAIAdgXNAfEHLQATAB8AABM0PgIzMh4CFRQOAiMiLgI3FBYzMjY1NCYjIgZ2HzNEJidFNR4eNUUnJkQzH1k2Ly03Ny0vNgZ7J0IvGhovQicmQC4aGi5AJis5OSstODgAAAEAGgYIAlYG0gAbAAABMjY3MxQOAiMiLgIjIgYHIzQ+AjMyHgIBqyMlAWIWKj4oI0A7NBgiJQFkFys/JyNAOjQGfyklK0g1HRofGiskK0k0HhofGgAAAAABAAAAzACCAAcAYgAEAAEAAAAAAAAAAAAAAAAAAgABAAAAAAAAADQAXADAATYBtAIlAj0CbQKdAuoDAwMxAz4DXgNzA7ED1AQhBIgEsgT3BT4FYQXFBhMGTAaUBrkGzQbwB0MHygf0CDUIewipCMII2AklCTwJSAlvCakJuQn2Ch8KXwqICtULDgthC3QLnAvBDAkMPgxmDIIMmwyxDMoM7Qz6DRANYg2cDdoOFA5XDoUPBg8pD1EPjg/ED9IQDxA1EGsQphDhEQYRWBGMEbMR2BIlElgSgxKjEvgTBRNaE4UThRO5FA4UZRS5FPQVBxWCFbwWQBaOFtQW5BbxF2cXdBeuF84YERhnGH0YrBjNGO0ZGxk4GWkZqRn3GmAa6Bs9G0kbVRthG20beRuFG7UcIBwsHDgcRBxQHFscZhxxHHwctBzAHMwc2BzkHPAc/B0eHXsdhx2THZ8dqx23HeIeQh5OHloeZh5yHn4eih8LH3AffB+IH5QfoB+rH7YfwR/MIDUgQSBNIFkgZSBxIH0gviESIR4hKiE2IUIhTiGGIZIhoCG7IesiFCJGInUiiyLFIt0i/CMsI1cAAAABAAAAARqgqZlgll8PPPUAGQfQAAAAAMqTXnAAAAAAyt8uhf9E/pMIuQctAAAACQACAAAAAAAABCcALQGCAAACrgDaAxoAmASIADYEiABqBiQASAV+AFIBzACYAlgAhgJYAEoDIABgBIgAZAGoAF4CtgBkAagAWALq//QEiAA8BIgAygSIAGgEiABsBIgAKASIAGwEiABsBIgAbgSIAGAEiACUAfgAgAH4AIAEiACUBIgAlgSIAO4DHAAiBmwAVgVQAAoFDgCuBVoAWgXiAK4EigCuBGwArgW8AFoF6ACuAmYA0gN4ADwFUgDCBAQArgcwAK4F6ACuBjwAXATGAMIGPABcBQgAwgQkADoEnAAcBbQAoAVQAAgH9gAOBQYADgTqAAgE4ABWAlgAjgLu/+wCWABaBIgAngMUAAACZgAmA/YAXAReAJgDpgBKBF4ASAQYAEoCogAaA/4AMgRYAJICAACCAfz/yAQYAJgCAACmBmoAkgRYAJIEWABIBFAAkgReAEgDJgCSA2QAPgLqACwEWAB6BAAAEgX8AA4D8AAcBAAADgOcAEYCWAAsAlgA5gJYAFgEiAB0AYIAAAKuANoEiACKBIgANASIAIQEiAAsAlgA5gPuAHICZgAOBjwARAKsAFwDngCKBIgAlAK2AGQGPABEAmYAFAMaAEYEiABkApgAUgKYAFQCZgDEBFgAegU6ACoCIgB8AmYAhAKYAHgC+gBIA54AlgWQAGYFkABmBZIARAMcACwFUAAKBVAACgVQAAoFUAAKBVAACgVQAAoHQv/oBVoAWgSKAK4EigCuBIoArgSKAK4CZv/MAmYAmgJm/+8CZv/yBioAMgXoAK4GPABcBjwAXAY8AFwGPABcBjwAXASIAH4GPABcBbQAoAW0AKAFtACgBbQAoATqAAgExgDCBMIAugP2AFwD9gBcA/YAXAP2AFwD9gBcA/YAXAZgAFwDpgBKBBgASgQYAEoEGABKBBgASgIA//kCAACXAgD/0gIA/+EEUgBMBFgAkgRYAEgEWABIBFgASARYAEgEWABIBIgAZARYAEAEWAB6BFgAegRYAHoEWAB6BAAADgRQAJIEAAAOAgAApgJmAAACZgBqAmYAEgR0ABoEpAAaAmb/1P/wAKL/7AB2ABoAAAABAAAHtv5WAAAJAv9E/0MIuQABAAAAAAAAAAAAAAAAAAAAxwADBBIBkAAFAAAFeAUUAAABGAV4BRQAAAO6AHgB9AgDAg8FAgICBAMCAwAAAAMAAAAAAAAAAAAAAAB0eVBMAEAAIAD/Bkr+egGQB7YBqgAAAAEAAAAAA/UFmQAAACAAAgAAAAIAAAADAAAAFAADAAEAAAAUAAQAKAAAAAYABAABAAIAfgD///8AAAAgAKD////h/8AAAQAAAAAAAAAAAAcAWgADAAEECQAAARQAAAADAAEECQABAAgBFAADAAEECQACAA4BHAADAAEECQADAFQBKgADAAEECQAEABgBfgADAAEECQAFAFABlgADAAEECQAGABgB5gBDAG8AcAB5AHIAaQBnAGgAdAAgACgAYwApACAAMgAwADEAMAAtADIAMAAxADEAIABiAHkAIAB0AHkAUABvAGwAYQBuAGQAIABMAHUAawBhAHMAegAgAEQAegBpAGUAZAB6AGkAYwAgAHcAaQB0AGgAIABSAGUAcwBlAHIAdgBlAGQAIABGAG8AbgB0ACAATgBhAG0AZQAgACIATABhAHQAbwAiAC4AIABMAGkAYwBlAG4AcwBlAGQAIAB1AG4AZABlAHIAIAB0AGgAZQAgAFMASQBMACAATwBwAGUAbgAgAEYAbwBuAHQAIABMAGkAYwBlAG4AcwBlACwAIABWAGUAcgBzAGkAbwBuACAAMQAuADEALgBMAGEAdABvAFIAZQBnAHUAbABhAHIAdAB5AFAAbwBsAGEAbgBkAEwAdQBrAGEAcwB6AEQAegBpAGUAZAB6AGkAYwA6ACAATABhAHQAbwAgAFIAZQBnAHUAbABhAHIAOgAgADIAMAAxADEATABhAHQAbwAgAFIAZQBnAHUAbABhAHIAVgBlAHIAcwBpAG8AbgAgADEALgAxADAANAA7ACAAVwBlAHMAdABlAHIAbgArAFAAbwBsAGkAcwBoACAAbwBwAGUAbgBzAG8AdQByAGMAZQBMAGEAdABvAC0AUgBlAGcAdQBsAGEAcgADAAAAAAAA/3QAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgASAAf//wAPAAEAAAAKACQAMgACREZMVAAObGF0bgAOAAQAAAAA//8AAQAAAAFrZXJuAAgAAAABAAAAAQAEAAIAAAABAAgAAQDGAAQAAABeCuwK7Ao4CuwBhgvaAYYFqg6EDEQM6g6EAggNAAfiAroOhAOYDoQEMgR8DQAFqgcEB+INMgiACjgMRA72DygPKAkaDvYJfA72DvYPKA8oCUgJwglyCXwJwgo4CuwL2gvaDoQK7AquCq4L2gquCuwL2gxEDEQMRAxEDEQMRAzqDoQOhA6EDoQOhA6EDQANAA0ADQANMg6EDvYO9g72DvYO9g72DygPKA8oDygPKA72DygPKA8oDygPKA8oDygAAQBeAAMACAAJAAsADQAOAA8AEAAhACIAJAAlACcAKwAsAC0AMAAxADIAMwA1ADYANwA4ADkAOgA7ADwAPQBCAEMARgBHAEkATABOAE8AUABRAFMAVwBYAFkAWgBcAGoAawBtAG4AcAByAHMAdwB5AHoAewCAAIEAggCDAIQAhQCHAJAAkgCTAJQAlQCWAJkAmgCbAJwAnQCeAKAAoQCiAKMApAClAKYAqACpAKoAqwCxALIAswC0ALUAtgC4AL4AIAAD/xwACP8cAAv/HAAO/3gAIf/IACT/yAAo/8gAMP/IADL/yAA1/0wAN/9MADj/hgA6/2gAPf9MAFf/fABY/8IAWv98AGr/HABr/3gAbf94AHD/HAB3/3gAev8cAHv/eACH/8gAkv/IAJP/yACU/8gAlf/IAJb/yACY/8gAnf9oACwAB/98AA3/TAAP/0wAEP98ABv/xAAc/8QAIAAeACL/fAAr/zoARP+6AEX/ugBG/7oATv/EAE//xABQ/7oAUf/EAFL/ugBT/8QAVv/EAHX/xACA/3wAgf98AIL/fACD/3wAhP98AIX/fACG/3wAp/+6AKj/ugCp/7oAqv+6AKv/ugCw/7oAsf/EALL/ugCz/7oAtP+6ALX/ugC2/7oAuP+6ALn/xAC6/8QAu//EALz/xAA3AAP+3gAI/t4AC/7eAA0ANgAO/zoADwA2ACD/zgAh/7AAJP+wACj/sAAw/7AAMv+wADX/VAA3/0oAOP9oADr/LAA9/0oARP/cAEX/3ABG/9wAUP/cAFL/3ABX/5QAWP+wAFr/lABq/t4Aa/86AG3/OgBw/t4Acv82AHP/NgB3/zoAef82AHr+3gB7/zoAh/+wAJL/sACT/7AAlP+wAJX/sACW/7AAmP+wAJ3/LACn/9wAqP/cAKn/3ACq/9wAq//cALD/3ACy/9wAs//cALT/3AC1/9wAtv/cALj/3AAmAAf/dgAN/wgAD/8IABD/dgAi/3YAK/9KAEL/zgBE/+IARf/iAEb/4gBQ/+IAUv/iAID/dgCB/3YAgv92AIP/dgCE/3YAhf92AIb/dgCg/84Aof/OAKL/zgCj/84ApP/OAKX/zgCm/84Ap//iAKj/4gCp/+IAqv/iAKv/4gCw/+IAsv/iALP/4gC0/+IAtf/iALb/4gC4/+IAEgAh/9IAJP/SACj/0gAw/9IAMv/SADX/zAA2/9YAh//SAJL/0gCT/9IAlP/SAJX/0gCW/9IAmP/SAJn/1gCa/9YAm//WAJz/1gBLAAf/fAAN/0wADv9MAA//TAAQ/3wAG/9gABz/YAAh/54AIv98ACT/ngAo/54AK/84ADD/ngAy/54AQv8GAET/LgBF/y4ARv8uAEj/RABO/2AAT/9gAFD/LgBR/2AAUv8uAFP/YABU/14AVv9gAFf/TABY/3QAWf9wAFr/TABb/4gAa/9MAG3/TAB1/2AAd/9MAHv/TACA/3wAgf98AIL/fACD/3wAhP98AIX/fACG/3wAh/+eAJL/ngCT/54AlP+eAJX/ngCW/54AmP+eAKD/BgCh/wYAov8GAKP/BgCk/wYApf8GAKb/BgCn/y4AqP8uAKn/LgCq/y4Aq/8uALD/LgCx/2AAsv8uALP/LgC0/y4Atf8uALb/LgC4/y4Auf9gALr/YAC7/2AAvP9gAFYAAwAwAAf/eAAIADAACwAwAA3/QAAO/5AAD/9AABD/eAAb/6gAHP+oACAAMAAh/8wAIv94ACT/zAAo/8wAK/9oADD/zAAy/8wAQv+MAET/jABF/4wARv+MAEf/4gBI/3gATv+oAE//qABQ/4wAUf+oAFL/jABT/6gAVP+WAFX/1gBW/6gAV//QAFn/zABa/9AAW/+uAGoAMABr/5AAbf+QAHAAMAByADoAcwA6AHX/qAB3/5AAeQA6AHoAMAB7/5AAgP94AIH/eACC/3gAg/94AIT/eACF/3gAhv94AIf/zACS/8wAk//MAJT/zACV/8wAlv/MAJj/zACg/4wAof+MAKL/jACj/4wApP+MAKX/jACm/4wAp/+MAKj/jACp/4wAqv+MAKv/jACw/4wAsf+oALL/jACz/4wAtP+MALX/jAC2/4wAuP+MALn/qAC6/6gAu/+oALz/qAA3AAMAMAAH/6IACAAwAAsAMAAN/4YADv/gAA//hgAQ/6IAIAAiACL/ogAr/5oAQv+oAET/4ABF/+AARv/gAEj/ngBQ/+AAUv/gAFT/0gBqADAAa//gAG3/4ABwADAAcgAwAHMAMAB3/+AAeQAwAHoAMAB7/+AAgP+iAIH/ogCC/6IAg/+iAIT/ogCF/6IAhv+iAKD/qACh/6gAov+oAKP/qACk/6gApf+oAKb/qACn/+AAqP/gAKn/4ACq/+AAq//gALD/4ACy/+AAs//gALT/4AC1/+AAtv/gALj/4AAnAA7/wgAh/+IAJP/iACj/4gAw/+IAMv/iAET/3ABF/9wARv/cAEf/zABQ/9wAUv/cAFX/rgBX/74AWP/IAFr/vgBr/8IAbf/CAHf/wgB7/8IAh//iAJL/4gCT/+IAlP/iAJX/4gCW/+IAmP/iAKf/3ACo/9wAqf/cAKr/3ACr/9wAsP/cALL/3ACz/9wAtP/cALX/3AC2/9wAuP/cACYADv+6ACAAIgAh/8YAJP/GACj/xgAw/8YAMv/GAET/2gBF/9oARv/aAFD/2gBS/9oAVP/kAFf/2ABa/9gAa/+6AG3/ugB3/7oAe/+6AIf/xgCS/8YAk//GAJT/xgCV/8YAlv/GAJj/xgCn/9oAqP/aAKn/2gCq/9oAq//aALD/2gCy/9oAs//aALT/2gC1/9oAtv/aALj/2gALAAMARAAIAEQACwBEAA3/fgAP/34AagBEAHAARAByAGQAcwBkAHkAZAB6AEQACgAN/3wAD/98AEL/2gCg/9oAof/aAKL/2gCj/9oApP/aAKX/2gCm/9oAAgAN/8IAD//CABEARP/EAEX/xABG/8QAUP/EAFL/xACn/8QAqP/EAKn/xACq/8QAq//EALD/xACy/8QAs//EALT/xAC1/8QAtv/EALj/xAAdAAf/rgAN/3wAD/98ABD/rgAi/64ARP/mAEX/5gBG/+YAUP/mAFL/5gCA/64Agf+uAIL/rgCD/64AhP+uAIX/rgCG/64Ap//mAKj/5gCp/+YAqv/mAKv/5gCw/+YAsv/mALP/5gC0/+YAtf/mALb/5gC4/+YAHQAh/9gAJP/YACj/2AAw/9gAMv/YAET/4ABF/+AARv/gAFD/4ABS/+AAh//YAJL/2ACT/9gAlP/YAJX/2ACW/9gAmP/YAKf/4ACo/+AAqf/gAKr/4ACr/+AAsP/gALL/4ACz/+AAtP/gALX/4AC2/+AAuP/gAA8AB/9IABD/SAAi/0gANwA6ADgAOgA6ACgAPQA6AID/SACB/0gAgv9IAIP/SACE/0gAhf9IAIb/SACdACgAOwAH/0oADf8cAA7/TgAP/xwAEP9KACH/0gAi/0oAJP/SACj/0gAw/9IAMv/SADcAMAA4ADAAOgAeAD0AMABC/8AARP+kAEX/pABG/6QAUP+kAFL/pABr/04Abf9OAHf/TgB7/04AgP9KAIH/SgCC/0oAg/9KAIT/SgCF/0oAhv9KAIf/0gCS/9IAk//SAJT/0gCV/9IAlv/SAJj/0gCdAB4AoP/AAKH/wACi/8AAo//AAKT/wACl/8AApv/AAKf/pACo/6QAqf+kAKr/pACr/6QAsP+kALL/pACz/6QAtP+kALX/pAC2/6QAuP+kABoAA/9OAAf/zAAI/04AC/9OAA3/eAAP/3gAEP/MACL/zAA1/0wAN/+QADj/4AA5/8IAOv9gADv/0gA9/5AAav9OAHD/TgB6/04AgP/MAIH/zACC/8wAg//MAIT/zACF/8wAhv/MAJ3/YAApAAP/SgAI/0oAC/9KAA7/zAAg/8gAIf/WACT/1gAo/9YAKwAyADD/1gAy/9YANf98ADb/yAA3/3gAOP+sADr/XAA9/3gAV/+uAFr/rgBq/0oAa//MAG3/zABw/0oAcv9IAHP/SAB3/8wAef9IAHr/SgB7/8wAh//WAJL/1gCT/9YAlP/WAJX/1gCW/9YAmP/WAJn/yACa/8gAm//IAJz/yACd/1wABQAO/2oAa/9qAG3/agB3/2oAe/9qAAwAB//IAA3/zgAP/84AEP/IACL/yACA/8gAgf/IAIL/yACD/8gAhP/IAIX/yACG/8gAVAADAB4AB/9cAAgAHgALAB4ADf9oAA7/YAAP/2gAEP9cABv/hgAc/4YAIAAiACH/sAAi/1wAJP+wACj/sAAr/zgAMP+wADL/sABC/4AARP9gAEX/YABG/2AASP9UAE7/hgBP/4YAUP9gAFH/hgBS/2AAU/+GAFT/gABW/4YAV/+cAFj/pABZ/3wAWv+cAGoAHgBr/2AAbf9gAHAAHgByADIAcwAyAHX/hgB3/2AAeQAyAHoAHgB7/2AAgP9cAIH/XACC/1wAg/9cAIT/XACF/1wAhv9cAIf/sACS/7AAk/+wAJT/sACV/7AAlv+wAJj/sACg/4AAof+AAKL/gACj/4AApP+AAKX/gACm/4AAp/9gAKj/YACp/2AAqv9gAKv/YACw/2AAsf+GALL/YACz/2AAtP9gALX/YAC2/2AAuP9gALn/hgC6/4YAu/+GALz/hgAcAAP/0gAH/9YACP/SAAr/2AAL/9IADf/IAA//yAAQ/9YAIv/WADX/ngA3/8wAOf/iADr/sAA7/7oAPf/MAD7/2ABe/9gAav/SAHD/0gB6/9IAgP/WAIH/1gCC/9YAg//WAIT/1gCF/9YAhv/WAJ3/sAAMAAP/uAAI/7gAC/+4AFf/4ABY//AAWv/gAGr/uABw/7gAcv+4AHP/uAB5/7gAev+4AA8AA/+kAAj/pAAK/+AAC/+kADf/jAA4/+AAPf+MAD7/4ABX/+YAWf/EAFr/5gBe/+AAav+kAHD/pAB6/6QAAQAAAAoAJAAyAAJERkxUAA5sYXRuAA4ABAAAAAD//wABAAAAAWxpZ2EACAAAAAEAAAABAAQABAAAAAEACAABABoAAQAIAAIABgAMAMQAAgBKAMUAAgBNAAEAAQBHAAA=";
+/**
+* Decode the embedded font bytes into an ArrayBuffer.
+* Synchronous, allocation-only — no network, no I/O, SSR-safe.
+*/
+function decodeEmbeddedFont() {
+	return Uint8Array.from(atob(EMBEDDED_FONT_B64), (c) => c.charCodeAt(0)).buffer;
+}
+//#endregion
+//#region src/text/cpu-glyph-atlas.ts
+var CpuGlyphAtlas = class {
+	font;
+	pxRange;
+	atlasFontSize;
+	atlasSize;
+	cache = /* @__PURE__ */ new Map();
+	/** Glyphs indexed by `atlasGlyphId`. Append-only; mirrors MsdfGlyphAtlas. */
+	_glyphList = [];
+	/** Bumps every time `_glyphList` grows. */
+	_version = 0;
+	measureCache = /* @__PURE__ */ new Map();
+	_destroyed = false;
+	constructor(font, options = {}) {
+		this.font = font;
+		this.atlasSize = options.atlasSize ?? 2048;
+		this.atlasFontSize = options.atlasFontSize ?? 64;
+		this.pxRange = options.pxRange ?? 8;
+	}
+	get version() {
+		return this._version;
+	}
+	get glyphCount() {
+		return this._glyphList.length;
+	}
+	get destroyed() {
+		return this._destroyed;
+	}
+	/** Always 0 — no shelf packer needed (no texture). */
+	get fillPercent() {
+		return 0;
+	}
+	/**
+	* CPU atlas has no GPU texture. Throws if accessed so misuse is loud, not
+	* silent corruption. The SVG renderer never reads `texture` — it gates on
+	* `layer.atlas` and decodes via `getGlyphById` (`svg-renderer.ts:285`).
+	*/
+	get texture() {
+		throw new Error("CpuGlyphAtlas has no GPU texture — SVG/measure only; use SdfGlyphAtlas/MsdfGlyphAtlas for GPU rendering.");
+	}
+	/**
+	* Return the glyph entry for `codepoint`, computing metrics from the font
+	* outline on first request. UVs are set to 0 (no texture).
+	*
+	* Mirrors `MsdfGlyphAtlas.getGlyph` (atlas.ts:133-232) with the
+	* shelf-packer, `generate()`, and UV-from-origin math removed.
+	*/
+	getGlyph(codepoint) {
+		const cached = this.cache.get(codepoint);
+		if (cached !== void 0) return cached;
+		const outline = this.font.getOutline(codepoint);
+		if (!outline) {
+			this.cache.set(codepoint, null);
+			return null;
+		}
+		if (outline.contours.length === 0) {
+			const entry = {
+				codepoint,
+				atlasGlyphId: this._glyphList.length,
+				uvMinX: 0,
+				uvMinY: 0,
+				uvMaxX: 0,
+				uvMaxY: 0,
+				pxRange: this.pxRange,
+				advance: outline.advance,
+				bearingX: 0,
+				bearingY: 0,
+				width: 0,
+				height: 0
+			};
+			this.cache.set(codepoint, entry);
+			this._glyphList.push(entry);
+			this._version++;
+			return entry;
+		}
+		const emPad = this.pxRange / this.atlasFontSize / 2;
+		const minX = outline.bbox.minX - emPad;
+		const minY = outline.bbox.minY - emPad;
+		const maxX = outline.bbox.maxX + emPad;
+		const maxY = outline.bbox.maxY + emPad;
+		const entry = {
+			codepoint,
+			atlasGlyphId: this._glyphList.length,
+			uvMinX: 0,
+			uvMinY: 0,
+			uvMaxX: 0,
+			uvMaxY: 0,
+			pxRange: this.pxRange,
+			advance: outline.advance,
+			bearingX: minX,
+			bearingY: maxY,
+			width: maxX - minX,
+			height: maxY - minY
+		};
+		this.cache.set(codepoint, entry);
+		this._glyphList.push(entry);
+		this._version++;
+		return entry;
+	}
+	/**
+	* Fetch a glyph by its `atlasGlyphId` (allocation order). O(1) array lookup.
+	* This is the decode contract: `svg-renderer.ts:512` calls this to reconstruct
+	* the original codepoint from a glyph-pack instance.
+	*/
+	getGlyphById(id) {
+		return this._glyphList[id];
+	}
+	/**
+	* Verbatim copy of `msdf-adapter.ts:75-109` — depends only on `this.font`
+	* and `this` as the GlyphAtlas shaper arg (no GPU involvement).
+	*/
+	measureText(text, options) {
+		const simple = options.simple === true;
+		const lineHeight = options.lineHeight ?? options.fontSize * 1.2;
+		const key = `${options.fontSize}|${simple ? 1 : 0}|${options.maxWidth ?? -1}|${lineHeight}|${text}`;
+		const cached = this.measureCache.get(key);
+		if (cached !== void 0) return cached;
+		let metrics;
+		if (options.maxWidth === void 0) {
+			const width = measureBlockWidth(text, this.font, this, options.fontSize, simple);
+			let lineCount = 1;
+			if (!simple) {
+				for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) lineCount++;
+			}
+			metrics = {
+				width: Math.max(0, width),
+				height: lineCount * lineHeight
+			};
+		} else {
+			const block = shapeText(text, this.font, this, 0, 0, {
+				fontSize: options.fontSize,
+				maxWidth: options.maxWidth,
+				lineHeight: options.lineHeight,
+				simple
+			});
+			const width = Number.isFinite(block.bbox.maxX) ? block.bbox.maxX - block.bbox.minX : 0;
+			metrics = {
+				width: Math.max(0, width),
+				height: block.height
+			};
+		}
+		this.measureCache.set(key, metrics);
+		return metrics;
+	}
+	/** Pre-warm the glyph cache for a string of text. No GPU work. */
+	preload(text) {
+		for (const ch of text) this.getGlyph(ch.codePointAt(0));
+	}
+	/** Clear caches and mark as destroyed. */
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		this.cache.clear();
+		this._glyphList.length = 0;
+	}
+};
+/**
+* Module-scope lazy singleton: parses the embedded Lato subset font ONCE and
+* reuses the atlas across every `toSVG()` call. O(1) after first load.
+*
+* Do NOT destroy this instance — it is shared across all export calls.
+*/
+let _shared = null;
+function sharedCpuGlyphAtlas() {
+	if (_shared === null) _shared = new CpuGlyphAtlas(parseFont$1(decodeEmbeddedFont(), { family: EMBEDDED_FONT_FAMILY }));
+	return _shared;
+}
+/**
+* Create a non-singleton `CpuGlyphAtlas`, optionally with a custom font.
+*
+* - Pass `font` (an already-parsed `Font`) for zero-overhead construction.
+* - Pass `fontBytes` (ArrayBuffer or Uint8Array) to parse on construction.
+* - Pass neither to fall back to the embedded Lato subset (same font as the
+*   shared singleton, but a fresh atlas instance).
+*/
+function createCpuGlyphAtlas(opts = {}) {
+	let font;
+	if (opts.font !== void 0) font = opts.font;
+	else if (opts.fontBytes !== void 0) font = parseFont$1(opts.fontBytes);
+	else font = parseFont$1(decodeEmbeddedFont(), { family: EMBEDDED_FONT_FAMILY });
+	return new CpuGlyphAtlas(font, opts.options);
+}
+//#endregion
+export { CpuGlyphAtlas, Font, MsdfGlyphAtlas, createCpuGlyphAtlas, loadFont, parseFont, sharedCpuGlyphAtlas };

package/dist/texture-dABoqFoP.mjs

@@ -0,0 +1,131 @@
+import { n as resolveRoot } from "./root-CHradZKM.mjs";
+//#region src/shared/texture.ts
+let _nextTextureId = 0;
+/**
+* Caller-owned GPU texture wrapper used by sprite APIs.
+*
+* `Layer`, `SpriteAtlas`, `GridAtlas`, and `Renderer2D` may retain references
+* to a `Texture`, but none of them take ownership of it or destroy it on the caller's behalf.
+*/
+var Texture = class {
+	id;
+	gpuTexture;
+	view;
+	width;
+	height;
+	_destroyed = false;
+	constructor(gpuTexture, width, height) {
+		this.id = _nextTextureId++;
+		this.gpuTexture = gpuTexture;
+		this.view = gpuTexture.createView();
+		this.width = width;
+		this.height = height;
+	}
+	/** Sub-region by pixel coordinates. */
+	region(x, y, w, h) {
+		this.ensureAlive();
+		assertTextureRect(x, y, w, h, this.width, this.height);
+		return {
+			texture: this,
+			uvMin: [x / this.width, y / this.height],
+			uvMax: [(x + w) / this.width, (y + h) / this.height]
+		};
+	}
+	/** Sub-region by normalized UV coordinates. */
+	regionUV(u0, v0, u1, v1) {
+		this.ensureAlive();
+		return {
+			texture: this,
+			uvMin: [u0, v0],
+			uvMax: [u1, v1]
+		};
+	}
+	get destroyed() {
+		return this._destroyed;
+	}
+	/**
+	* Release the underlying GPU texture.
+	*
+	* Destroying a texture that is still referenced by a `Layer` is a caller error.
+	* Future sprite draws that still reference it will throw a clear runtime error.
+	*/
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		this.gpuTexture.destroy();
+	}
+	ensureAlive() {
+		if (this._destroyed) throw new Error("Texture has been destroyed.");
+	}
+};
+var SpriteAtlas = class {
+	_regions;
+	constructor(texture, regions) {
+		this._regions = new Map(Object.entries(regions).map(([name, def]) => [name, texture.region(def.x, def.y, def.w, def.h)]));
+	}
+	region(name) {
+		const r = this._regions.get(name);
+		if (!r) throw new Error(`SpriteAtlas: region "${name}" not found.`);
+		return r;
+	}
+};
+var GridAtlas = class {
+	texture;
+	cellW;
+	cellH;
+	cols;
+	rows;
+	constructor(texture, options) {
+		this.texture = texture;
+		this.cellW = options.cell[0];
+		this.cellH = options.cell[1];
+		if (this.cellW <= 0 || this.cellH <= 0) throw new Error("GridAtlas cell dimensions must be positive.");
+		const maxCols = Math.floor(texture.width / this.cellW);
+		const maxRows = Math.floor(texture.height / this.cellH);
+		if (maxCols < 1 || maxRows < 1) throw new Error("GridAtlas cell dimensions must fit inside the texture.");
+		this.cols = options.cols ?? maxCols;
+		this.rows = options.rows ?? maxRows;
+		if (!Number.isInteger(this.cols) || !Number.isInteger(this.rows) || this.cols < 1 || this.rows < 1) throw new Error("GridAtlas rows and cols must be positive integers.");
+		if (this.cols > maxCols || this.rows > maxRows) throw new Error(`GridAtlas ${this.rows}x${this.cols} exceeds the ${maxRows}x${maxCols} grid that fits in this texture.`);
+	}
+	/** Get a frame by linear index, or by (row, col). */
+	frame(indexOrRow, col) {
+		const row = col === void 0 ? Math.floor(indexOrRow / this.cols) : indexOrRow;
+		const c = col === void 0 ? indexOrRow % this.cols : col;
+		if (!Number.isInteger(row) || !Number.isInteger(c) || row < 0 || row >= this.rows || c < 0 || c >= this.cols) throw new Error(`GridAtlas frame (${row}, ${c}) is out of bounds for a ${this.rows}x${this.cols} atlas.`);
+		return this.texture.region(c * this.cellW, row * this.cellH, this.cellW, this.cellH);
+	}
+};
+/**
+* Load a texture from a URL or any ImageBitmapSource.
+* The result is in premultiplied alpha format, matching the renderer's blend state.
+*
+* The returned `Texture` remains caller-owned. The renderer may cache per-texture bind groups
+* while it is in use, but it will never destroy the texture for you.
+*/
+async function loadTexture(owner, src, options = {}) {
+	const device = resolveRoot(owner).device;
+	const bitmap = typeof src === "string" ? await createImageBitmap(await (await fetch(src)).blob()) : await createImageBitmap(src);
+	const width = bitmap.width;
+	const height = bitmap.height;
+	const format = options.format ?? "rgba8unorm";
+	const gpuTexture = device.createTexture({
+		label: options.label,
+		size: [width, height],
+		format,
+		usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+	});
+	device.queue.copyExternalImageToTexture({ source: bitmap }, {
+		texture: gpuTexture,
+		premultipliedAlpha: true
+	}, [width, height]);
+	bitmap.close();
+	return new Texture(gpuTexture, width, height);
+}
+function assertTextureRect(x, y, w, h, textureWidth, textureHeight) {
+	if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(w) || !Number.isFinite(h)) throw new Error("Texture region coordinates must be finite.");
+	if (w <= 0 || h <= 0) throw new Error("Texture region dimensions must be positive.");
+	if (x < 0 || y < 0 || x + w > textureWidth || y + h > textureHeight) throw new Error(`Texture region (${x}, ${y}, ${w}, ${h}) is out of bounds for a ${textureWidth}x${textureHeight} texture.`);
+}
+//#endregion
+export { loadTexture as i, SpriteAtlas as n, Texture as r, GridAtlas as t };

package/dist/viewport.d.mts

@@ -0,0 +1,2 @@
+import { _ as ViewportLike, b as worldCullBounds, d as CameraPanBoundsOptions, f as CameraViewport, g as Viewport, h as PanBoundsMargins, m as PanBoundsMargin, p as CameraViewportOptions, u as CameraInternal, v as ZoomFactor, y as createViewport } from "./camera-view-DHmMiKvP.mjs";
+export { CameraInternal, CameraPanBoundsOptions, CameraViewport, CameraViewportOptions, PanBoundsMargin, PanBoundsMargins, Viewport, ViewportLike, ZoomFactor, createViewport, worldCullBounds };