textmode.js 0.1.6-beta.5 → 0.1.6-beta.7

package/dist/textmode.esm.min.js

@@ -0,0 +1,1870 @@
+var J = Object.defineProperty;
+var K = (a, t, e) => t in a ? J(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var h = (a, t, e) => K(a, typeof t != "symbol" ? t + "" : t, e);
+class b extends Error {
+  constructor(t, e = {}) {
+    super(b.i(t, e)), this.name = "TextmodeError";
+  }
+  static i(t, e) {
+    let r = t;
+    if (e && Object.keys(e).length > 0) {
+      r += `
+
+📋 Context:`;
+      for (const [s, i] of Object.entries(e))
+        r += `
+  - ${s}: ${b.o(i)}`;
+    }
+    return r += `
+
+`, r += "↓".repeat(24) + `
+`, r;
+  }
+  static o(t) {
+    if (t === null) return "null";
+    if (t === void 0) return "undefined";
+    if (typeof t == "string") return `"${t}"`;
+    if (typeof t == "number" || typeof t == "boolean") return t + "";
+    if (Array.isArray(t)) return t.length === 0 ? "[]" : t.length <= 5 ? `[${t.map((e) => b.o(e)).join(", ")}]` : `[${t.slice(0, 3).map((e) => b.o(e)).join(", ")}, ... +${t.length - 3} more]`;
+    if (typeof t == "object") {
+      const e = Object.keys(t);
+      return e.length === 0 ? "{}" : e.length <= 3 ? `{ ${e.map((r) => `${r}: ${b.o(t[r])}`).join(", ")} }` : `{ ${e.slice(0, 2).map((r) => `${r}: ${b.o(t[r])}`).join(", ")}, ... +${e.length - 2} more }`;
+    }
+    return t + "";
+  }
+}
+var tt = ((a) => (a[a.SILENT = 0] = "SILENT", a[a.WARNING = 1] = "WARNING", a[a.ERROR = 2] = "ERROR", a[a.THROW = 3] = "THROW", a))(tt || {});
+const P = class P {
+  constructor() {
+    h(this, "l", { globalLevel: 3 });
+  }
+  static u() {
+    return P.h || (P.h = new P()), P.h;
+  }
+  m(t, e) {
+    const r = "%c[textmode.js] Oops! (╯°□°)╯︵ Something went wrong in your code.", s = "color: #f44336; font-weight: bold; background: #ffebee; padding: 2px 6px; border-radius: 3px;";
+    switch (this.l.globalLevel) {
+      case 0:
+        return !1;
+      case 1:
+        return console.group(r, s), console.warn(b.i(t, e)), console.groupEnd(), !1;
+      case 2:
+        return console.group(r, s), console.error(b.i(t, e)), console.groupEnd(), !1;
+      default:
+        throw new b(t, e);
+    }
+  }
+  p(t, e, r) {
+    return !!t || (this.m(e, r), !1);
+  }
+  _(t) {
+    this.l.globalLevel = t;
+  }
+};
+h(P, "h", null);
+let B = P;
+const C = B.u(), X = /* @__PURE__ */ new WeakMap();
+function $(a, t) {
+  X.set(a, t);
+}
+function W(a) {
+  return X.get(a);
+}
+class H {
+  constructor(t, e, r = e, s = {}) {
+    h(this, "v");
+    h(this, "C");
+    h(this, "$");
+    h(this, "F");
+    h(this, "D");
+    h(this, "l");
+    h(this, "M", null);
+    h(this, "S", null);
+    this.v = t, this.F = e, this.D = r, this.l = { filter: "nearest", wrap: "clamp", format: "rgba", type: "unsigned_byte", ...s }, this.$ = this.R(), this.C = t.createFramebuffer(), this.V();
+  }
+  k(t) {
+    const { v: e } = this, r = e.getParameter(e.FRAMEBUFFER_BINDING);
+    e.bindFramebuffer(e.FRAMEBUFFER, this.C);
+    try {
+      return t();
+    } finally {
+      e.bindFramebuffer(e.FRAMEBUFFER, r);
+    }
+  }
+  R() {
+    const { v: t } = this, e = t.createTexture();
+    t.bindTexture(t.TEXTURE_2D, e);
+    const r = this.l.filter === "linear" ? t.LINEAR : t.NEAREST, s = this.l.wrap === "repeat" ? t.REPEAT : t.CLAMP_TO_EDGE;
+    return t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, r), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, r), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, s), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, s), this.I(), e;
+  }
+  I() {
+    const { v: t } = this, e = this.l.type === "float" ? t.FLOAT : t.UNSIGNED_BYTE;
+    t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, this.F, this.D, 0, t.RGBA, e, null);
+  }
+  V() {
+    const { v: t } = this;
+    t.bindFramebuffer(t.FRAMEBUFFER, this.C), t.framebufferTexture2D(t.FRAMEBUFFER, t.COLOR_ATTACHMENT0, t.TEXTURE_2D, this.$, 0), t.bindFramebuffer(t.FRAMEBUFFER, null);
+  }
+  update(t) {
+    const { v: e } = this;
+    e.bindTexture(e.TEXTURE_2D, this.$), e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL, 1), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, t), e.bindTexture(e.TEXTURE_2D, null);
+  }
+  updatePixels(t, e, r) {
+    const { v: s } = this;
+    s.bindTexture(s.TEXTURE_2D, this.$), s.texImage2D(s.TEXTURE_2D, 0, s.RGBA, e, r, 0, s.RGBA, s.UNSIGNED_BYTE, t), s.bindTexture(s.TEXTURE_2D, null);
+  }
+  resize(t, e) {
+    const { v: r } = this;
+    this.F = t, this.D = e, this.S = null, r.bindTexture(r.TEXTURE_2D, this.$), this.I(), r.bindTexture(r.TEXTURE_2D, null);
+  }
+  begin() {
+    const { v: t } = this;
+    this.M = { framebuffer: t.getParameter(t.FRAMEBUFFER_BINDING), viewport: t.getParameter(t.VIEWPORT) }, t.bindFramebuffer(t.FRAMEBUFFER, this.C), t.viewport(0, 0, this.F, this.D), $(t, [0, 0, this.F, this.D]);
+  }
+  end() {
+    if (!this.M) return;
+    const { v: t } = this;
+    t.bindFramebuffer(t.FRAMEBUFFER, this.M.framebuffer), t.viewport(...this.M.viewport), $(t, this.M.viewport), this.M = null;
+  }
+  loadPixels() {
+    const { v: t } = this;
+    this.S || (this.S = new Uint8Array(this.F * this.D * 4)), this.k(() => {
+      t.readPixels(0, 0, this.F, this.D, t.RGBA, t.UNSIGNED_BYTE, this.S);
+    });
+  }
+  get(t, e, r, s) {
+    const { v: i } = this;
+    if (t === void 0 && e === void 0) {
+      const o = new Uint8Array(this.F * this.D * 4);
+      return this.k(() => (i.readPixels(0, 0, this.F, this.D, i.RGBA, i.UNSIGNED_BYTE, o), o));
+    }
+    if (r === void 0 && s === void 0) {
+      (t < 0 || e < 0 || t >= this.F || e >= this.D) && (console.warn("The x and y values passed to Framebuffer.get are outside of its range and will be clamped."), t = Math.max(0, Math.min(t, this.F - 1)), e = Math.max(0, Math.min(e, this.D - 1)));
+      const o = new Uint8Array(4);
+      return this.k(() => (i.readPixels(t, e, 1, 1, i.RGBA, i.UNSIGNED_BYTE, o), [o[0], o[1], o[2], o[3]]));
+    }
+    {
+      t = Math.max(0, Math.min(t, this.F - 1)), e = Math.max(0, Math.min(e, this.D - 1)), r = Math.max(1, Math.min(r, this.F - t)), s = Math.max(1, Math.min(s, this.D - e));
+      const o = new Uint8Array(r * s * 4);
+      return this.k(() => (i.readPixels(t, e, r, s, i.RGBA, i.UNSIGNED_BYTE, o), o));
+    }
+  }
+  P() {
+    this.C && this.v.deleteFramebuffer(this.C), this.$ && this.v.deleteTexture(this.$);
+  }
+  get framebuffer() {
+    return this.C;
+  }
+  get texture() {
+    return this.$;
+  }
+  get width() {
+    return this.F;
+  }
+  get height() {
+    return this.D;
+  }
+  get pixels() {
+    return this.S;
+  }
+}
+class y {
+  constructor(t, e, r) {
+    h(this, "v");
+    h(this, "U");
+    h(this, "A", /* @__PURE__ */ new Map());
+    h(this, "G", /* @__PURE__ */ new Map());
+    h(this, "L", 0);
+    h(this, "H");
+    this.v = t, this.U = this.O(e, r), this.H = t.getParameter(t.MAX_TEXTURE_IMAGE_UNITS), this.j();
+  }
+  j() {
+    const t = this.v.getProgramParameter(this.U, this.v.ACTIVE_UNIFORMS);
+    for (let e = 0; e < t; e++) {
+      const r = this.v.getActiveUniform(this.U, e);
+      if (r) {
+        const s = this.v.getUniformLocation(this.U, r.name);
+        s && (this.A.set(r.name, s), this.G.set(r.name, r.type));
+      }
+    }
+  }
+  O(t, e) {
+    const r = this.W(this.v.VERTEX_SHADER, t), s = this.W(this.v.FRAGMENT_SHADER, e), i = this.v.createProgram();
+    if (this.v.attachShader(i, r), this.v.attachShader(i, s), this.v.linkProgram(i), !this.v.getProgramParameter(i, this.v.LINK_STATUS)) {
+      const o = this.v.getProgramInfoLog(i);
+      throw Error("Shader program link error: " + o);
+    }
+    return this.v.deleteShader(r), this.v.deleteShader(s), i;
+  }
+  W(t, e) {
+    const r = this.v.createShader(t);
+    if (this.v.shaderSource(r, e), this.v.compileShader(r), !this.v.getShaderParameter(r, this.v.COMPILE_STATUS)) {
+      const s = this.v.getShaderInfoLog(r);
+      throw this.v.deleteShader(r), Error("Shader compilation error: " + s);
+    }
+    return r;
+  }
+  N() {
+    this.v.useProgram(this.U), this.X();
+  }
+  setUniform(t, e) {
+    const r = this.A.get(t);
+    if (r) if (typeof e == "number")
+      this.q(t) ? this.v.uniform1i(r, Math.floor(e)) : this.v.uniform1f(r, e);
+    else if (typeof e == "boolean") this.v.uniform1i(r, e ? 1 : 0);
+    else if (Array.isArray(e)) switch (e.length) {
+      case 2:
+        this.v.uniform2f(r, e[0], e[1]);
+        break;
+      case 3:
+        this.v.uniform3f(r, e[0], e[1], e[2]);
+        break;
+      case 4:
+        this.v.uniform4f(r, e[0], e[1], e[2], e[3]);
+        break;
+      default:
+        console.warn(`Unsupported array length ${e.length} for uniform '${t}'`);
+    }
+    else if (e instanceof WebGLTexture) {
+      const s = this.Y();
+      this.v.uniform1i(r, s), this.v.activeTexture(this.v.TEXTURE0 + s), this.v.bindTexture(this.v.TEXTURE_2D, e);
+    } else if (e instanceof H) {
+      const s = this.Y();
+      this.v.uniform1i(r, s), this.v.activeTexture(this.v.TEXTURE0 + s), this.v.bindTexture(this.v.TEXTURE_2D, e.texture);
+    } else console.warn(`Unsupported uniform type for '${t}':`, typeof e);
+  }
+  Y() {
+    return this.L >= this.H && console.warn(`Exceeded maximum texture units (${this.H}). Texture may not render correctly.`), this.L++;
+  }
+  q(t) {
+    const e = this.G.get(t);
+    return !!e && (e === this.v.INT || e === this.v.INT_VEC2 || e === this.v.INT_VEC3 || e === this.v.INT_VEC4 || e === this.v.SAMPLER_2D || e === this.v.SAMPLER_CUBE);
+  }
+  get glProgram() {
+    return this.U;
+  }
+  P() {
+    this.v.deleteProgram(this.U);
+  }
+  X() {
+    this.L = 0;
+  }
+}
+class q {
+  constructor(t) {
+    h(this, "v");
+    h(this, "Z", null);
+    h(this, "J", 16);
+    h(this, "K", /* @__PURE__ */ new Map());
+    this.v = t;
+  }
+  tt() {
+    if (this.Z) return;
+    const t = this.v;
+    this.Z = t.createBuffer(), t.bindBuffer(t.ARRAY_BUFFER, this.Z);
+  }
+  et() {
+    const t = this.v, e = t.getParameter(t.CURRENT_PROGRAM);
+    let r = this.K.get(e);
+    return r || (r = { a_position: t.getAttribLocation(e, "a_position"), a_texCoord: t.getAttribLocation(e, "a_texCoord") }, this.K.set(e, r)), t.enableVertexAttribArray(r.a_position), t.vertexAttribPointer(r.a_position, 2, t.FLOAT, !1, this.J, 0), t.enableVertexAttribArray(r.a_texCoord), t.vertexAttribPointer(r.a_texCoord, 2, t.FLOAT, !1, this.J, 8), { positionLoc: r.a_position, texLoc: r.a_texCoord };
+  }
+  rt(t, e) {
+    const r = this.v;
+    r.disableVertexAttribArray(t), r.disableVertexAttribArray(e);
+  }
+  st(t, e) {
+    const r = this.v, s = W(r) || [0, 0, r.canvas.width, r.canvas.height];
+    return { nx: t / s[2] * 2 - 1, ny: 1 - e / s[3] * 2 };
+  }
+  it(t, e, r, s) {
+    const i = this.v;
+    this.tt(), i.bindBuffer(i.ARRAY_BUFFER, this.Z);
+    const o = new Float32Array([t, s, 0, 0, r, s, 1, 0, t, e, 0, 1, t, e, 0, 1, r, s, 1, 0, r, e, 1, 1]);
+    i.bufferData(i.ARRAY_BUFFER, o, i.DYNAMIC_DRAW);
+  }
+  P() {
+    this.Z && this.v.deleteBuffer(this.Z);
+  }
+}
+class et extends q {
+  constructor(t) {
+    super(t);
+  }
+  ot(t, e, r, s) {
+    const i = this.st(t, e), o = this.st(t + r, e + s);
+    this.it(i.nx, i.ny, o.nx, o.ny);
+    const n = this.et();
+    this.v.drawArrays(this.v.TRIANGLES, 0, 6), this.rt(n.positionLoc, n.texLoc);
+  }
+  nt(t, e, r, s, i) {
+    this.ot(t, e, r, i), this.ot(t + r - i, e, i, s), this.ot(t, e + s - i, r, i), this.ot(t, e, i, s);
+  }
+}
+class rt extends q {
+  constructor(t) {
+    super(t);
+  }
+  ht(t, e, r, s, i) {
+    const o = r - t, n = s - e, l = Math.hypot(o, n);
+    if (l === 0) {
+      const u = i / 2, d = this.st(t - u, e - u), f = this.st(t + u, e + u);
+      this.it(d.nx, d.ny, f.nx, f.ny);
+    } else {
+      const u = -n / l, d = o / l, f = i / 2, m = t + u * f, v = e + d * f, p = t - u * f, x = e - d * f, _ = r + u * f, w = s + d * f, T = r - u * f, E = s - d * f, S = this.st(m, v), R = this.st(p, x), F = this.st(_, w), z = this.st(T, E), M = this.v;
+      this.tt(), M.bindBuffer(M.ARRAY_BUFFER, this.Z);
+      const Q = new Float32Array([S.nx, S.ny, 0, 0, R.nx, R.ny, 0, 1, F.nx, F.ny, 1, 0, R.nx, R.ny, 0, 1, z.nx, z.ny, 1, 1, F.nx, F.ny, 1, 0]);
+      M.bufferData(M.ARRAY_BUFFER, Q, M.DYNAMIC_DRAW);
+    }
+    const c = this.et();
+    this.v.drawArrays(this.v.TRIANGLES, 0, 6), this.rt(c.positionLoc, c.texLoc);
+  }
+}
+var Z = "attribute vec2 a_position;attribute vec2 a_texCoord;varying vec2 v_uv;uniform float u_rotation;uniform vec2 u_center;uniform float u_aspectRatio;mat2 rotate2D(float angle){float s=sin(angle);float c=cos(angle);return mat2(c,-s,s,c);}void main(){v_uv=a_texCoord;vec2 pos=a_position;pos-=u_center;pos.x*=u_aspectRatio;pos=rotate2D(-u_rotation)*pos;pos.x/=u_aspectRatio;pos+=u_center;gl_Position=vec4(pos,0.0,1.0);}";
+class st {
+  constructor(t) {
+    h(this, "v");
+    h(this, "lt");
+    h(this, "ct");
+    h(this, "ut", null);
+    h(this, "ft");
+    h(this, "dt");
+    h(this, "gt", [1, 1, 1, 1]);
+    h(this, "_t", !0);
+    h(this, "vt", [0, 0, 0, 1]);
+    h(this, "xt", 1);
+    h(this, "bt", !0);
+    h(this, "wt", 0);
+    h(this, "Ct", []);
+    this.v = t, this.lt = new y(this.v, Z, "precision lowp float;uniform sampler2D u_texture;varying vec2 v_uv;void main(){gl_FragColor=texture2D(u_texture,v_uv);}"), this.ct = new y(this.v, Z, "precision lowp float;uniform vec4 u_color;void main(){gl_FragColor=u_color;}"), this.ft = new et(this.v), this.dt = new rt(this.v), this.v.enable(this.v.BLEND), this.v.blendEquation(this.v.FUNC_ADD), this.v.blendFunc(this.v.ONE, this.v.ONE_MINUS_SRC_ALPHA), $(this.v, [0, 0, this.v.canvas.width, this.v.canvas.height]);
+  }
+  yt(t) {
+    this.ut !== t && (this.ut = t, t.N());
+  }
+  $t(t, e, r, s) {
+    if (this._t = !0, e === void 0 && r === void 0 && s === void 0) {
+      const i = t / 255;
+      this.gt = [i, i, i, 1];
+    } else if (r !== void 0 && s === void 0) this.gt = [t / 255, e / 255, r / 255, 1];
+    else {
+      if (r === void 0 || s === void 0) throw Error("Invalid fill parameters. Use fill(gray), fill(r,g,b), or fill(r,g,b,a)");
+      this.gt = [t / 255, e / 255, r / 255, s / 255];
+    }
+  }
+  Ft(t, e, r, s) {
+    if (this.bt = !0, e === void 0 && r === void 0 && s === void 0) {
+      const i = t / 255;
+      this.vt = [i, i, i, 1];
+    } else if (r !== void 0 && s === void 0) this.vt = [t / 255, e / 255, r / 255, 1];
+    else {
+      if (r === void 0 || s === void 0) throw Error("Invalid stroke parameters. Use stroke(gray), stroke(r,g,b), or stroke(r,g,b,a)");
+      this.vt = [t / 255, e / 255, r / 255, s / 255];
+    }
+  }
+  Tt(t) {
+    if (t < 0) throw Error("Stroke weight must be non-negative");
+    this.xt = t;
+  }
+  Dt() {
+    this.bt = !1;
+  }
+  Mt() {
+    this._t = !1;
+  }
+  St(t) {
+    this.wt = t;
+  }
+  Rt() {
+    this.Ct.push({ fillColor: [...this.gt], fillMode: this._t, strokeColor: [...this.vt], strokeWeight: this.xt, strokeMode: this.bt, rotation: this.wt });
+  }
+  Vt() {
+    const t = this.Ct.pop();
+    t ? (this.gt = t.fillColor, this._t = t.fillMode, this.vt = t.strokeColor, this.xt = t.strokeWeight, this.bt = t.strokeMode, this.wt = t.rotation) : console.warn("pop() called without matching push()");
+  }
+  kt() {
+    this.ut = null, this.Ct = [], this.wt = 0;
+  }
+  zt(t, e) {
+    return new y(this.v, t, e);
+  }
+  It(t) {
+    return new y(this.v, Z, t);
+  }
+  Pt(t, e) {
+    this.ut.setUniform(t, e);
+  }
+  Ut(t, e, r, s) {
+    if (this.ut !== null) {
+      const { centerX: d, centerY: f, radians: m, aspectRatio: v } = this.At(t, e, r, s);
+      return this.Pt("u_rotation", m), this.Pt("u_center", [d, f]), this.Pt("u_aspectRatio", v), this.ft.ot(t, e, r, s), void (this.ut = null);
+    }
+    const i = this.ct;
+    let o = 0, n = 0, l = 0, c = 1;
+    const u = this.At(t, e, r, s);
+    o = u.centerX, n = u.centerY, l = u.radians, c = u.aspectRatio, this._t && (this.yt(i), this.Pt("u_color", this.gt), this.Pt("u_rotation", l), this.Pt("u_center", [o, n]), this.Pt("u_aspectRatio", c), this.ft.ot(t, e, r, s)), this.bt && this.xt > 0 && (this.yt(i), this.Pt("u_color", this.vt), this.Pt("u_rotation", l), this.Pt("u_center", [o, n]), this.Pt("u_aspectRatio", c), this.ft.nt(t, e, r, s, this.xt)), this.ut = null;
+  }
+  Gt(t, e, r, s) {
+    if (this.ut !== null) {
+      const p = (t + r) / 2, x = (e + s) / 2, _ = Math.abs(r - t) || 1, w = Math.abs(s - e) || 1, { centerX: T, centerY: E, radians: S, aspectRatio: R } = this.At(p - _ / 2, x - w / 2, _, w);
+      this.Pt("u_rotation", S), this.Pt("u_center", [T, E]), this.Pt("u_aspectRatio", R);
+      const F = this.xt > 0 ? this.xt : 1;
+      return this.dt.ht(t, e, r, s, F), void (this.ut = null);
+    }
+    if (!this.bt || this.xt <= 0) return;
+    const i = this.ct, o = (t + r) / 2, n = (e + s) / 2, l = Math.abs(r - t) || 1, c = Math.abs(s - e) || 1, u = this.wt !== 0;
+    let d = 0, f = 0, m = 0, v = 1;
+    if (u) {
+      const p = this.At(o - l / 2, n - c / 2, l, c);
+      d = p.centerX, f = p.centerY, m = p.radians, v = p.aspectRatio;
+    }
+    this.yt(i), this.Pt("u_color", this.vt), u && (this.Pt("u_rotation", m), this.Pt("u_center", [d, f]), this.Pt("u_aspectRatio", v)), this.dt.ht(t, e, r, s, this.xt);
+  }
+  At(t, e, r, s) {
+    const i = W(this.v) || [0, 0, this.v.canvas.width, this.v.canvas.height], o = i[2], n = i[3], l = o / n;
+    return { centerX: (t + r / 2) / o * 2 - 1, centerY: 1 - (e + s / 2) / n * 2, radians: this.wt * Math.PI / 180, aspectRatio: l };
+  }
+  Et(t, e, r = {}) {
+    return new H(this.v, t, e, r);
+  }
+  Lt(t, e = t, r = t, s = 255) {
+    this.Bt(t / 255, e / 255, r / 255, s / 255);
+  }
+  Bt(t = 0, e = 0, r = 0, s = 0) {
+    this.v.clearColor(t, e, r, s), this.v.clear(this.v.COLOR_BUFFER_BIT);
+  }
+  Ht() {
+    this.v.viewport(0, 0, this.v.canvas.width, this.v.canvas.height), $(this.v, [0, 0, this.v.canvas.width, this.v.canvas.height]);
+  }
+  get context() {
+    return this.v;
+  }
+  P() {
+    this.lt.P(), this.ct.P(), this.ft.P(), this.dt.P();
+  }
+  Ot(t, e, r, s, i) {
+    const o = this.v, n = s ?? t.width, l = i ?? t.height;
+    this.yt(this.lt), this.Pt("u_texture", t.texture);
+    const c = this.At(e, r, n, l);
+    this.Pt("u_rotation", c.radians), this.Pt("u_center", [c.centerX, c.centerY]), this.Pt("u_aspectRatio", c.aspectRatio), this.ft.ot(e, r, n, l), o.bindTexture(o.TEXTURE_2D, null), this.ut = null;
+  }
+}
+var A, g = {};
+g.parse = function(a) {
+  var t = function(e, r, s, i) {
+    var o = g.T, n = { cmap: o.cmap, head: o.head, hhea: o.hhea, maxp: o.maxp, hmtx: o.hmtx, loca: o.loca, glyf: o.glyf }, l = { _data: e, _index: r, _offset: s };
+    for (var c in n) {
+      var u = g.findTable(e, c, s);
+      if (u) {
+        var d = u[0], f = i[d];
+        f == null && (f = n[c].parseTab(e, d, u[1], l)), l[c] = i[d] = f;
+      }
+    }
+    return l;
+  }(new Uint8Array(a), 0, 0, {});
+  return [t];
+}, g.findTable = function(a, t, e) {
+  for (var r = g.B, s = r.readUshort(a, e + 4), i = e + 12, o = 0; o < s; o++) {
+    var n = r.readASCII(a, i, 4);
+    r.readUint(a, i + 4);
+    var l = r.readUint(a, i + 8), c = r.readUint(a, i + 12);
+    if (n == t) return [l, c];
+    i += 16;
+  }
+  return null;
+}, g.T = {}, g.B = { readShort: function(a, t) {
+  return g.B.t.uint16[0] = a[t] << 8 | a[t + 1], g.B.t.int16[0];
+}, readUshort: function(a, t) {
+  return a[t] << 8 | a[t + 1];
+}, readUshorts: function(a, t, e) {
+  for (var r = [], s = 0; s < e; s++) r.push(g.B.readUshort(a, t + 2 * s));
+  return r;
+}, readUint: function(a, t) {
+  var e = g.B.t.uint8;
+  return e[3] = a[t], e[2] = a[t + 1], e[1] = a[t + 2], e[0] = a[t + 3], g.B.t.uint32[0];
+}, readASCII: function(a, t, e) {
+  for (var r = "", s = 0; s < e; s++) r += String.fromCharCode(a[t + s]);
+  return r;
+}, t: (A = new ArrayBuffer(8), { uint8: new Uint8Array(A), int16: new Int16Array(A), uint16: new Uint16Array(A), uint32: new Uint32Array(A) }) }, g.T.cmap = { parseTab: function(a, t, e) {
+  var r = { tables: [], ids: {}, off: t };
+  a = new Uint8Array(a.buffer, t, e), t = 0;
+  var s = g.B, i = s.readUshort, o = g.T.cmap;
+  i(a, t);
+  var n = i(a, t += 2);
+  t += 2;
+  for (var l = [], c = 0; c < n; c++) {
+    var u = i(a, t), d = i(a, t += 2);
+    t += 2;
+    var f = s.readUint(a, t);
+    t += 4;
+    var m = "p" + u + "e" + d, v = l.indexOf(f);
+    if (v == -1) {
+      v = r.tables.length;
+      var p = {};
+      l.push(f);
+      var x = p.format = i(a, f);
+      x == 4 ? p = o.parse4(a, f, p) : x == 12 && (p = o.parse12(a, f, p)), r.tables.push(p);
+    }
+    r.ids[m] != null && console.log("multiple tables for one platform+encoding: " + m), r.ids[m] = v;
+  }
+  return r;
+}, parse4: function(a, t, e) {
+  var r = g.B, s = r.readUshort, i = r.readUshorts, o = t, n = s(a, t += 2);
+  s(a, t += 2);
+  var l = s(a, t += 2);
+  t += 2;
+  var c = l >>> 1;
+  e.searchRange = s(a, t), t += 2, e.entrySelector = s(a, t), t += 2, e.rangeShift = s(a, t), t += 2, e.endCount = i(a, t, c), t += 2 * c, t += 2, e.startCount = i(a, t, c), t += 2 * c, e.idDelta = [];
+  for (var u = 0; u < c; u++) e.idDelta.push(r.readShort(a, t)), t += 2;
+  return e.idRangeOffset = i(a, t, c), t += 2 * c, e.glyphIdArray = i(a, t, o + n - t >> 1), e;
+}, parse12: function(a, t, e) {
+  var r = g.B.readUint;
+  r(a, t += 4), r(a, t += 4);
+  var s = 3 * r(a, t += 4);
+  t += 4;
+  for (var i = e.groups = new Uint32Array(s), o = 0; o < s; o += 3) i[o] = r(a, t + (o << 2)), i[o + 1] = r(a, t + (o << 2) + 4), i[o + 2] = r(a, t + (o << 2) + 8);
+  return e;
+} }, g.T.head = { parseTab: function(a, t, e) {
+  var r = g.B, s = {};
+  return t += 18, s.unitsPerEm = r.readUshort(a, t), t += 2, t += 16, s.xMin = r.readShort(a, t), t += 2, s.yMin = r.readShort(a, t), t += 2, s.xMax = r.readShort(a, t), t += 2, s.yMax = r.readShort(a, t), t += 2, t += 6, s.indexToLocFormat = r.readShort(a, t), s;
+} }, g.T.hhea = { parseTab: function(a, t, e) {
+  var r = g.B, s = {};
+  t += 4;
+  for (var i = ["ascender", "descender", "lineGap", "advanceWidthMax", "minLeftSideBearing", "minRightSideBearing", "xMaxExtent", "caretSlopeRise", "caretSlopeRun", "caretOffset", "res0", "res1", "res2", "res3", "metricDataFormat", "numberOfHMetrics"], o = 0; o < i.length; o++) {
+    var n = i[o], l = n == "advanceWidthMax" || n == "numberOfHMetrics" ? r.readUshort : r.readShort;
+    s[n] = l(a, t + 2 * o);
+  }
+  return s;
+} }, g.T.hmtx = { parseTab: function(a, t, e, r) {
+  for (var s = g.B, i = [], o = [], n = r.maxp.numGlyphs, l = r.hhea.numberOfHMetrics, c = 0, u = 0, d = 0; d < l; ) c = s.readUshort(a, t + (d << 2)), u = s.readShort(a, t + (d << 2) + 2), i.push(c), o.push(u), d++;
+  for (; d < n; ) i.push(c), o.push(u), d++;
+  return { aWidth: i, lsBearing: o };
+} }, g.T.maxp = { parseTab: function(a, t, e) {
+  var r = g.B, s = r.readUshort, i = {};
+  return r.readUint(a, t), t += 4, i.numGlyphs = s(a, t), t += 2, i;
+} }, g.T.loca = { parseTab: function(a, t, e, r) {
+  var s = g.B, i = [], o = r.head.indexToLocFormat, n = r.maxp.numGlyphs + 1;
+  if (o == 0) for (var l = 0; l < n; l++) i.push(s.readUshort(a, t + (l << 1)) << 1);
+  if (o == 1) for (l = 0; l < n; l++) i.push(s.readUint(a, t + (l << 2)));
+  return i;
+} }, g.T.glyf = { parseTab: function(a, t, e, r) {
+  for (var s = [], i = r.maxp.numGlyphs, o = 0; o < i; o++) s.push(null);
+  return s;
+}, jt: function(a, t) {
+  var e = g.B, r = a._data, s = a.loca;
+  if (s[t] == s[t + 1]) return null;
+  var i = g.findTable(r, "glyf", a._offset)[0] + s[t], o = {};
+  if (o.noc = e.readShort(r, i), i += 2, o.xMin = e.readShort(r, i), i += 2, o.yMin = e.readShort(r, i), i += 2, o.xMax = e.readShort(r, i), i += 2, o.yMax = e.readShort(r, i), i += 2, o.xMin >= o.xMax || o.yMin >= o.yMax) return null;
+  if (o.noc > 0) {
+    o.endPts = [];
+    for (var n = 0; n < o.noc; n++) o.endPts.push(e.readUshort(r, i)), i += 2;
+    var l = e.readUshort(r, i);
+    if (i += 2, r.length - i < l) return null;
+    i += l;
+    var c = o.endPts[o.noc - 1] + 1;
+    for (o.flags = [], n = 0; n < c; n++) {
+      var u = r[i];
+      if (i++, o.flags.push(u), 8 & u) {
+        var d = r[i];
+        i++;
+        for (var f = 0; f < d; f++) o.flags.push(u), n++;
+      }
+    }
+    for (o.xs = [], n = 0; n < c; n++) {
+      var m = !!(2 & o.flags[n]), v = !!(16 & o.flags[n]);
+      m ? (o.xs.push(v ? r[i] : -r[i]), i++) : v ? o.xs.push(0) : (o.xs.push(e.readShort(r, i)), i += 2);
+    }
+    for (o.ys = [], n = 0; n < c; n++)
+      m = !!(4 & o.flags[n]), v = !!(32 & o.flags[n]), m ? (o.ys.push(v ? r[i] : -r[i]), i++) : v ? o.ys.push(0) : (o.ys.push(e.readShort(r, i)), i += 2);
+    var p = 0, x = 0;
+    for (n = 0; n < c; n++) p += o.xs[n], x += o.ys[n], o.xs[n] = p, o.ys[n] = x;
+  } else o.parts = [];
+  return o;
+} }, typeof module < "u" && module.exports ? module.exports = g : typeof window < "u" && (window.Typr = g);
+class it {
+  extractCharacters(t) {
+    var r;
+    const e = [];
+    return (r = t == null ? void 0 : t.cmap) != null && r.tables ? (t.cmap.tables.forEach((s) => {
+      if (s.format === 4) {
+        const i = this.Wt(s);
+        e.push(...i);
+      } else if (s.format === 12) {
+        const i = this.Nt(s);
+        e.push(...i);
+      }
+    }), [...new Set(e)]) : [];
+  }
+  Wt(t) {
+    const e = [];
+    if (!(t.startCount && t.endCount && t.idRangeOffset && t.idDelta)) return e;
+    for (let r = 0; r < t.startCount.length; r++) {
+      const s = t.startCount[r], i = t.endCount[r];
+      if (s !== 65535 || i !== 65535) {
+        for (let o = s; o <= i; o++)
+          if (this.Xt(t, o, r) > 0) {
+            const n = String.fromCodePoint(o);
+            e.push(n);
+          }
+      }
+    }
+    return e;
+  }
+  Nt(t) {
+    const e = [];
+    if (!t.groups) return e;
+    for (let r = 0; r < t.groups.length; r += 3) {
+      const s = t.groups[r], i = t.groups[r + 1], o = t.groups[r + 2];
+      for (let n = s; n <= i; n++)
+        if (o + (n - s) > 0) {
+          const l = String.fromCodePoint(n);
+          e.push(l);
+        }
+    }
+    return e;
+  }
+  Xt(t, e, r) {
+    if (t.idRangeOffset[r] === 0) return e + t.idDelta[r] & 65535;
+    {
+      const s = t.idRangeOffset[r] / 2 + (e - t.startCount[r]) - (t.startCount.length - r);
+      if (s >= 0 && t.glyphIdArray && s < t.glyphIdArray.length) {
+        const i = t.glyphIdArray[s];
+        if (i !== 0) return i + t.idDelta[r] & 65535;
+      }
+    }
+    return 0;
+  }
+  filterProblematicCharacters(t) {
+    return t.filter((e) => this.qt(e));
+  }
+  qt(t) {
+    const e = t.codePointAt(0) || 0;
+    return !(e >= 0 && e <= 31 && e !== 9 && e !== 10 && e !== 13 || e >= 127 && e <= 159);
+  }
+}
+class ot {
+  constructor(t) {
+    h(this, "Yt");
+    h(this, "Qt");
+    h(this, "Zt");
+    this.Zt = t, this.Yt = document.createElement("canvas"), this.Qt = this.Yt.getContext("2d", { willReadFrequently: !0, alpha: !1 });
+  }
+  createTextureAtlas(t, e, r, s) {
+    const i = t.length, o = Math.ceil(Math.sqrt(i)), n = Math.ceil(i / o), l = e.width * o, c = e.height * n;
+    this.Jt(l, c, r, s), this.Kt(t, e, o, r), this.te();
+    const u = this.Zt.Et(l, c, { filter: "nearest" });
+    return u.update(this.Yt), { framebuffer: u, columns: o, rows: n };
+  }
+  Jt(t, e, r, s) {
+    this.Yt.width = t, this.Yt.height = e, this.Yt.style.width = t + "px", this.Yt.style.height = t + "px", this.Qt.imageSmoothingEnabled = !1, this.Yt.style.imageRendering = "pixelated", this.Qt.fillStyle = "black", this.Qt.fillRect(0, 0, t, e), this.Qt.font = `${r}px ${s}`, this.Qt.textBaseline = "top", this.Qt.textAlign = "left", this.Qt.fillStyle = "white";
+  }
+  Kt(t, e, r, s) {
+    for (let i = 0; i < t.length; i++) {
+      const o = i % r, n = Math.floor(i / r), l = o * e.width + 0.5 * e.width, c = n * e.height + 0.5 * e.height, u = Math.round(l - 0.5 * e.width), d = Math.round(c - 0.5 * s);
+      this.Qt.fillText(t[i].character, u, d);
+    }
+  }
+  te(t = 128) {
+    const e = this.Qt.getImageData(0, 0, this.Yt.width, this.Yt.height), r = e.data;
+    for (let s = 0; s < r.length; s += 4) {
+      const i = 0.299 * r[s] + 0.587 * r[s + 1] + 0.114 * r[s + 2] > t + 32 ? 255 : 0;
+      r[s] = i, r[s + 1] = i, r[s + 2] = i;
+    }
+    this.Qt.putImageData(e, 0, 0);
+  }
+}
+class nt {
+  constructor() {
+    h(this, "ee");
+    h(this, "re");
+    this.ee = document.createElement("canvas"), this.re = this.ee.getContext("2d");
+  }
+  calculateMaxGlyphDimensions(t, e, r) {
+    this.re.font = `${e}px ${r}`;
+    let s = 0, i = 0;
+    for (const o of t) {
+      const n = this.re.measureText(o);
+      s = Math.max(s, n.width), i = Math.max(i, n.actualBoundingBoxAscent + n.actualBoundingBoxDescent);
+    }
+    return { width: s, height: i };
+  }
+}
+class at {
+  createCharacterObjects(t, e) {
+    return t.map((r, s) => {
+      const i = r.codePointAt(0) || 0, o = this.se(s);
+      let n = 0;
+      if (e.hmtx && e.hmtx.aWidth) {
+        const l = this.ie(e, i);
+        l > 0 && e.hmtx.aWidth[l] !== void 0 && (n = e.hmtx.aWidth[l]);
+      }
+      return { character: r, unicode: i, color: o, advanceWidth: n };
+    });
+  }
+  ie(t, e) {
+    const r = t.cmap;
+    if (!r || !r.tables) return 0;
+    for (const s of r.tables) if (s.format === 4) {
+      for (let i = 0; i < s.startCount.length; i++) if (e >= s.startCount[i] && e <= s.endCount[i]) {
+        if (s.idRangeOffset[i] === 0) return e + s.idDelta[i] & 65535;
+        {
+          const o = s.idRangeOffset[i] / 2 + (e - s.startCount[i]) - (s.startCount.length - i);
+          if (o >= 0 && o < s.glyphIdArray.length) {
+            const n = s.glyphIdArray[o];
+            if (n !== 0) return n + s.idDelta[i] & 65535;
+          }
+        }
+      }
+    }
+    return 0;
+  }
+  se(t) {
+    return [t % 256, Math.floor(t / 256) % 256, Math.floor(t / 65536) % 256];
+  }
+  getCharacterColor(t, e) {
+    if (!C.p(typeof t == "string", "Character must be a string.", { method: "getCharacterColor", providedValue: t })) return [0, 0, 0];
+    const r = e.find((s) => s.character === t);
+    return r ? r.color : [0, 0, 0];
+  }
+  getCharacterColors(t, e) {
+    return C.p(typeof t == "string" && t.length > 0, "Characters must be a string with at least one character.", { method: "getCharacterColors", providedValue: t }) ? t.split("").map((r) => this.getCharacterColor(r, e) || [0, 0, 0]) : [[0, 0, 0]];
+  }
+}
+class ht {
+  constructor(t, e = 16) {
+    h(this, "oe");
+    h(this, "ne", []);
+    h(this, "ae");
+    h(this, "he", 16);
+    h(this, "le", 0);
+    h(this, "ce", 0);
+    h(this, "ue", { width: 0, height: 0 });
+    h(this, "fe");
+    h(this, "de", "UrsaFont");
+    h(this, "me");
+    h(this, "pe");
+    h(this, "ge");
+    h(this, "_e");
+    this.he = e, this.me = new it(), this.pe = new ot(t), this.ge = new nt(), this._e = new at();
+  }
+  async ve(t) {
+    let e;
+    if (!t) throw new b("Embedded font not available. This appears to be a minified build - please provide `fontSource`.");
+    {
+      const r = await fetch(t);
+      if (!r.ok) throw new b(`Failed to load font file: ${r.status} ${r.statusText}`);
+      e = await r.arrayBuffer();
+    }
+    await this.xe(e), this.oe = g.parse(e)[0], await this.be();
+  }
+  we(t) {
+    if (t === void 0) return this.he;
+    this.he = t, this.ue = this.ge.calculateMaxGlyphDimensions(this.ne.map((r) => r.character), this.he, this.de);
+    const e = this.pe.createTextureAtlas(this.ne, this.ue, this.he, this.de);
+    this.ae = e.framebuffer, this.le = e.columns, this.ce = e.rows;
+  }
+  async Ce(t) {
+    try {
+      const e = await fetch(t);
+      if (!e.ok) throw new b(`Failed to load font file: ${e.status} ${e.statusText}`);
+      const r = await e.arrayBuffer();
+      await this.xe(r);
+      const s = g.parse(r);
+      if (!s || s.length === 0) throw Error("Failed to parse font file");
+      this.oe = s[0], await this.be();
+    } catch (e) {
+      throw new b("Failed to load font: " + (e instanceof Error ? e.message : "Unknown error"), e);
+    }
+  }
+  async xe(t) {
+    const e = Date.now();
+    this.de = this.de === "UrsaFont" ? "UrsaFont" : "CustomFont_" + e, this.fe = new FontFace(this.de, t), await this.fe.load(), document.fonts.add(this.fe);
+  }
+  async be() {
+    const t = this.me.extractCharacters(this.oe), e = this.me.filterProblematicCharacters(t);
+    this.ne = this._e.createCharacterObjects(e, this.oe), this.ue = this.ge.calculateMaxGlyphDimensions(e, this.he, this.de);
+    const r = this.pe.createTextureAtlas(this.ne, this.ue, this.he, this.de);
+    this.ae = r.framebuffer, this.le = r.columns, this.ce = r.rows;
+  }
+  getCharacterColor(t) {
+    return this._e.getCharacterColor(t, this.ne);
+  }
+  getCharacterColors(t) {
+    return this._e.getCharacterColors(t, this.ne);
+  }
+  hasAllCharacters(t) {
+    if (typeof t != "string" || t.length === 0) return !1;
+    const e = new Set(this.ne.map((r) => r.character));
+    for (const r of t) if (!e.has(r)) return !1;
+    return !0;
+  }
+  P() {
+    this.ae.P(), document.fonts.delete(this.fe);
+  }
+  get fontFramebuffer() {
+    return this.ae;
+  }
+  get characters() {
+    return this.ne;
+  }
+  get textureColumns() {
+    return this.le;
+  }
+  get textureRows() {
+    return this.ce;
+  }
+  get maxGlyphDimensions() {
+    return this.ue;
+  }
+  get fontSize() {
+    return this.he;
+  }
+  get font() {
+    return this.oe;
+  }
+}
+class lt {
+  constructor(t, e, r) {
+    h(this, "ye");
+    h(this, "$e");
+    h(this, "F");
+    h(this, "D");
+    h(this, "Fe");
+    h(this, "Te");
+    h(this, "De", !1);
+    h(this, "Me");
+    h(this, "Se");
+    h(this, "Re");
+    this.Me = t, this.Se = e, this.Re = r, this.kt();
+  }
+  kt() {
+    this.De || (this.ye = Math.floor(this.Me.width / this.Se), this.$e = Math.floor(this.Me.height / this.Re)), this.Ve();
+  }
+  Ve() {
+    this.F = this.ye * this.Se, this.D = this.$e * this.Re, this.Fe = Math.floor((this.Me.width - this.F) / 2), this.Te = Math.floor((this.Me.height - this.D) / 2);
+  }
+  ke(t, e) {
+    this.Se = t, this.Re = e, this.kt();
+  }
+  ze(t, e) {
+    this.De = !0, this.ye = t, this.$e = e, this.Ve();
+  }
+  Ie() {
+    this.De = !1, this.kt();
+  }
+  Pe() {
+    this.De ? this.Ve() : this.kt();
+  }
+  Ue(t) {
+    if (t === void 0) return this.De;
+    this.De = t;
+  }
+  get cellWidth() {
+    return this.Se;
+  }
+  get cellHeight() {
+    return this.Re;
+  }
+  get cols() {
+    return this.ye;
+  }
+  get rows() {
+    return this.$e;
+  }
+  get width() {
+    return this.F;
+  }
+  get height() {
+    return this.D;
+  }
+  get offsetX() {
+    return this.Fe;
+  }
+  get offsetY() {
+    return this.Te;
+  }
+}
+class ct {
+  constructor(t, e = !1, r = {}) {
+    h(this, "Me");
+    h(this, "Ae");
+    h(this, "Ge");
+    h(this, "Ee");
+    h(this, "onTransformChange");
+    this.Ae = t, this.Ge = e, this.Me = this.Le(r.width, r.height), e && this.setupTransformObserver();
+  }
+  Le(t, e) {
+    var s;
+    const r = document.createElement("canvas");
+    if (r.className = "textmodeCanvas", r.style.imageRendering = "pixelated", this.Ge) r.width = t || 800, r.height = e || 600, document.body.appendChild(r);
+    else {
+      const i = this.Ae.getBoundingClientRect();
+      let o = Math.round(i.width), n = Math.round(i.height);
+      if (this.Ae instanceof HTMLVideoElement) {
+        const u = this.Ae;
+        (o === 0 || n === 0) && u.videoWidth > 0 && u.videoHeight > 0 && (o = u.videoWidth, n = u.videoHeight);
+      }
+      r.width = o, r.height = n, r.style.position = "absolute", r.style.pointerEvents = "none";
+      const l = window.getComputedStyle(this.Ae);
+      let c = parseInt(l.zIndex || "0", 10);
+      isNaN(c) && (c = 0), r.style.zIndex = "" + (c + 1), this.Be(r), (s = this.Ae.parentNode) == null || s.insertBefore(r, this.Ae.nextSibling);
+    }
+    return r;
+  }
+  Be(t) {
+    const e = this.Ae.getBoundingClientRect();
+    let r = this.Ae.offsetParent;
+    if (r && r !== document.body) {
+      const s = r.getBoundingClientRect();
+      t.style.top = e.top - s.top + "px", t.style.left = e.left - s.left + "px";
+    } else t.style.top = e.top + window.scrollY + "px", t.style.left = e.left + window.scrollX + "px";
+  }
+  Pe(t, e) {
+    if (this.Ge) this.Me.width = t ?? this.Me.width, this.Me.height = e ?? this.Me.height;
+    else {
+      const r = this.Ae.getBoundingClientRect();
+      let s = Math.round(r.width), i = Math.round(r.height);
+      if (this.Ae instanceof HTMLVideoElement) {
+        const o = this.Ae;
+        (s === 0 || i === 0) && o.videoWidth > 0 && o.videoHeight > 0 && (s = o.videoWidth, i = o.videoHeight);
+      }
+      this.Me.width = s, this.Me.height = i, this.Be(this.Me);
+    }
+  }
+  He() {
+    const t = { alpha: !1, premultipliedAlpha: !1, preserveDrawingBuffer: !0, antialias: !1, depth: !1, stencil: !1, powerPreference: "high-performance" }, e = this.Me.getContext("webgl2", t) || this.Me.getContext("webgl", t);
+    if (!e) throw new b("WebGL context could not be created. Ensure your browser supports WebGL.");
+    return e;
+  }
+  setupTransformObserver() {
+    this.Ee = new ResizeObserver((t) => {
+      for (const e of t) {
+        const r = e.contentRect;
+        !this.onTransformChange || Math.round(r.width) === this.Me.width && Math.round(r.height) === this.Me.height || this.onTransformChange();
+      }
+    }), this.Ee.observe(this.Me);
+  }
+  P() {
+    this.Ee && this.Ee.disconnect();
+    const t = this.Me.getContext("webgl") || this.Me.getContext("webgl2");
+    if (t) {
+      const e = t.getExtension("WEBGL_lose_context");
+      e && e.loseContext();
+    }
+    this.Me.parentNode && this.Me.parentNode.removeChild(this.Me);
+  }
+  get canvas() {
+    return this.Me;
+  }
+  get width() {
+    return this.Me.width;
+  }
+  get height() {
+    return this.Me.height;
+  }
+}
+class U {
+  constructor(t, e, r, s = {}) {
+    h(this, "Zt");
+    h(this, "Oe");
+    h(this, "je");
+    h(this, "We");
+    h(this, "Ne");
+    h(this, "Xe");
+    h(this, "qe");
+    h(this, "Ye");
+    h(this, "l");
+    this.Zt = t, this.Oe = e, this.je = r, this.l = s;
+    const i = this.je.cols, o = this.je.rows;
+    this.We = this.Zt.Et(i, o), this.Ne = this.Zt.Et(i, o), this.Xe = this.Zt.Et(i, o), this.qe = this.Zt.Et(i, o), this.Ye = this.Zt.Et(i, o);
+  }
+  Pe() {
+    const t = this.je.cols, e = this.je.rows;
+    this.We.resize(t, e), this.Ne.resize(t, e), this.Xe.resize(t, e), this.qe.resize(t, e), this.Ye.resize(t, e);
+  }
+  enabled(t) {
+    this.l.enabled = t;
+  }
+  enable() {
+    this.enabled(!0);
+  }
+  disable() {
+    this.enabled(!1);
+  }
+  P() {
+    this.We.P(), this.Ne.P(), this.Xe.P(), this.qe.P(), this.Ye.P();
+  }
+  get characterFramebuffer() {
+    return this.We;
+  }
+  get primaryColorFramebuffer() {
+    return this.Ne;
+  }
+  get secondaryColorFramebuffer() {
+    return this.Xe;
+  }
+  get rotationFramebuffer() {
+    return this.qe;
+  }
+  get transformFramebuffer() {
+    return this.Ye;
+  }
+  get options() {
+    return this.l;
+  }
+}
+class ut {
+  constructor(t, e) {
+    h(this, "C");
+    h(this, "Zt");
+    h(this, "Qe");
+    this.Zt = t, this.Qe = e;
+    const r = Math.max(this.Qe.length, 1);
+    this.C = this.Zt.Et(r, 1), this.Ze();
+  }
+  Ze() {
+    const t = this.Qe.length;
+    this.C.width !== t && this.C.resize(t, 1);
+    const e = new Uint8Array(1 * t * 4);
+    for (let r = 0; r < t; r++) {
+      const s = this.Qe[r], i = 4 * r;
+      e[i] = s[0], e[i + 1] = s[1], e[i + 2] = s[2], e[i + 3] = 255;
+    }
+    this.C.updatePixels(e, t, 1);
+  }
+  setColors(t) {
+    this.Qe = t, this.Ze();
+  }
+  get colors() {
+    return this.Qe;
+  }
+  get framebuffer() {
+    return this.C;
+  }
+  get texture() {
+    return this.C.texture;
+  }
+}
+class k extends U {
+  constructor(e, r, s, i = {}) {
+    super(e, r, s, i);
+    h(this, "Je");
+    this.Je = new ut(this.Zt, this.Oe.getCharacterColors(" .:-=+*%@#"));
+  }
+  characters(e) {
+    C.p(this.Oe.hasAllCharacters(e), "One or more characters do not exist in the current font.", { method: "characters", providedValue: e }) && (this.l.characters = e, this.Je.setColors(this.Oe.getCharacterColors(e)));
+  }
+  characterColor(e, r, s, i = 255) {
+    const o = this.Ke(e, "characterColor", r, s, i);
+    o && (this.l.characterColor = o);
+  }
+  characterColorMode(e) {
+    this.tr(e, "characterColorMode");
+  }
+  cellColor(e, r, s, i = 255) {
+    const o = this.Ke(e, "cellColor", r, s, i);
+    o && (this.l.cellColor = o);
+  }
+  cellColorMode(e) {
+    this.tr(e, "cellColorMode");
+  }
+  invert(e) {
+    this.er(e, "invert", "Invert");
+  }
+  rotation(e) {
+    if (!C.p(typeof e == "number", "Rotation angle must be a number.", { method: "rotation", providedValue: e })) return;
+    (e %= 360) < 0 && (e += 360);
+    const r = 255 * e / 360, s = Math.floor(r) / 255, i = Math.round(r - s);
+    this.l.rotation = [s, i, 0, 1];
+  }
+  flipHorizontally(e) {
+    this.er(e, "flipHorizontally", "Flip horizontally");
+  }
+  flipVertically(e) {
+    this.er(e, "flipVertically", "Flip vertically");
+  }
+  Ke(e, r, s, i, o = 255) {
+    let n, l, c, u;
+    if (typeof e == "string") {
+      const d = this.rr(e);
+      if (!d) return C.p(!1, "Invalid hex color format. Use '#FF0000', '#F00', 'FF0000', or 'F00'.", { method: r, providedValue: e }), null;
+      [n, l, c, u] = d;
+    } else if (n = e, l = s !== void 0 ? s : e, c = i !== void 0 ? i : e, u = o, !C.p([n, l, c, u].every((d) => d >= 0 && d <= 255), r.charAt(0).toUpperCase() + r.slice(1) + " color values must be between 0 and 255", { method: r, providedValues: { r: n, g: l, b: c, a: u } })) return null;
+    return [n / 255, l / 255, c / 255, u / 255];
+  }
+  tr(e, r) {
+    C.p(["sampled", "fixed"].includes(e), "Invalid color mode. Must be 'sampled' or 'fixed'.", { method: r, providedValue: e }) && (this.l[r] = e);
+  }
+  er(e, r, s) {
+    C.p(typeof e == "boolean" || typeof e == "number" && Number.isInteger(e), s + " must be a boolean value or an integer (0 for false, any other number for true).", { method: r, providedValue: e }) && (this.l[r] = !!e);
+  }
+  rr(e) {
+    return e = e.replace(/^#/, ""), /^[0-9A-Fa-f]{3}$|^[0-9A-Fa-f]{6}$/.test(e) ? (e.length === 3 && (e = e.split("").map((r) => r + r).join("")), [parseInt(e.slice(0, 2), 16), parseInt(e.slice(2, 4), 16), parseInt(e.slice(4, 6), 16), 255]) : null;
+  }
+}
+const D = `attribute vec2 a_position;\r
+attribute vec2 a_texCoord;\r
+varying vec2 v_uv;\r
+\r
+uniform float u_rotation; // rotation angle in radians\r
+uniform vec2 u_center; // rotation center in normalized coordinates\r
+uniform float u_aspectRatio; // canvas width / canvas height\r
+\r
+mat2 rotate2D(float angle) {\r
+    float s = sin(angle);\r
+    float c = cos(angle);\r
+    return mat2(c, -s, s, c);\r
+}\r
+\r
+void main() {\r
+    v_uv = a_texCoord;\r
+    \r
+    // Use the position directly (it's already in normalized device coordinates)\r
+    vec2 pos = a_position;\r
+    \r
+    // Translate to origin for rotation\r
+    pos -= u_center;\r
+    \r
+    // Correct for aspect ratio: scale X coordinate to make space square\r
+    pos.x *= u_aspectRatio;\r
+    \r
+    // Rotate in corrected space\r
+    // Negate rotation to make positive values rotate clockwise (like p5.js)\r
+    pos = rotate2D(-u_rotation) * pos;\r
+    \r
+    // Restore aspect ratio: scale X coordinate back\r
+    pos.x /= u_aspectRatio;\r
+    \r
+    // Translate back from origin\r
+    pos += u_center;\r
+    \r
+    gl_Position = vec4(pos, 0.0, 1.0);\r
+}\r
+`, dt = { enabled: !0, characters: " .:-=+*%@#", characterColor: [1, 1, 1, 1], characterColorMode: "sampled", cellColor: [0, 0, 0, 1], cellColorMode: "fixed", invert: !1, rotation: [0, 0, 0, 255], flipHorizontally: !1, flipVertically: !1, brightnessRange: [0, 255] };
+class I extends k {
+  constructor(e, r, s) {
+    super(e, r, s, { ...dt });
+    h(this, "sr");
+    h(this, "ir");
+    h(this, "nr");
+    h(this, "ar");
+    h(this, "hr");
+    h(this, "lr");
+    this.sr = new y(e.context, D, "precision lowp float;uniform sampler2D u_sketchTexture;uniform vec2 u_gridCellDimensions;uniform vec2 u_brightnessRange;varying vec2 v_uv;void main(){vec2 cellCenter=(floor(v_uv*u_gridCellDimensions)+vec2(0.5))/u_gridCellDimensions;vec4 color=texture2D(u_sketchTexture,cellCenter);float brightness=dot(color.rgb,vec3(0.299,0.587,0.114));float brightnessValue=brightness*255.0;if(brightnessValue>=u_brightnessRange.x&&brightnessValue<=u_brightnessRange.y){gl_FragColor=color;}else{gl_FragColor=vec4(0.0);}}"), this.ir = new y(e.context, D, "precision lowp float;uniform sampler2D u_sampleTexture;uniform vec4 u_fillColor;uniform bool u_useFixedColor;varying vec2 v_uv;void main(){vec4 sampleColor=texture2D(u_sampleTexture,v_uv);if(sampleColor.a>0.0){if(u_useFixedColor){gl_FragColor=u_fillColor;}else{gl_FragColor=sampleColor;}}else{gl_FragColor=vec4(0.0);}}"), this.ar = new y(e.context, D, "precision lowp float;uniform sampler2D u_sampleTexture;uniform bool u_invert;uniform bool u_flipHorizontally;uniform bool u_flipVertically;varying vec2 v_uv;void main(){vec4 sampleColor=texture2D(u_sampleTexture,v_uv);if(sampleColor.a>0.0){float invertValue=u_invert ? 1.0 : 0.0;float flipHValue=u_flipHorizontally ? 1.0 : 0.0;float flipVValue=u_flipVertically ? 1.0 : 0.0;gl_FragColor=vec4(invertValue,flipHValue,flipVValue,1.0);}else{gl_FragColor=vec4(0.0);}}"), this.hr = new y(e.context, D, "precision lowp float;uniform sampler2D u_sampleTexture;uniform vec4 u_rotationColor;varying vec2 v_uv;void main(){vec4 sampleColor=texture2D(u_sampleTexture,v_uv);if(sampleColor.a>0.0){gl_FragColor=u_rotationColor;}else{gl_FragColor=vec4(0.0);}}"), this.nr = new y(e.context, D, "precision lowp float;uniform sampler2D u_colorSampleFramebuffer;uniform sampler2D u_charPaletteTexture;uniform vec2 u_charPaletteSize;uniform vec2 u_brightnessRange;varying vec2 v_uv;void main(){vec4 color=texture2D(u_colorSampleFramebuffer,v_uv);if(color.a==0.0){gl_FragColor=vec4(0.0);return;}float brightness=dot(color.rgb,vec3(0.299,0.587,0.114))*255.0;vec2 range=u_brightnessRange;if(brightness<range.x||brightness>range.y){gl_FragColor=vec4(0.0);return;}float t=(brightness-range.x)/(range.y-range.x);float idx=clamp(floor(t*u_charPaletteSize.x),0.0,u_charPaletteSize.x-1.0);vec3 charColor=texture2D(u_charPaletteTexture,vec2((idx+0.5)/u_charPaletteSize.x,0.0)).rgb;gl_FragColor=vec4(charColor,1.0);}"), this.lr = this.Zt.Et(this.je.cols, this.je.rows);
+  }
+  cr(e) {
+    const r = this.je.cols, s = this.je.rows;
+    this.lr.begin(), this.Zt.Bt(), this.Zt.yt(this.sr), this.Zt.Pt("u_sketchTexture", e), this.Zt.Pt("u_gridCellDimensions", [r, s]), this.Zt.Pt("u_brightnessRange", this.l.brightnessRange), this.Zt.Ut(0, 0, r, s), this.lr.end(), this.Ne.begin(), this.Zt.Bt(), this.Zt.yt(this.ir), this.Zt.Pt("u_sampleTexture", this.lr), this.Zt.Pt("u_fillColor", this.l.characterColor), this.Zt.Pt("u_useFixedColor", this.l.characterColorMode === "fixed"), this.Zt.Ut(0, 0, r, s), this.Ne.end(), this.Xe.begin(), this.Zt.Bt(), this.Zt.yt(this.ir), this.Zt.Pt("u_sampleTexture", this.lr), this.Zt.Pt("u_fillColor", this.l.cellColor), this.Zt.Pt("u_useFixedColor", this.l.cellColorMode === "fixed"), this.Zt.Ut(0, 0, r, s), this.Xe.end(), this.Ye.begin(), this.Zt.Bt(), this.Zt.yt(this.ar), this.Zt.Pt("u_sampleTexture", this.lr), this.Zt.Pt("u_invert", this.l.invert), this.Zt.Pt("u_flipHorizontally", this.l.flipHorizontally), this.Zt.Pt("u_flipVertically", this.l.flipVertically), this.Zt.Ut(0, 0, r, s), this.Ye.end(), this.qe.begin(), this.Zt.Bt(), this.Zt.yt(this.hr), this.Zt.Pt("u_sampleTexture", this.lr), this.Zt.Pt("u_rotationColor", this.l.rotation), this.Zt.Ut(0, 0, r, s), this.qe.end(), this.We.begin(), this.Zt.Bt(), this.Zt.yt(this.nr), this.Zt.Pt("u_colorSampleFramebuffer", this.lr), this.Zt.Pt("u_charPaletteTexture", this.Je.texture), this.Zt.Pt("u_charPaletteSize", [this.Je.colors.length, 1]), this.Zt.Pt("u_brightnessRange", this.l.brightnessRange), this.Zt.Ut(0, 0, r, s), this.We.end();
+  }
+  Pe() {
+    super.Pe(), this.lr.resize(this.je.cols, this.je.rows);
+  }
+  brightnessRange(e) {
+    C.p(Array.isArray(e) && e.length === 2 && e.every((r) => typeof r == "number" && r >= 0 && r <= 255), "Brightness range must be an array of two numbers between 0 and 255.", { method: "brightnessRange", providedValue: e }) && (this.l.brightnessRange = e);
+  }
+}
+const Ut = Object.freeze(Object.defineProperty({ __proto__: null, TextmodeBrightnessConverter: I, TextmodeConverter: U, TextmodeFeatureConverter: k }, Symbol.toStringTag, { value: "Module" }));
+class ft {
+  constructor(t, e, r) {
+    h(this, "Zt");
+    h(this, "oe");
+    h(this, "je");
+    h(this, "ur");
+    h(this, "dr");
+    h(this, "mr");
+    h(this, "pr");
+    h(this, "gr");
+    h(this, "We");
+    h(this, "Ne");
+    h(this, "Xe");
+    h(this, "qe");
+    h(this, "Ye");
+    this.Zt = t, this.oe = e, this.je = r, this.gr = this.Zt.zt(Z, "precision mediump float;uniform sampler2D u_characterTexture;uniform vec2 u_charsetDimensions;uniform sampler2D u_primaryColorTexture;uniform sampler2D u_secondaryColorTexture;uniform sampler2D u_transformTexture;uniform sampler2D u_asciiCharacterTexture;uniform sampler2D u_rotationTexture;uniform sampler2D u_captureTexture;uniform vec2 u_captureDimensions;uniform int u_backgroundMode;uniform vec2 u_gridCellDimensions;uniform vec2 u_gridPixelDimensions;mat2 rotate2D(float angle){float s=sin(angle);float c=cos(angle);return mat2(c,-s,s,c);}void main(){vec2 adjustedCoord=gl_FragCoord.xy/u_gridPixelDimensions;vec2 gridCoord=adjustedCoord*u_gridCellDimensions;vec2 cellCoord=floor(gridCoord);vec2 charIndexTexCoord=(cellCoord+0.5)/u_gridCellDimensions;vec4 primaryColor=texture2D(u_primaryColorTexture,charIndexTexCoord);vec4 secondaryColor=texture2D(u_secondaryColorTexture,charIndexTexCoord);vec4 transformColor=texture2D(u_transformTexture,charIndexTexCoord);bool isInverted=transformColor.r>0.5;bool flipHorizontal=transformColor.g>0.5;bool flipVertical=transformColor.b>0.5;vec4 encodedIndexVec=texture2D(u_asciiCharacterTexture,charIndexTexCoord);if(encodedIndexVec.a<0.01){gl_FragColor=(u_backgroundMode==0)? vec4(0.0):texture2D(u_captureTexture,gl_FragCoord.xy/u_captureDimensions);return;}int charIndex=int(encodedIndexVec.r*255.0+0.5)+int(encodedIndexVec.g*255.0+0.5)*256;int charCol=int(mod(float(charIndex),u_charsetDimensions.x));int charRow=charIndex/int(u_charsetDimensions.x);float flippedRow=(u_charsetDimensions.y-1.0)-float(charRow);vec2 charCoord=vec2(float(charCol),flippedRow)/u_charsetDimensions;vec4 rotationColor=texture2D(u_rotationTexture,charIndexTexCoord);float scaledAngle=rotationColor.r*255.0+rotationColor.g;float rotationAngle=(scaledAngle*360.0/255.0)*0.017453292;vec2 fractionalPart=fract(gridCoord)-0.5;if(flipHorizontal)fractionalPart.x=-fractionalPart.x;if(flipVertical)fractionalPart.y=-fractionalPart.y;fractionalPart=rotate2D(rotationAngle)*fractionalPart+0.5;vec2 cellSize=1.0/u_charsetDimensions;vec2 texCoord=charCoord+fractionalPart*cellSize;vec2 cellMax=charCoord+cellSize;if(any(lessThan(texCoord,charCoord))||any(greaterThan(texCoord,cellMax))){gl_FragColor=isInverted ? primaryColor : secondaryColor;return;}vec4 charTexel=texture2D(u_characterTexture,texCoord);if(isInverted)charTexel.rgb=1.0-charTexel.rgb;gl_FragColor=mix(secondaryColor,primaryColor,charTexel);}"), this.dr = new I(t, e, r), this.mr = new U(t, e, r), this.ur = [this.dr, this.mr], this.We = this.Zt.Et(r.cols, r.rows), this.Ne = this.Zt.Et(r.cols, r.rows), this.Xe = this.Zt.Et(r.cols, r.rows), this.qe = this.Zt.Et(r.cols, r.rows), this.Ye = this.Zt.Et(r.cols, r.rows), this.pr = this.Zt.Et(this.je.width, this.je.height);
+  }
+  _r(t) {
+    for (const r of this.ur) r.options.enabled && r instanceof k && r.cr(t);
+    const e = (r, s) => {
+      r.begin(), this.Zt.Bt();
+      for (const i of this.ur) i.options.enabled && this.Zt.Ot(s(i), 0, 0);
+      r.end();
+    };
+    e(this.We, (r) => r.characterFramebuffer), e(this.Ne, (r) => r.primaryColorFramebuffer), e(this.Xe, (r) => r.secondaryColorFramebuffer), e(this.qe, (r) => r.rotationFramebuffer), e(this.Ye, (r) => r.transformFramebuffer), this.pr.begin(), this.Zt.Bt(), this.Zt.yt(this.gr), this.Zt.Pt("u_characterTexture", this.oe.fontFramebuffer), this.Zt.Pt("u_charsetDimensions", [this.oe.textureColumns, this.oe.textureRows]), this.Zt.Pt("u_asciiCharacterTexture", this.We.texture), this.Zt.Pt("u_primaryColorTexture", this.Ne.texture), this.Zt.Pt("u_secondaryColorTexture", this.Xe.texture), this.Zt.Pt("u_transformTexture", this.Ye.texture), this.Zt.Pt("u_rotationTexture", this.qe.texture), this.Zt.Pt("u_captureTexture", t.texture), this.Zt.Pt("u_backgroundMode", !1), this.Zt.Pt("u_captureDimensions", [t.width, t.height]), this.Zt.Pt("u_gridCellDimensions", [this.je.cols, this.je.rows]), this.Zt.Pt("u_gridPixelDimensions", [this.je.width, this.je.height]), this.Zt.Ut(0, 0, this.pr.width, this.pr.height), this.pr.end();
+  }
+  add(t) {
+    if (!C.p(t === "brightness" || t === "custom", 'Converter type must be either "brightness" or "custom".', { method: "add", providedValue: t })) return;
+    let e;
+    return e = t === "brightness" ? new I(this.Zt, this.oe, this.je) : new U(this.Zt, this.oe, this.je), this.ur.push(e), e;
+  }
+  remove(t) {
+    if (!C.p(t instanceof U, "Parameter must be a TextmodeConverter instance.", { method: "remove", providedValue: t })) return;
+    const e = this.ur.indexOf(t);
+    C.p(e !== -1, "Converter instance not found in pipeline.", { method: "remove", providedValue: t, convertersCount: this.ur.length }) && this.ur.splice(e, 1);
+  }
+  Pe() {
+    this.pr.resize(this.je.width, this.je.height);
+    const t = this.je.cols, e = this.je.rows;
+    this.We.resize(t, e), this.Ne.resize(t, e), this.Xe.resize(t, e), this.qe.resize(t, e), this.Ye.resize(t, e);
+    for (const r of this.ur) r.Pe();
+  }
+  hasEnabledConverters() {
+    return this.ur.some((t) => t.options.enabled);
+  }
+  disable() {
+    for (const t of this.ur) t.disable();
+  }
+  enable() {
+    for (const t of this.ur) t.enable();
+  }
+  P() {
+    for (const t of this.ur) t.P();
+    this.We.P(), this.Ne.P(), this.Xe.P(), this.qe.P(), this.Ye.P(), this.pr.P(), this.gr.P();
+  }
+  get texture() {
+    return this.pr;
+  }
+  get characterFramebuffer() {
+    return this.We;
+  }
+  get primaryColorFramebuffer() {
+    return this.Ne;
+  }
+  get secondaryColorFramebuffer() {
+    return this.Xe;
+  }
+  get rotationFramebuffer() {
+    return this.qe;
+  }
+  get transformFramebuffer() {
+    return this.Ye;
+  }
+  get brightness() {
+    return this.dr;
+  }
+  get custom() {
+    return this.mr;
+  }
+}
+const gt = (a) => class extends a {
+  fill(t, e, r, s) {
+    this.Zt.$t(t, e, r, s);
+  }
+  stroke(t, e, r, s) {
+    this.Zt.Ft(t, e, r, s);
+  }
+  strokeWeight(t) {
+    this.Zt.Tt(t);
+  }
+  noStroke() {
+    this.Zt.Dt();
+  }
+  noFill() {
+    this.Zt.Mt();
+  }
+  rotate(t) {
+    this.Zt.St(t);
+  }
+  push() {
+    this.Zt.Rt();
+  }
+  pop() {
+    this.Zt.Vt();
+  }
+  rect(t, e, r = 1, s = 1) {
+    this.Zt.Ut(t, e, r, s);
+  }
+  line(t, e, r, s) {
+    this.Zt.Gt(t, e, r, s);
+  }
+  background(t, e = t, r = t, s = 255) {
+    this.Zt.Lt(t, e, r, s);
+  }
+  createShader(t, e) {
+    return this.Zt.zt(t, e);
+  }
+  createFilterShader(t) {
+    return this.Zt.It(t);
+  }
+  shader(t) {
+    this.Zt.yt(t);
+  }
+  setUniform(t, e) {
+    this.Zt.Pt(t, e);
+  }
+};
+class j {
+  vr(t) {
+    const e = t.get("brightness"), r = e == null ? void 0 : e.characterFramebuffer, s = e == null ? void 0 : e.primaryColorFramebuffer, i = e == null ? void 0 : e.secondaryColorFramebuffer, o = e == null ? void 0 : e.transformFramebuffer, n = e == null ? void 0 : e.rotationFramebuffer;
+    return r == null || r.loadPixels(), s == null || s.loadPixels(), i == null || i.loadPixels(), o == null || o.loadPixels(), n == null || n.loadPixels(), { characterPixels: (r == null ? void 0 : r.pixels) || new Uint8Array(0), primaryColorPixels: (s == null ? void 0 : s.pixels) || new Uint8Array(0), secondaryColorPixels: (i == null ? void 0 : i.pixels) || new Uint8Array(0), transformPixels: (o == null ? void 0 : o.pixels) || new Uint8Array(0), rotationPixels: (n == null ? void 0 : n.pixels) || new Uint8Array(0) };
+  }
+  br(t, e) {
+    return t[e] + (t[e + 1] << 8);
+  }
+  wr(t, e) {
+    return { r: t[e], g: t[e + 1], b: t[e + 2], a: t[e + 3] };
+  }
+}
+class L {
+  Cr(t, e) {
+    return new Blob([t], { type: e });
+  }
+  yr(t, e, r) {
+    try {
+      const s = this.Cr(t, r), i = URL.createObjectURL(s), o = document.createElement("a");
+      o.href = i, o.download = e, o.style.display = "none", o.rel = "noopener", document.body.appendChild(o), o.click(), document.body.removeChild(o), URL.revokeObjectURL(i);
+    } catch (s) {
+      throw console.error("Failed to download file:", s), Error("File download failed: " + (s instanceof Error ? s.message : "Unknown error"));
+    }
+  }
+  $r() {
+    return (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-");
+  }
+  Fr() {
+    const t = /* @__PURE__ */ new Date();
+    return { date: t.toISOString().split("T")[0], time: t.toTimeString().split(" ")[0].replace(/:/g, "-") };
+  }
+  Tr(t) {
+    return t.replace(/[<>:"/\\|?*]/g, "_").replace(/\s+/g, "_").replace(/_{2,}/g, "_").replace(/^_+|_+$/g, "").substring(0, 255);
+  }
+  Dr() {
+    return "'textmode-export'-" + this.$r();
+  }
+}
+class pt extends j {
+  Mr(t, e, r) {
+    const s = t[r] === 255, i = t[r + 1] === 255, o = t[r + 2] === 255, n = e[r], l = e[r + 1];
+    return { isInverted: s, flipHorizontal: i, flipVertical: o, rotation: Math.round(360 * (n + l / 255) / 255 * 100) / 100 };
+  }
+  Sr(t, e, r) {
+    return { x: t, y: e, cellX: t * r.cellWidth, cellY: e * r.cellHeight };
+  }
+  Rr(t, e) {
+    const r = [];
+    let s = 0;
+    for (let i = 0; i < e.rows; i++) for (let o = 0; o < e.cols; o++) {
+      const n = 4 * s, l = this.br(t.characterPixels, n);
+      let c = this.wr(t.primaryColorPixels, n), u = this.wr(t.secondaryColorPixels, n);
+      const d = this.Mr(t.transformPixels, t.rotationPixels, n);
+      if (d.isInverted) {
+        const m = c;
+        c = u, u = m;
+      }
+      const f = this.Sr(o, i, e);
+      r.push({ charIndex: l, primaryColor: c, secondaryColor: u, transform: d, position: f }), s++;
+    }
+    return r;
+  }
+}
+class mt {
+  ie(t, e) {
+    const r = t.cmap;
+    for (const s of r.tables) if (s.format === 4) {
+      for (let i = 0; i < s.startCount.length; i++) if (e >= s.startCount[i] && e <= s.endCount[i]) {
+        if (s.idRangeOffset[i] === 0) return e + s.idDelta[i] & 65535;
+        {
+          const o = s.idRangeOffset[i] / 2 + (e - s.startCount[i]) - (s.startCount.length - i);
+          if (o >= 0 && o < s.glyphIdArray.length) {
+            const n = s.glyphIdArray[o];
+            if (n !== 0) return n + s.idDelta[i] & 65535;
+          }
+        }
+      }
+    }
+    return 0;
+  }
+  Vr(t, e, r, s, i) {
+    const o = i / t.head.unitsPerEm;
+    return { getBoundingBox: () => ({ x1: r + e.xMin * o, y1: s + -e.yMax * o, x2: r + e.xMax * o, y2: s + -e.yMin * o }), toSVG: () => this.kr(e, r, s, o) };
+  }
+  kr(t, e, r, s) {
+    if (!t || !t.xs) return "";
+    const { xs: i, ys: o, endPts: n, flags: l } = t;
+    if (!(i && o && n && l)) return "";
+    let c = "", u = 0;
+    for (let d = 0; d < n.length; d++) {
+      const f = n[d];
+      if (!(f < u)) {
+        if (f >= u) {
+          const m = e + i[u] * s, v = r - o[u] * s;
+          c += `M${m.toFixed(2)},${v.toFixed(2)}`;
+          let p = u + 1;
+          for (; p <= f; )
+            if (1 & l[p]) {
+              const x = e + i[p] * s, _ = r - o[p] * s;
+              c += `L${x.toFixed(2)},${_.toFixed(2)}`, p++;
+            } else {
+              const x = e + i[p] * s, _ = r - o[p] * s;
+              let w = p + 1 > f ? u : p + 1;
+              if (1 & l[w]) {
+                const T = e + i[w] * s, E = r - o[w] * s;
+                c += `Q${x.toFixed(2)},${_.toFixed(2)} ${T.toFixed(2)},${E.toFixed(2)}`, p = w + 1;
+              } else {
+                const T = (x + (e + i[w] * s)) / 2, E = (_ + (r - o[w] * s)) / 2;
+                c += `Q${x.toFixed(2)},${_.toFixed(2)} ${T.toFixed(2)},${E.toFixed(2)}`, p = w;
+              }
+            }
+          c += "Z";
+        }
+        u = f + 1;
+      }
+    }
+    return c;
+  }
+  zr(t, e, r, s, i) {
+    const o = t.codePointAt(0) || 0, n = this.ie(e, o);
+    let l = null;
+    return e.glyf && e.glyf[n] !== null ? l = e.glyf[n] : g && g.T && g.T.glyf && g.T.glyf.jt && (l = g.T.glyf.jt(e, n), e.glyf && l && (e.glyf[n] = l)), this.Vr(e, l, r, s, i);
+  }
+  Ir(t, e, r, s, i, o, n, l) {
+    const c = r + (i - l * (n / e.head.unitsPerEm)) / 2, u = s + (o + 0.7 * n) / 2;
+    return this.zr(t, e, c, u, n).toSVG() || null;
+  }
+}
+class vt {
+  constructor() {
+    h(this, "Pr");
+    this.Pr = new mt();
+  }
+  Ur(t) {
+    return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="${t.width}" height="${t.height}" viewBox="0 0 ${t.width} ${t.height}" 
+     xmlns="http://www.w3.org/2000/svg" version="1.1">
+<title>textmode art generated via textmode.js</title>
+<desc>textmode art visualization generated by textmode.js library</desc>`;
+  }
+  Ar() {
+    return `
+</g>
+</svg>`;
+  }
+  Gr(t, e) {
+    if (!e.includeBackgroundRectangles) return "";
+    const r = e.backgroundColor, s = `rgba(${r[0]},${r[1]},${r[2]},${r[3] / 255})`;
+    return `
+<rect width="${t.width}" height="${t.height}" fill="${s}" />`;
+  }
+  Er(t) {
+    return `rgba(${t.r},${t.g},${t.b},${t.a / 255})`;
+  }
+  Lr(t, e) {
+    const { transform: r, position: s } = t, i = s.cellX + e.cellWidth / 2, o = s.cellY + e.cellHeight / 2, n = [];
+    if (r.flipHorizontal || r.flipVertical) {
+      const l = r.flipHorizontal ? -1 : 1, c = r.flipVertical ? -1 : 1;
+      n.push(`translate(${i} ${o})`), n.push(`scale(${l} ${c})`), n.push(`translate(${-i} ${-o})`);
+    }
+    return r.rotation && n.push(`rotate(${r.rotation} ${i} ${o})`), n.length ? ` transform="${n.join(" ")}"` : "";
+  }
+  Br(t, e, r) {
+    if (!r.includeBackgroundRectangles || t.secondaryColor.a === 0) return "";
+    const { position: s } = t, i = this.Er(t.secondaryColor);
+    return r.drawMode === "stroke" ? `
+  <rect x="${s.cellX}" y="${s.cellY}" width="${e.cellWidth}" height="${e.cellHeight}" stroke="${i}" fill="none" stroke-width="${r.strokeWidth}" />` : `
+  <rect x="${s.cellX}" y="${s.cellY}" width="${e.cellWidth}" height="${e.cellHeight}" fill="${i}" />`;
+  }
+  zr(t, e, r, s) {
+    const i = r.characters[t.charIndex];
+    if (!i) return "";
+    const o = this.Pr.Ir(i.character, r.font, t.position.cellX, t.position.cellY, e.cellWidth, e.cellHeight, r.fontSize, i.advanceWidth);
+    if (!o) return "";
+    const n = this.Er(t.primaryColor);
+    return s.drawMode === "stroke" ? `
+    <path id="${`path-${t.charIndex}-${t.position.cellX}-${t.position.cellY}`.replace(/\./g, "-")}" d="${o}" stroke="${n}" stroke-width="${s.strokeWidth}" fill="none" />` : `
+    <path d="${o}" fill="${n}" />`;
+  }
+  Hr(t, e, r, s) {
+    let i = "";
+    i += this.Br(t, e, s);
+    const o = this.Lr(t, e), n = this.zr(t, e, r, s);
+    return n && (o ? (i += `
+  <g${o}>`, i += n, i += `
+  </g>`) : i += n), i;
+  }
+  Or(t, e, r, s) {
+    let i = this.Ur(e);
+    i += this.Gr(e, s), i += `
+<g id="ascii-cells">`;
+    for (const o of t) i += this.Hr(o, e, r, s);
+    return i += this.Ar(), i;
+  }
+  jr(t) {
+    return t.replace(/<path[^>]*d=""[^>]*\/>/g, "").replace(/\n\s*\n/g, `
+`).replace(/[ \t]+$/gm, "");
+  }
+}
+class xt extends L {
+  Wr(t) {
+    return this.Cr(t, "image/svg+xml;charset=utf-8");
+  }
+  Nr(t, e) {
+    this.yr(t, this.Tr(e) + ".svg", "image/svg+xml;charset=utf-8");
+  }
+  Xr(t, e) {
+    this.Nr(t, e || this.Dr());
+  }
+}
+class V {
+  constructor() {
+    h(this, "qr");
+    h(this, "Yr");
+    h(this, "Qr");
+    this.qr = new pt(), this.Yr = new vt(), this.Qr = new xt();
+  }
+  Zr(t) {
+    return { includeBackgroundRectangles: t.includeBackgroundRectangles ?? !0, drawMode: t.drawMode ?? "fill", strokeWidth: t.strokeWidth ?? 1, backgroundColor: t.backgroundColor ?? [0, 0, 0, 0] };
+  }
+  Jr(t, e = {}) {
+    const r = this.Zr(e), s = this.qr.vr(t.pipeline), i = this.qr.Rr(s, t.grid), o = this.Yr.Or(i, t.grid, t.font, r);
+    return this.Yr.jr(o);
+  }
+  Xr(t, e = {}) {
+    const r = this.Jr(t, e), s = e.filename || this.Qr.Dr();
+    this.Qr.Xr(r, s);
+  }
+}
+class bt extends j {
+  Kr(t, e, r, s = " ") {
+    var n;
+    const i = [];
+    let o = 0;
+    for (let l = 0; l < e.rows; l++) {
+      const c = [];
+      for (let u = 0; u < e.cols; u++) {
+        const d = 4 * o, f = this.br(t.characterPixels, d), m = ((n = r.characters[f]) == null ? void 0 : n.character) || s;
+        c.push(m), o++;
+      }
+      i.push(c);
+    }
+    return i;
+  }
+}
+class Ct {
+  ts(t, e) {
+    const r = [];
+    for (const i of t) {
+      let o = i.join("");
+      e.preserveTrailingSpaces || (o = o.replace(/\s+$/, "")), r.push(o);
+    }
+    const s = e.lineEnding === "crlf" ? `\r
+` : `
+`;
+    return r.join(s);
+  }
+}
+class wt extends L {
+  es(t, e) {
+    const r = this.rs(e);
+    this.yr(t, r, "text/plain;charset=utf-8");
+  }
+  rs(t) {
+    let e = this.Tr(t);
+    return e === ".txt" || e.length <= 4 ? this.Dr() : e;
+  }
+}
+class Y {
+  constructor() {
+    h(this, "qr");
+    h(this, "Yr");
+    h(this, "Qr");
+    this.qr = new bt(), this.Yr = new Ct(), this.Qr = new wt();
+  }
+  Zr(t) {
+    return { preserveTrailingSpaces: t.preserveTrailingSpaces ?? !1, lineEnding: t.lineEnding ?? "lf", emptyCharacter: t.emptyCharacter ?? " " };
+  }
+  ss(t, e = {}) {
+    const r = this.Zr(e), s = this.qr.vr(t.pipeline), i = this.qr.Kr(s, t.grid, t.font, r.emptyCharacter);
+    return this.Yr.ts(i, r);
+  }
+  es(t, e = {}) {
+    const r = this.ss(t, e), s = e.filename || this.Qr.Dr();
+    this.Qr.es(r, s);
+  }
+}
+class _t extends j {
+  ns(t, e = 1, r = "transparent") {
+    const s = t.canvas;
+    if (e === 1 && r === "transparent") return s;
+    const i = document.createElement("canvas"), o = i.getContext("2d"), n = Math.round(s.width * e), l = Math.round(s.height * e);
+    return i.width = n, i.height = l, r !== "transparent" && (o.fillStyle = r, o.fillRect(0, 0, n, l)), o.imageSmoothingEnabled = !1, o.drawImage(s, 0, 0, s.width, s.height, 0, 0, n, l), i;
+  }
+}
+class yt {
+  hs(t, e) {
+    const r = this.ls(e.format);
+    return e.format === "png" ? t.toDataURL(r) : t.toDataURL(r, e.quality);
+  }
+  async cs(t, e) {
+    return new Promise((r, s) => {
+      const i = this.ls(e.format), o = (n) => {
+        n ? r(n) : s(Error(`Failed to generate ${e.format.toUpperCase()} blob`));
+      };
+      e.format === "png" ? t.toBlob(o, i) : t.toBlob(o, i, e.quality);
+    });
+  }
+  ls(t) {
+    switch (t) {
+      case "png":
+        return "image/png";
+      case "jpg":
+        return "image/jpeg";
+      case "webp":
+        return "image/webp";
+      default:
+        throw Error("Unsupported image format: " + t);
+    }
+  }
+}
+const Tt = { png: "image/png", jpg: "image/jpeg", webp: "image/webp" }, G = { png: ".png", jpg: ".jpg", webp: ".webp" };
+class Et extends L {
+  us(t, e, r) {
+    this.fs(t, this.Tr(e) + G[r]);
+  }
+  fs(t, e) {
+    const r = URL.createObjectURL(t);
+    try {
+      const s = document.createElement("a");
+      s.href = r, s.download = e, s.style.display = "none", s.rel = "noopener", document.body.appendChild(s), s.click(), document.body.removeChild(s);
+    } finally {
+      URL.revokeObjectURL(r);
+    }
+  }
+  ds(t) {
+    return t in Tt && t in G;
+  }
+}
+class Pt {
+  constructor() {
+    h(this, "qr");
+    h(this, "Yr");
+    h(this, "Qr");
+    this.qr = new _t(), this.Yr = new yt(), this.Qr = new Et();
+  }
+  Zr(t) {
+    return { format: t.format ?? "png", quality: t.quality ?? 1, scale: t.scale ?? 1, backgroundColor: t.backgroundColor ?? "transparent" };
+  }
+  ps(t) {
+    if (console.log("Validating image export options:", t), !this.Qr.ds(t.format)) throw Error(`Saving '${t.format}' files is not supported`);
+    if (t.quality < 0 || t.quality > 1) throw Error("Image quality must be between 0.0 and 1.0");
+    if (t.scale <= 0) throw Error("Scale factor must be greater than 0");
+    t.scale > 10 && console.warn("Large scale factors may result in very large files and slow performance"), t.format === "jpg" && t.backgroundColor === "transparent" && (t.backgroundColor = "black");
+  }
+  gs(t, e = {}) {
+    const r = this.Zr(e);
+    if (this.ps(r), r.scale === 1 && r.backgroundColor === "transparent") return this.Yr.hs(t.canvas, r);
+    const s = this.qr.ns(t, r.scale, r.backgroundColor);
+    return this.Yr.hs(s, r);
+  }
+  async cs(t, e = {}) {
+    const r = this.Zr(e);
+    if (this.ps(r), r.scale === 1 && r.backgroundColor === "transparent") return await this.Yr.cs(t.canvas, r);
+    const s = this.qr.ns(t, r.scale, r.backgroundColor);
+    return await this.Yr.cs(s, r);
+  }
+  async us(t, e = {}) {
+    const r = await this.cs(t, e), s = e.format ?? "png", i = e.filename || this.Qr.Dr();
+    this.Qr.us(r, i, s);
+  }
+}
+const Rt = (a) => class extends a {
+  toString(t = {}) {
+    return new Y().ss(this, t);
+  }
+  saveStrings(t = {}) {
+    new Y().es(this, t);
+  }
+  toSVG(t = {}) {
+    return new V().Jr(this, t);
+  }
+  saveSVG(t = {}) {
+    new V().Xr(this, t);
+  }
+  async saveCanvas(t, e = "png", r = {}) {
+    await new Pt().us(this.textmodeCanvas, { ...r, filename: t, format: e });
+  }
+}, Ft = (a) => class extends a {
+  async loadFont(t) {
+    return this.oe.Ce(t).then(() => {
+      const e = this.oe.maxGlyphDimensions;
+      this.je.ke(e.width, e.height), this._s.Pe();
+    });
+  }
+  fontSize(t) {
+    if (!C.p(typeof t == "number" && t > 0, "Font size must be a positive number greater than 0.", { method: "fontSize", providedValue: t }) || this.oe.fontSize === t) return;
+    this.oe.we(t);
+    const e = this.oe.maxGlyphDimensions;
+    this.je.ke(e.width, e.height), this._s.Pe(), this.Zt.Ht();
+  }
+}, Mt = (a) => class extends a {
+  addConverter(t) {
+    return this._s.add(t);
+  }
+  removeConverter(t) {
+    this._s.remove(t);
+  }
+};
+class At {
+  constructor() {
+    h(this, "Zt");
+    h(this, "oe");
+    h(this, "_s");
+    h(this, "textmodeCanvas");
+    h(this, "je");
+  }
+}
+class O extends function(e, ...r) {
+  return r.reduce((s, i) => i(s), e);
+}(At, gt, Rt, Ft, Mt) {
+  constructor(e = null, r = {}) {
+    super();
+    h(this, "Ae");
+    h(this, "vs");
+    h(this, "Ee");
+    h(this, "bs");
+    h(this, "ws");
+    h(this, "Cs", null);
+    h(this, "$s", 0);
+    h(this, "Fs");
+    h(this, "Ts", !0);
+    h(this, "Ds", 0);
+    h(this, "Ms", 0);
+    h(this, "Ss", 0);
+    h(this, "Rs", []);
+    h(this, "Vs", 10);
+    h(this, "ks", !1);
+    h(this, "zs", !1);
+    h(this, "Is", () => {
+    });
+    h(this, "Ps", () => {
+    });
+    h(this, "Us");
+    this.Ae = e, this.zs = e === null, this.bs = r.renderMode ?? "auto", this.ws = r.frameRate ?? 60, this.Fs = 1e3 / this.ws;
+  }
+  static async create(e = null, r = {}) {
+    const s = new this(e, r), i = s.zs ? r : void 0;
+    let o, n;
+    s.textmodeCanvas = new ct(s.captureSource, s.zs, i), s.Zt = new st(s.textmodeCanvas.He()), s.zs ? (o = r.width || 800, n = r.height || 600) : (o = s.textmodeCanvas.width || 800, n = s.textmodeCanvas.height || 600), s.vs = s.Zt.Et(o, n), s.oe = new ht(s.Zt, r.fontSize ?? 16), await s.oe.ve(r.fontSource);
+    const l = s.oe.maxGlyphDimensions;
+    return s.je = new lt(s.textmodeCanvas.canvas, l.width, l.height), s._s = new ft(s.Zt, s.oe, s.je), s.As(), s.Gs(), s;
+  }
+  As() {
+    this.Us = () => {
+      this.zs ? this.Ps() : this.Es();
+    }, window.addEventListener("resize", this.Us), window.ResizeObserver && this.Ae && !this.zs && (this.Ee = new ResizeObserver(() => {
+      this.Es();
+    }), this.Ee.observe(this.Ae));
+  }
+  render() {
+    this.Ls(), this.Ss++, this.ks ? console.warn("Cannot render: Required resources have been disposed") : (this.zs ? (this.vs.begin(), this.Is(), this.vs.end()) : this.vs.update(this.Ae), this._s.hasEnabledConverters() ? (this._s._r(this.vs), this.Zt.Lt(0), this.Zt.Ot(this._s.texture, this.je.offsetX, this.je.offsetY, this._s.texture.width, this._s.texture.height)) : (this.Zt.Bt(), this.Zt.Ot(this.vs, this.je.offsetX, this.je.offsetY, this.vs.width, this.vs.height)));
+  }
+  Es() {
+    this.textmodeCanvas.Pe(), this.vs.resize(this.textmodeCanvas.width, this.textmodeCanvas.height), this.je.Pe(), this._s.Pe(), this.Zt.Ht(), this.bs !== "manual" && this.render();
+  }
+  Gs() {
+    if (this.bs !== "auto" || !this.Ts) return;
+    this.$s = performance.now();
+    const e = (r) => {
+      if (!this.Ts) return void (this.Cs = null);
+      const s = r - this.$s;
+      s >= this.Fs && (this.render(), this.$s = r - s % this.Fs), this.Ts && (this.Cs = requestAnimationFrame(e));
+    };
+    this.Cs = requestAnimationFrame(e);
+  }
+  Ls() {
+    const e = performance.now();
+    if (this.Ms > 0) {
+      const r = e - this.Ms;
+      this.Rs.push(r), this.Rs.length > this.Vs && this.Rs.shift();
+      const s = this.Rs.reduce((i, o) => i + o, 0) / this.Rs.length;
+      this.Ds = 1e3 / s;
+    }
+    this.Ms = e;
+  }
+  Bs() {
+    this.Cs && (cancelAnimationFrame(this.Cs), this.Cs = null);
+  }
+  renderMode(e) {
+    this.bs !== e && (this.Bs(), this.bs = e, e === "auto" && this.Ts && this.Gs());
+  }
+  frameRate(e) {
+    if (e === void 0) return this.Ds;
+    this.ws = e, this.Fs = 1e3 / e, this.bs === "auto" && this.Ts && (this.Bs(), this.Gs());
+  }
+  noLoop() {
+    this.Ts && (this.Ts = !1, this.Cs && (cancelAnimationFrame(this.Cs), this.Cs = null));
+  }
+  loop() {
+    this.Ts || (this.Ts = !0, this.bs === "auto" && this.Gs());
+  }
+  redraw(e = 1) {
+    if (C.p(typeof e == "number" && e > 0 && Number.isInteger(e), "Redraw count must be a positive integer.", { method: "redraw", providedValue: e })) for (let r = 0; r < e; r++) this.render();
+  }
+  isLooping() {
+    return this.bs === "auto" && this.Ts;
+  }
+  draw(e) {
+    this.Is = e;
+  }
+  windowResized(e) {
+    this.Ps = e;
+  }
+  resizeCanvas(e, r) {
+    this.textmodeCanvas.Pe(e, r), this.vs.resize(this.textmodeCanvas.width, this.textmodeCanvas.height), this.je.Pe(), this._s.Pe(), this.Zt.Ht(), this.bs !== "manual" && this.render();
+  }
+  destroy() {
+    this.ks || (this.Bs(), window.removeEventListener("resize", this.Us), this.Ee && this.Ee.disconnect(), this._s.P(), this.oe.P(), this.vs.P(), this.Zt.P(), this.ks = !0);
+  }
+  get grid() {
+    return this.je;
+  }
+  get font() {
+    return this.oe;
+  }
+  get mode() {
+    return this.bs;
+  }
+  get pipeline() {
+    return this._s;
+  }
+  get frameCount() {
+    return this.Ss;
+  }
+  set frameCount(e) {
+    this.Ss = e;
+  }
+  get width() {
+    return this.textmodeCanvas.width;
+  }
+  get height() {
+    return this.textmodeCanvas.height;
+  }
+  get isDisposed() {
+    return this.ks;
+  }
+}
+class N {
+  static async create(t, e = {}) {
+    if (t instanceof HTMLCanvasElement || t instanceof HTMLVideoElement) return O.create(t, e);
+    {
+      const r = t || {};
+      return O.create(null, r);
+    }
+  }
+  static setErrorLevel(t) {
+    C._(t);
+  }
+  static get version() {
+    return "0.1.6-beta.7";
+  }
+}
+const St = Object.freeze(Object.defineProperty({ __proto__: null }, Symbol.toStringTag, { value: "Module" })), Zt = N.create, $t = N.setErrorLevel, Bt = N.version;
+export {
+  ct as TextmodeCanvas,
+  ft as TextmodeConversionPipeline,
+  tt as TextmodeErrorLevel,
+  ht as TextmodeFont,
+  lt as TextmodeGrid,
+  O as Textmodifier,
+  Ut as converters,
+  Zt as create,
+  St as export,
+  $t as setErrorLevel,
+  N as textmode,
+  Bt as version
+};