@weasel-js/text 1.12.0 → 1.13.0

package/dist/{chunk-ADRQIIHS.js → chunk-DOTR55MR.js}

@@ -619,6 +619,180 @@ function orderLine(paragraphs, start, count) {
   return { visual: restoreRemoved([...kept], count, (pos) => levels[pos] % 2 === 1), levels };
 }
 
+// src/layout/layoutColumns.ts
+var NUM = 12;
+var X = 0;
+var STEP = 1;
+var ADVANCE = 2;
+var FONT_SIZE = 3;
+var BASELINE = 4;
+var SRC_INDEX = 5;
+var SRC_END = 6;
+var CP3 = 7;
+var LEVEL = 8;
+var FLAGS = 9;
+var RUN = 10;
+var VISUAL = 11;
+var DRAWS_INK = 1;
+var CLUSTER_END = 2;
+var REF = 4;
+var TEMPLATE_LIMIT = 1 << 16;
+var template = [0.5];
+function doubles(n) {
+  if (n > TEMPLATE_LIMIT) return new Array(n).fill(0.5);
+  while (template.length < n) template = template.concat(template);
+  return template.slice(0, n);
+}
+var LayoutColumns = class {
+  num;
+  ref;
+  constructor(size) {
+    this.num = doubles(size * NUM);
+    this.ref = new Array(size * REF);
+  }
+  /** Store code point `i`: entry `e`, set at `x` on a baseline at `baselineY`,
+   *  moving the pen `step`. */
+  set(i, e, level, x, step, baselineY) {
+    const n = i * NUM, r = i * REF;
+    const { num, ref } = this;
+    num[n + X] = x;
+    num[n + STEP] = step;
+    num[n + ADVANCE] = e.advance;
+    num[n + FONT_SIZE] = e.fontSize;
+    num[n + BASELINE] = baselineY;
+    num[n + SRC_INDEX] = e.srcIndex;
+    num[n + SRC_END] = e.srcEnd;
+    num[n + CP3] = e.cp;
+    num[n + LEVEL] = level;
+    num[n + RUN] = e.run;
+    num[n + FLAGS] = (e.drawsInk ? DRAWS_INK : 0) | (e.clusterEnd ? CLUSTER_END : 0);
+    ref[r] = e.resolved;
+    ref[r + 1] = e.metrics;
+    ref[r + 2] = e.font;
+    ref[r + 3] = e.glyph;
+  }
+  /** Record that the `slot`-th code point the pen reaches on the line starting
+   *  at `start` is the line's `pos`-th in logical order. */
+  setVisual(start, slot, pos) {
+    this.num[(start + slot) * NUM + VISUAL] = pos;
+  }
+  /** Logical index, within its line, of the glyph at visual `slot`. */
+  visual(start, slot) {
+    return this.num[(start + slot) * NUM + VISUAL];
+  }
+  /** Fill `out` with code point `start + pos`'s placed glyph and return it.
+   *  Every field is overwritten, so one object can walk a whole layout. */
+  glyph(start, pos, out) {
+    const i = start + pos;
+    const n = i * NUM, r = i * REF;
+    const { num, ref } = this;
+    out.run = num[n + RUN];
+    out.cell = pos;
+    out.cp = num[n + CP3];
+    out.fontSize = num[n + FONT_SIZE];
+    out.resolved = ref[r];
+    out.metrics = ref[r + 1];
+    out.font = ref[r + 2];
+    out.glyph = ref[r + 3];
+    out.x = num[n + X];
+    out.baselineY = num[n + BASELINE];
+    out.advance = num[n + ADVANCE];
+    out.step = num[n + STEP];
+    return out;
+  }
+  /** Code point `start + pos`'s cell, as a new object. */
+  cell(start, pos) {
+    const n = (start + pos) * NUM;
+    const { num } = this;
+    const flags = num[n + FLAGS];
+    return {
+      srcIndex: num[n + SRC_INDEX],
+      srcEnd: num[n + SRC_END],
+      cp: num[n + CP3],
+      x: num[n + X],
+      advance: num[n + STEP],
+      level: num[n + LEVEL],
+      drawsInk: (flags & DRAWS_INK) !== 0,
+      clusterEnd: (flags & CLUSTER_END) !== 0
+    };
+  }
+};
+function blankGlyph() {
+  return {
+    run: 0,
+    cell: 0,
+    cp: 0,
+    fontSize: 0.5,
+    resolved: null,
+    metrics: null,
+    font: null,
+    glyph: null,
+    x: 0.5,
+    baselineY: 0.5,
+    advance: 0.5,
+    step: 0.5
+  };
+}
+var LineBox = class _LineBox {
+  x0;
+  y0;
+  x1;
+  y1;
+  baselineY;
+  srcEnd;
+  justified;
+  #cols;
+  #start;
+  #count;
+  constructor(f, cols, start, count) {
+    this.x0 = f.x0;
+    this.y0 = f.y0;
+    this.x1 = f.x1;
+    this.y1 = f.y1;
+    this.baselineY = f.baselineY;
+    this.srcEnd = f.srcEnd;
+    this.justified = f.justified;
+    this.#cols = cols;
+    this.#start = start;
+    this.#count = count;
+    Object.defineProperties(this, _LineBox.#views);
+  }
+  /** The line's code points in its layout's columns, for a reader that walks
+   *  them without building the views; null for a line built by hand. */
+  static span(line) {
+    return line instanceof _LineBox ? { cols: line.#cols, start: line.#start, count: line.#count } : null;
+  }
+  /** How many code points the line holds, without building a view. */
+  static count(line) {
+    return line instanceof _LineBox ? line.#count : line.glyphs.length;
+  }
+  static #views = {
+    cells: lazy("cells", (l) => {
+      const out = new Array(l.#count);
+      for (let pos = 0; pos < l.#count; pos++) out[pos] = l.#cols.cell(l.#start, pos);
+      return out;
+    }),
+    glyphs: lazy("glyphs", (l) => {
+      const out = new Array(l.#count);
+      for (let slot = 0; slot < l.#count; slot++) {
+        out[slot] = l.#cols.glyph(l.#start, l.#cols.visual(l.#start, slot), blankGlyph());
+      }
+      return out;
+    })
+  };
+};
+function lazy(key, build) {
+  return {
+    enumerable: true,
+    configurable: true,
+    get() {
+      const value = build(this);
+      Object.defineProperty(this, key, { value, enumerable: true, configurable: true, writable: false });
+      return value;
+    }
+  };
+}
+
 // src/measure/graphemes.ts
 var segmenter;
 var NEEDS_SEGMENTING = /[\r\u0300-\uffff]/;
@@ -808,8 +982,9 @@ function aboveBaseline(e, lineHeight) {
   if (e.metrics.descent === void 0) return ascent;
   return (e.lineSize * lineHeight - ascent - e.metrics.descent * k) / 2 + ascent;
 }
-function breakLines(entries, maxWidth, lineHeight) {
-  const sum = new Float64Array(entries.length + 1);
+function breakLines(entries, cps, maxWidth, lineHeight) {
+  const sum = doubles(entries.length + 1);
+  sum[0] = 0;
   const tabs = [];
   entries.forEach((e, k) => {
     sum[k + 1] = sum[k] + e.kerningBefore + e.advance + e.tracking;
@@ -817,7 +992,7 @@ function breakLines(entries, maxWidth, lineHeight) {
   });
   const flatWidth = (start, end) => entries[start].advance + entries[start].tracking + sum[end] - sum[start + 1];
   const widthOf = tabs.length === 0 ? flatWidth : (start, end) => widthWithTabs(start, end, tabs, (k) => entries[k].tab, flatWidth);
-  return wrapLines(entries.map((e) => e.cp), maxWidth, widthOf).map((span) => {
+  return wrapLines(cps, maxWidth, widthOf).map((span) => {
     const line = {
       start: span.start,
       entries: [],
@@ -870,66 +1045,41 @@ function alignOffset(align, alignWidth, inkWidth) {
   const slack = alignWidth - inkWidth;
   return align === "center" ? slack / 2 : slack;
 }
-function placeLine(line, y, order, align, alignWidth, justify) {
+var NO_GAPS = /* @__PURE__ */ new Set();
+function placeLine(line, y, order, align, alignWidth, justify, cols, start) {
   const { entries } = line;
   const hung = hungWidth(entries);
   const inkWidth = line.width - hung;
   const slack = alignWidth - inkWidth;
-  const gaps = justify && line.wrapped && Number.isFinite(alignWidth) && slack > 0 ? wordGaps(entries) : /* @__PURE__ */ new Set();
+  const gaps = justify && line.wrapped && Number.isFinite(alignWidth) && slack > 0 ? wordGaps(entries) : NO_GAPS;
   const gapExtra = gaps.size > 0 ? slack / gaps.size : 0;
   const spread = gapExtra * gaps.size;
   const inkLeft = spread > 0 ? 0 : alignOffset(align, alignWidth, inkWidth);
   const hangsLeft = hung > 0 && order.levels[entries.length - 1] % 2 === 1;
   const left = hangsLeft ? inkLeft - hung : inkLeft;
   const lineBaselineY = y + line.ascent;
-  const cells = new Array(entries.length);
-  const glyphs = [];
   let penX = left;
   let prevPos = -1;
+  let slot = 0;
   for (const pos of order.visual) {
     const e = entries[pos];
     penX += prevPos < 0 ? 0 : pos === prevPos + 1 ? e.kerningBefore : prevPos === pos + 1 ? entries[prevPos].kerningBefore : 0;
     prevPos = pos;
     const step = e.advance + e.tracking + (gaps.has(pos) ? gapExtra : 0);
-    cells[pos] = {
-      srcIndex: e.srcIndex,
-      srcEnd: e.srcEnd,
-      cp: e.cp,
-      x: penX,
-      advance: step,
-      level: order.levels[pos],
-      drawsInk: e.drawsInk,
-      clusterEnd: e.clusterEnd
-    };
-    glyphs.push({
-      run: e.run,
-      cell: pos,
-      cp: e.cp,
-      fontSize: e.fontSize,
-      resolved: e.resolved,
-      metrics: e.metrics,
-      font: e.font,
-      glyph: e.glyph,
-      x: penX,
-      // Positive raises, and y grows down, so the shift subtracts.
-      baselineY: lineBaselineY - e.baselineShift,
-      advance: e.advance,
-      step
-    });
+    cols.set(start + pos, e, order.levels[pos], penX, step, lineBaselineY - e.baselineShift);
+    cols.setVisual(start, slot++, pos);
     penX += step;
   }
   return {
-    box: {
+    box: new LineBox({
       x0: left,
       y0: y,
       x1: left + line.width + spread,
       y1: y + line.height,
       baselineY: lineBaselineY,
-      cells,
-      glyphs,
       srcEnd: line.srcEnd,
       justified: spread > 0
-    },
+    }, cols, start, entries.length),
     inkWidth: inkWidth + spread
   };
 }
@@ -956,14 +1106,20 @@ function layoutRuns(runs, opts) {
   const { bidi } = o;
   const paragraphs = bidi ? analyzeParagraphs(bidi, cps, (i) => isHardLineBreak(cps[i]), o.direction) : null;
   if (!bidi) warnRtlWithoutEngine(cps);
+  const broken = breakLines(entries, cps, o.maxWidth, o.lineHeight);
+  let size = 0;
+  for (const line of broken) size += line.entries.length;
+  const cols = new LayoutColumns(size);
   const lines = [];
   let y = 0;
   let width = 0;
-  for (const line of breakLines(entries, o.maxWidth, o.lineHeight)) {
+  let start = 0;
+  for (const line of broken) {
     const order = orderLine(paragraphs, line.start, line.entries.length);
     if (bidi) line.entries = mirrorEntries(line.entries, order.levels, (cp) => bidi.mirror(cp), runs);
     const reads = o.direction !== "auto" ? o.direction : directionOfLevel(line.entries.length > 0 ? paragraphs?.baseLevel(line.start) ?? 0 : 0);
-    const placed = placeLine(line, y, order, resolveAlign(o.align, reads), o.alignWidth, o.justify);
+    const placed = placeLine(line, y, order, resolveAlign(o.align, reads), o.alignWidth, o.justify, cols, start);
+    start += line.entries.length;
     lines.push(placed.box);
     width = Math.max(width, placed.inkWidth);
     y += line.height;
@@ -1038,6 +1194,6 @@ function _resetLayoutCacheForTests() {
   structuralGeneration = -1;
 }
 
-export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_TAB_SIZE, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, _resetBidiWarningForTests, _resetLayoutCacheForTests, cachedLayoutRuns, fontString, graphemeCount, hangs, isHardLineBreak, layoutRuns, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle, tabAdvance, widthWithTabs, wrapLines };
-//# sourceMappingURL=chunk-ADRQIIHS.js.map
-//# sourceMappingURL=chunk-ADRQIIHS.js.map
+export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_TAB_SIZE, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, LineBox, NO_BREAK, _resetBidiWarningForTests, _resetLayoutCacheForTests, blankGlyph, cachedLayoutRuns, doubles, fontString, graphemeCount, hangs, isHardLineBreak, layoutRuns, lazy, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle, tabAdvance, widthWithTabs, wrapLines };
+//# sourceMappingURL=chunk-DOTR55MR.js.map
+//# sourceMappingURL=chunk-DOTR55MR.js.map