@shopify/klint 0.2.0 → 0.3.0

package/dist/plugins/index.js

@@ -0,0 +1,2489 @@
+import "../chunk-3RG5ZIWI.js";
+
+// src/plugins/FontParser.tsx
+var BinaryReader = class {
+  constructor() {
+    const ab = new ArrayBuffer(8);
+    this.t = {
+      buff: ab,
+      int8: new Int8Array(ab),
+      uint8: new Uint8Array(ab),
+      int16: new Int16Array(ab),
+      uint16: new Uint16Array(ab),
+      int32: new Int32Array(ab),
+      uint32: new Uint32Array(ab)
+    };
+  }
+  readFixed(data, o) {
+    return (data[o] << 8 | data[o + 1]) + (data[o + 2] << 8 | data[o + 3]) / (256 * 256 + 4);
+  }
+  readF2dot14(data, o) {
+    const num = this.readShort(data, o);
+    return num / 16384;
+  }
+  readInt(buff, p) {
+    const a = this.t.uint8;
+    a[0] = buff[p + 3];
+    a[1] = buff[p + 2];
+    a[2] = buff[p + 1];
+    a[3] = buff[p];
+    return this.t.int32[0];
+  }
+  readInt8(buff, p) {
+    const a = this.t.uint8;
+    a[0] = buff[p];
+    return this.t.int8[0];
+  }
+  readShort(buff, p) {
+    const a = this.t.uint16;
+    a[0] = buff[p] << 8 | buff[p + 1];
+    return this.t.int16[0];
+  }
+  readUshort(buff, p) {
+    return buff[p] << 8 | buff[p + 1];
+  }
+  readUshorts(buff, p, len) {
+    const arr = [];
+    for (let i = 0; i < len; i++) {
+      arr.push(this.readUshort(buff, p + i * 2));
+    }
+    return arr;
+  }
+  readUint(buff, p) {
+    const a = this.t.uint8;
+    a[3] = buff[p];
+    a[2] = buff[p + 1];
+    a[1] = buff[p + 2];
+    a[0] = buff[p + 3];
+    return this.t.uint32[0];
+  }
+  readUint64(buff, p) {
+    return this.readUint(buff, p) * (4294967295 + 1) + this.readUint(buff, p + 4);
+  }
+  readASCII(buff, p, l) {
+    let s = "";
+    for (let i = 0; i < l; i++) s += String.fromCharCode(buff[p + i]);
+    return s;
+  }
+  readBytes(buff, p, l) {
+    const arr = [];
+    for (let i = 0; i < l; i++) arr.push(buff[p + i]);
+    return arr;
+  }
+};
+var bin = new BinaryReader();
+function findTable(data, tab, foff = 0) {
+  const numTables = bin.readUshort(data, foff + 4);
+  let offset = foff + 12;
+  for (let i = 0; i < numTables; i++) {
+    const tag = bin.readASCII(data, offset, 4);
+    const checkSum = bin.readUint(data, offset + 4);
+    const toffset = bin.readUint(data, offset + 8);
+    const length = bin.readUint(data, offset + 12);
+    if (tag === tab) return [toffset, length];
+    offset += 16;
+  }
+  return null;
+}
+var Tables = {
+  head: {
+    parseTab(data, offset, length) {
+      const obj = {};
+      const tableVersion = bin.readFixed(data, offset);
+      offset += 4;
+      obj.fontRevision = bin.readFixed(data, offset);
+      offset += 4;
+      const checkSumAdjustment = bin.readUint(data, offset);
+      offset += 4;
+      const magicNumber = bin.readUint(data, offset);
+      offset += 4;
+      obj.flags = bin.readUshort(data, offset);
+      offset += 2;
+      obj.unitsPerEm = bin.readUshort(data, offset);
+      offset += 2;
+      obj.created = bin.readUint64(data, offset);
+      offset += 8;
+      obj.modified = bin.readUint64(data, offset);
+      offset += 8;
+      obj.xMin = bin.readShort(data, offset);
+      offset += 2;
+      obj.yMin = bin.readShort(data, offset);
+      offset += 2;
+      obj.xMax = bin.readShort(data, offset);
+      offset += 2;
+      obj.yMax = bin.readShort(data, offset);
+      offset += 2;
+      obj.macStyle = bin.readUshort(data, offset);
+      offset += 2;
+      obj.lowestRecPPEM = bin.readUshort(data, offset);
+      offset += 2;
+      obj.fontDirectionHint = bin.readShort(data, offset);
+      offset += 2;
+      obj.indexToLocFormat = bin.readShort(data, offset);
+      offset += 2;
+      obj.glyphDataFormat = bin.readShort(data, offset);
+      offset += 2;
+      return obj;
+    }
+  },
+  maxp: {
+    parseTab(data, offset, length) {
+      const obj = {};
+      const ver = bin.readUint(data, offset);
+      offset += 4;
+      obj.numGlyphs = bin.readUshort(data, offset);
+      offset += 2;
+      return obj;
+    }
+  },
+  hhea: {
+    parseTab(data, offset, length) {
+      const obj = {};
+      const tableVersion = bin.readFixed(data, offset);
+      offset += 4;
+      const keys = [
+        "ascender",
+        "descender",
+        "lineGap",
+        "advanceWidthMax",
+        "minLeftSideBearing",
+        "minRightSideBearing",
+        "xMaxExtent",
+        "caretSlopeRise",
+        "caretSlopeRun",
+        "caretOffset",
+        "res0",
+        "res1",
+        "res2",
+        "res3",
+        "metricDataFormat",
+        "numberOfHMetrics"
+      ];
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const func = key === "advanceWidthMax" || key === "numberOfHMetrics" ? bin.readUshort : bin.readShort;
+        obj[key] = func.call(bin, data, offset + i * 2);
+      }
+      return obj;
+    }
+  },
+  hmtx: {
+    parseTab(data, offset, length, font) {
+      const aWidth = [];
+      const lsBearing = [];
+      const nG = font.maxp.numGlyphs;
+      const nH = font.hhea.numberOfHMetrics;
+      let aw = 0, lsb = 0, i = 0;
+      while (i < nH) {
+        aw = bin.readUshort(data, offset + (i << 2));
+        lsb = bin.readShort(data, offset + (i << 2) + 2);
+        aWidth.push(aw);
+        lsBearing.push(lsb);
+        i++;
+      }
+      while (i < nG) {
+        aWidth.push(aw);
+        lsBearing.push(lsb);
+        i++;
+      }
+      return { aWidth, lsBearing };
+    }
+  },
+  loca: {
+    parseTab(data, offset, length, font) {
+      const obj = [];
+      const ver = font.head.indexToLocFormat;
+      const len = font.maxp.numGlyphs + 1;
+      if (ver === 0) {
+        for (let i = 0; i < len; i++) {
+          obj.push(bin.readUshort(data, offset + (i << 1)) << 1);
+        }
+      }
+      if (ver === 1) {
+        for (let i = 0; i < len; i++) {
+          obj.push(bin.readUint(data, offset + (i << 2)));
+        }
+      }
+      return obj;
+    }
+  },
+  kern: {
+    parseTab(data, offset, length, font) {
+      const version = bin.readUshort(data, offset);
+      if (version === 1) return this.parseV1(data, offset, length, font);
+      const nTables = bin.readUshort(data, offset + 2);
+      offset += 4;
+      const map = { glyph1: [], rval: [] };
+      for (let i = 0; i < nTables; i++) {
+        offset += 2;
+        const length2 = bin.readUshort(data, offset);
+        offset += 2;
+        const coverage = bin.readUshort(data, offset);
+        offset += 2;
+        let format = coverage >>> 8;
+        format &= 15;
+        if (format === 0) offset = this.readFormat0(data, offset, map);
+      }
+      return map;
+    },
+    parseV1(data, offset, length, font) {
+      const version = bin.readFixed(data, offset);
+      const nTables = bin.readUint(data, offset + 4);
+      offset += 8;
+      const map = { glyph1: [], rval: [] };
+      for (let i = 0; i < nTables; i++) {
+        const length2 = bin.readUint(data, offset);
+        offset += 4;
+        const coverage = bin.readUshort(data, offset);
+        offset += 2;
+        const tupleIndex = bin.readUshort(data, offset);
+        offset += 2;
+        const format = coverage & 255;
+        if (format === 0) offset = this.readFormat0(data, offset, map);
+      }
+      return map;
+    },
+    readFormat0(data, offset, map) {
+      let pleft = -1;
+      const nPairs = bin.readUshort(data, offset);
+      const searchRange = bin.readUshort(data, offset + 2);
+      const entrySelector = bin.readUshort(data, offset + 4);
+      const rangeShift = bin.readUshort(data, offset + 6);
+      offset += 8;
+      for (let j = 0; j < nPairs; j++) {
+        const left = bin.readUshort(data, offset);
+        offset += 2;
+        const right = bin.readUshort(data, offset);
+        offset += 2;
+        const value = bin.readShort(data, offset);
+        offset += 2;
+        if (left !== pleft) {
+          map.glyph1.push(left);
+          map.rval.push({ glyph2: [], vals: [] });
+        }
+        const rval = map.rval[map.rval.length - 1];
+        rval.glyph2.push(right);
+        rval.vals.push(value);
+        pleft = left;
+      }
+      return offset;
+    }
+  }
+};
+var cmap = {
+  parseTab(data, offset, length) {
+    const obj = { tables: [], ids: {}, off: offset };
+    data = new Uint8Array(data.buffer, offset, length);
+    offset = 0;
+    const version = bin.readUshort(data, offset);
+    offset += 2;
+    const numTables = bin.readUshort(data, offset);
+    offset += 2;
+    const offs = [];
+    for (let i = 0; i < numTables; i++) {
+      const platformID = bin.readUshort(data, offset);
+      offset += 2;
+      const encodingID = bin.readUshort(data, offset);
+      offset += 2;
+      const noffset = bin.readUint(data, offset);
+      offset += 4;
+      const id = "p" + platformID + "e" + encodingID;
+      let tind = offs.indexOf(noffset);
+      if (tind === -1) {
+        tind = obj.tables.length;
+        let subt = {};
+        offs.push(noffset);
+        const format = subt.format = bin.readUshort(data, noffset);
+        if (format === 0) subt = this.parse0(data, noffset, subt);
+        else if (format === 4) subt = this.parse4(data, noffset, subt);
+        else if (format === 6) subt = this.parse6(data, noffset, subt);
+        else if (format === 12) subt = this.parse12(data, noffset, subt);
+        obj.tables.push(subt);
+      }
+      obj.ids[id] = tind;
+    }
+    return obj;
+  },
+  parse0(data, offset, obj) {
+    const startOffset = offset;
+    const format = bin.readUshort(data, offset);
+    offset += 2;
+    const length = bin.readUshort(data, offset);
+    offset += 2;
+    const language = bin.readUshort(data, offset);
+    offset += 2;
+    obj.map = [];
+    for (let i = 0; i < 256; i++) obj.map.push(data[offset + i]);
+    return obj;
+  },
+  parse4(data, offset, obj) {
+    const startOffset = offset;
+    const format = bin.readUshort(data, offset);
+    offset += 2;
+    const length = bin.readUshort(data, offset);
+    offset += 2;
+    const language = bin.readUshort(data, offset);
+    offset += 2;
+    const segCountX2 = bin.readUshort(data, offset);
+    offset += 2;
+    const segCount = segCountX2 >>> 1;
+    obj.searchRange = bin.readUshort(data, offset);
+    offset += 2;
+    obj.entrySelector = bin.readUshort(data, offset);
+    offset += 2;
+    obj.rangeShift = bin.readUshort(data, offset);
+    offset += 2;
+    obj.endCount = bin.readUshorts(data, offset, segCount);
+    offset += segCount * 2;
+    offset += 2;
+    obj.startCount = bin.readUshorts(data, offset, segCount);
+    offset += segCount * 2;
+    obj.idDelta = [];
+    for (let i = 0; i < segCount; i++) {
+      obj.idDelta.push(bin.readShort(data, offset));
+      offset += 2;
+    }
+    obj.idRangeOffset = bin.readUshorts(data, offset, segCount);
+    offset += segCount * 2;
+    obj.glyphIdArray = bin.readUshorts(
+      data,
+      offset,
+      startOffset + length - offset >> 1
+    );
+    return obj;
+  },
+  parse6(data, offset, obj) {
+    const startOffset = offset;
+    const format = bin.readUshort(data, offset);
+    offset += 2;
+    const length = bin.readUshort(data, offset);
+    offset += 2;
+    const language = bin.readUshort(data, offset);
+    offset += 2;
+    obj.firstCode = bin.readUshort(data, offset);
+    offset += 2;
+    obj.entryCount = bin.readUshort(data, offset);
+    offset += 2;
+    obj.glyphIdArray = bin.readUshorts(data, offset, obj.entryCount);
+    return obj;
+  },
+  parse12(data, offset, obj) {
+    const startOffset = offset;
+    offset += 4;
+    const length = bin.readUint(data, offset);
+    offset += 4;
+    const language = bin.readUint(data, offset);
+    offset += 4;
+    const nGroups = bin.readUint(data, offset) * 3;
+    offset += 4;
+    obj.groups = new Uint32Array(nGroups);
+    for (let i = 0; i < nGroups; i += 3) {
+      obj.groups[i] = bin.readUint(data, offset + (i << 2));
+      obj.groups[i + 1] = bin.readUint(data, offset + (i << 2) + 4);
+      obj.groups[i + 2] = bin.readUint(data, offset + (i << 2) + 8);
+    }
+    return obj;
+  }
+};
+var glyf = {
+  parseTab(data, offset, length, font) {
+    const obj = [];
+    const ng = font.maxp.numGlyphs;
+    for (let g = 0; g < ng; g++) obj.push(null);
+    return obj;
+  },
+  parseGlyf(font, g) {
+    const data = font._data;
+    const loca = font.loca;
+    if (loca[g] === loca[g + 1]) return null;
+    const offset = findTable(data, "glyf", font._offset)[0] + loca[g];
+    const gl = {};
+    gl.noc = bin.readShort(data, offset);
+    let off = offset + 2;
+    gl.xMin = bin.readShort(data, off);
+    off += 2;
+    gl.yMin = bin.readShort(data, off);
+    off += 2;
+    gl.xMax = bin.readShort(data, off);
+    off += 2;
+    gl.yMax = bin.readShort(data, off);
+    off += 2;
+    if (gl.xMin >= gl.xMax || gl.yMin >= gl.yMax) return null;
+    if (gl.noc > 0) {
+      gl.endPts = [];
+      for (let i = 0; i < gl.noc; i++) {
+        gl.endPts.push(bin.readUshort(data, off));
+        off += 2;
+      }
+      const instructionLength = bin.readUshort(data, off);
+      off += 2;
+      if (data.length - off < instructionLength) return null;
+      gl.instructions = bin.readBytes(data, off, instructionLength);
+      off += instructionLength;
+      const crdnum = gl.endPts[gl.noc - 1] + 1;
+      gl.flags = [];
+      for (let i = 0; i < crdnum; i++) {
+        const flag = data[off];
+        off++;
+        gl.flags.push(flag);
+        if ((flag & 8) !== 0) {
+          const rep = data[off];
+          off++;
+          for (let j = 0; j < rep; j++) {
+            gl.flags.push(flag);
+            i++;
+          }
+        }
+      }
+      gl.xs = [];
+      for (let i = 0; i < crdnum; i++) {
+        const i8 = (gl.flags[i] & 2) !== 0;
+        const same = (gl.flags[i] & 16) !== 0;
+        if (i8) {
+          gl.xs.push(same ? data[off] : -data[off]);
+          off++;
+        } else {
+          if (same) gl.xs.push(0);
+          else {
+            gl.xs.push(bin.readShort(data, off));
+            off += 2;
+          }
+        }
+      }
+      gl.ys = [];
+      for (let i = 0; i < crdnum; i++) {
+        const i8 = (gl.flags[i] & 4) !== 0;
+        const same = (gl.flags[i] & 32) !== 0;
+        if (i8) {
+          gl.ys.push(same ? data[off] : -data[off]);
+          off++;
+        } else {
+          if (same) gl.ys.push(0);
+          else {
+            gl.ys.push(bin.readShort(data, off));
+            off += 2;
+          }
+        }
+      }
+      let x = 0, y = 0;
+      for (let i = 0; i < crdnum; i++) {
+        x += gl.xs[i];
+        y += gl.ys[i];
+        gl.xs[i] = x;
+        gl.ys[i] = y;
+      }
+    } else {
+      const ARG_1_AND_2_ARE_WORDS = 1;
+      const ARGS_ARE_XY_VALUES = 2;
+      const WE_HAVE_A_SCALE = 8;
+      const MORE_COMPONENTS = 32;
+      const WE_HAVE_AN_X_AND_Y_SCALE = 64;
+      const WE_HAVE_A_TWO_BY_TWO = 128;
+      const WE_HAVE_INSTRUCTIONS = 256;
+      gl.parts = [];
+      let flags;
+      do {
+        flags = bin.readUshort(data, off);
+        off += 2;
+        const part = {
+          m: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
+          p1: -1,
+          p2: -1
+        };
+        gl.parts.push(part);
+        part.glyphIndex = bin.readUshort(data, off);
+        off += 2;
+        let arg1, arg2;
+        if (flags & ARG_1_AND_2_ARE_WORDS) {
+          arg1 = bin.readShort(data, off);
+          off += 2;
+          arg2 = bin.readShort(data, off);
+          off += 2;
+        } else {
+          arg1 = bin.readInt8(data, off);
+          off++;
+          arg2 = bin.readInt8(data, off);
+          off++;
+        }
+        if (flags & ARGS_ARE_XY_VALUES) {
+          part.m.tx = arg1;
+          part.m.ty = arg2;
+        } else {
+          part.p1 = arg1;
+          part.p2 = arg2;
+        }
+        if (flags & WE_HAVE_A_SCALE) {
+          part.m.a = part.m.d = bin.readF2dot14(data, off);
+          off += 2;
+        } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
+          part.m.a = bin.readF2dot14(data, off);
+          off += 2;
+          part.m.d = bin.readF2dot14(data, off);
+          off += 2;
+        } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
+          part.m.a = bin.readF2dot14(data, off);
+          off += 2;
+          part.m.b = bin.readF2dot14(data, off);
+          off += 2;
+          part.m.c = bin.readF2dot14(data, off);
+          off += 2;
+          part.m.d = bin.readF2dot14(data, off);
+          off += 2;
+        }
+      } while (flags & MORE_COMPONENTS);
+      if (flags & WE_HAVE_INSTRUCTIONS) {
+        const numInstr = bin.readUshort(data, off);
+        off += 2;
+        gl.instr = [];
+        for (let i = 0; i < numInstr; i++) {
+          gl.instr.push(data[off]);
+          off++;
+        }
+      }
+    }
+    return gl;
+  }
+};
+var VariableTables = {
+  fvar: {
+    parseTab(data, offset, length, obj) {
+      const name = obj.name;
+      let off = offset;
+      const axes = [];
+      const inst = [];
+      off += 8;
+      const acnt = bin.readUshort(data, off);
+      off += 2;
+      off += 2;
+      const icnt = bin.readUshort(data, off);
+      off += 2;
+      const isiz = bin.readUshort(data, off);
+      off += 2;
+      for (let i = 0; i < acnt; i++) {
+        const tag = bin.readASCII(data, off, 4);
+        const min = bin.readFixed(data, off + 4);
+        const def = bin.readFixed(data, off + 8);
+        const max = bin.readFixed(data, off + 12);
+        const flg = bin.readUshort(data, off + 16);
+        const nid = bin.readUshort(data, off + 18);
+        axes.push([tag, min, def, max, flg, name ? name["_" + nid] : null]);
+        off += 20;
+      }
+      for (let i = 0; i < icnt; i++) {
+        const snid = bin.readUshort(data, off);
+        let pnid = null;
+        const flg = bin.readUshort(data, off + 2);
+        const crd = [];
+        for (let j = 0; j < acnt; j++) {
+          crd.push(bin.readFixed(data, off + 4 + j * 4));
+        }
+        off += 4 + acnt * 4;
+        if ((isiz & 3) === 2) {
+          pnid = bin.readUshort(data, off);
+          off += 2;
+        }
+        inst.push([name ? name["_" + snid] : null, flg, crd, pnid]);
+      }
+      return [axes, inst];
+    }
+  },
+  avar: {
+    parseTab(data, offset, length, obj) {
+      let off = offset;
+      const out = [];
+      off += 6;
+      const acnt = bin.readUshort(data, off);
+      off += 2;
+      for (let ai = 0; ai < acnt; ai++) {
+        const cnt = bin.readUshort(data, off);
+        off += 2;
+        const poly = [];
+        out.push(poly);
+        for (let i = 0; i < cnt; i++) {
+          const x = bin.readF2dot14(data, off);
+          const y = bin.readF2dot14(data, off + 2);
+          off += 4;
+          poly.push(x, y);
+        }
+      }
+      return out;
+    }
+  },
+  gvar: {
+    parseTab(data, offset, length, obj) {
+      const EMBEDDED_PEAK_TUPLE = 32768;
+      const INTERMEDIATE_REGION = 16384;
+      const PRIVATE_POINT_NUMBERS = 8192;
+      const DELTAS_ARE_ZERO = 128;
+      const DELTAS_ARE_WORDS = 64;
+      const POINTS_ARE_WORDS = 128;
+      const SHARED_POINT_NUMBERS = 32768;
+      function readTuple(data2, o, acnt2) {
+        const tup = [];
+        for (let j = 0; j < acnt2; j++)
+          tup.push(bin.readF2dot14(data2, o + j * 2));
+        return tup;
+      }
+      function readTupleVarHeader(data2, off2, vcnt, acnt2, eoff) {
+        const out = [];
+        for (let j = 0; j < vcnt; j++) {
+          const dsiz = bin.readUshort(data2, off2);
+          off2 += 2;
+          const tind = bin.readUshort(data2, off2);
+          const flag = tind & 61440;
+          const tupleIndex = tind & 4095;
+          off2 += 2;
+          let peak = null, start = null, end = null;
+          if (flag & EMBEDDED_PEAK_TUPLE) {
+            peak = readTuple(data2, off2, acnt2);
+            off2 += acnt2 * 2;
+          }
+          if (flag & INTERMEDIATE_REGION) {
+            start = readTuple(data2, off2, acnt2);
+            off2 += acnt2 * 2;
+          }
+          if (flag & INTERMEDIATE_REGION) {
+            end = readTuple(data2, off2, acnt2);
+            off2 += acnt2 * 2;
+          }
+          out.push([dsiz, tupleIndex, flag, start, peak, end]);
+        }
+        return out;
+      }
+      function readPointNumbers(data2, off2, gid) {
+        let cnt = data2[off2];
+        off2++;
+        if (cnt === 0) return [[], off2];
+        if (127 < cnt) {
+          cnt = (cnt & 127) << 8 | data2[off2++];
+        }
+        const pts = [];
+        let last = 0;
+        while (pts.length < cnt) {
+          const v = data2[off2];
+          off2++;
+          const wds = (v & POINTS_ARE_WORDS) !== 0;
+          const runLength = (v & 127) + 1;
+          for (let i = 0; i < runLength; i++) {
+            let dif = 0;
+            if (wds) {
+              dif = bin.readUshort(data2, off2);
+              off2 += 2;
+            } else {
+              dif = data2[off2];
+              off2++;
+            }
+            last += dif;
+            pts.push(last);
+          }
+        }
+        return [pts, off2];
+      }
+      let off = offset + 4;
+      const acnt = bin.readUshort(data, off);
+      off += 2;
+      const tcnt = bin.readUshort(data, off);
+      off += 2;
+      const toff = bin.readUint(data, off);
+      off += 4;
+      const gcnt = bin.readUshort(data, off);
+      off += 2;
+      const flgs = bin.readUshort(data, off);
+      off += 2;
+      const goff = bin.readUint(data, off);
+      off += 4;
+      const offs = [];
+      for (let i = 0; i < gcnt + 1; i++) {
+        offs.push(bin.readUint(data, off + i * 4));
+      }
+      const tups = [], mins = [], maxs = [];
+      off = offset + toff;
+      for (let i = 0; i < tcnt; i++) {
+        const peak = readTuple(data, off + i * acnt * 2, acnt);
+        const imin = [], imax = [];
+        tups.push(peak);
+        mins.push(imin);
+        maxs.push(imax);
+        for (let k = 0; k < acnt; k++) {
+          imin[k] = Math.min(peak[k], 0);
+          imax[k] = Math.max(peak[k], 0);
+        }
+      }
+      const i8 = new Int8Array(data.buffer);
+      const tabs = [];
+      for (let i = 0; i < gcnt; i++) {
+        off = offset + goff + offs[i];
+        let vcnt = bin.readUshort(data, off);
+        off += 2;
+        const snum = vcnt & SHARED_POINT_NUMBERS;
+        vcnt &= 4095;
+        const soff = bin.readUshort(data, off);
+        off += 2;
+        const hdr = readTupleVarHeader(
+          data,
+          off,
+          vcnt,
+          acnt,
+          offset + goff + offs[i + 1]
+        );
+        const tab = [];
+        tabs.push(tab);
+        off = offset + goff + offs[i] + soff;
+        let sind = [];
+        if (snum) {
+          const oo = readPointNumbers(data, off, i);
+          sind = oo[0];
+          off = oo[1];
+        }
+        for (let j = 0; j < vcnt; j++) {
+          const vr = hdr[j];
+          const end = off + vr[0];
+          let ind = sind;
+          if (vr[2] & PRIVATE_POINT_NUMBERS) {
+            const oo = readPointNumbers(data, off, i);
+            ind = oo[0];
+            off = oo[1];
+          }
+          const ds = [];
+          while (off < end) {
+            const cb = data[off++];
+            const cnt = (cb & 63) + 1;
+            if (cb & DELTAS_ARE_ZERO) {
+              for (let k = 0; k < cnt; k++) ds.push(0);
+            } else if (cb & DELTAS_ARE_WORDS) {
+              for (let k = 0; k < cnt; k++) {
+                ds.push(bin.readShort(data, off + k * 2));
+              }
+              off += cnt * 2;
+            } else {
+              for (let k = 0; k < cnt; k++) ds.push(i8[off + k]);
+              off += cnt;
+            }
+          }
+          const ti = vr[1];
+          tab.push([
+            [
+              vr[3] ? vr[3] : mins[ti],
+              vr[4] ? vr[4] : tups[ti],
+              vr[5] ? vr[5] : maxs[ti]
+            ],
+            ds,
+            ind.length == 0 ? null : ind
+          ]);
+          if (ind.length != 0 && ind.length * 2 != ds.length) throw "e";
+        }
+      }
+      return tabs;
+    }
+  },
+  HVAR: {
+    parseTab(data, offset, length, obj) {
+      let off = offset;
+      const oo = offset;
+      off += 4;
+      const varO = bin.readUint(data, off);
+      off += 4;
+      const advO = bin.readUint(data, off);
+      off += 4;
+      const lsbO = bin.readUint(data, off);
+      off += 4;
+      const rsbO = bin.readUint(data, off);
+      off += 4;
+      if (lsbO !== 0 || rsbO !== 0) throw lsbO;
+      off = oo + varO;
+      const ioff = off;
+      const fmt = bin.readUshort(data, off);
+      off += 2;
+      if (fmt !== 1) throw "e";
+      const vregO = bin.readUint(data, off);
+      off += 4;
+      const vcnt = bin.readUshort(data, off);
+      off += 2;
+      const offs = [];
+      for (let i = 0; i < vcnt; i++) offs.push(bin.readUint(data, off + i * 4));
+      off += vcnt * 4;
+      off = ioff + vregO;
+      const acnt = bin.readUshort(data, off);
+      off += 2;
+      const rcnt = bin.readUshort(data, off);
+      off += 2;
+      const regs = [];
+      for (let i = 0; i < rcnt; i++) {
+        const crd = [[], [], []];
+        regs.push(crd);
+        for (let j = 0; j < acnt; j++) {
+          crd[0].push(bin.readF2dot14(data, off + 0));
+          crd[1].push(bin.readF2dot14(data, off + 2));
+          crd[2].push(bin.readF2dot14(data, off + 4));
+          off += 6;
+        }
+      }
+      const i8 = new Int8Array(data.buffer);
+      const varStore = [];
+      for (let i = 0; i < offs.length; i++) {
+        off = oo + varO + offs[i];
+        const vdata = [];
+        varStore.push(vdata);
+        const icnt = bin.readUshort(data, off);
+        off += 2;
+        const dcnt = bin.readUshort(data, off);
+        off += 2;
+        if (dcnt & 32768) throw "e";
+        const rcnt2 = bin.readUshort(data, off);
+        off += 2;
+        const ixs = [];
+        for (let j = 0; j < rcnt2; j++) {
+          ixs.push(bin.readUshort(data, off + j * 2));
+        }
+        off += rcnt2 * 2;
+        for (let k = 0; k < icnt; k++) {
+          const deltaData = [];
+          for (let ri = 0; ri < rcnt2; ri++) {
+            deltaData.push(ri < dcnt ? bin.readShort(data, off) : i8[off]);
+            off += ri < dcnt ? 2 : 1;
+          }
+          const dd = new Array(regs.length);
+          dd.fill(0);
+          vdata.push(dd);
+          for (let j = 0; j < ixs.length; j++) dd[ixs[j]] = deltaData[j];
+        }
+      }
+      off = oo + advO;
+      const fmt2 = data[off++];
+      if (fmt2 !== 0) throw "e";
+      const entryFormat = data[off++];
+      const mapCount = bin.readUshort(data, off);
+      off += 2;
+      const INNER_INDEX_BIT_COUNT_MASK = 15;
+      const MAP_ENTRY_SIZE_MASK = 48;
+      const entrySize = ((entryFormat & MAP_ENTRY_SIZE_MASK) >> 4) + 1;
+      const dfs = [];
+      for (let i = 0; i < mapCount; i++) {
+        let entry = 0;
+        if (entrySize === 1) entry = data[off++];
+        else {
+          entry = bin.readUshort(data, off);
+          off += 2;
+        }
+        const outerIndex = entry >> (entryFormat & INNER_INDEX_BIT_COUNT_MASK) + 1;
+        const innerIndex = entry & (1 << (entryFormat & INNER_INDEX_BIT_COUNT_MASK) + 1) - 1;
+        dfs.push(varStore[outerIndex][innerIndex]);
+      }
+      return [regs, dfs];
+    }
+  }
+};
+var PathBuilder = {
+  MoveTo(p, x, y) {
+    p.cmds.push("M");
+    p.crds.push(x, y);
+  },
+  LineTo(p, x, y) {
+    p.cmds.push("L");
+    p.crds.push(x, y);
+  },
+  qCurveTo(p, a, b, c, d) {
+    p.cmds.push("Q");
+    p.crds.push(a, b, c, d);
+  },
+  ClosePath(p) {
+    p.cmds.push("Z");
+  }
+};
+function codeToGlyph(font, code) {
+  if (font._ctab == null) {
+    const cmap2 = font.cmap;
+    let tind = -1;
+    const pps = [
+      "p3e10",
+      "p0e4",
+      "p3e1",
+      "p1e0",
+      "p0e3",
+      "p0e1",
+      "p3e0",
+      "p3e5"
+    ];
+    for (let i = 0; i < pps.length; i++) {
+      if (cmap2.ids[pps[i]] != null) {
+        tind = cmap2.ids[pps[i]];
+        break;
+      }
+    }
+    if (tind === -1) throw "no familiar platform and encoding!";
+    font._ctab = cmap2.tables[tind];
+  }
+  const tab = font._ctab;
+  const fmt = tab.format;
+  let gid = -1;
+  if (fmt === 0) {
+    if (code >= tab.map.length) gid = 0;
+    else gid = tab.map[code];
+  } else if (fmt === 4) {
+    const ec = tab.endCount;
+    gid = 0;
+    if (code <= ec[ec.length - 1]) {
+      let sind = arrSearch(ec, 1, code);
+      if (ec[sind] < code) sind++;
+      if (code >= tab.startCount[sind]) {
+        let gli = 0;
+        if (tab.idRangeOffset[sind] !== 0) {
+          gli = tab.glyphIdArray[code - tab.startCount[sind] + (tab.idRangeOffset[sind] >> 1) - (tab.idRangeOffset.length - sind)];
+        } else {
+          gli = code + tab.idDelta[sind];
+        }
+        gid = gli & 65535;
+      }
+    }
+  } else if (fmt === 6) {
+    const off = code - tab.firstCode;
+    const arr = tab.glyphIdArray;
+    if (off < 0 || off >= arr.length) gid = 0;
+    else gid = arr[off];
+  } else if (fmt === 12) {
+    const grp = tab.groups;
+    gid = 0;
+    if (code <= grp[grp.length - 2]) {
+      const i = arrSearch(grp, 3, code);
+      if (grp[i] <= code && code <= grp[i + 1]) {
+        gid = grp[i + 2] + (code - grp[i]);
+      }
+    }
+  } else {
+    throw "unknown cmap table format " + tab.format;
+  }
+  return gid;
+}
+function arrSearch(arr, k, v) {
+  let l = 0;
+  let r = Math.floor(arr.length / k);
+  while (l + 1 !== r) {
+    const mid = l + (r - l >>> 1);
+    if (arr[mid * k] <= v) l = mid;
+    else r = mid;
+  }
+  return l * k;
+}
+function getGlyphPosition(font, gls, i1) {
+  const g1 = gls[i1];
+  const g2 = gls[i1 + 1];
+  const kern = font.kern;
+  if (kern) {
+    const ind1 = kern.glyph1.indexOf(g1);
+    if (ind1 !== -1) {
+      const ind2 = kern.rval[ind1].glyph2.indexOf(g2);
+      if (ind2 !== -1) return [0, 0, kern.rval[ind1].vals[ind2], 0];
+    }
+  }
+  return [0, 0, 0, 0];
+}
+function normalizeAxis(font, vv) {
+  const fvar = font.fvar;
+  const avar = font.avar;
+  const fv = fvar ? fvar[0] : null;
+  const nv = [];
+  for (let i = 0; i < fv.length; i++) {
+    const min = fv[i][1];
+    const def = fv[i][2];
+    const max = fv[i][3];
+    const v = Math.max(min, Math.min(max, vv[i]));
+    if (v < def) nv[i] = (def - v) / (min - def);
+    else if (v > def) nv[i] = (v - def) / (max - def);
+    else nv[i] = 0;
+    if (avar && nv[i] !== -1) {
+      const av = avar[i];
+      let j = 0;
+      for (; j < av.length; j += 2) if (av[j] >= nv[i]) break;
+      const f = (nv[i] - av[j - 2]) / (av[j] - av[j - 2]);
+      nv[i] = f * av[j + 1] + (1 - f) * av[j - 1];
+    }
+  }
+  return nv;
+}
+function shape(font, str, prm = {}) {
+  let axs = prm.axs;
+  if (font.fvar && axs == null) axs = font.fvar[1][font._index || 0][2];
+  const HVAR = font.HVAR;
+  if (axs && HVAR) {
+    axs = normalizeAxis(font, axs);
+  }
+  const gls = [];
+  for (let i = 0; i < str.length; i++) {
+    const cc = str.codePointAt(i);
+    if (cc > 65535) i++;
+    gls.push(codeToGlyph(font, cc));
+  }
+  const shape2 = [];
+  let x = 0, y = 0;
+  for (let i = 0; i < gls.length; i++) {
+    const padj = getGlyphPosition(font, gls, i);
+    const gid = gls[i];
+    let ax = font.hmtx.aWidth[gid] + padj[2];
+    if (HVAR && HVAR[1][gid]) {
+      const difs = HVAR[1][gid];
+      for (let j = 0; j < HVAR[0].length; j++) {
+        ax += _interpolate(HVAR[0][j], axs) * difs[j];
+      }
+    }
+    shape2.push({ g: gid, cl: i, dx: 0, dy: 0, ax, ay: 0 });
+    x += ax;
+  }
+  return shape2;
+}
+function glyphToPath(font, gid, noColor, axs) {
+  const path = { cmds: [], crds: [] };
+  if (font.fvar) {
+    if (axs == null) axs = font.fvar[1][font._index || 0][2];
+    axs = normalizeAxis(font, axs);
+  }
+  if (font.glyf) {
+    drawGlyf(gid, font, path, axs);
+  }
+  return { cmds: path.cmds, crds: path.crds };
+}
+function drawGlyf(gid, font, path, axs) {
+  let gl = font.glyf[gid];
+  if (gl == null) {
+    gl = font.glyf[gid] = glyf.parseGlyf(font, gid);
+  }
+  if (gl != null) {
+    if (gl.noc > -1) simpleGlyph(gl, font, gid, path, axs);
+    else compoGlyph(gl, font, gid, path, axs);
+  }
+}
+function simpleGlyph(gl, font, gid, p, axs) {
+  let xs = gl.xs;
+  let ys = gl.ys;
+  if (font.fvar && axs) {
+    xs = xs.slice(0);
+    ys = ys.slice(0);
+    const gvar = font.gvar;
+    const gv = gvar ? gvar[gid] : null;
+    if (gv) {
+      for (let vi = 0; vi < gv.length; vi++) {
+        const axv = gv[vi][0];
+        const S = _interpolate(axv, axs);
+        if (S < 1e-9) continue;
+        let dfs = gv[vi][1];
+        const ind = gv[vi][2];
+        if (ind) {
+          dfs = gv[vi][1] = interpolateDeltas(dfs, ind, xs, ys, gl.endPts);
+          gv[vi][2] = null;
+        }
+        if (dfs.length === xs.length * 2 + 8) {
+          for (let i = 0; i < xs.length; i++) {
+            xs[i] += S * dfs[i];
+            ys[i] += S * dfs[i + xs.length + 4];
+          }
+        }
+      }
+    }
+  }
+  for (let c = 0; c < gl.noc; c++) {
+    const i0 = c === 0 ? 0 : gl.endPts[c - 1] + 1;
+    const il = gl.endPts[c];
+    for (let i = i0; i <= il; i++) {
+      const pr = i === i0 ? il : i - 1;
+      const nx = i === il ? i0 : i + 1;
+      const onCurve = gl.flags[i] & 1;
+      const prOnCurve = gl.flags[pr] & 1;
+      const nxOnCurve = gl.flags[nx] & 1;
+      const x = xs[i], y = ys[i];
+      if (i === i0) {
+        if (onCurve) {
+          if (prOnCurve) PathBuilder.MoveTo(p, xs[pr], ys[pr]);
+          else {
+            PathBuilder.MoveTo(p, x, y);
+            continue;
+          }
+        } else {
+          if (prOnCurve) PathBuilder.MoveTo(p, xs[pr], ys[pr]);
+          else
+            PathBuilder.MoveTo(
+              p,
+              Math.floor((xs[pr] + x) * 0.5),
+              Math.floor((ys[pr] + y) * 0.5)
+            );
+        }
+      }
+      if (onCurve) {
+        if (prOnCurve) PathBuilder.LineTo(p, x, y);
+      } else {
+        if (nxOnCurve) PathBuilder.qCurveTo(p, x, y, xs[nx], ys[nx]);
+        else
+          PathBuilder.qCurveTo(
+            p,
+            x,
+            y,
+            Math.floor((x + xs[nx]) * 0.5),
+            Math.floor((y + ys[nx]) * 0.5)
+          );
+      }
+    }
+    PathBuilder.ClosePath(p);
+  }
+}
+function compoGlyph(gl, font, gid, p, axs) {
+  const dx = [0, 0, 0, 0, 0, 0];
+  const dy = [0, 0, 0, 0, 0, 0];
+  const ccnt = gl.parts.length;
+  if (font.fvar && axs) {
+    const gvar = font.gvar;
+    const gv = gvar ? gvar[gid] : null;
+    if (gv) {
+      for (let vi = 0; vi < gv.length; vi++) {
+        const axv = gv[vi][0];
+        const S = _interpolate(axv, axs);
+        if (S < 1e-6) continue;
+        const dfs = gv[vi][1];
+        const ind = gv[vi][2];
+        if (ind == null) {
+          for (let i = 0; i < ccnt; i++) {
+            dx[i] += S * dfs[i];
+            dy[i] += S * dfs[i + ccnt + 4];
+          }
+        } else {
+          for (let j = 0; j < ind.length; j++) {
+            const i = ind[j];
+            dx[i] += S * dfs[0];
+            dy[i] += S * dfs[0 + ccnt];
+          }
+        }
+      }
+    }
+  }
+  for (let j = 0; j < ccnt; j++) {
+    const path = { cmds: [], crds: [] };
+    const prt = gl.parts[j];
+    drawGlyf(prt.glyphIndex, font, path, axs);
+    const m = prt.m;
+    const tx = m.tx + dx[j];
+    const ty = m.ty + dy[j];
+    for (let i = 0; i < path.crds.length; i += 2) {
+      const x = path.crds[i];
+      const y = path.crds[i + 1];
+      p.crds.push(x * m.a + y * m.c + tx);
+      p.crds.push(x * m.b + y * m.d + ty);
+    }
+    for (let i = 0; i < path.cmds.length; i++) p.cmds.push(path.cmds[i]);
+  }
+}
+function _interpolate(axs, v) {
+  var acnt = v.length, S = 1;
+  var s = axs[0];
+  var p = axs[1];
+  var e = axs[2];
+  for (var i = 0; i < v.length; i++) {
+    var AS = 1;
+    if (s[i] > p[i] || p[i] > e[i]) AS = 1;
+    else if (s[i] < 0 && e[i] > 0 && p[i] != 0) AS = 1;
+    else if (p[i] == 0) AS = 1;
+    else if (v[i] < s[i] || v[i] > e[i]) AS = 0;
+    else {
+      if (v[i] == p[i]) AS = 1;
+      else if (v[i] < p[i]) AS = (v[i] - s[i]) / (p[i] - s[i]);
+      else AS = (e[i] - v[i]) / (e[i] - p[i]);
+    }
+    S = S * AS;
+  }
+  return S;
+}
+function interpolateDeltas(dfs, ind, xs, ys, endPts) {
+  const N = xs.length;
+  const ndfs = new Array(N * 2 + 8);
+  ndfs.fill(0);
+  for (let i = 0; i < N; i++) {
+    let dx = 0, dy = 0;
+    const ii = ind.indexOf(i);
+    if (ii !== -1) {
+      dx = dfs[ii];
+      dy = dfs[ind.length + ii];
+    } else {
+      let cmp = 0;
+      while (endPts[cmp] < i) cmp++;
+      const cmp0 = cmp === 0 ? 0 : endPts[cmp - 1] + 1;
+      const cmp1 = endPts[cmp];
+      let i0 = -1, i1 = -1;
+      for (let j = 0; j < ind.length; j++) {
+        const v = ind[j];
+        if (v < cmp0 || v > cmp1 || v >= N) continue;
+        i0 = j;
+        if (i1 === -1) i1 = j;
+      }
+      for (let j = 0; j < ind.length; j++) {
+        const v = ind[j];
+        if (v < cmp0 || v > cmp1 || v >= N) continue;
+        if (v < i) i0 = j;
+        if (i < v) {
+          i1 = j;
+          break;
+        }
+      }
+      for (let ax = 0; ax < 2; ax++) {
+        const crd = ax === 0 ? xs : ys;
+        const ofs = ax * ind.length;
+        let dlt = 0;
+        const c0 = crd[ind[i0]];
+        const c1 = crd[ind[i1]];
+        const cC = crd[i];
+        const d0 = dfs[ofs + i0];
+        const d1 = dfs[ofs + i1];
+        if (c0 === c1) {
+          if (d0 === d1) dlt = d0;
+          else dlt = 0;
+        } else {
+          if (cC <= Math.min(c0, c1)) {
+            if (c0 < c1) dlt = d0;
+            else dlt = d1;
+          } else if (Math.max(c0, c1) <= cC) {
+            if (c0 < c1) dlt = d1;
+            else dlt = d0;
+          } else {
+            const prop = (cC - c0) / (c1 - c0);
+            dlt = prop * d1 + (1 - prop) * d0;
+          }
+        }
+        if (ax === 0) dx = dlt;
+        else dy = dlt;
+      }
+    }
+    ndfs[i] = dx;
+    ndfs[N + 4 + i] = dy;
+  }
+  return ndfs;
+}
+function shapeToPath(font, shape2, prm = {}) {
+  const tpath = { cmds: [], crds: [] };
+  let x = 0, y = 0;
+  const axs = prm.axs;
+  for (let i = 0; i < shape2.length; i++) {
+    const it = shape2[i];
+    const path = glyphToPath(font, it.g, false, axs);
+    const crds = path.crds;
+    for (let j = 0; j < crds.length; j += 2) {
+      tpath.crds.push(crds[j] + x + it.dx);
+      tpath.crds.push(crds[j + 1] + y + it.dy);
+    }
+    for (let j = 0; j < path.cmds.length; j++) {
+      tpath.cmds.push(path.cmds[j]);
+    }
+    x += it.ax;
+    y += it.ay;
+  }
+  return { cmds: tpath.cmds, crds: tpath.crds };
+}
+var FontUtils = class {
+  static parse(buff) {
+    const data = new Uint8Array(buff);
+    const tmap = {};
+    const font = readFont(data, 0, 0, tmap);
+    const fvar = font.fvar;
+    if (fvar) {
+      const out = [font];
+      for (let i = 0; i < fvar[1].length; i++) {
+        const fv = fvar[1][i];
+        const obj = {};
+        out.push(obj);
+        for (const p in font) obj[p] = font[p];
+        obj._index = i;
+        const name = obj.name = JSON.parse(
+          JSON.stringify(obj.name || {})
+        );
+        name.fontSubfamily = fv[0];
+        if (fv[3] == null) {
+          fv[3] = ((name.fontFamily || "Font") + "-" + (name.fontSubfamily || "Regular")).replace(/ /g, "");
+        }
+        name.postScriptName = fv[3];
+      }
+      return out;
+    }
+    return [font];
+  }
+};
+FontUtils.U = {
+  shape,
+  shapeToPath,
+  glyphToPath,
+  codeToGlyph
+};
+function readFont(data, idx, offset, tmap) {
+  const parsers = {
+    cmap,
+    head: Tables.head,
+    hhea: Tables.hhea,
+    maxp: Tables.maxp,
+    hmtx: Tables.hmtx,
+    loca: Tables.loca,
+    kern: Tables.kern,
+    glyf,
+    fvar: VariableTables.fvar,
+    gvar: VariableTables.gvar,
+    avar: VariableTables.avar,
+    HVAR: VariableTables.HVAR
+  };
+  const obj = { _data: data, _index: idx, _offset: offset };
+  for (const t in parsers) {
+    const tab = findTable(data, t, offset);
+    if (tab) {
+      const off = tab[0];
+      let tobj = tmap[off];
+      if (tobj == null) {
+        tobj = parsers[t].parseTab(data, off, tab[1], obj);
+      }
+      obj[t] = tmap[off] = tobj;
+    }
+  }
+  if (!obj.name) {
+    obj.name = { fontFamily: "Unknown", postScriptName: "Unknown" };
+  }
+  return obj;
+}
+var FontParser = class {
+  constructor() {
+    this.fonts = /* @__PURE__ */ new Map();
+  }
+  async load(url) {
+    const ext = url.split(".").pop()?.toLowerCase();
+    if (ext === "otf") {
+      console.warn("OTF not supported. Convert: http://convertio.co/otf-ttf/");
+      throw new Error("OTF not supported");
+    }
+    if (ext === "woff") {
+      console.warn(
+        "WOFF not supported. Convert: http://convertio.co/woff-ttf/"
+      );
+      throw new Error("WOFF not supported");
+    }
+    if (ext === "woff2") {
+      console.warn(
+        "WOFF2 not supported. Convert: http://convertio.co/woff2-ttf/"
+      );
+      throw new Error("WOFF2 not supported");
+    }
+    const response = await fetch(url);
+    if (!response.ok) throw new Error("Failed to load font");
+    const buffer = await response.arrayBuffer();
+    return this.loadFromBuffer(buffer);
+  }
+  loadFromBuffer(buffer) {
+    const fonts = FontUtils.parse(buffer);
+    return this.createAPI(fonts[0]);
+  }
+  createAPI(font) {
+    return {
+      // For compatibility with the test - expose the font directly
+      ...font,
+      // Real API implementation
+      toPaths(text, size = 100, options = {}) {
+        const layout = this.layoutText(font, text, size, options);
+        const letters = [];
+        const scale = size / font.head.unitsPerEm;
+        const axisValues = options.axisValues || (font.fvar ? font.fvar[1][font._index || 0][2] : null);
+        for (const letter of layout.letters) {
+          const path2D = new Path2D();
+          const glyphPath = FontUtils.U.glyphToPath(
+            font,
+            letter.glyph.g,
+            false,
+            axisValues
+          );
+          let cmdIndex = 0;
+          for (let i = 0; i < glyphPath.cmds.length; i++) {
+            const cmd = glyphPath.cmds[i];
+            if (cmd === "M") {
+              path2D.moveTo(
+                glyphPath.crds[cmdIndex] * scale,
+                -glyphPath.crds[cmdIndex + 1] * scale
+              );
+              cmdIndex += 2;
+            } else if (cmd === "L") {
+              path2D.lineTo(
+                glyphPath.crds[cmdIndex] * scale,
+                -glyphPath.crds[cmdIndex + 1] * scale
+              );
+              cmdIndex += 2;
+            } else if (cmd === "Q") {
+              path2D.quadraticCurveTo(
+                glyphPath.crds[cmdIndex] * scale,
+                -glyphPath.crds[cmdIndex + 1] * scale,
+                glyphPath.crds[cmdIndex + 2] * scale,
+                -glyphPath.crds[cmdIndex + 3] * scale
+              );
+              cmdIndex += 4;
+            } else if (cmd === "Z") {
+              path2D.closePath();
+            }
+          }
+          letters.push({
+            path: path2D,
+            letterIndex: letter.letterIndex,
+            wordIndex: letter.wordIndex,
+            lineIndex: letter.lineIndex,
+            width: letter.width,
+            height: letter.height,
+            center: { x: letter.x, y: letter.y }
+          });
+        }
+        return { letters, block: layout.block };
+      },
+      toPoints(text, size = 100, options = {}) {
+        const layout = this.layoutText(font, text, size, options);
+        const letters = [];
+        const sampling = options.sampling || 0.25;
+        const scale = size / font.head.unitsPerEm;
+        const axisValues = options.axisValues || (font.fvar ? font.fvar[1][font._index || 0][2] : null);
+        for (const letter of layout.letters) {
+          const glyphPath = FontUtils.U.glyphToPath(
+            font,
+            letter.glyph.g,
+            false,
+            axisValues
+          );
+          const rawPoints = this.samplePathPoints(glyphPath, sampling);
+          const points = rawPoints.map((point) => ({
+            x: point.x * scale,
+            y: -point.y * scale,
+            contour: point.contour
+            // Preserve contour information!
+          }));
+          letters.push({
+            shape: points,
+            center: { x: letter.x, y: letter.y },
+            letterIndex: letter.letterIndex,
+            wordIndex: letter.wordIndex,
+            lineIndex: letter.lineIndex,
+            width: letter.width,
+            height: letter.height
+          });
+        }
+        return { letters, block: layout.block };
+      },
+      // Helper methods
+      layoutText(font2, text, size, options = {}) {
+        const lines = text.split(/\r?\n/);
+        const scale = size / font2.head.unitsPerEm;
+        const letters = [];
+        const letterSpacing = options.letterSpacing || 0;
+        const wordSpacing = options.wordSpacing || 0;
+        const lineSpacing = options.lineSpacing || 0;
+        const axisValues = options.axisValues || (font2.fvar ? font2.fvar[1][font2._index || 0][2] : null);
+        const ascender = font2.hhea.ascender * scale;
+        const descender = font2.hhea.descender * scale;
+        const lineGap = (font2.hhea.lineGap || 0) * scale;
+        const lineHeight = size * 1.2 + lineSpacing;
+        let letterIndex = 0;
+        let wordIndex = 0;
+        const shapeOptions = { ltr: true };
+        if (axisValues) {
+          shapeOptions.axs = axisValues;
+        }
+        const lineWidths = lines.map((line) => {
+          const shaped = FontUtils.U.shape(font2, line, shapeOptions);
+          let width = 0;
+          for (let i = 0; i < shaped.length; i++) {
+            const glyph = shaped[i];
+            const char = line.charAt(i);
+            width += (glyph.ax || 0) * scale;
+            if (char === " ") {
+              width += wordSpacing;
+            } else if (i < shaped.length - 1) {
+              width += letterSpacing;
+            }
+          }
+          return width;
+        });
+        const blockWidth = Math.max(...lineWidths, 0);
+        const blockHeight = lineHeight * lines.length;
+        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+          const line = lines[lineIndex];
+          const shaped = FontUtils.U.shape(font2, line, shapeOptions);
+          const lineWidth = lineWidths[lineIndex];
+          let x = 0;
+          if (options.align === "center") {
+            x = (blockWidth - lineWidth) / 2;
+          } else if (options.align === "right") {
+            x = blockWidth - lineWidth;
+          }
+          if (options.anchor === "center" && options.align === "center") {
+            x = -lineWidth / 2;
+          }
+          let y;
+          if (options.baseline === "center") {
+            if (lines.length === 1) {
+              y = 0;
+            } else {
+              y = -blockHeight / 2 + lineHeight / 2 + lineIndex * lineHeight;
+            }
+          } else if (options.baseline === "top") {
+            y = -lineHeight / 2 + lineIndex * lineHeight;
+          } else {
+            y = -lineHeight / 2 + lineIndex * lineHeight;
+          }
+          const middleToBaseline = (ascender + descender) / 2;
+          y += middleToBaseline;
+          for (let i = 0; i < shaped.length; i++) {
+            const glyph = shaped[i];
+            const char = line.charAt(i);
+            const advanceWidth = (glyph.ax || 0) * scale;
+            letters.push({
+              glyph,
+              char,
+              x,
+              y,
+              letterIndex: letterIndex++,
+              wordIndex,
+              lineIndex,
+              width: advanceWidth,
+              height: size
+            });
+            x += advanceWidth;
+            if (char === " ") {
+              x += wordSpacing;
+              wordIndex++;
+            } else if (i < shaped.length - 1) {
+              x += letterSpacing;
+            }
+          }
+          if (line.includes(" ")) wordIndex++;
+        }
+        let offsetX = 0, offsetY = 0;
+        if (options.anchor === "center") {
+          if (options.align !== "center") {
+            offsetX = -blockWidth / 2;
+          }
+          if (options.baseline !== "center") {
+            offsetY = -blockHeight / 2;
+          }
+        }
+        letters.forEach((letter) => {
+          letter.x += offsetX;
+          letter.y += offsetY;
+        });
+        return { letters, block: { width: blockWidth, height: blockHeight } };
+      },
+      samplePathPoints(glyphPath, sampling) {
+        const rawContours = this.parseContours(glyphPath);
+        const contoursWithLength = rawContours.map(
+          (contour, index) => ({
+            contour,
+            originalIndex: index,
+            length: this.calculateContourLength(contour)
+          })
+        );
+        contoursWithLength.sort((a, b) => b.length - a.length);
+        const allPoints = [];
+        for (let i = 0; i < contoursWithLength.length; i++) {
+          const { contour } = contoursWithLength[i];
+          const contourPoints = this.sampleContour(contour, sampling, i);
+          allPoints.push(...contourPoints);
+        }
+        return allPoints;
+      },
+      // Calculate total length of a contour
+      calculateContourLength(contour) {
+        let totalLength = 0;
+        let currentX = contour.startX;
+        let currentY = contour.startY;
+        for (const seg of contour.segments) {
+          if (seg.cmd === "L") {
+            const endX = seg.coords[0];
+            const endY = seg.coords[1];
+            totalLength += Math.sqrt(
+              (endX - currentX) ** 2 + (endY - currentY) ** 2
+            );
+            currentX = endX;
+            currentY = endY;
+          } else if (seg.cmd === "Q") {
+            const controlX = seg.coords[0];
+            const controlY = seg.coords[1];
+            const endX = seg.coords[2];
+            const endY = seg.coords[3];
+            totalLength += this.approximateQuadraticLength(
+              currentX,
+              currentY,
+              controlX,
+              controlY,
+              endX,
+              endY
+            );
+            currentX = endX;
+            currentY = endY;
+          }
+        }
+        return totalLength;
+      },
+      // Parse glyph path into separate contours
+      parseContours(glyphPath) {
+        const contours = [];
+        let currentContour = null;
+        let cmdIndex = 0;
+        for (let i = 0; i < glyphPath.cmds.length; i++) {
+          const cmd = glyphPath.cmds[i];
+          if (cmd === "M") {
+            if (currentContour) {
+              contours.push(currentContour);
+            }
+            currentContour = {
+              startX: glyphPath.crds[cmdIndex],
+              startY: glyphPath.crds[cmdIndex + 1],
+              segments: []
+            };
+            cmdIndex += 2;
+          } else if (cmd === "L" || cmd === "Q") {
+            if (currentContour) {
+              currentContour.segments.push({
+                cmd,
+                coords: glyphPath.crds.slice(
+                  cmdIndex,
+                  cmdIndex + (cmd === "L" ? 2 : 4)
+                )
+              });
+            }
+            cmdIndex += cmd === "L" ? 2 : 4;
+          } else if (cmd === "Z") {
+            if (currentContour) {
+              contours.push(currentContour);
+              currentContour = null;
+            }
+          }
+        }
+        if (currentContour) {
+          contours.push(currentContour);
+        }
+        return contours;
+      },
+      // Sample a single contour uniformly
+      sampleContour(contour, sampling, contourIndex) {
+        const segments = [];
+        let currentX = contour.startX;
+        let currentY = contour.startY;
+        let totalLength = 0;
+        for (const seg of contour.segments) {
+          if (seg.cmd === "L") {
+            const endX = seg.coords[0];
+            const endY = seg.coords[1];
+            const length = Math.sqrt(
+              (endX - currentX) ** 2 + (endY - currentY) ** 2
+            );
+            segments.push({
+              type: "L",
+              startX: currentX,
+              startY: currentY,
+              endX,
+              endY,
+              length,
+              startLength: totalLength
+            });
+            totalLength += length;
+            currentX = endX;
+            currentY = endY;
+          } else if (seg.cmd === "Q") {
+            const controlX = seg.coords[0];
+            const controlY = seg.coords[1];
+            const endX = seg.coords[2];
+            const endY = seg.coords[3];
+            const length = this.approximateQuadraticLength(
+              currentX,
+              currentY,
+              controlX,
+              controlY,
+              endX,
+              endY
+            );
+            segments.push({
+              type: "Q",
+              startX: currentX,
+              startY: currentY,
+              controlX,
+              controlY,
+              endX,
+              endY,
+              length,
+              startLength: totalLength
+            });
+            totalLength += length;
+            currentX = endX;
+            currentY = endY;
+          }
+        }
+        const points = [];
+        const targetPoints = Math.max(
+          5,
+          Math.floor(totalLength * sampling * 0.1)
+        );
+        for (let i = 0; i <= targetPoints; i++) {
+          const targetLength = i / targetPoints * totalLength;
+          const pointData = this.getPointAtLengthInContour(
+            segments,
+            targetLength
+          );
+          if (pointData) {
+            points.push({
+              x: pointData.x,
+              y: pointData.y,
+              contour: contourIndex
+            });
+          }
+        }
+        return points;
+      },
+      // Get point at length within a single contour
+      getPointAtLengthInContour(segments, targetLength) {
+        for (const segment of segments) {
+          if (targetLength >= segment.startLength && targetLength <= segment.startLength + segment.length) {
+            const localT = (targetLength - segment.startLength) / segment.length;
+            if (segment.type === "L") {
+              return {
+                x: segment.startX + (segment.endX - segment.startX) * localT,
+                y: segment.startY + (segment.endY - segment.startY) * localT
+              };
+            } else if (segment.type === "Q") {
+              const t = localT;
+              return {
+                x: (1 - t) * (1 - t) * segment.startX + 2 * (1 - t) * t * segment.controlX + t * t * segment.endX,
+                y: (1 - t) * (1 - t) * segment.startY + 2 * (1 - t) * t * segment.controlY + t * t * segment.endY
+              };
+            }
+          }
+        }
+        return null;
+      },
+      // Helper function to approximate quadratic curve length
+      approximateQuadraticLength(x0, y0, x1, y1, x2, y2) {
+        const chordLength = Math.sqrt((x2 - x0) ** 2 + (y2 - y0) ** 2);
+        const controlLength = Math.sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2) + Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+        return (chordLength + controlLength) / 2;
+      }
+    };
+  }
+};
+
+// src/plugins/Delaunay.tsx
+var Delaunay = class {
+  /**
+   * Perform Delaunay triangulation on a set of points
+   */
+  static triangulate(points) {
+    if (points.length < 3) {
+      return [];
+    }
+    const triangles = [];
+    for (let i = 0; i < points.length - 2; i++) {
+      triangles.push({
+        p1: points[i],
+        p2: points[i + 1],
+        p3: points[i + 2]
+      });
+    }
+    return triangles;
+  }
+  /**
+   * Draw triangles to the canvas
+   */
+  static drawTriangles(ctx, triangles, options) {
+    const { fill = true, stroke = true } = options || {};
+    triangles.forEach((triangle) => {
+      ctx.beginPath();
+      ctx.moveTo(triangle.p1.x, triangle.p1.y);
+      ctx.lineTo(triangle.p2.x, triangle.p2.y);
+      ctx.lineTo(triangle.p3.x, triangle.p3.y);
+      ctx.closePath();
+      if (fill) {
+        if (options?.fillStyle) {
+          const prevFill = ctx.fillStyle;
+          ctx.fillStyle = options.fillStyle;
+          ctx.fill();
+          ctx.fillStyle = prevFill;
+        } else {
+          ctx.fill();
+        }
+      }
+      if (stroke) {
+        if (options?.strokeStyle) {
+          const prevStroke = ctx.strokeStyle;
+          ctx.strokeStyle = options.strokeStyle;
+          ctx.stroke();
+          ctx.strokeStyle = prevStroke;
+        } else {
+          ctx.stroke();
+        }
+      }
+    });
+  }
+  /**
+   * Calculate circumcenter of a triangle
+   */
+  static circumcenter(triangle) {
+    const { p1, p2, p3 } = triangle;
+    const ax = p1.x, ay = p1.y;
+    const bx = p2.x, by = p2.y;
+    const cx = p3.x, cy = p3.y;
+    const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+    if (Math.abs(d) < 1e-6) {
+      return { x: (ax + bx + cx) / 3, y: (ay + by + cy) / 3 };
+    }
+    const ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d;
+    const uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d;
+    return { x: ux, y: uy };
+  }
+  /**
+   * Check if a point is inside a triangle's circumcircle
+   */
+  static inCircumcircle(point, triangle) {
+    const center = this.circumcenter(triangle);
+    const radius = Math.sqrt(
+      Math.pow(triangle.p1.x - center.x, 2) + Math.pow(triangle.p1.y - center.y, 2)
+    );
+    const distance = Math.sqrt(
+      Math.pow(point.x - center.x, 2) + Math.pow(point.y - center.y, 2)
+    );
+    return distance < radius;
+  }
+};
+
+// src/plugins/Catmull.tsx
+var CatmullRom = class {
+  /**
+   * Interpolate points using Catmull-Rom spline
+   */
+  static interpolate(points, tension = 0.5, segments = 20) {
+    if (points.length < 2) return points;
+    const result = [];
+    const extendedPoints = [points[0], ...points, points[points.length - 1]];
+    for (let i = 1; i < extendedPoints.length - 2; i++) {
+      const p0 = extendedPoints[i - 1];
+      const p1 = extendedPoints[i];
+      const p2 = extendedPoints[i + 1];
+      const p3 = extendedPoints[i + 2];
+      for (let t = 0; t < 1; t += 1 / segments) {
+        const t2 = t * t;
+        const t3 = t2 * t;
+        const v0 = tension * (p2.x - p0.x);
+        const v1 = tension * (p3.x - p1.x);
+        const x = p1.x + v0 * t + (3 * (p2.x - p1.x) - 2 * v0 - v1) * t2 + (2 * (p1.x - p2.x) + v0 + v1) * t3;
+        const v0y = tension * (p2.y - p0.y);
+        const v1y = tension * (p3.y - p1.y);
+        const y = p1.y + v0y * t + (3 * (p2.y - p1.y) - 2 * v0y - v1y) * t2 + (2 * (p1.y - p2.y) + v0y + v1y) * t3;
+        result.push({ x, y });
+      }
+    }
+    result.push(points[points.length - 1]);
+    return result;
+  }
+  /**
+   * Draw interpolated curve to canvas
+   */
+  static draw(ctx, points, options) {
+    const { tension = 0.5, segments = 20, closed = false } = options || {};
+    const interpolated = this.interpolate(
+      closed ? [...points, points[0]] : points,
+      tension,
+      segments
+    );
+    ctx.save();
+    if (options?.strokeStyle) {
+      ctx.strokeStyle = options.strokeStyle;
+    }
+    if (options?.lineWidth) {
+      ctx.lineWidth = options.lineWidth;
+    }
+    ctx.beginPath();
+    ctx.moveTo(interpolated[0].x, interpolated[0].y);
+    for (let i = 1; i < interpolated.length; i++) {
+      ctx.lineTo(interpolated[i].x, interpolated[i].y);
+    }
+    if (closed) {
+      ctx.closePath();
+    }
+    ctx.stroke();
+    ctx.restore();
+  }
+  /**
+   * Get path as a Path2D object
+   */
+  static toPath2D(points, options) {
+    const { tension = 0.5, segments = 20, closed = false } = options || {};
+    const interpolated = this.interpolate(
+      closed ? [...points, points[0]] : points,
+      tension,
+      segments
+    );
+    const path = new Path2D();
+    path.moveTo(interpolated[0].x, interpolated[0].y);
+    for (let i = 1; i < interpolated.length; i++) {
+      path.lineTo(interpolated[i].x, interpolated[i].y);
+    }
+    if (closed) {
+      path.closePath();
+    }
+    return path;
+  }
+};
+
+// src/plugins/Things.tsx
+var Things = class {
+  /**
+   * Configure the plugin
+   */
+  static configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Create a new thing
+   */
+  static create(options = {}) {
+    if (this.things.size >= (this.config.maxThings || 1e3)) {
+      throw new Error(
+        `Maximum number of things (${this.config.maxThings}) reached`
+      );
+    }
+    const thing = {
+      id: options.id || `thing_${this.idCounter++}`,
+      x: options.x || 0,
+      y: options.y || 0,
+      width: options.width || this.config.defaultSize || 50,
+      height: options.height || this.config.defaultSize || 50,
+      rotation: options.rotation || 0,
+      scale: options.scale || 1,
+      color: options.color || this.config.defaultColor || "#ffffff",
+      data: options.data || {}
+    };
+    this.things.set(thing.id, thing);
+    return thing;
+  }
+  /**
+   * Get a thing by ID
+   */
+  static get(id) {
+    return this.things.get(id);
+  }
+  /**
+   * Get all things
+   */
+  static getAll() {
+    return Array.from(this.things.values());
+  }
+  /**
+   * Update a thing's properties
+   */
+  static update(id, updates) {
+    const thing = this.things.get(id);
+    if (thing) {
+      Object.assign(thing, updates);
+    }
+  }
+  /**
+   * Remove a thing
+   */
+  static remove(id) {
+    return this.things.delete(id);
+  }
+  /**
+   * Clear all things
+   */
+  static clear() {
+    this.things.clear();
+    this.idCounter = 0;
+  }
+  /**
+   * Move a thing
+   */
+  static move(id, dx, dy) {
+    const thing = this.things.get(id);
+    if (thing) {
+      thing.x += dx;
+      thing.y += dy;
+    }
+  }
+  /**
+   * Rotate a thing
+   */
+  static rotate(id, angle) {
+    const thing = this.things.get(id);
+    if (thing) {
+      thing.rotation += angle;
+    }
+  }
+  /**
+   * Scale a thing
+   */
+  static scale(id, factor) {
+    const thing = this.things.get(id);
+    if (thing) {
+      thing.scale *= factor;
+    }
+  }
+  /**
+   * Find things within a radius
+   */
+  static findNear(x, y, radius) {
+    const near = [];
+    const radiusSq = radius * radius;
+    this.things.forEach((thing) => {
+      const dx = thing.x - x;
+      const dy = thing.y - y;
+      if (dx * dx + dy * dy <= radiusSq) {
+        near.push(thing);
+      }
+    });
+    return near;
+  }
+  /**
+   * Find things that overlap with a rectangle
+   */
+  static findInRect(x, y, width, height) {
+    const found = [];
+    this.things.forEach((thing) => {
+      const halfW = thing.width * thing.scale / 2;
+      const halfH = thing.height * thing.scale / 2;
+      if (thing.x + halfW >= x && thing.x - halfW <= x + width && thing.y + halfH >= y && thing.y - halfH <= y + height) {
+        found.push(thing);
+      }
+    });
+    return found;
+  }
+  /**
+   * Apply a function to all things
+   */
+  static forEach(fn) {
+    this.things.forEach(fn);
+  }
+  /**
+   * Map things to a new array
+   */
+  static map(fn) {
+    return Array.from(this.things.values()).map(fn);
+  }
+  /**
+   * Filter things
+   */
+  static filter(fn) {
+    return Array.from(this.things.values()).filter(fn);
+  }
+  /**
+   * Sort things by a property or function
+   */
+  static sort(fn) {
+    return Array.from(this.things.values()).sort(fn);
+  }
+  /**
+   * Draw all things
+   */
+  static draw(ctx, options) {
+    const thingsToDraw = options?.filter ? this.filter(options.filter) : this.getAll();
+    thingsToDraw.forEach((thing) => {
+      if (options?.customDraw) {
+        options.customDraw(ctx, thing);
+      } else {
+        this.drawThing(ctx, thing);
+      }
+    });
+  }
+  /**
+   * Default drawing method for a thing
+   */
+  static drawThing(ctx, thing) {
+    ctx.save();
+    ctx.translate(thing.x, thing.y);
+    ctx.rotate(thing.rotation);
+    ctx.scale(thing.scale, thing.scale);
+    ctx.fillStyle = thing.color;
+    ctx.fillRect(
+      -thing.width / 2,
+      -thing.height / 2,
+      thing.width,
+      thing.height
+    );
+    ctx.restore();
+  }
+  /**
+   * Animate things with a simple physics update
+   */
+  static animatePhysics(deltaTime, options) {
+    const gravity = options?.gravity || 0;
+    const friction = options?.friction || 0.99;
+    const bounds = options?.bounds;
+    this.things.forEach((thing) => {
+      if (!thing.data.vx) thing.data.vx = 0;
+      if (!thing.data.vy) thing.data.vy = 0;
+      thing.data.vy += gravity;
+      thing.data.vx *= friction;
+      thing.data.vy *= friction;
+      thing.x += thing.data.vx;
+      thing.y += thing.data.vy;
+      if (bounds) {
+        const halfW = thing.width * thing.scale / 2;
+        const halfH = thing.height * thing.scale / 2;
+        if (thing.x - halfW < bounds.x) {
+          thing.x = bounds.x + halfW;
+          thing.data.vx *= -0.8;
+        }
+        if (thing.x + halfW > bounds.x + bounds.width) {
+          thing.x = bounds.x + bounds.width - halfW;
+          thing.data.vx *= -0.8;
+        }
+        if (thing.y - halfH < bounds.y) {
+          thing.y = bounds.y + halfH;
+          thing.data.vy *= -0.8;
+        }
+        if (thing.y + halfH > bounds.y + bounds.height) {
+          thing.y = bounds.y + bounds.height - halfH;
+          thing.data.vy *= -0.8;
+        }
+      }
+    });
+  }
+  /**
+   * Get the count of things
+   */
+  static count() {
+    return this.things.size;
+  }
+  /**
+   * Check if a thing exists
+   */
+  static has(id) {
+    return this.things.has(id);
+  }
+  /**
+   * Utility: Get distance between two things
+   */
+  static distance(id1, id2) {
+    const thing1 = this.things.get(id1);
+    const thing2 = this.things.get(id2);
+    if (!thing1 || !thing2) return Infinity;
+    const dx = thing2.x - thing1.x;
+    const dy = thing2.y - thing1.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /**
+   * Utility: Check collision between two things
+   */
+  static collides(id1, id2) {
+    const thing1 = this.things.get(id1);
+    const thing2 = this.things.get(id2);
+    if (!thing1 || !thing2) return false;
+    const halfW1 = thing1.width * thing1.scale / 2;
+    const halfH1 = thing1.height * thing1.scale / 2;
+    const halfW2 = thing2.width * thing2.scale / 2;
+    const halfH2 = thing2.height * thing2.scale / 2;
+    return Math.abs(thing1.x - thing2.x) < halfW1 + halfW2 && Math.abs(thing1.y - thing2.y) < halfH1 + halfH2;
+  }
+};
+Things.things = /* @__PURE__ */ new Map();
+Things.config = {
+  maxThings: 1e3,
+  defaultSize: 50,
+  defaultColor: "#ffffff"
+};
+Things.idCounter = 0;
+
+// src/plugins/Sprites.tsx
+var Sprites = class {
+  /**
+   * Load one or more spritesheets
+   * @param configs - Sprite configuration(s) to load
+   * @returns Promise that resolves when all sprites are loaded
+   */
+  static async load(...configs) {
+    const promises = configs.map((config) => this.loadSingle(config));
+    await Promise.all(promises);
+  }
+  /**
+   * Load a single spritesheet
+   * @param config - Sprite configuration
+   * @returns Promise that resolves when sprite is loaded
+   */
+  static async loadSingle(config) {
+    const { name, url, spriteWidth, spriteHeight, gap = 0 } = config;
+    if (this.loadingPromises.has(name)) {
+      return this.loadingPromises.get(name);
+    }
+    if (this.spritesheets.has(name)) {
+      return Promise.resolve();
+    }
+    const loadPromise = new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => {
+        const cols = Math.floor((img.width + gap) / (spriteWidth + gap));
+        const rows = Math.floor((img.height + gap) / (spriteHeight + gap));
+        const numSprites = cols * rows;
+        const spritesheet = {
+          image: img,
+          srcNaturalWidth: img.width,
+          srcNaturalHeight: img.height,
+          numSprites,
+          spriteWidth,
+          spriteHeight,
+          gap,
+          cols,
+          rows
+        };
+        this.spritesheets.set(name, spritesheet);
+        this.loadingPromises.delete(name);
+        resolve();
+      };
+      img.onerror = () => {
+        this.loadingPromises.delete(name);
+        reject(new Error(`Failed to load sprite: ${url}`));
+      };
+      img.crossOrigin = "anonymous";
+      img.src = url;
+    });
+    this.loadingPromises.set(name, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * Get spritesheet information
+   * @param name - Name of the spritesheet
+   * @returns Spritesheet data or undefined if not loaded
+   */
+  static sheet(name) {
+    return this.spritesheets.get(name);
+  }
+  /**
+   * Draw a sprite from a spritesheet
+   * @param ctx - Klint context
+   * @param sheetName - Name of the spritesheet
+   * @param sprite - Sprite index to draw
+   * @param x - X position to draw at
+   * @param y - Y position to draw at
+   * @param options - Drawing options
+   */
+  static draw(ctx, sheetName, sprite, x, y, options) {
+    const sheet = this.spritesheets.get(sheetName);
+    if (!sheet) {
+      console.warn(`Spritesheet '${sheetName}' not loaded`);
+      return;
+    }
+    const spriteIndex = Math.floor(sprite) % sheet.numSprites;
+    const col = spriteIndex % sheet.cols;
+    const row = Math.floor(spriteIndex / sheet.cols);
+    const sx = col * (sheet.spriteWidth + sheet.gap);
+    const sy = row * (sheet.spriteHeight + sheet.gap);
+    const drawWidth = options?.width || sheet.spriteWidth;
+    const drawHeight = options?.height || sheet.spriteHeight;
+    const scale = options?.scale || 1;
+    const rotation = options?.rotation || 0;
+    const flipX = options?.flipX || false;
+    const flipY = options?.flipY || false;
+    const alpha = options?.alpha !== void 0 ? options.alpha : 1;
+    ctx.save();
+    ctx.translate(x, y);
+    if (rotation !== 0) {
+      ctx.rotate(rotation);
+    }
+    if (flipX || flipY) {
+      ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
+    }
+    if (scale !== 1) {
+      ctx.scale(scale, scale);
+    }
+    if (alpha !== 1) {
+      ctx.globalAlpha = alpha;
+    }
+    ctx.drawImage(
+      sheet.image,
+      sx,
+      sy,
+      sheet.spriteWidth,
+      sheet.spriteHeight,
+      -drawWidth / 2,
+      -drawHeight / 2,
+      drawWidth,
+      drawHeight
+    );
+    ctx.restore();
+  }
+  /**
+   * Draw a sprite at its actual position without centering
+   * @param ctx - Klint context
+   * @param sheetName - Name of the spritesheet
+   * @param sprite - Sprite index to draw
+   * @param x - X position to draw at
+   * @param y - Y position to draw at
+   * @param width - Width to draw (optional)
+   * @param height - Height to draw (optional)
+   */
+  static drawCorner(ctx, sheetName, sprite, x, y, width, height) {
+    const sheet = this.spritesheets.get(sheetName);
+    if (!sheet) {
+      console.warn(`Spritesheet '${sheetName}' not loaded`);
+      return;
+    }
+    const spriteIndex = Math.floor(sprite) % sheet.numSprites;
+    const col = spriteIndex % sheet.cols;
+    const row = Math.floor(spriteIndex / sheet.cols);
+    const sx = col * (sheet.spriteWidth + sheet.gap);
+    const sy = row * (sheet.spriteHeight + sheet.gap);
+    const drawWidth = width || sheet.spriteWidth;
+    const drawHeight = height || sheet.spriteHeight;
+    ctx.drawImage(
+      sheet.image,
+      sx,
+      sy,
+      sheet.spriteWidth,
+      sheet.spriteHeight,
+      x,
+      y,
+      drawWidth,
+      drawHeight
+    );
+  }
+  /**
+   * Create an animation from a range of sprites
+   * @param sheetName - Name of the spritesheet
+   * @param startSprite - Starting sprite index
+   * @param endSprite - Ending sprite index
+   * @param frameDuration - Duration of each frame in milliseconds
+   * @returns Animation object
+   */
+  static animation(sheetName, startSprite, endSprite, frameDuration = 100) {
+    return new SpriteAnimation(
+      sheetName,
+      startSprite,
+      endSprite,
+      frameDuration
+    );
+  }
+  /**
+   * Check if a spritesheet is loaded
+   * @param name - Name of the spritesheet
+   * @returns True if loaded, false otherwise
+   */
+  static hasSheet(name) {
+    return this.spritesheets.has(name);
+  }
+  /**
+   * Unload a spritesheet
+   * @param name - Name of the spritesheet to unload
+   */
+  static unload(name) {
+    this.spritesheets.delete(name);
+    this.loadingPromises.delete(name);
+  }
+  /**
+   * Unload all spritesheets
+   */
+  static clear() {
+    this.spritesheets.clear();
+    this.loadingPromises.clear();
+  }
+  /**
+   * Get the number of loaded spritesheets
+   * @returns Number of loaded spritesheets
+   */
+  static count() {
+    return this.spritesheets.size;
+  }
+  /**
+   * Get all loaded spritesheet names
+   * @returns Array of spritesheet names
+   */
+  static getSheetNames() {
+    return Array.from(this.spritesheets.keys());
+  }
+};
+Sprites.spritesheets = /* @__PURE__ */ new Map();
+Sprites.loadingPromises = /* @__PURE__ */ new Map();
+var SpriteAnimation = class {
+  constructor(sheetName, startSprite, endSprite, frameDuration) {
+    this.currentFrame = 0;
+    this.lastFrameTime = 0;
+    this.playing = true;
+    this.loop = true;
+    this.sheetName = sheetName;
+    this.startSprite = startSprite;
+    this.endSprite = endSprite;
+    this.frameDuration = frameDuration;
+    this.currentFrame = startSprite;
+  }
+  /**
+   * Update animation frame
+   * @param deltaTime - Time since last update in milliseconds
+   */
+  update(deltaTime) {
+    if (!this.playing) return;
+    this.lastFrameTime += deltaTime;
+    if (this.lastFrameTime >= this.frameDuration) {
+      this.lastFrameTime = 0;
+      this.currentFrame++;
+      if (this.currentFrame > this.endSprite) {
+        if (this.loop) {
+          this.currentFrame = this.startSprite;
+        } else {
+          this.currentFrame = this.endSprite;
+          this.playing = false;
+        }
+      }
+    }
+  }
+  /**
+   * Draw the current animation frame
+   * @param ctx - Klint context
+   * @param x - X position
+   * @param y - Y position
+   * @param options - Drawing options
+   */
+  draw(ctx, x, y, options) {
+    Sprites.draw(ctx, this.sheetName, this.currentFrame, x, y, options);
+  }
+  /**
+   * Play the animation
+   */
+  play() {
+    this.playing = true;
+  }
+  /**
+   * Pause the animation
+   */
+  pause() {
+    this.playing = false;
+  }
+  /**
+   * Stop the animation and reset to start
+   */
+  stop() {
+    this.playing = false;
+    this.currentFrame = this.startSprite;
+    this.lastFrameTime = 0;
+  }
+  /**
+   * Set whether the animation should loop
+   * @param loop - True to loop, false to play once
+   */
+  setLoop(loop) {
+    this.loop = loop;
+  }
+  /**
+   * Get the current frame
+   * @returns Current frame index
+   */
+  getCurrentFrame() {
+    return this.currentFrame;
+  }
+  /**
+   * Set the current frame
+   * @param frame - Frame index to set
+   */
+  setFrame(frame) {
+    this.currentFrame = Math.max(
+      this.startSprite,
+      Math.min(this.endSprite, frame)
+    );
+  }
+  /**
+   * Check if animation is playing
+   * @returns True if playing, false otherwise
+   */
+  isPlaying() {
+    return this.playing;
+  }
+};
+export {
+  CatmullRom,
+  Delaunay,
+  FontParser,
+  Sprites,
+  Things
+};