@weasel-js/text 1.15.0 → 1.15.1

package/dist/{chunk-ZNSU5C43.js → chunk-WUFANHTE.js}

@@ -1,5 +1,5 @@
 import { isSolidPaint, resolveFill, resolveScreenLength, fillHasInk, strokeHasInk, paintKey, strokeKey } from '@weasel-js/paint';
-import { cssFamilyName, cachedFontVariant, syntheticBoldGrowth, glyphOutline, faceMetricsOf, glyphGeneration, faceGeneration, metricsOf, warnNoMetrics, resolveColorCluster, glyphIn, resolveGlyph } from '@weasel-js/font';
+import { cssFamilyName, cachedFontVariant, syntheticBoldGrowth, glyphOutline, faceMetricsOf, glyphGeneration, faceGeneration, metricsOf, warnNoMetrics, resolveColorCluster, glyphIn, resolveGlyph, outlineMetrics } from '@weasel-js/font';
 import { mergeRegion, growRegion, pathToD, pathFromD } from '@weasel-js/geom';
 
 var __defProp = Object.defineProperty;
@@ -134,16 +134,20 @@ function registerShaper(shaper) {
 function registeredShaper() {
   return registered;
 }
-var bytesOf = /* @__PURE__ */ new WeakMap();
-function shapeableBytes(resolved2) {
-  const face = resolved2.outlineFace;
+var embeddingOf = /* @__PURE__ */ new WeakMap();
+function shapingFace(resolved2) {
+  const { family, weight, style } = resolved2.resolved;
+  const face = resolved2.outlineFace ?? (resolved2.source === "outline" ? void 0 : outlineMetrics(family, weight, style === "italic" ? "italic" : "normal"));
   if (!face) return null;
-  let bytes = bytesOf.get(face);
-  if (bytes === void 0) {
-    bytes = face.embedding?.().sfnt ?? null;
-    bytesOf.set(face, bytes);
+  let embedding = embeddingOf.get(face);
+  if (embedding === void 0) {
+    embedding = face.embedding?.() ?? null;
+    embeddingOf.set(face, embedding);
   }
-  return bytes;
+  return embedding;
+}
+function shapeableBytes(resolved2) {
+  return shapingFace(resolved2)?.sfnt ?? null;
 }
 function shapesWithFeature(family, weight, style, tag, shaper = registered) {
   if (shaper === null) return false;
@@ -1122,19 +1126,23 @@ function graphemeCount(text) {
 var NOTHING_DRAWN = Object.freeze({ d: null, key: "", glyphs: Object.freeze([]), rtl: false, text: "" });
 var COVERED = Object.freeze({ cluster: NOTHING_DRAWN, advance: 0 });
 var slotsOf = /* @__PURE__ */ new WeakMap();
+var atlasSlotsOf = /* @__PURE__ */ new WeakMap();
 var fmt = (v) => String(Math.round(v * 1e5) / 1e5);
 function shapeRun(run, resolved2, shaper) {
   if (shaper === null) return null;
-  const face = shapeableBytes(resolved2);
-  if (face === null) return null;
+  const embedding = shapingFace(resolved2);
+  if (embedding === null) return null;
+  const face = embedding.sfnt;
   const glyphs = shaper.shape(face, run.text, run.fontFeatures, run.lang);
-  let slots2 = slotsOf.get(glyphs);
+  const cache2 = resolved2.source === "outline" ? slotsOf : atlasSlotsOf;
+  let slots2 = cache2.get(glyphs);
   if (slots2) return slots2;
-  slots2 = slotsFor(shaper, face, run.text, glyphs);
-  slotsOf.set(glyphs, slots2);
+  const plain2 = resolved2.source === "outline" ? null : (cp2) => embedding.glyphIndexOf(cp2);
+  slots2 = slotsFor(shaper, face, run.text, glyphs, plain2);
+  cache2.set(glyphs, slots2);
   return slots2;
 }
-function slotsFor(shaper, face, text, glyphs) {
+function slotsFor(shaper, face, text, glyphs, plain2) {
   const slots2 = new Array(text.length);
   const ends = graphemeEnds(text);
   let g = 0;
@@ -1147,7 +1155,7 @@ function slotsFor(shaper, face, text, glyphs) {
     while (g < ends.length && ends[g] <= start2) g++;
     let inner = 0;
     for (let k = g; k < ends.length && ends[k] < end; k++) inner++;
-    if (!holdsNotdef(glyphs, i, j)) {
+    if (!holdsNotdef(glyphs, i, j) && !(plain2 && isPlain(glyphs[i], j - i, text, start2, end, plain2))) {
       const total = advanceOf(glyphs, i, j);
       const share = total / (inner + 1);
       const shift = glyphs[i].rtl ? share - total : 0;
@@ -1163,6 +1171,11 @@ function slotsFor(shaper, face, text, glyphs) {
   }
   return slots2;
 }
+function isPlain(first, count, text, start2, end, plain2) {
+  if (count !== 1 || first.dx !== 0 || first.dy !== 0) return false;
+  const cp2 = text.codePointAt(start2);
+  return end - start2 === (cp2 > 65535 ? 2 : 1) && plain2(cp2) === first.gid;
+}
 function advanceOf(glyphs, from, to) {
   let sum2 = 0;
   for (let k = from; k < to; k++) sum2 += glyphs[k].advance;
@@ -1180,7 +1193,7 @@ function clusterSlot(shaper, face, glyphs, from, to, text, shift, advance) {
   for (let k = from; k < to; k++) {
     const g = glyphs[k];
     const x = pen + g.dx, y = g.dy;
-    placed2.push({ gid: g.gid, x, y });
+    placed2.push({ gid: g.gid, x, y, advance: g.advance });
     d += shaper.glyphD(face, g.gid, x, y) ?? "";
     key += `${k === from ? "" : ";"}${g.gid}${x === 0 && y === 0 ? "" : `@${fmt(x)},${fmt(y)}`}`;
     pen += g.advance;
@@ -1359,7 +1372,7 @@ function mirrorEntries(entries2, levels, mirror, runs) {
     const odd = levels[pos] % 2 === 1;
     if (entry.shaped !== null && entry.shaped.rtl !== odd) {
       const flipped = mirror(entry.cp);
-      if (flipped !== null && flipped !== entry.cp) entry = { ...entry, shaped: null };
+      if (flipped !== null && flipped !== entry.cp) entry = unshaped(entry, runs[entry.run]);
     }
     if (!odd) return entry;
     if (entry.shaped !== null) return entry;
@@ -1372,6 +1385,11 @@ function mirrorEntries(entries2, levels, mirror, runs) {
     return { ...entry, cp: cp2, resolved: hit.resolved, metrics: hit.metrics, font: hit.font, glyph: hit.glyph };
   });
 }
+function unshaped(entry, run) {
+  if (entry.resolved.source === "outline") return { ...entry, shaped: null };
+  const hit = resolveGlyph(entry.resolved, run.fontFamily, run.fontWeight, run.fontStyle, entry.cp, false);
+  return hit ? { ...entry, shaped: null, resolved: hit.resolved, metrics: hit.metrics, font: hit.font, glyph: hit.glyph } : { ...entry, shaped: null };
+}
 
 // src/layout/lineBreak/wrapLines.ts
 var hangs = (cp2) => cp2 === 32 || cp2 === 9;
@@ -1876,9 +1894,9 @@ function takeGroups(out) {
 }
 
 // src/layout/paintRuns.ts
-function glyphOutlineD(g, run, minSize) {
+function glyphOutlineD(g, run, minSize, ungated = false) {
   const outlineOnly = g.resolved.source === "outline";
-  if (!outlineOnly) {
+  if (!outlineOnly && !ungated) {
     if (minSize === void 0) return null;
     if (run.fontSize < minSize && !strokeHasInk(run.stroke)) return null;
   }
@@ -1897,6 +1915,14 @@ function faceOutlineD(g) {
   if (g.resolved.source !== "outline" && g.glyph === null) return null;
   return glyphOutline(family, weight, style, g.cp);
 }
+function shapedQuadGlyph(g) {
+  const face = g.resolved.dynamicFace;
+  const shaped = g.shaped;
+  if (!face || shaped.d === null) return null;
+  const glyph = face.requestShaped(shaped.key, shaped.d);
+  if (!glyph || glyph.page < 0 || glyph.width === 0) return null;
+  return { ...g, font: face.font, glyph };
+}
 function runFaces(runs) {
   const faces = runs.map((r) => faceMetricsOf(cachedFontVariant(r.fontFamily, r.fontWeight, r.fontStyle)));
   return (run) => faces[run];
@@ -1937,7 +1963,13 @@ function paintRunsInto(laid, runs, opts, out) {
       rules?.add(g);
       const run = runs[g.run];
       const inks = cols !== null ? cols.drawsInk(start2, pos) : line.cells[g.cell].drawsInk;
-      const outline = inks ? glyphOutlineD(g, run, opts.outlineMinSize) : null;
+      let outline = inks ? glyphOutlineD(g, run, opts.outlineMinSize) : null;
+      let q = g;
+      if (inks && outline === null && g.shaped) {
+        const baked = shapedQuadGlyph(g);
+        if (baked) q = baked;
+        else outline = glyphOutlineD(g, run, opts.outlineMinSize, true);
+      }
       if (!fillHasInk(run.fill) && !(outline !== null && strokeHasInk(run.stroke))) continue;
       if (outline !== null) {
         const placed2 = { ...outline, x: g.x, baselineY: g.baselineY, scale: g.fontSize };
@@ -1945,8 +1977,8 @@ function paintRunsInto(laid, runs, opts, out) {
         groupFor(runs, g, "outline").glyphs.push(placed2);
         continue;
       }
-      if (!hasGlyphQuad(g)) continue;
-      const group = groupFor(runs, g, g.glyph.color ? "color" : g.resolved.source);
+      if (!hasGlyphQuad(q)) continue;
+      const group = groupFor(runs, q, q.glyph.color ? "color" : q.resolved.source);
       if (sized === null) {
         sized = group;
         group.quadData = buf;
@@ -1954,12 +1986,12 @@ function paintRunsInto(laid, runs, opts, out) {
       let quads = group.quadData;
       if (quads === NO_QUADS) group.quadData = quads = [];
       if (group === sized) {
-        writeGlyphQuad(g, quads, sizedAt);
+        writeGlyphQuad(q, quads, sizedAt);
         sizedAt += QUAD_STRIDE;
       } else {
-        writeGlyphQuad(g, quads, quads.length);
+        writeGlyphQuad(q, quads, quads.length);
       }
-      group.colorGlyphs?.push(g.glyph);
+      group.colorGlyphs?.push(q.glyph);
     }
     if (!rules) continue;
     for (const rule of rules.end()) {
@@ -2388,5 +2420,5 @@ function _resetLayoutCacheForTests() {
 }
 
 export { BREAK_ALLOWED, BREAK_MANDATORY, DECORATION_KINDS, DEFAULT_DECORATION_METRICS, DEFAULT_TAB_SIZE, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, QUAD_STRIDE, _resetBidiWarningForTests, _resetLayoutCacheForTests, cachedLayoutRuns, cachedPaintRuns, clearRuns, decorationMetrics, decorationRule, dropRuns, emboldenGlyph, emboldenGlyphD, faceOutlineD, fontString, graphemeCount, hangs, hasGlyphQuad, isHardLineBreak, layoutRuns, lineBreakOpportunities, lineDecorations, paintRuns, paragraphDirection, registerBidi, registerShaper, registeredBidi, resolveAlign, resolveTextStyle, resolveTextStyleInto, runFaces, shapesWithFeature, syntheticBoldOffset, tabAdvance, warnRtlWithoutEngine, widthWithTabs, wrapLines };
-//# sourceMappingURL=chunk-ZNSU5C43.js.map
-//# sourceMappingURL=chunk-ZNSU5C43.js.map
+//# sourceMappingURL=chunk-WUFANHTE.js.map
+//# sourceMappingURL=chunk-WUFANHTE.js.map