@pixerate/editor 0.192.0 → 0.193.0

package/dist/{chunk-RQ2EM5TY.js → chunk-5OC22IEO.js}

@@ -1061,6 +1061,59 @@ function gposKerning(view, t) {
     return 0;
   };
 }
+function coverageGlyphs(view, at) {
+  const format = view.getUint16(at);
+  const n = view.getUint16(at + 2);
+  const out = [];
+  if (format === 1) for (let i = 0; i < n; i++) out.push(view.getUint16(at + 4 + i * 2));
+  else if (format === 2)
+    for (let i = 0; i < n; i++) {
+      const r = at + 4 + i * 6;
+      for (let g = view.getUint16(r); g <= view.getUint16(r + 2); g++) out.push(g);
+    }
+  return out;
+}
+function gsubVertical(view, t) {
+  const out = /* @__PURE__ */ new Map();
+  if (!t || t.length < 10) return out;
+  const base = t.offset;
+  const features = base + view.getUint16(base + 6);
+  const lookups = base + view.getUint16(base + 8);
+  const ids = /* @__PURE__ */ new Set();
+  const nf = view.getUint16(features);
+  for (let i = 0; i < nf; i++) {
+    const rec = features + 2 + i * 6;
+    let tag = "";
+    for (let k = 0; k < 4; k++) tag += String.fromCharCode(view.getUint8(rec + k));
+    if (tag !== "vert") continue;
+    const f = features + view.getUint16(rec + 4);
+    const n = view.getUint16(f + 2);
+    for (let k = 0; k < n; k++) ids.add(view.getUint16(f + 4 + k * 2));
+  }
+  const nl = view.getUint16(lookups);
+  for (const id of [...ids].sort((a, b) => a - b)) {
+    if (id >= nl) continue;
+    const l = lookups + view.getUint16(lookups + 2 + id * 2);
+    const n = view.getUint16(l + 4);
+    for (let k = 0; k < n; k++) {
+      let type = view.getUint16(l);
+      let st = l + view.getUint16(l + 6 + k * 2);
+      if (type === 7) {
+        type = view.getUint16(st + 2);
+        st = st + view.getUint32(st + 4);
+      }
+      if (type !== 1) continue;
+      const format = view.getUint16(st);
+      const glyphs = coverageGlyphs(view, st + view.getUint16(st + 2));
+      glyphs.forEach((g, i) => {
+        if (out.has(g)) return;
+        if (format === 1) out.set(g, (g + view.getInt16(st + 4) + 65536) % 65536);
+        else if (format === 2 && i < view.getUint16(st + 4)) out.set(g, view.getUint16(st + 6 + i * 2));
+      });
+    }
+  }
+  return out;
+}
 var toView = (data) => data instanceof ArrayBuffer ? new DataView(data) : new DataView(data.buffer, data.byteOffset, data.byteLength);
 function parseOpenTypeFont(data, options = {}) {
   const view = toView(data);
@@ -1125,6 +1178,12 @@ function parseOpenTypeFont(data, options = {}) {
     if (i >= 0 && hmtx.offset + i * 4 + 2 <= hmtx.offset + hmtx.length) return view.getUint16(hmtx.offset + i * 4);
     return cffWidth?.(g) ?? 0;
   };
+  const vhea = tables.get("vhea");
+  const vmtx = tables.get("vmtx");
+  const numVMetrics = vhea && vhea.length >= 36 ? view.getUint16(vhea.offset + 34) : 0;
+  const hasVerticalMetrics = Boolean(vmtx && numVMetrics > 0);
+  const vorg = tables.get("VORG");
+  const vertSub = gsubVertical(view, tables.get("GSUB"));
   const kernPairs = readKern(view, tables.get("kern"));
   const gpos = gposKerning(view, tables.get("GPOS"));
   const kerning = (a, b) => (gpos ? gpos(a, b) : 0) || kernPairs.get(a * 65536 + b) || 0;
@@ -1139,17 +1198,43 @@ function parseOpenTypeFont(data, options = {}) {
     }
     return p;
   };
-  const glyphs = (text) => {
+  const verticalGlyph = (g) => vertSub.get(g) ?? g;
+  const vertOrigin = (g) => {
+    if (vorg && vorg.length >= 8) {
+      const n = view.getUint16(vorg.offset + 6);
+      let lo = 0;
+      let hi = n - 1;
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        const at2 = vorg.offset + 8 + mid * 4;
+        const v = view.getUint16(at2);
+        if (v === g) return view.getInt16(at2 + 2);
+        if (v < g) lo = mid + 1;
+        else hi = mid - 1;
+      }
+      return view.getInt16(vorg.offset + 4);
+    }
+    if (!hasVerticalMetrics) return ascender;
+    const tsb = g < numVMetrics ? view.getInt16(vmtx.offset + g * 4 + 2) : view.getInt16(vmtx.offset + numVMetrics * 4 + (g - numVMetrics) * 2);
+    let top = -Infinity;
+    for (const c of glyphPath(g)) for (const v of [c.y, c.y1, c.y2]) if (v !== void 0 && v > top) top = v;
+    return Number.isFinite(top) ? top + tsb : ascender;
+  };
+  const verticalAdvance = (g) => {
+    if (!hasVerticalMetrics || g < 0 || g >= numGlyphs) return ascender - descender;
+    return view.getUint16(vmtx.offset + Math.min(g, numVMetrics - 1) * 4);
+  };
+  const glyphs = (text, vertical = false) => {
     const out = [];
     for (const ch of text) {
       const cp = ch.codePointAt(0);
       if (cp >= 55296 && cp <= 57343 || cp === 10 || cp === 13) continue;
-      out.push(glyphIndex(cp));
+      out.push(vertical ? verticalGlyph(glyphIndex(cp)) : glyphIndex(cp));
     }
     return out;
   };
-  const layout = (text, kern) => {
-    const gs = glyphs(text);
+  const layout = (text, kern, vertical = false) => {
+    const gs = glyphs(text, vertical);
     const xs = [];
     let x = 0;
     for (let i = 0; i < gs.length; i++) {
@@ -1176,12 +1261,19 @@ function parseOpenTypeFont(data, options = {}) {
     advance,
     kerning,
     glyphPath,
+    hasVerticalMetrics,
+    verticalGlyph,
+    getVerticalMetrics(char) {
+      const g = glyphIndex(char.codePointAt(0) ?? 0);
+      const v = verticalGlyph(g);
+      return { advance: verticalAdvance(v), originY: vertOrigin(v), alternate: v !== g };
+    },
     getAdvanceWidth(text, fontSize, opts) {
       return layout(text, opts?.kerning !== false).width * fontSize / unitsPerEm;
     },
     getPath(text, x, y, fontSize, opts) {
       const k = fontSize / unitsPerEm;
-      const { gs, xs } = layout(text, opts?.kerning !== false);
+      const { gs, xs } = layout(text, opts?.kerning !== false, Boolean(opts?.vertical));
       const commands = [];
       gs.forEach((g, i) => {
         const ox = x + xs[i] * k;