restty 0.1.16 → 0.1.18

package/dist/renderer/index.js

@@ -1,1612 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/renderer/box-drawing-map.ts
-var BOX_LINE_MAP = new Map([
-  [9472, [0, 1, 0, 1]],
-  [9473, [0, 2, 0, 2]],
-  [9474, [1, 0, 1, 0]],
-  [9475, [2, 0, 2, 0]],
-  [9484, [0, 1, 1, 0]],
-  [9485, [0, 2, 1, 0]],
-  [9486, [0, 1, 2, 0]],
-  [9487, [0, 2, 2, 0]],
-  [9488, [0, 0, 1, 1]],
-  [9489, [0, 0, 1, 2]],
-  [9490, [0, 0, 2, 1]],
-  [9491, [0, 0, 2, 2]],
-  [9492, [1, 1, 0, 0]],
-  [9493, [1, 2, 0, 0]],
-  [9494, [2, 1, 0, 0]],
-  [9495, [2, 2, 0, 0]],
-  [9496, [1, 0, 0, 1]],
-  [9497, [1, 0, 0, 2]],
-  [9498, [2, 0, 0, 1]],
-  [9499, [2, 0, 0, 2]],
-  [9500, [1, 1, 1, 0]],
-  [9501, [1, 2, 1, 0]],
-  [9502, [2, 1, 1, 0]],
-  [9503, [1, 1, 2, 0]],
-  [9504, [2, 1, 2, 0]],
-  [9505, [2, 2, 1, 0]],
-  [9506, [1, 2, 2, 0]],
-  [9507, [2, 2, 2, 0]],
-  [9508, [1, 0, 1, 1]],
-  [9509, [1, 0, 1, 2]],
-  [9510, [2, 0, 1, 1]],
-  [9511, [1, 0, 2, 1]],
-  [9512, [2, 0, 2, 1]],
-  [9513, [2, 0, 1, 2]],
-  [9514, [1, 0, 2, 2]],
-  [9515, [2, 0, 2, 2]],
-  [9516, [0, 1, 1, 1]],
-  [9517, [0, 1, 1, 2]],
-  [9518, [0, 2, 1, 1]],
-  [9519, [0, 2, 1, 2]],
-  [9520, [0, 1, 2, 1]],
-  [9521, [0, 1, 2, 2]],
-  [9522, [0, 2, 2, 1]],
-  [9523, [0, 2, 2, 2]],
-  [9524, [1, 1, 0, 1]],
-  [9525, [1, 1, 0, 2]],
-  [9526, [1, 2, 0, 1]],
-  [9527, [1, 2, 0, 2]],
-  [9528, [2, 1, 0, 1]],
-  [9529, [2, 1, 0, 2]],
-  [9530, [2, 2, 0, 1]],
-  [9531, [2, 2, 0, 2]],
-  [9532, [1, 1, 1, 1]],
-  [9533, [1, 1, 1, 2]],
-  [9534, [1, 2, 1, 1]],
-  [9535, [1, 2, 1, 2]],
-  [9536, [2, 1, 1, 1]],
-  [9537, [1, 1, 2, 1]],
-  [9538, [2, 1, 2, 1]],
-  [9539, [2, 1, 1, 2]],
-  [9540, [2, 2, 1, 1]],
-  [9541, [1, 1, 2, 2]],
-  [9542, [1, 2, 2, 1]],
-  [9543, [2, 2, 1, 2]],
-  [9544, [1, 2, 2, 2]],
-  [9545, [2, 1, 2, 2]],
-  [9546, [2, 2, 2, 1]],
-  [9547, [2, 2, 2, 2]],
-  [9552, [0, 3, 0, 3]],
-  [9553, [3, 0, 3, 0]],
-  [9554, [0, 3, 1, 0]],
-  [9555, [0, 1, 3, 0]],
-  [9556, [0, 3, 3, 0]],
-  [9557, [0, 0, 1, 3]],
-  [9558, [0, 0, 3, 1]],
-  [9559, [0, 0, 3, 3]],
-  [9560, [1, 3, 0, 0]],
-  [9561, [3, 1, 0, 0]],
-  [9562, [3, 3, 0, 0]],
-  [9563, [1, 0, 0, 3]],
-  [9564, [3, 0, 0, 1]],
-  [9565, [3, 0, 0, 3]],
-  [9566, [1, 3, 1, 0]],
-  [9567, [3, 1, 3, 0]],
-  [9568, [3, 3, 3, 0]],
-  [9569, [1, 0, 1, 3]],
-  [9570, [3, 0, 3, 1]],
-  [9571, [3, 0, 3, 3]],
-  [9572, [0, 3, 1, 3]],
-  [9573, [0, 1, 3, 1]],
-  [9574, [0, 3, 3, 3]],
-  [9575, [1, 3, 0, 3]],
-  [9576, [3, 1, 0, 1]],
-  [9577, [3, 3, 0, 3]],
-  [9578, [1, 3, 1, 3]],
-  [9579, [3, 1, 3, 1]],
-  [9580, [3, 3, 3, 3]],
-  [9588, [0, 0, 0, 1]],
-  [9589, [1, 0, 0, 0]],
-  [9590, [0, 1, 0, 0]],
-  [9591, [0, 0, 1, 0]],
-  [9592, [0, 0, 0, 2]],
-  [9593, [2, 0, 0, 0]],
-  [9594, [0, 2, 0, 0]],
-  [9595, [0, 0, 2, 0]],
-  [9596, [0, 2, 0, 1]],
-  [9597, [1, 0, 2, 0]],
-  [9598, [0, 1, 0, 2]],
-  [9599, [2, 0, 1, 0]]
-]);
-
-// src/renderer/shapes.ts
-var BOX_STYLE_NONE = 0;
-var BOX_STYLE_LIGHT = 1;
-var BOX_STYLE_HEAVY = 2;
-var BOX_STYLE_DOUBLE = 3;
-function isPrivateUse(cp) {
-  return cp >= 57344 && cp <= 63743 || cp >= 983040 && cp <= 1048573 || cp >= 1048576 && cp <= 1114109;
-}
-function isSpaceCp(cp) {
-  return cp === 0 || cp === 32 || cp === 8194;
-}
-function isBoxDrawing(cp) {
-  return cp >= 9472 && cp <= 9599;
-}
-function isBlockElement(cp) {
-  return cp >= 9600 && cp <= 9631;
-}
-function isLegacyComputing(cp) {
-  return cp >= 129792 && cp <= 130047 || cp >= 117760 && cp <= 118463;
-}
-function isPowerline(cp) {
-  return cp >= 57520 && cp <= 57559;
-}
-function isBraille(cp) {
-  return cp >= 10240 && cp <= 10495;
-}
-function isGraphicsElement(cp) {
-  return isBoxDrawing(cp) || isBlockElement(cp) || isLegacyComputing(cp) || isPowerline(cp);
-}
-function isSymbolCp(cp) {
-  return isPrivateUse(cp) || isGraphicsElement(cp);
-}
-function applyAlpha(color, alpha) {
-  return [color[0], color[1], color[2], color[3] * alpha];
-}
-function pushRect(out, x, y, w, h, color) {
-  out.push(x, y, w, h, color[0], color[1], color[2], color[3]);
-}
-function pushRectSnapped(out, x, y, w, h, color) {
-  const x0 = Math.floor(x);
-  const y0 = Math.floor(y);
-  const x1 = Math.ceil(x + w);
-  const y1 = Math.ceil(y + h);
-  const width = Math.max(0, x1 - x0);
-  const height = Math.max(0, y1 - y0);
-  if (width <= 0 || height <= 0)
-    return;
-  out.push(x0, y0, width, height, color[0], color[1], color[2], color[3]);
-}
-function pushRectBox(out, x, y, w, h, color) {
-  const x0 = Math.round(x);
-  const y0 = Math.round(y);
-  const width = Math.max(1, Math.round(w));
-  const height = Math.max(1, Math.round(h));
-  if (width <= 0 || height <= 0)
-    return;
-  out.push(x0, y0, width, height, color[0], color[1], color[2], color[3]);
-}
-function fillFrac(out, x, y, cellW, cellH, fx0, fx1, fy0, fy1, color) {
-  const px0 = x + cellW * fx0;
-  const px1 = x + cellW * fx1;
-  const py0 = y + cellH * fy0;
-  const py1 = y + cellH * fy1;
-  pushRectSnapped(out, px0, py0, px1 - px0, py1 - py0, color);
-}
-function drawBlockElement(cp, x, y, cellW, cellH, color, out) {
-  const full = () => pushRectSnapped(out, x, y, cellW, cellH, color);
-  const lower = (fraction) => fillFrac(out, x, y, cellW, cellH, 0, 1, 1 - fraction, 1, color);
-  const upper = (fraction) => fillFrac(out, x, y, cellW, cellH, 0, 1, 0, fraction, color);
-  const left = (fraction) => fillFrac(out, x, y, cellW, cellH, 0, fraction, 0, 1, color);
-  const right = (fraction) => fillFrac(out, x, y, cellW, cellH, 1 - fraction, 1, 0, 1, color);
-  switch (cp) {
-    case 9600:
-      upper(0.5);
-      return true;
-    case 9601:
-      lower(0.125);
-      return true;
-    case 9602:
-      lower(0.25);
-      return true;
-    case 9603:
-      lower(0.375);
-      return true;
-    case 9604:
-      lower(0.5);
-      return true;
-    case 9605:
-      lower(0.625);
-      return true;
-    case 9606:
-      lower(0.75);
-      return true;
-    case 9607:
-      lower(0.875);
-      return true;
-    case 9608:
-      full();
-      return true;
-    case 9609:
-      left(0.875);
-      return true;
-    case 9610:
-      left(0.75);
-      return true;
-    case 9611:
-      left(0.625);
-      return true;
-    case 9612:
-      left(0.5);
-      return true;
-    case 9613:
-      left(0.375);
-      return true;
-    case 9614:
-      left(0.25);
-      return true;
-    case 9615:
-      left(0.125);
-      return true;
-    case 9616:
-      right(0.5);
-      return true;
-    case 9617:
-      pushRectSnapped(out, x, y, cellW, cellH, applyAlpha(color, 0.25));
-      return true;
-    case 9618:
-      pushRectSnapped(out, x, y, cellW, cellH, applyAlpha(color, 0.5));
-      return true;
-    case 9619:
-      pushRectSnapped(out, x, y, cellW, cellH, applyAlpha(color, 0.75));
-      return true;
-    case 9620:
-      upper(0.125);
-      return true;
-    case 9621:
-      right(0.125);
-      return true;
-    case 9622:
-      fillFrac(out, x, y, cellW, cellH, 0, 0.5, 0.5, 1, color);
-      return true;
-    case 9623:
-      fillFrac(out, x, y, cellW, cellH, 0.5, 1, 0.5, 1, color);
-      return true;
-    case 9624:
-      fillFrac(out, x, y, cellW, cellH, 0, 0.5, 0, 0.5, color);
-      return true;
-    case 9625:
-      fillFrac(out, x, y, cellW, cellH, 0, 0.5, 0, 1, color);
-      fillFrac(out, x, y, cellW, cellH, 0.5, 1, 0.5, 1, color);
-      return true;
-    case 9626:
-      fillFrac(out, x, y, cellW, cellH, 0, 0.5, 0, 0.5, color);
-      fillFrac(out, x, y, cellW, cellH, 0.5, 1, 0.5, 1, color);
-      return true;
-    case 9627:
-      fillFrac(out, x, y, cellW, cellH, 0, 1, 0, 0.5, color);
-      fillFrac(out, x, y, cellW, cellH, 0, 0.5, 0.5, 1, color);
-      return true;
-    case 9628:
-      fillFrac(out, x, y, cellW, cellH, 0, 1, 0, 0.5, color);
-      fillFrac(out, x, y, cellW, cellH, 0.5, 1, 0.5, 1, color);
-      return true;
-    case 9629:
-      fillFrac(out, x, y, cellW, cellH, 0.5, 1, 0, 0.5, color);
-      return true;
-    case 9630:
-      fillFrac(out, x, y, cellW, cellH, 0.5, 1, 0, 0.5, color);
-      fillFrac(out, x, y, cellW, cellH, 0, 0.5, 0.5, 1, color);
-      return true;
-    case 9631:
-      fillFrac(out, x, y, cellW, cellH, 0.5, 1, 0, 1, color);
-      fillFrac(out, x, y, cellW, cellH, 0, 0.5, 0.5, 1, color);
-      return true;
-    default:
-      return false;
-  }
-}
-function drawBoxDrawing(cp, x, y, cellW, cellH, color, out) {
-  const spec = BOX_LINE_MAP.get(cp);
-  if (!spec) {
-    const minDim2 = Math.min(cellW, cellH);
-    const light2 = Math.max(1, Math.round(minDim2 * 0.08));
-    const heavy2 = Math.max(light2 + 1, Math.round(light2 * 1.8));
-    const dashedH = (count, thickness) => {
-      const gap2 = Math.max(1, Math.round(thickness));
-      const totalGap = gap2 * (count - 1);
-      const seg = Math.max(1, Math.floor((cellW - totalGap) / count));
-      const y0 = y + cellH * 0.5 - thickness * 0.5;
-      let px = x;
-      for (let i = 0;i < count; i += 1) {
-        pushRectBox(out, px, y0, seg, thickness, color);
-        px += seg + gap2;
-      }
-    };
-    const dashedV = (count, thickness) => {
-      const gap2 = Math.max(1, Math.round(thickness));
-      const totalGap = gap2 * (count - 1);
-      const seg = Math.max(1, Math.floor((cellH - totalGap) / count));
-      const x0 = x + cellW * 0.5 - thickness * 0.5;
-      let py = y;
-      for (let i = 0;i < count; i += 1) {
-        pushRectBox(out, x0, py, thickness, seg, color);
-        py += seg + gap2;
-      }
-    };
-    const drawDiagonal = (dir) => {
-      const thickness = light2;
-      const steps = Math.max(2, Math.round(Math.max(cellW, cellH)));
-      for (let i = 0;i < steps; i += 1) {
-        const t = steps === 1 ? 0 : i / (steps - 1);
-        const px = dir === "ul_lr" ? x + t * cellW : x + (1 - t) * cellW;
-        const py = y + t * cellH;
-        pushRectBox(out, px - thickness * 0.5, py - thickness * 0.5, thickness, thickness, color);
-      }
-    };
-    const drawArc = (corner) => {
-      const thickness = light2;
-      const halfThick = thickness * 0.5;
-      const cx2 = x + cellW * 0.5;
-      const cy2 = y + cellH * 0.5;
-      const r = Math.min(cellW, cellH) * 0.5;
-      const steps = Math.max(24, Math.round(r * 4));
-      const s = 0.25;
-      const cubicBezier = (x0, y0, cx1, cy1, cx22, cy22, x1, y1) => {
-        for (let i = 0;i <= steps; i++) {
-          const t = i / steps;
-          const mt = 1 - t;
-          const px = mt * mt * mt * x0 + 3 * mt * mt * t * cx1 + 3 * mt * t * t * cx22 + t * t * t * x1;
-          const py = mt * mt * mt * y0 + 3 * mt * mt * t * cy1 + 3 * mt * t * t * cy22 + t * t * t * y1;
-          pushRectBox(out, px - halfThick, py - halfThick, thickness, thickness, color);
-        }
-      };
-      if (corner === "br") {
-        pushRectBox(out, cx2 - halfThick, cy2 + r, thickness, y + cellH - (cy2 + r), color);
-        cubicBezier(cx2, cy2 + r, cx2, cy2 + s * r, cx2 + s * r, cy2, cx2 + r, cy2);
-        pushRectBox(out, cx2 + r, cy2 - halfThick, x + cellW - (cx2 + r), thickness, color);
-      } else if (corner === "bl") {
-        pushRectBox(out, cx2 - halfThick, cy2 + r, thickness, y + cellH - (cy2 + r), color);
-        cubicBezier(cx2, cy2 + r, cx2, cy2 + s * r, cx2 - s * r, cy2, cx2 - r, cy2);
-        pushRectBox(out, x, cy2 - halfThick, cx2 - r - x, thickness, color);
-      } else if (corner === "tl") {
-        pushRectBox(out, cx2 - halfThick, y, thickness, cy2 - r - y, color);
-        cubicBezier(cx2, cy2 - r, cx2, cy2 - s * r, cx2 - s * r, cy2, cx2 - r, cy2);
-        pushRectBox(out, x, cy2 - halfThick, cx2 - r - x, thickness, color);
-      } else {
-        pushRectBox(out, cx2 - halfThick, y, thickness, cy2 - r - y, color);
-        cubicBezier(cx2, cy2 - r, cx2, cy2 - s * r, cx2 + s * r, cy2, cx2 + r, cy2);
-        pushRectBox(out, cx2 + r, cy2 - halfThick, x + cellW - (cx2 + r), thickness, color);
-      }
-    };
-    switch (cp) {
-      case 9476:
-        dashedH(3, light2);
-        return true;
-      case 9477:
-        dashedH(3, heavy2);
-        return true;
-      case 9480:
-        dashedH(4, light2);
-        return true;
-      case 9481:
-        dashedH(4, heavy2);
-        return true;
-      case 9478:
-        dashedV(3, light2);
-        return true;
-      case 9479:
-        dashedV(3, heavy2);
-        return true;
-      case 9482:
-        dashedV(4, light2);
-        return true;
-      case 9483:
-        dashedV(4, heavy2);
-        return true;
-      case 9548:
-        dashedH(2, light2);
-        return true;
-      case 9549:
-        dashedH(2, heavy2);
-        return true;
-      case 9550:
-        dashedV(2, light2);
-        return true;
-      case 9551:
-        dashedV(2, heavy2);
-        return true;
-      case 9581:
-        drawArc("br");
-        return true;
-      case 9582:
-        drawArc("bl");
-        return true;
-      case 9583:
-        drawArc("tl");
-        return true;
-      case 9584:
-        drawArc("tr");
-        return true;
-      case 9585:
-        drawDiagonal("ur_ll");
-        return true;
-      case 9586:
-        drawDiagonal("ul_lr");
-        return true;
-      case 9587:
-        drawDiagonal("ul_lr");
-        drawDiagonal("ur_ll");
-        return true;
-      default:
-        return false;
-    }
-  }
-  const [up, right, down, left] = spec;
-  const minDim = Math.min(cellW, cellH);
-  const light = Math.max(1, Math.round(minDim * 0.08));
-  const heavy = Math.max(light + 1, Math.round(light * 1.8));
-  const gap = Math.max(1, Math.round(light));
-  const cx = x + cellW * 0.5;
-  const cy = y + cellH * 0.5;
-  const drawH = (style, x0, x1) => {
-    if (style === BOX_STYLE_NONE)
-      return;
-    if (x1 <= x0)
-      return;
-    const thickness = style === BOX_STYLE_HEAVY ? heavy : light;
-    const t = Math.max(1, Math.round(thickness));
-    if (style === BOX_STYLE_DOUBLE) {
-      const offset = (gap + t) * 0.5;
-      const y02 = cy - offset - t * 0.5;
-      const y1 = cy + offset - t * 0.5;
-      pushRectSnapped(out, x0, y02, x1 - x0, t, color);
-      pushRectSnapped(out, x0, y1, x1 - x0, t, color);
-      return;
-    }
-    const y0 = cy - t * 0.5;
-    pushRectSnapped(out, x0, y0, x1 - x0, t, color);
-  };
-  const drawV = (style, y0, y1) => {
-    if (style === BOX_STYLE_NONE)
-      return;
-    if (y1 <= y0)
-      return;
-    const thickness = style === BOX_STYLE_HEAVY ? heavy : light;
-    const t = Math.max(1, Math.round(thickness));
-    if (style === BOX_STYLE_DOUBLE) {
-      const offset = (gap + t) * 0.5;
-      const x02 = cx - offset - t * 0.5;
-      const x1 = cx + offset - t * 0.5;
-      pushRectSnapped(out, x02, y0, t, y1 - y0, color);
-      pushRectSnapped(out, x1, y0, t, y1 - y0, color);
-      return;
-    }
-    const x0 = cx - t * 0.5;
-    pushRectSnapped(out, x0, y0, t, y1 - y0, color);
-  };
-  if (left !== BOX_STYLE_NONE && left === right)
-    drawH(left, x, x + cellW);
-  else {
-    drawH(left, x, cx);
-    drawH(right, cx, x + cellW);
-  }
-  if (up !== BOX_STYLE_NONE && up === down)
-    drawV(up, y, y + cellH);
-  else {
-    drawV(up, y, cy);
-    drawV(down, cy, y + cellH);
-  }
-  return true;
-}
-function drawBraille(cp, x, y, cellW, cellH, color, out) {
-  if (!isBraille(cp))
-    return false;
-  const bits = cp - 10240;
-  if (!bits)
-    return true;
-  const dotW = Math.max(1, Math.round(cellW * 0.18));
-  const dotH = Math.max(1, Math.round(cellH * 0.18));
-  const colX = [x + cellW * 0.25 - dotW * 0.5, x + cellW * 0.75 - dotW * 0.5];
-  const rowY = [
-    y + cellH * 0.125 - dotH * 0.5,
-    y + cellH * 0.375 - dotH * 0.5,
-    y + cellH * 0.625 - dotH * 0.5,
-    y + cellH * 0.875 - dotH * 0.5
-  ];
-  const dots = [
-    [0, 0, 1],
-    [0, 1, 2],
-    [0, 2, 4],
-    [1, 0, 8],
-    [1, 1, 16],
-    [1, 2, 32],
-    [0, 3, 64],
-    [1, 3, 128]
-  ];
-  for (const [cx, cy, mask] of dots) {
-    if (bits & mask) {
-      pushRectSnapped(out, colX[cx], rowY[cy], dotW, dotH, color);
-    }
-  }
-  return true;
-}
-function drawPowerline(cp, x, y, cellW, cellH, color, out) {
-  if (!isPowerline(cp))
-    return false;
-  const w = cellW;
-  const h = cellH;
-  const steps = Math.max(2, Math.round(Math.max(w, h)));
-  const drawTriangle = (mode) => {
-    for (let i = 0;i < steps; i += 1) {
-      const t = steps === 1 ? 0 : i / (steps - 1);
-      const py = y + t * h;
-      let x0 = x;
-      let x1 = x + w;
-      if (mode === "right") {
-        const span = w * (1 - Math.abs(t - 0.5) * 2);
-        x1 = x + span;
-      } else if (mode === "left") {
-        const span = w * (1 - Math.abs(t - 0.5) * 2);
-        x0 = x + (w - span);
-      } else if (mode === "diag_ul_lr") {
-        x1 = x + t * w;
-      } else if (mode === "diag_ur_ll") {
-        x0 = x + t * w;
-      } else if (mode === "diag_ul_lr_inv") {
-        x1 = x + (1 - t) * w;
-      } else if (mode === "diag_ur_ll_inv") {
-        x0 = x + (1 - t) * w;
-      }
-      pushRectSnapped(out, x0, py, Math.max(1, x1 - x0), 1, color);
-    }
-  };
-  switch (cp) {
-    case 57520:
-      drawTriangle("right");
-      return true;
-    case 57522:
-      drawTriangle("left");
-      return true;
-    case 57528:
-      drawTriangle("diag_ul_lr");
-      return true;
-    case 57530:
-      drawTriangle("diag_ur_ll");
-      return true;
-    case 57532:
-      drawTriangle("diag_ul_lr_inv");
-      return true;
-    case 57534:
-      drawTriangle("diag_ur_ll_inv");
-      return true;
-    case 57529:
-    case 57531:
-    case 57533:
-    case 57535:
-    case 57521:
-    case 57523:
-      drawTriangle(cp === 57529 || cp === 57535 ? "diag_ul_lr" : "diag_ur_ll");
-      return true;
-    default:
-      return false;
-  }
-}
-function constrainGlyphBox(glyph, constraint, metrics, constraintWidth) {
-  if (!constraint)
-    return glyph;
-  const sizeMode = constraint.size ?? "none";
-  const alignH = constraint.align_horizontal ?? "none";
-  const alignV = constraint.align_vertical ?? "none";
-  const padLeft = constraint.pad_left ?? 0;
-  const padRight = constraint.pad_right ?? 0;
-  const padTop = constraint.pad_top ?? 0;
-  const padBottom = constraint.pad_bottom ?? 0;
-  const relW = constraint.relative_width ?? 1;
-  const relH = constraint.relative_height ?? 1;
-  const relX = constraint.relative_x ?? 0;
-  const relY = constraint.relative_y ?? 0;
-  const maxWidth = constraint.max_constraint_width ?? 2;
-  const minConstraintWidth = Math.min(constraintWidth, maxWidth);
-  if (glyph.width <= 0 || glyph.height <= 0)
-    return glyph;
-  const groupWidth = glyph.width / relW;
-  const groupHeight = glyph.height / relH;
-  let groupX = glyph.x - groupWidth * relX;
-  let groupY = glyph.y - groupHeight * relY;
-  const padWidthFactor = minConstraintWidth - (padLeft + padRight);
-  const padHeightFactor = 1 - (padBottom + padTop);
-  const targetWidth = padWidthFactor * metrics.faceWidth;
-  const baseHeight = (constraint.height ?? "cell") === "icon" ? minConstraintWidth > 1 ? metrics.iconHeight : metrics.iconHeightSingle : metrics.faceHeight;
-  const targetHeight = padHeightFactor * baseHeight;
-  let widthFactor = targetWidth / groupWidth;
-  let heightFactor = targetHeight / groupHeight;
-  const scaleDownFit = Math.min(1, widthFactor, heightFactor);
-  const scaleCover = Math.min(widthFactor, heightFactor);
-  if (sizeMode === "fit") {
-    widthFactor = scaleDownFit;
-    heightFactor = scaleDownFit;
-  } else if (sizeMode === "cover") {
-    widthFactor = scaleCover;
-    heightFactor = scaleCover;
-  } else if (sizeMode === "fit_cover1") {
-    widthFactor = scaleCover;
-    heightFactor = scaleCover;
-    if (minConstraintWidth > 1 && heightFactor > 1) {
-      const single = constrainGlyphBox({ x: 0, y: 0, width: groupWidth, height: groupHeight }, { ...constraint, max_constraint_width: 1 }, metrics, 1);
-      const singleScale = single.height / groupHeight;
-      heightFactor = Math.max(1, singleScale);
-      widthFactor = heightFactor;
-    }
-  } else if (sizeMode === "stretch") {} else {
-    widthFactor = 1;
-    heightFactor = 1;
-  }
-  if (constraint.max_xy_ratio !== undefined && constraint.max_xy_ratio !== null) {
-    const ratio = constraint.max_xy_ratio;
-    if (groupWidth * widthFactor > groupHeight * heightFactor * ratio) {
-      widthFactor = groupHeight * heightFactor * ratio / groupWidth;
-    }
-  }
-  const centerX = groupX + groupWidth * 0.5;
-  const centerY = groupY + groupHeight * 0.5;
-  const scaledGroupWidth = groupWidth * widthFactor;
-  const scaledGroupHeight = groupHeight * heightFactor;
-  groupX = centerX - scaledGroupWidth * 0.5;
-  groupY = centerY - scaledGroupHeight * 0.5;
-  const padBottomDy = padBottom * metrics.faceHeight;
-  const padTopDy = padTop * metrics.faceHeight;
-  const startY = metrics.faceY + padBottomDy;
-  const endY = metrics.faceY + (metrics.faceHeight - scaledGroupHeight - padTopDy);
-  const centerYAligned = (startY + endY) * 0.5;
-  if (!(sizeMode === "none" && alignV === "none")) {
-    if (alignV === "start")
-      groupY = startY;
-    else if (alignV === "end")
-      groupY = endY;
-    else if (alignV === "center" || alignV === "center1")
-      groupY = centerYAligned;
-    else
-      groupY = Math.max(startY, Math.min(groupY, endY));
-  }
-  const padLeftDx = padLeft * metrics.faceWidth;
-  const padRightDx = padRight * metrics.faceWidth;
-  const fullFaceSpan = metrics.faceWidth + (minConstraintWidth - 1) * metrics.cellWidth;
-  const startX = padLeftDx;
-  const endX = fullFaceSpan - scaledGroupWidth - padRightDx;
-  if (!(sizeMode === "none" && alignH === "none")) {
-    if (alignH === "start")
-      groupX = startX;
-    else if (alignH === "end")
-      groupX = Math.max(startX, endX);
-    else if (alignH === "center")
-      groupX = Math.max(startX, (startX + endX) * 0.5);
-    else if (alignH === "center1") {
-      const end1 = metrics.faceWidth - scaledGroupWidth - padRightDx;
-      groupX = Math.max(startX, (startX + end1) * 0.5);
-    } else {
-      groupX = Math.max(startX, Math.min(groupX, endX));
-    }
-  }
-  return {
-    width: glyph.width * widthFactor,
-    height: glyph.height * heightFactor,
-    x: groupX + scaledGroupWidth * relX,
-    y: groupY + scaledGroupHeight * relY
-  };
-}
-// src/renderer/shaders.ts
-var RECT_SHADER = `
-struct Uniforms {
-  res: vec2f,
-  _pad: vec2f,
-  blend: vec2f,
-  _pad2: vec2f,
-};
-
-@group(0) @binding(0) var<uniform> uniforms: Uniforms;
-
-struct VSIn {
-  @location(0) quad: vec2f,
-  @location(1) pos: vec2f,
-  @location(2) size: vec2f,
-  @location(3) color: vec4f,
-};
-
-struct VSOut {
-  @builtin(position) position: vec4f,
-  @location(0) color: vec4f,
-};
-
-// sRGB to linear conversion for proper blending
-fn srgbToLinear(c: f32) -> f32 {
-  if (c <= 0.04045) {
-    return c / 12.92;
-  }
-  return pow((c + 0.055) / 1.055, 2.4);
-}
-
-fn srgbToLinear3(c: vec3f) -> vec3f {
-  return vec3f(srgbToLinear(c.x), srgbToLinear(c.y), srgbToLinear(c.z));
-}
-
-@vertex
-fn vsMain(input: VSIn) -> VSOut {
-  let pixel = input.pos + input.quad * input.size;
-  let clip = vec2f(
-    (pixel.x / uniforms.res.x) * 2.0 - 1.0,
-    1.0 - (pixel.y / uniforms.res.y) * 2.0
-  );
-
-  var out: VSOut;
-  out.position = vec4f(clip.x, clip.y, 0.0, 1.0);
-  out.color = input.color;
-  return out;
-}
-
-@fragment
-fn fsMain(input: VSOut) -> @location(0) vec4f {
-  let useLinear = uniforms.blend.x > 0.5;
-  var color = input.color;
-  if (useLinear) {
-    color = vec4f(srgbToLinear3(color.rgb), color.a);
-  }
-  color = vec4f(color.rgb * color.a, color.a);
-  return color;
-}
-`;
-var RECT_SHADER_GL_VERT = `#version 300 es
-precision highp float;
-
-uniform vec2 u_resolution;
-
-layout(location = 0) in vec2 a_quad;
-layout(location = 1) in vec2 a_pos;
-layout(location = 2) in vec2 a_size;
-layout(location = 3) in vec4 a_color;
-
-out vec4 v_color;
-
-void main() {
-  vec2 pixel = a_pos + a_quad * a_size;
-  vec2 clip = vec2(
-    (pixel.x / u_resolution.x) * 2.0 - 1.0,
-    1.0 - (pixel.y / u_resolution.y) * 2.0
-  );
-  gl_Position = vec4(clip, 0.0, 1.0);
-  v_color = a_color;
-}
-`;
-var RECT_SHADER_GL_FRAG = `#version 300 es
-precision highp float;
-
-uniform vec2 u_blend;
-
-in vec4 v_color;
-out vec4 fragColor;
-
-// sRGB to linear conversion for proper blending
-float srgbToLinear(float c) {
-  if (c <= 0.04045) {
-    return c / 12.92;
-  }
-  return pow((c + 0.055) / 1.055, 2.4);
-}
-
-vec3 srgbToLinear(vec3 c) {
-  return vec3(srgbToLinear(c.r), srgbToLinear(c.g), srgbToLinear(c.b));
-}
-
-void main() {
-  bool useLinear = u_blend.x > 0.5;
-  vec4 color = v_color;
-  if (useLinear) {
-    color.rgb = srgbToLinear(color.rgb);
-  }
-  color.rgb *= color.a;
-  fragColor = color;
-}
-`;
-var GLYPH_SHADER_GL_VERT = `#version 300 es
-precision highp float;
-
-uniform vec2 u_resolution;
-
-layout(location = 0) in vec2 a_quad;
-layout(location = 1) in vec2 a_pos;
-layout(location = 2) in vec2 a_size;
-layout(location = 3) in vec2 a_uv0;
-layout(location = 4) in vec2 a_uv1;
-layout(location = 5) in vec4 a_color;
-layout(location = 6) in vec4 a_bg;
-layout(location = 7) in float a_slant;
-layout(location = 8) in float a_mode;
-
-out vec2 v_uv;
-out vec4 v_color;
-out vec4 v_bg;
-out float v_mode;
-
-void main() {
-  vec2 pixel = a_pos + vec2(a_quad.x * a_size.x + a_slant * (1.0 - a_quad.y), a_quad.y * a_size.y);
-  vec2 clip = vec2(
-    (pixel.x / u_resolution.x) * 2.0 - 1.0,
-    1.0 - (pixel.y / u_resolution.y) * 2.0
-  );
-  v_uv = a_uv0 + (a_uv1 - a_uv0) * a_quad;
-  gl_Position = vec4(clip, 0.0, 1.0);
-  v_color = a_color;
-  v_bg = a_bg;
-  v_mode = a_mode;
-}
-`;
-var GLYPH_SHADER_GL_FRAG = `#version 300 es
-precision highp float;
-
-uniform sampler2D u_atlas;
-uniform vec2 u_blend;
-
-in vec2 v_uv;
-in vec4 v_color;
-in vec4 v_bg;
-in float v_mode;
-out vec4 fragColor;
-
-// sRGB to linear conversion for proper blending
-float srgbToLinear(float c) {
-  if (c <= 0.04045) {
-    return c / 12.92;
-  }
-  return pow((c + 0.055) / 1.055, 2.4);
-}
-
-// Linear to sRGB conversion
-float linearToSrgb(float c) {
-  if (c <= 0.0031308) {
-    return c * 12.92;
-  }
-  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;
-}
-
-vec3 srgbToLinear(vec3 c) {
-  return vec3(srgbToLinear(c.r), srgbToLinear(c.g), srgbToLinear(c.b));
-}
-
-vec3 linearToSrgb(vec3 c) {
-  return vec3(linearToSrgb(c.r), linearToSrgb(c.g), linearToSrgb(c.b));
-}
-
-float luminance(vec3 color) {
-  return dot(color, vec3(0.2126, 0.7152, 0.0722));
-}
-
-void main() {
-  vec4 atlasSample = texture(u_atlas, v_uv);
-  bool useLinear = u_blend.x > 0.5;
-  bool useCorrection = u_blend.y > 0.5;
-
-  if (v_mode > 0.5) {
-    vec4 color = atlasSample;
-    if (useLinear) {
-      color.rgb = srgbToLinear(color.rgb);
-    }
-    color.rgb *= color.a;
-    fragColor = color;
-    return;
-  }
-
-  vec4 fg = v_color;
-  vec4 bg = v_bg;
-  if (useLinear) {
-    fg.rgb = srgbToLinear(fg.rgb);
-    bg.rgb = srgbToLinear(bg.rgb);
-  }
-  fg.rgb *= fg.a;
-  bg.rgb *= bg.a;
-
-  float alpha = atlasSample.a;
-  if (useCorrection && useLinear) {
-    float fg_l = luminance(fg.rgb);
-    float bg_l = luminance(bg.rgb);
-    if (abs(fg_l - bg_l) > 0.001) {
-      float blend_l = srgbToLinear(linearToSrgb(fg_l) * alpha + linearToSrgb(bg_l) * (1.0 - alpha));
-      alpha = clamp((blend_l - bg_l) / (fg_l - bg_l), 0.0, 1.0);
-    }
-  }
-
-  vec4 color = fg * alpha;
-  fragColor = color;
-}
-`;
-var GLYPH_SHADER = `
-struct Uniforms {
-  res: vec2f,
-  _pad: vec2f,
-  blend: vec2f,
-  _pad2: vec2f,
-};
-
-@group(0) @binding(0) var<uniform> uniforms: Uniforms;
-@group(0) @binding(1) var atlasSampler: sampler;
-@group(0) @binding(2) var atlasTex: texture_2d<f32>;
-
-struct VSIn {
-  @location(0) quad: vec2f,
-  @location(1) pos: vec2f,
-  @location(2) size: vec2f,
-  @location(3) uv0: vec2f,
-  @location(4) uv1: vec2f,
-  @location(5) color: vec4f,
-  @location(6) bg: vec4f,
-  @location(7) slant: f32,
-  @location(8) mode: f32,
-};
-
-struct VSOut {
-  @builtin(position) position: vec4f,
-  @location(0) uv: vec2f,
-  @location(1) color: vec4f,
-  @location(2) bg: vec4f,
-  @location(3) mode: f32,
-};
-
-@vertex
-fn vsMain(input: VSIn) -> VSOut {
-  let pixel = input.pos +
-    vec2f(input.quad.x * input.size.x + input.slant * (1.0 - input.quad.y), input.quad.y * input.size.y);
-  let clip = vec2f(
-    (pixel.x / uniforms.res.x) * 2.0 - 1.0,
-    1.0 - (pixel.y / uniforms.res.y) * 2.0
-  );
-  let uv = input.uv0 + (input.uv1 - input.uv0) * input.quad;
-
-  var out: VSOut;
-  out.position = vec4f(clip.x, clip.y, 0.0, 1.0);
-  out.uv = uv;
-  out.color = input.color;
-  out.bg = input.bg;
-  out.mode = input.mode;
-  return out;
-}
-
-// sRGB to linear conversion for proper blending
-fn srgbToLinear(c: f32) -> f32 {
-  if (c <= 0.04045) {
-    return c / 12.92;
-  }
-  return pow((c + 0.055) / 1.055, 2.4);
-}
-
-// Linear to sRGB conversion
-fn linearToSrgb(c: f32) -> f32 {
-  if (c <= 0.0031308) {
-    return c * 12.92;
-  }
-  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;
-}
-
-fn srgbToLinear3(c: vec3f) -> vec3f {
-  return vec3f(srgbToLinear(c.x), srgbToLinear(c.y), srgbToLinear(c.z));
-}
-
-fn linearToSrgb3(c: vec3f) -> vec3f {
-  return vec3f(linearToSrgb(c.x), linearToSrgb(c.y), linearToSrgb(c.z));
-}
-
-fn luminance(color: vec3f) -> f32 {
-  return dot(color, vec3f(0.2126, 0.7152, 0.0722));
-}
-
-@fragment
-fn fsMain(input: VSOut) -> @location(0) vec4f {
-  let atlasSample = textureSample(atlasTex, atlasSampler, input.uv);
-  let useLinear = uniforms.blend.x > 0.5;
-  let useCorrection = uniforms.blend.y > 0.5;
-
-  if (input.mode > 0.5) {
-    var color = atlasSample;
-    if (useLinear) {
-      color = vec4f(srgbToLinear3(color.rgb), color.a);
-    }
-    return vec4f(color.rgb * color.a, color.a);
-  }
-
-  var alpha = atlasSample.a;
-
-  var fg = input.color;
-  var bg = input.bg;
-  if (useLinear) {
-    fg = vec4f(srgbToLinear3(fg.rgb), fg.a);
-    bg = vec4f(srgbToLinear3(bg.rgb), bg.a);
-  }
-  fg = vec4f(fg.rgb * fg.a, fg.a);
-  bg = vec4f(bg.rgb * bg.a, bg.a);
-
-  if (useCorrection && useLinear) {
-    let fg_l = luminance(fg.rgb);
-    let bg_l = luminance(bg.rgb);
-    if (abs(fg_l - bg_l) > 0.001) {
-      let blend_l = srgbToLinear(linearToSrgb(fg_l) * alpha + linearToSrgb(bg_l) * (1.0 - alpha));
-      alpha = clamp((blend_l - bg_l) / (fg_l - bg_l), 0.0, 1.0);
-    }
-  }
-
-  var color = fg * alpha;
-  return color;
-}
-`;
-var GLYPH_SHADER_NEAREST = `
-struct Uniforms {
-  res: vec2f,
-  _pad: vec2f,
-  blend: vec2f,
-  _pad2: vec2f,
-};
-
-@group(0) @binding(0) var<uniform> uniforms: Uniforms;
-@group(0) @binding(1) var atlasSampler: sampler;
-@group(0) @binding(2) var atlasTex: texture_2d<f32>;
-
-struct VSIn {
-  @location(0) quad: vec2f,
-  @location(1) pos: vec2f,
-  @location(2) size: vec2f,
-  @location(3) uv0: vec2f,
-  @location(4) uv1: vec2f,
-  @location(5) color: vec4f,
-  @location(6) bg: vec4f,
-  @location(7) slant: f32,
-  @location(8) mode: f32,
-};
-
-struct VSOut {
-  @builtin(position) position: vec4f,
-  @location(0) uv: vec2f,
-  @location(1) color: vec4f,
-  @location(2) bg: vec4f,
-  @location(3) mode: f32,
-};
-
-@vertex
-fn vsMain(input: VSIn) -> VSOut {
-  let pixel = input.pos +
-    vec2f(input.quad.x * input.size.x + input.slant * (1.0 - input.quad.y), input.quad.y * input.size.y);
-  let clip = vec2f(
-    (pixel.x / uniforms.res.x) * 2.0 - 1.0,
-    1.0 - (pixel.y / uniforms.res.y) * 2.0
-  );
-  let uv = input.uv0 + (input.uv1 - input.uv0) * input.quad;
-
-  var out: VSOut;
-  out.position = vec4f(clip.x, clip.y, 0.0, 1.0);
-  out.uv = uv;
-  out.color = input.color;
-  out.bg = input.bg;
-  out.mode = input.mode;
-  return out;
-}
-
-// sRGB to linear conversion for proper blending
-fn srgbToLinear(c: f32) -> f32 {
-  if (c <= 0.04045) {
-    return c / 12.92;
-  }
-  return pow((c + 0.055) / 1.055, 2.4);
-}
-
-// Linear to sRGB conversion
-fn linearToSrgb(c: f32) -> f32 {
-  if (c <= 0.0031308) {
-    return c * 12.92;
-  }
-  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;
-}
-
-fn srgbToLinear3(c: vec3f) -> vec3f {
-  return vec3f(srgbToLinear(c.x), srgbToLinear(c.y), srgbToLinear(c.z));
-}
-
-fn linearToSrgb3(c: vec3f) -> vec3f {
-  return vec3f(linearToSrgb(c.x), linearToSrgb(c.y), linearToSrgb(c.z));
-}
-
-fn luminance(color: vec3f) -> f32 {
-  return dot(color, vec3f(0.2126, 0.7152, 0.0722));
-}
-
-@fragment
-fn fsMain(input: VSOut) -> @location(0) vec4f {
-  let atlasSample = textureSample(atlasTex, atlasSampler, input.uv);
-  let useLinear = uniforms.blend.x > 0.5;
-  let useCorrection = uniforms.blend.y > 0.5;
-
-  if (input.mode > 0.5) {
-    var color = atlasSample;
-    if (useLinear) {
-      color = vec4f(srgbToLinear3(color.rgb), color.a);
-    }
-    return vec4f(color.rgb * color.a, color.a);
-  }
-
-  var alpha = atlasSample.a;
-
-  var fg = input.color;
-  var bg = input.bg;
-  if (useLinear) {
-    fg = vec4f(srgbToLinear3(fg.rgb), fg.a);
-    bg = vec4f(srgbToLinear3(bg.rgb), bg.a);
-  }
-  fg = vec4f(fg.rgb * fg.a, fg.a);
-  bg = vec4f(bg.rgb * bg.a, bg.a);
-
-  if (useCorrection && useLinear) {
-    let fg_l = luminance(fg.rgb);
-    let bg_l = luminance(bg.rgb);
-    if (abs(fg_l - bg_l) > 0.001) {
-      let blend_l = srgbToLinear(linearToSrgb(fg_l) * alpha + linearToSrgb(bg_l) * (1.0 - alpha));
-      alpha = clamp((blend_l - bg_l) / (fg_l - bg_l), 0.0, 1.0);
-    }
-  }
-
-  var color = fg * alpha;
-  return color;
-}
-`;
-// src/renderer/webgpu.ts
-function getPreferredAndSrgbFormats() {
-  const preferredFormat = navigator.gpu.getPreferredCanvasFormat();
-  const srgbFormat = preferredFormat === "bgra8unorm" ? "bgra8unorm-srgb" : preferredFormat === "rgba8unorm" ? "rgba8unorm-srgb" : preferredFormat;
-  return { preferredFormat, srgbFormat };
-}
-function configureContextFormat(context, device, preferredFormat, srgbFormat) {
-  let format = preferredFormat;
-  try {
-    context.configure({ device, format: srgbFormat, alphaMode: "opaque" });
-    format = srgbFormat;
-  } catch {
-    context.configure({ device, format: preferredFormat, alphaMode: "opaque" });
-  }
-  return { format, srgbSwapchain: format.endsWith("-srgb") };
-}
-function createWebGPUCoreState(device, format, srgbSwapchain) {
-  const quadVertices = new Float32Array([0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]);
-  const vertexBuffer = device.createBuffer({
-    size: quadVertices.byteLength,
-    usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-    mappedAtCreation: true
-  });
-  new Float32Array(vertexBuffer.getMappedRange()).set(quadVertices);
-  vertexBuffer.unmap();
-  const rectModule = device.createShaderModule({ code: RECT_SHADER });
-  const glyphModule = device.createShaderModule({ code: GLYPH_SHADER });
-  const glyphNearestModule = device.createShaderModule({ code: GLYPH_SHADER_NEAREST });
-  const rectPipeline = device.createRenderPipeline({
-    layout: "auto",
-    vertex: {
-      module: rectModule,
-      entryPoint: "vsMain",
-      buffers: [
-        {
-          arrayStride: 8,
-          attributes: [{ shaderLocation: 0, offset: 0, format: "float32x2" }]
-        },
-        {
-          arrayStride: 32,
-          stepMode: "instance",
-          attributes: [
-            { shaderLocation: 1, offset: 0, format: "float32x2" },
-            { shaderLocation: 2, offset: 8, format: "float32x2" },
-            { shaderLocation: 3, offset: 16, format: "float32x4" }
-          ]
-        }
-      ]
-    },
-    fragment: {
-      module: rectModule,
-      entryPoint: "fsMain",
-      targets: [
-        {
-          format,
-          blend: {
-            color: {
-              srcFactor: "one",
-              dstFactor: "one-minus-src-alpha",
-              operation: "add"
-            },
-            alpha: {
-              srcFactor: "one",
-              dstFactor: "one-minus-src-alpha",
-              operation: "add"
-            }
-          }
-        }
-      ]
-    },
-    primitive: { topology: "triangle-list", cullMode: "none" }
-  });
-  const glyphPipeline = device.createRenderPipeline({
-    layout: "auto",
-    vertex: {
-      module: glyphModule,
-      entryPoint: "vsMain",
-      buffers: [
-        {
-          arrayStride: 8,
-          attributes: [{ shaderLocation: 0, offset: 0, format: "float32x2" }]
-        },
-        {
-          arrayStride: 72,
-          stepMode: "instance",
-          attributes: [
-            { shaderLocation: 1, offset: 0, format: "float32x2" },
-            { shaderLocation: 2, offset: 8, format: "float32x2" },
-            { shaderLocation: 3, offset: 16, format: "float32x2" },
-            { shaderLocation: 4, offset: 24, format: "float32x2" },
-            { shaderLocation: 5, offset: 32, format: "float32x4" },
-            { shaderLocation: 6, offset: 48, format: "float32x4" },
-            { shaderLocation: 7, offset: 64, format: "float32" },
-            { shaderLocation: 8, offset: 68, format: "float32" }
-          ]
-        }
-      ]
-    },
-    fragment: {
-      module: glyphModule,
-      entryPoint: "fsMain",
-      targets: [
-        {
-          format,
-          blend: {
-            color: {
-              srcFactor: "one",
-              dstFactor: "one-minus-src-alpha",
-              operation: "add"
-            },
-            alpha: {
-              srcFactor: "one",
-              dstFactor: "one-minus-src-alpha",
-              operation: "add"
-            }
-          }
-        }
-      ]
-    },
-    primitive: { topology: "triangle-list", cullMode: "none" }
-  });
-  const glyphPipelineNearest = device.createRenderPipeline({
-    layout: "auto",
-    vertex: {
-      module: glyphNearestModule,
-      entryPoint: "vsMain",
-      buffers: [
-        {
-          arrayStride: 8,
-          attributes: [{ shaderLocation: 0, offset: 0, format: "float32x2" }]
-        },
-        {
-          arrayStride: 72,
-          stepMode: "instance",
-          attributes: [
-            { shaderLocation: 1, offset: 0, format: "float32x2" },
-            { shaderLocation: 2, offset: 8, format: "float32x2" },
-            { shaderLocation: 3, offset: 16, format: "float32x2" },
-            { shaderLocation: 4, offset: 24, format: "float32x2" },
-            { shaderLocation: 5, offset: 32, format: "float32x4" },
-            { shaderLocation: 6, offset: 48, format: "float32x4" },
-            { shaderLocation: 7, offset: 64, format: "float32" },
-            { shaderLocation: 8, offset: 68, format: "float32" }
-          ]
-        }
-      ]
-    },
-    fragment: {
-      module: glyphNearestModule,
-      entryPoint: "fsMain",
-      targets: [
-        {
-          format,
-          blend: {
-            color: {
-              srcFactor: "one",
-              dstFactor: "one-minus-src-alpha",
-              operation: "add"
-            },
-            alpha: {
-              srcFactor: "one",
-              dstFactor: "one-minus-src-alpha",
-              operation: "add"
-            }
-          }
-        }
-      ]
-    },
-    primitive: { topology: "triangle-list", cullMode: "none" }
-  });
-  return {
-    device,
-    format,
-    srgbSwapchain,
-    rectPipeline,
-    glyphPipeline,
-    glyphPipelineNearest,
-    vertexBuffer
-  };
-}
-async function initWebGPUCore(canvas) {
-  if (!navigator.gpu)
-    return null;
-  const adapter = await navigator.gpu.requestAdapter();
-  if (!adapter)
-    return null;
-  const device = await adapter.requestDevice();
-  const context = canvas.getContext("webgpu");
-  if (!context)
-    return null;
-  const { preferredFormat, srgbFormat } = getPreferredAndSrgbFormats();
-  const { format, srgbSwapchain } = configureContextFormat(context, device, preferredFormat, srgbFormat);
-  return createWebGPUCoreState(device, format, srgbSwapchain);
-}
-async function initWebGPU(canvas, options = {}) {
-  const core = options.core ?? await initWebGPUCore(canvas);
-  if (!core)
-    return null;
-  const context = canvas.getContext("webgpu");
-  if (!context)
-    return null;
-  try {
-    context.configure({ device: core.device, format: core.format, alphaMode: "opaque" });
-  } catch {
-    return null;
-  }
-  const uniformBuffer = core.device.createBuffer({
-    size: 8 * 4,
-    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-  });
-  const rectBindGroup = core.device.createBindGroup({
-    layout: core.rectPipeline.getBindGroupLayout(0),
-    entries: [{ binding: 0, resource: { buffer: uniformBuffer } }]
-  });
-  return {
-    core,
-    device: core.device,
-    context,
-    format: core.format,
-    srgbSwapchain: core.srgbSwapchain,
-    rectPipeline: core.rectPipeline,
-    glyphPipeline: core.glyphPipeline,
-    glyphPipelineNearest: core.glyphPipelineNearest,
-    rectBindGroup,
-    uniformBuffer,
-    vertexBuffer: core.vertexBuffer,
-    rectInstanceBuffer: core.device.createBuffer({
-      size: 4,
-      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
-    }),
-    rectCapacity: 4,
-    glyphInstanceBuffer: core.device.createBuffer({
-      size: 4,
-      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
-    }),
-    glyphCapacity: 4,
-    glyphAtlases: new Map
-  };
-}
-function compileShader(gl, type, source) {
-  const shader = gl.createShader(type);
-  if (!shader)
-    return null;
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    console.error("Shader compile error:", gl.getShaderInfoLog(shader));
-    gl.deleteShader(shader);
-    return null;
-  }
-  return shader;
-}
-function createProgram(gl, vertSrc, fragSrc) {
-  const vert = compileShader(gl, gl.VERTEX_SHADER, vertSrc);
-  const frag = compileShader(gl, gl.FRAGMENT_SHADER, fragSrc);
-  if (!vert || !frag)
-    return null;
-  const program = gl.createProgram();
-  if (!program)
-    return null;
-  gl.attachShader(program, vert);
-  gl.attachShader(program, frag);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    console.error("Program link error:", gl.getProgramInfoLog(program));
-    gl.deleteProgram(program);
-    return null;
-  }
-  gl.deleteShader(vert);
-  gl.deleteShader(frag);
-  return program;
-}
-function initWebGL(canvas) {
-  const gl = canvas.getContext("webgl2", { antialias: false, alpha: false });
-  if (!gl)
-    return null;
-  const rectProgram = createProgram(gl, RECT_SHADER_GL_VERT, RECT_SHADER_GL_FRAG);
-  const glyphProgram = createProgram(gl, GLYPH_SHADER_GL_VERT, GLYPH_SHADER_GL_FRAG);
-  if (!rectProgram || !glyphProgram)
-    return null;
-  const rectResolutionLoc = gl.getUniformLocation(rectProgram, "u_resolution");
-  const rectBlendLoc = gl.getUniformLocation(rectProgram, "u_blend");
-  const glyphResolutionLoc = gl.getUniformLocation(glyphProgram, "u_resolution");
-  const glyphBlendLoc = gl.getUniformLocation(glyphProgram, "u_blend");
-  const glyphAtlasLoc = gl.getUniformLocation(glyphProgram, "u_atlas");
-  if (!rectResolutionLoc || !rectBlendLoc || !glyphResolutionLoc || !glyphBlendLoc || !glyphAtlasLoc) {
-    return null;
-  }
-  const quadVertices = new Float32Array([0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]);
-  const quadBuffer = gl.createBuffer();
-  if (!quadBuffer)
-    return null;
-  gl.bindBuffer(gl.ARRAY_BUFFER, quadBuffer);
-  gl.bufferData(gl.ARRAY_BUFFER, quadVertices, gl.STATIC_DRAW);
-  const rectVao = gl.createVertexArray();
-  if (!rectVao)
-    return null;
-  gl.bindVertexArray(rectVao);
-  gl.bindBuffer(gl.ARRAY_BUFFER, quadBuffer);
-  gl.enableVertexAttribArray(0);
-  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-  const rectInstanceBuffer = gl.createBuffer();
-  if (!rectInstanceBuffer)
-    return null;
-  gl.bindBuffer(gl.ARRAY_BUFFER, rectInstanceBuffer);
-  gl.bufferData(gl.ARRAY_BUFFER, 1024, gl.DYNAMIC_DRAW);
-  gl.enableVertexAttribArray(1);
-  gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 32, 0);
-  gl.vertexAttribDivisor(1, 1);
-  gl.enableVertexAttribArray(2);
-  gl.vertexAttribPointer(2, 2, gl.FLOAT, false, 32, 8);
-  gl.vertexAttribDivisor(2, 1);
-  gl.enableVertexAttribArray(3);
-  gl.vertexAttribPointer(3, 4, gl.FLOAT, false, 32, 16);
-  gl.vertexAttribDivisor(3, 1);
-  gl.bindVertexArray(null);
-  const glyphVao = gl.createVertexArray();
-  if (!glyphVao)
-    return null;
-  gl.bindVertexArray(glyphVao);
-  gl.bindBuffer(gl.ARRAY_BUFFER, quadBuffer);
-  gl.enableVertexAttribArray(0);
-  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-  const glyphInstanceBuffer = gl.createBuffer();
-  if (!glyphInstanceBuffer)
-    return null;
-  gl.bindBuffer(gl.ARRAY_BUFFER, glyphInstanceBuffer);
-  gl.bufferData(gl.ARRAY_BUFFER, 1024, gl.DYNAMIC_DRAW);
-  gl.enableVertexAttribArray(1);
-  gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 72, 0);
-  gl.vertexAttribDivisor(1, 1);
-  gl.enableVertexAttribArray(2);
-  gl.vertexAttribPointer(2, 2, gl.FLOAT, false, 72, 8);
-  gl.vertexAttribDivisor(2, 1);
-  gl.enableVertexAttribArray(3);
-  gl.vertexAttribPointer(3, 2, gl.FLOAT, false, 72, 16);
-  gl.vertexAttribDivisor(3, 1);
-  gl.enableVertexAttribArray(4);
-  gl.vertexAttribPointer(4, 2, gl.FLOAT, false, 72, 24);
-  gl.vertexAttribDivisor(4, 1);
-  gl.enableVertexAttribArray(5);
-  gl.vertexAttribPointer(5, 4, gl.FLOAT, false, 72, 32);
-  gl.vertexAttribDivisor(5, 1);
-  gl.enableVertexAttribArray(6);
-  gl.vertexAttribPointer(6, 4, gl.FLOAT, false, 72, 48);
-  gl.vertexAttribDivisor(6, 1);
-  gl.enableVertexAttribArray(7);
-  gl.vertexAttribPointer(7, 1, gl.FLOAT, false, 72, 64);
-  gl.vertexAttribDivisor(7, 1);
-  gl.enableVertexAttribArray(8);
-  gl.vertexAttribPointer(8, 1, gl.FLOAT, false, 72, 68);
-  gl.vertexAttribDivisor(8, 1);
-  gl.bindVertexArray(null);
-  gl.enable(gl.BLEND);
-  gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-  return {
-    gl,
-    rectProgram,
-    glyphProgram,
-    rectResolutionLoc,
-    rectBlendLoc,
-    glyphResolutionLoc,
-    glyphBlendLoc,
-    glyphAtlasLoc,
-    quadBuffer,
-    rectVao,
-    glyphVao,
-    rectInstanceBuffer,
-    glyphInstanceBuffer,
-    rectCapacity: 1024,
-    glyphCapacity: 1024,
-    glyphAtlases: new Map
-  };
-}
-function ensureInstanceBuffer(state, kind, byteLength) {
-  const bufferKey = kind === "rect" ? "rectInstanceBuffer" : "glyphInstanceBuffer";
-  const capKey = kind === "rect" ? "rectCapacity" : "glyphCapacity";
-  if (byteLength <= state[capKey])
-    return;
-  const newSize = Math.max(byteLength, state[capKey] * 2, 1024);
-  state[bufferKey] = state.device.createBuffer({
-    size: newSize,
-    usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
-  });
-  state[capKey] = newSize;
-}
-function configureContext(state) {
-  state.context.configure({
-    device: state.device,
-    format: state.format,
-    alphaMode: "opaque"
-  });
-}
-function ensureGLInstanceBuffer(state, kind, byteLength) {
-  const { gl } = state;
-  const bufferKey = kind === "rect" ? "rectInstanceBuffer" : "glyphInstanceBuffer";
-  const capKey = kind === "rect" ? "rectCapacity" : "glyphCapacity";
-  const vaoKey = kind === "rect" ? "rectVao" : "glyphVao";
-  if (byteLength <= state[capKey])
-    return;
-  const newSize = Math.max(byteLength, state[capKey] * 2, 1024);
-  gl.bindVertexArray(state[vaoKey]);
-  gl.bindBuffer(gl.ARRAY_BUFFER, state[bufferKey]);
-  gl.bufferData(gl.ARRAY_BUFFER, newSize, gl.DYNAMIC_DRAW);
-  state[capKey] = newSize;
-  gl.bindVertexArray(null);
-}
-function createResizeState() {
-  return {
-    active: false,
-    lastAt: 0,
-    cols: 0,
-    rows: 0,
-    dpr: 1
-  };
-}
-function createScrollbarState() {
-  return {
-    lastInputAt: 0,
-    lastTotal: 0,
-    lastOffset: 0,
-    lastLen: 0
-  };
-}
-export {
-  pushRectSnapped,
-  pushRectBox,
-  pushRect,
-  isSymbolCp,
-  isSpaceCp,
-  isPrivateUse,
-  isPowerline,
-  isLegacyComputing,
-  isGraphicsElement,
-  isBraille,
-  isBoxDrawing,
-  isBlockElement,
-  initWebGPUCore,
-  initWebGPU,
-  initWebGL,
-  ensureInstanceBuffer,
-  ensureGLInstanceBuffer,
-  drawPowerline,
-  drawBraille,
-  drawBoxDrawing,
-  drawBlockElement,
-  createScrollbarState,
-  createResizeState,
-  constrainGlyphBox,
-  configureContext,
-  applyAlpha,
-  RECT_SHADER_GL_VERT,
-  RECT_SHADER_GL_FRAG,
-  RECT_SHADER,
-  GLYPH_SHADER_NEAREST,
-  GLYPH_SHADER_GL_VERT,
-  GLYPH_SHADER_GL_FRAG,
-  GLYPH_SHADER,
-  BOX_STYLE_NONE,
-  BOX_STYLE_LIGHT,
-  BOX_STYLE_HEAVY,
-  BOX_STYLE_DOUBLE,
-  BOX_LINE_MAP
-};