@aethervtt/shard-text 0.0.1

package/dist/index.js

@@ -0,0 +1,140 @@
+import { packRects, SkylinePacker } from "@aethervtt/shard-texture";
+import { buildFont, fontFromBytes } from "./build.js";
+import { charsetCodepoints } from "./charset.js";
+import { Localized, SCREEN_CORNERS, ScreenText, TEXT_ALIGNS, Text } from "./components.js";
+import {
+  Font,
+  FontPage,
+  GLYPH_PADDING,
+  Glyph,
+  RUNTIME_PAGE_SIZE
+} from "./font.js";
+import {
+  atlasLabel,
+  FontAssetType,
+  FontImporter,
+  FontImportSettings,
+  FontStore,
+  Fonts
+} from "./importer.js";
+import { hasGposKerning, readGposKerning } from "./kerning.js";
+import {
+  isCjk,
+  layoutText,
+  measureText,
+  TextLayout
+} from "./layout.js";
+import {
+  installLocalization,
+  KEYED_COMPONENTS,
+  Locale,
+  LocaleState,
+  LocaleStore,
+  loadStringTables,
+  localeChain,
+  localeMethods,
+  localeOfPath,
+  localizationKeysIn,
+  localizeComponent,
+  localizeText,
+  PLURAL_CATEGORIES,
+  placeholdersOf,
+  StringTable,
+  StringTableAssetType,
+  StringTableImporter,
+  StringTables,
+  setLocale,
+  tr,
+  validateLocalization,
+  validateStringTable
+} from "./locale.js";
+import {
+  blitMsdf,
+  generateMsdf,
+  msdfBox,
+  prepareShape
+} from "./msdf.js";
+import { textPlugin } from "./plugin.js";
+import { describeText, prepareTexts, TextRenderer, TextStore } from "./render.js";
+import { TEXT_SHADERS } from "./shaders.js";
+import {
+  colorEdgesSimple,
+  EdgeColor,
+  shapeBounds,
+  shapeFromCommands
+} from "./shape.js";
+import {
+  FontSource,
+  rasterizeGlyph,
+  TOFU_ADVANCE,
+  tofuShape
+} from "./source.js";
+export {
+  EdgeColor,
+  Font,
+  FontAssetType,
+  FontImportSettings,
+  FontImporter,
+  FontPage,
+  FontSource,
+  FontStore,
+  Fonts,
+  GLYPH_PADDING,
+  Glyph,
+  KEYED_COMPONENTS,
+  Locale,
+  LocaleState,
+  LocaleStore,
+  Localized,
+  PLURAL_CATEGORIES,
+  RUNTIME_PAGE_SIZE,
+  SCREEN_CORNERS,
+  ScreenText,
+  SkylinePacker,
+  StringTable,
+  StringTableAssetType,
+  StringTableImporter,
+  StringTables,
+  TEXT_ALIGNS,
+  TEXT_SHADERS,
+  TOFU_ADVANCE,
+  Text,
+  TextLayout,
+  TextRenderer,
+  TextStore,
+  atlasLabel,
+  blitMsdf,
+  buildFont,
+  charsetCodepoints,
+  colorEdgesSimple,
+  describeText,
+  fontFromBytes,
+  generateMsdf,
+  hasGposKerning,
+  installLocalization,
+  isCjk,
+  layoutText,
+  loadStringTables,
+  localeChain,
+  localeMethods,
+  localeOfPath,
+  localizationKeysIn,
+  localizeComponent,
+  localizeText,
+  measureText,
+  msdfBox,
+  packRects,
+  placeholdersOf,
+  prepareShape,
+  prepareTexts,
+  rasterizeGlyph,
+  readGposKerning,
+  setLocale,
+  shapeBounds,
+  shapeFromCommands,
+  textPlugin,
+  tofuShape,
+  tr,
+  validateLocalization,
+  validateStringTable
+};

package/dist/kerning.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Kerning pairs straight from the font's bytes: GPOS pair adjustment (lookup type 2, also inside
+ * type 9 extension lookups, which opentype.js doesn't read) under the `kern` feature. Only pairs
+ * between the given glyphs are collected. Values are in font units.
+ */
+export declare function readGposKerning(bytes: Uint8Array, glyphs: Iterable<number>): Map<number, number>;
+/** Whether the font has a GPOS `kern` feature (then the legacy `kern` table is ignored). */
+export declare function hasGposKerning(bytes: Uint8Array): boolean;

package/dist/kerning.js

@@ -0,0 +1,168 @@
+function tableOffset(view, tag) {
+  if (view.byteLength < 12) return -1;
+  const count = view.getUint16(4);
+  for (let i = 0; i < count; i++) {
+    const rec = 12 + i * 16;
+    if (rec + 16 > view.byteLength) return -1;
+    let name = "";
+    for (let c = 0; c < 4; c++) name += String.fromCharCode(view.getUint8(rec + c));
+    if (name === tag) return view.getUint32(rec + 8);
+  }
+  return -1;
+}
+function readCoverage(view, offset) {
+  const out = /* @__PURE__ */ new Map();
+  const format = view.getUint16(offset);
+  if (format === 1) {
+    const count = view.getUint16(offset + 2);
+    for (let i = 0; i < count; i++) out.set(view.getUint16(offset + 4 + i * 2), i);
+  } else if (format === 2) {
+    const count = view.getUint16(offset + 2);
+    for (let i = 0; i < count; i++) {
+      const rec = offset + 4 + i * 6;
+      const start = view.getUint16(rec);
+      const end = view.getUint16(rec + 2);
+      const index = view.getUint16(rec + 4);
+      for (let g = start; g <= end; g++) out.set(g, index + g - start);
+    }
+  }
+  return out;
+}
+function readClassDef(view, offset) {
+  const out = /* @__PURE__ */ new Map();
+  const format = view.getUint16(offset);
+  if (format === 1) {
+    const start = view.getUint16(offset + 2);
+    const count = view.getUint16(offset + 4);
+    for (let i = 0; i < count; i++) out.set(start + i, view.getUint16(offset + 6 + i * 2));
+  } else if (format === 2) {
+    const count = view.getUint16(offset + 2);
+    for (let i = 0; i < count; i++) {
+      const rec = offset + 4 + i * 6;
+      const start = view.getUint16(rec);
+      const end = view.getUint16(rec + 2);
+      const cls = view.getUint16(rec + 4);
+      for (let g = start; g <= end; g++) out.set(g, cls);
+    }
+  }
+  return out;
+}
+function popcount(v) {
+  let n = 0;
+  for (let x = v; x; x >>= 1) n += x & 1;
+  return n;
+}
+function pairValue(view, rec, format1, format2) {
+  let v = 0;
+  if (format1 & 4) v += view.getInt16(rec + 2 * popcount(format1 & 3));
+  if (format2 & 1) v += view.getInt16(rec + 2 * popcount(format1));
+  return v;
+}
+const pairKey = (a, b) => a * 65536 + b;
+function readGposKerning(bytes, glyphs) {
+  const out = /* @__PURE__ */ new Map();
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const gpos = tableOffset(view, "GPOS");
+  if (gpos < 0) return out;
+  const wanted = [...new Set(glyphs)];
+  const featureList = gpos + view.getUint16(gpos + 6);
+  const lookupList = gpos + view.getUint16(gpos + 8);
+  const lookupIndices = /* @__PURE__ */ new Set();
+  const featureCount = view.getUint16(featureList);
+  for (let i = 0; i < featureCount; i++) {
+    const rec = featureList + 2 + i * 6;
+    let tag = "";
+    for (let c = 0; c < 4; c++) tag += String.fromCharCode(view.getUint8(rec + c));
+    if (tag !== "kern") continue;
+    const feature = featureList + view.getUint16(rec + 4);
+    const count = view.getUint16(feature + 2);
+    for (let j = 0; j < count; j++) lookupIndices.add(view.getUint16(feature + 4 + j * 2));
+  }
+  const lookupCount = view.getUint16(lookupList);
+  for (const index of [...lookupIndices].sort((a, b) => a - b)) {
+    if (index >= lookupCount) continue;
+    const lookup = lookupList + view.getUint16(lookupList + 2 + index * 2);
+    const type = view.getUint16(lookup);
+    const subCount = view.getUint16(lookup + 4);
+    const matched = /* @__PURE__ */ new Set();
+    for (let s = 0; s < subCount; s++) {
+      let sub = lookup + view.getUint16(lookup + 6 + s * 2);
+      let subType = type;
+      if (type === 9) {
+        subType = view.getUint16(sub + 2);
+        sub += view.getUint32(sub + 4);
+      }
+      if (subType !== 2) continue;
+      readPairPos(view, sub, wanted, matched, out);
+    }
+  }
+  for (const [k, v] of out) if (v === 0) out.delete(k);
+  return out;
+}
+function readPairPos(view, sub, wanted, matched, out) {
+  const format = view.getUint16(sub);
+  const coverage = readCoverage(view, sub + view.getUint16(sub + 2));
+  const format1 = view.getUint16(sub + 4);
+  const format2 = view.getUint16(sub + 6);
+  const recordSize = 2 * (popcount(format1) + popcount(format2));
+  if (format === 1) {
+    const setOffsets = sub + 10;
+    for (const g1 of wanted) {
+      const ci = coverage.get(g1);
+      if (ci === void 0) continue;
+      const set = sub + view.getUint16(setOffsets + ci * 2);
+      const count = view.getUint16(set);
+      const seconds = /* @__PURE__ */ new Map();
+      for (let i = 0; i < count; i++) {
+        const rec = set + 2 + i * (2 + recordSize);
+        seconds.set(view.getUint16(rec), rec + 2);
+      }
+      for (const g2 of wanted) {
+        const rec = seconds.get(g2);
+        const key = pairKey(g1, g2);
+        if (rec === void 0 || matched.has(key)) continue;
+        matched.add(key);
+        out.set(key, (out.get(key) ?? 0) + pairValue(view, rec, format1, format2));
+      }
+    }
+  } else if (format === 2) {
+    const class1 = readClassDef(view, sub + view.getUint16(sub + 8));
+    const class2 = readClassDef(view, sub + view.getUint16(sub + 10));
+    const class1Count = view.getUint16(sub + 12);
+    const class2Count = view.getUint16(sub + 14);
+    const records = sub + 16;
+    for (const g1 of wanted) {
+      if (!coverage.has(g1)) continue;
+      const c1 = class1.get(g1) ?? 0;
+      if (c1 >= class1Count) continue;
+      for (const g2 of wanted) {
+        const key = pairKey(g1, g2);
+        if (matched.has(key)) continue;
+        const c2 = class2.get(g2) ?? 0;
+        if (c2 >= class2Count) continue;
+        matched.add(key);
+        const rec = records + (c1 * class2Count + c2) * recordSize;
+        const v = pairValue(view, rec, format1, format2);
+        if (v !== 0) out.set(key, (out.get(key) ?? 0) + v);
+      }
+    }
+  }
+}
+function hasGposKerning(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const gpos = tableOffset(view, "GPOS");
+  if (gpos < 0) return false;
+  const featureList = gpos + view.getUint16(gpos + 6);
+  const count = view.getUint16(featureList);
+  for (let i = 0; i < count; i++) {
+    const rec = featureList + 2 + i * 6;
+    let tag = "";
+    for (let c = 0; c < 4; c++) tag += String.fromCharCode(view.getUint8(rec + c));
+    if (tag === "kern") return true;
+  }
+  return false;
+}
+export {
+  hasGposKerning,
+  readGposKerning
+};

package/dist/layout.d.ts

@@ -0,0 +1,84 @@
+import type { Font, FontPage, Glyph } from './font.js';
+export type TextAlign = 'left' | 'center' | 'right';
+export interface TextLayoutOptions {
+    /** Layout units per em (world units, or pixels for screen text). Default 1. */
+    size?: number;
+    /** Line alignment within the block. Default 'left'. */
+    align?: TextAlign;
+    /**
+     * Pivot of the text block, normalized, y up: [0, 0] is the bottom-left corner, [1, 1] the
+     * top-right, [0.5, 0.5] (default) the center. The pivot sits at the layout origin.
+     */
+    anchor?: readonly [number, number];
+    /** Wrap lines longer than this (layout units); 0 (default) never wraps. */
+    maxWidth?: number;
+    /** Distance between baselines, as a multiple of the size. Default 1.2. */
+    lineHeight?: number;
+    /** Extra space between glyphs, in em. Default 0. */
+    letterSpacing?: number;
+    /** Apply kerning pairs. Default true. */
+    kerning?: boolean;
+}
+export interface TextLine {
+    /** UTF-16 range in the value: [start, end). Excludes the break's collapsed space or '\n'. */
+    start: number;
+    end: number;
+    /** Advance width, trailing spaces excluded (layout units). */
+    width: number;
+}
+export interface TextMetrics {
+    width: number;
+    height: number;
+    lines: TextLine[];
+}
+/**
+ * Glyph instances of a laid-out string, in reusable typed arrays: laying out into the same object
+ * again doesn't allocate once its arrays are big enough. Positions are layout units, y up, with
+ * the block's anchor at the origin.
+ */
+export declare class TextLayout {
+    /** Glyph quads drawn (spaces and other blank glyphs aren't). */
+    count: number;
+    /** Per quad: x, y (bottom-left corner), width, height. */
+    quads: Float32Array<ArrayBuffer>;
+    /** Per quad: u0, v0, u1, v1 in texture space (v down); (u0, v0) is the quad's top-left. */
+    uvs: Float32Array<ArrayBuffer>;
+    /** Per quad: index into `pages`. */
+    page: Uint16Array<ArrayBuffer>;
+    /** Per quad: UTF-16 index of its character in the value. */
+    source: Uint32Array<ArrayBuffer>;
+    /** Per quad: the glyph (font, codepoint, runtime or fallback). Entries past `count` are stale. */
+    glyphs: Glyph[];
+    /** Atlas pages the quads sample, in first-use order. Entries past `pageCount` are stale. */
+    pages: FontPage[];
+    pageCount: number;
+    /** Block size (layout units): widest line, and ascent to descent over all lines. */
+    width: number;
+    height: number;
+    /** Block bounds relative to the origin (after the anchor). */
+    left: number;
+    bottom: number;
+    lineCount: number;
+    /** Per line: UTF-16 [start, end), width, first quad. */
+    lineStart: Uint32Array<ArrayBuffer>;
+    lineEnd: Uint32Array<ArrayBuffer>;
+    lineWidth: Float32Array<ArrayBuffer>;
+    lineQuad: Uint32Array<ArrayBuffer>;
+    /** Characters that fell back to the missing-glyph box. */
+    missing: number;
+    /** Bumps on every layout. */
+    version: number;
+    /** Lines as objects (allocates). */
+    lines(): TextLine[];
+}
+/** CJK ideographs, kana, Hangul, and fullwidth forms: a line may break between any two. */
+export declare function isCjk(cp: number): boolean;
+/**
+ * Lays out `value` into `out` (reused; its arrays grow as needed): advances and kerning, line
+ * breaks at spaces (the breaking space collapses), at '\n', between CJK characters, and inside a
+ * word wider than `maxWidth`; then alignment and the anchor. Doesn't allocate once `out` is big
+ * enough, except when a new glyph has to be generated.
+ */
+export declare function layoutText(font: Font, value: string, options?: TextLayoutOptions, out?: TextLayout): TextLayout;
+/** Measures a string without keeping glyph instances: its block size and line breaks. */
+export declare function measureText(font: Font, value: string, options?: TextLayoutOptions): TextMetrics;

package/dist/layout.js

@@ -0,0 +1,297 @@
+function grow(a, n) {
+  if (a.length >= n) return a;
+  let len = Math.max(16, a.length * 2);
+  while (len < n) len *= 2;
+  const out = new a.constructor(len);
+  out.set(a);
+  return out;
+}
+class TextLayout {
+  /** Glyph quads drawn (spaces and other blank glyphs aren't). */
+  count = 0;
+  /** Per quad: x, y (bottom-left corner), width, height. */
+  quads = new Float32Array(64);
+  /** Per quad: u0, v0, u1, v1 in texture space (v down); (u0, v0) is the quad's top-left. */
+  uvs = new Float32Array(64);
+  /** Per quad: index into `pages`. */
+  page = new Uint16Array(16);
+  /** Per quad: UTF-16 index of its character in the value. */
+  source = new Uint32Array(16);
+  /** Per quad: the glyph (font, codepoint, runtime or fallback). Entries past `count` are stale. */
+  glyphs = [];
+  /** Atlas pages the quads sample, in first-use order. Entries past `pageCount` are stale. */
+  pages = [];
+  pageCount = 0;
+  /** Block size (layout units): widest line, and ascent to descent over all lines. */
+  width = 0;
+  height = 0;
+  /** Block bounds relative to the origin (after the anchor). */
+  left = 0;
+  bottom = 0;
+  lineCount = 0;
+  /** Per line: UTF-16 [start, end), width, first quad. */
+  lineStart = new Uint32Array(8);
+  lineEnd = new Uint32Array(8);
+  lineWidth = new Float32Array(8);
+  lineQuad = new Uint32Array(8);
+  /** Characters that fell back to the missing-glyph box. */
+  missing = 0;
+  /** Bumps on every layout. */
+  version = 0;
+  /** Lines as objects (allocates). */
+  lines() {
+    const out = [];
+    for (let i = 0; i < this.lineCount; i++) {
+      out.push({ start: this.lineStart[i], end: this.lineEnd[i], width: this.lineWidth[i] });
+    }
+    return out;
+  }
+}
+function isCjk(cp) {
+  return cp >= 11904 && cp <= 40959 || cp >= 4352 && cp <= 4607 || cp >= 43360 && cp <= 43391 || cp >= 44032 && cp <= 55215 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65519 || cp >= 131072 && cp <= 262143;
+}
+const NO_BREAK_BEFORE = /* @__PURE__ */ new Set();
+for (const ch of "\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\uFF09\u300D\u300F\u3011\u3015\u3009\u300B\u3019\u3017\u309D\u309E\u30FD\u30FE\u30FC\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308E\u3095\u3096\u30A1\u30A3\u30A5\u30A7\u30A9\u30C3\u30E3\u30E5\u30E7\u30EE\u30F5\u30F6\u3005\u303B\u2010\u30A0\u301C\u2026\u2025\uFF01\uFF09\uFF0C\uFF0E\uFF1A\uFF1B\uFF1F\uFF3D\uFF5D\uFF61\uFF63\uFF64\uFF65\uFF70") {
+  NO_BREAK_BEFORE.add(ch.codePointAt(0));
+}
+const NO_BREAK_AFTER = /* @__PURE__ */ new Set();
+for (const ch of "\uFF08\u300C\u300E\u3010\u3014\u3008\u300A\u3018\u3016\uFF3B\uFF5B\uFF62") NO_BREAK_AFTER.add(ch.codePointAt(0));
+const isSpace = (cp) => cp === 32 || cp === 9 || cp === 12288;
+const scratch = new TextLayout();
+function layoutText(font, value, options = {}, out = new TextLayout()) {
+  const size = options.size ?? 1;
+  const maxWidth = options.maxWidth ?? 0;
+  const lineAdvance = (options.lineHeight ?? 1.2) * size;
+  const spacing = (options.letterSpacing ?? 0) * size;
+  const kerning = options.kerning !== false;
+  const alignFactor = options.align === "center" ? 0.5 : options.align === "right" ? 1 : 0;
+  const anchor = options.anchor;
+  const anchorX = anchor ? anchor[0] : 0.5;
+  const anchorY = anchor ? anchor[1] : 0.5;
+  const limit = maxWidth > 0 ? maxWidth + size * 1e-6 : Infinity;
+  out.count = 0;
+  out.lineCount = 0;
+  out.missing = 0;
+  out.version++;
+  const notdef = font.notdef;
+  let count = 0;
+  let quads = out.quads;
+  let uvs = out.uvs;
+  let pageOf = out.page;
+  let sourceOf = out.source;
+  const glyphs = out.glyphs;
+  const pages = out.pages;
+  let lastPage;
+  let lastPageIndex = 0;
+  let pageCount = 0;
+  let lineStartChar = 0;
+  let lineQuad = 0;
+  let pen = 0;
+  let contentEnd = 0;
+  let contentEndChar = 0;
+  let prev = null;
+  let prevCp = -1;
+  let prevSpace = false;
+  let opp = false;
+  let oppChar = 0;
+  let oppQuad = 0;
+  let oppPen = 0;
+  let oppWidth = 0;
+  let oppEnd = 0;
+  const n = value.length;
+  let i = 0;
+  while (i <= n) {
+    let cp = -1;
+    let next = i + 1;
+    if (i < n) {
+      cp = value.charCodeAt(i);
+      if (cp >= 55296 && cp <= 56319 && i + 1 < n) {
+        const lo = value.charCodeAt(i + 1);
+        if (lo >= 56320 && lo <= 57343) {
+          cp = (cp - 55296 << 10) + (lo - 56320) + 65536;
+          next = i + 2;
+        }
+      }
+    }
+    if (cp === -1 || cp === 10) {
+      out.lineCount = pushLine(out, lineStartChar, i, contentEnd, lineQuad);
+      if (cp === -1) break;
+      lineStartChar = next;
+      lineQuad = count;
+      pen = 0;
+      contentEnd = 0;
+      contentEndChar = next;
+      prev = null;
+      prevCp = -1;
+      prevSpace = false;
+      opp = false;
+      i = next;
+      continue;
+    }
+    if (cp === 13) {
+      i = next;
+      continue;
+    }
+    const space = isSpace(cp);
+    let g = font.resolve(cp === 9 ? 32 : cp);
+    if (g === notdef) {
+      if (space) g = font.resolve(32);
+      else out.missing++;
+    }
+    let kern = 0;
+    if (prev !== null) {
+      kern = spacing;
+      if (kerning && prev.kernCount > 0 && prev.font === g.font) {
+        const f = prev.font;
+        const keys = f.kernRight;
+        const target = g.codepoint;
+        let lo = prev.kernStart;
+        let hi = lo + prev.kernCount - 1;
+        while (lo <= hi) {
+          const mid = lo + hi >> 1;
+          const k = keys[mid];
+          if (k === target) {
+            kern += f.kernValue[mid] * size;
+            break;
+          }
+          if (k < target) lo = mid + 1;
+          else hi = mid - 1;
+        }
+      }
+    }
+    if (!space && prev !== null) {
+      if (prevSpace) {
+        if (contentEnd > 0 || count > lineQuad) {
+          opp = true;
+          oppChar = i;
+          oppQuad = count;
+          oppPen = pen + kern;
+          oppWidth = contentEnd;
+          oppEnd = contentEndChar;
+        }
+      } else if ((isCjk(cp) || isCjk(prevCp)) && !NO_BREAK_BEFORE.has(cp) && !NO_BREAK_AFTER.has(prevCp)) {
+        opp = true;
+        oppChar = i;
+        oppQuad = count;
+        oppPen = pen + kern;
+        oppWidth = contentEnd;
+        oppEnd = i;
+      }
+    }
+    let x = pen + kern;
+    let advanceEnd = x + g.advance * size;
+    if (!space && advanceEnd > limit && (count > lineQuad || contentEnd > 0)) {
+      if (opp) {
+        out.lineCount = pushLine(out, lineStartChar, oppEnd, oppWidth, lineQuad);
+        for (let q = oppQuad; q < count; q++) quads[q * 4] = quads[q * 4] - oppPen;
+        lineStartChar = oppChar;
+        lineQuad = oppQuad;
+        pen -= oppPen;
+        contentEnd -= oppPen;
+        if (contentEnd < 0) contentEnd = 0;
+        x -= oppPen;
+        advanceEnd -= oppPen;
+        opp = false;
+      }
+      if (advanceEnd > limit && (count > lineQuad || contentEnd > 0)) {
+        out.lineCount = pushLine(out, lineStartChar, i, contentEnd, lineQuad);
+        lineStartChar = i;
+        lineQuad = count;
+        advanceEnd -= x;
+        x = 0;
+        pen = 0;
+        contentEnd = 0;
+      }
+    }
+    if (g.visible) {
+      if (count * 4 + 4 > quads.length) {
+        quads = out.quads = grow(quads, count * 4 + 4);
+        uvs = out.uvs = grow(uvs, count * 4 + 4);
+        pageOf = out.page = grow(pageOf, count + 1);
+        sourceOf = out.source = grow(sourceOf, count + 1);
+      }
+      const o = count * 4;
+      quads[o] = x + g.left * size;
+      quads[o + 1] = g.bottom * size;
+      quads[o + 2] = (g.right - g.left) * size;
+      quads[o + 3] = (g.top - g.bottom) * size;
+      uvs[o] = g.u0;
+      uvs[o + 1] = g.v0;
+      uvs[o + 2] = g.u1;
+      uvs[o + 3] = g.v1;
+      const page = g.font.pages[g.page];
+      if (page !== lastPage) {
+        let p = 0;
+        while (p < pageCount && pages[p] !== page) p++;
+        if (p === pageCount) {
+          if (p < pages.length) pages[p] = page;
+          else pages.push(page);
+          pageCount++;
+        }
+        lastPage = page;
+        lastPageIndex = p;
+      }
+      pageOf[count] = lastPageIndex;
+      sourceOf[count] = i;
+      if (count < glyphs.length) glyphs[count] = g;
+      else glyphs.push(g);
+      count++;
+    }
+    pen = advanceEnd;
+    if (!space) {
+      contentEnd = pen;
+      contentEndChar = next;
+    }
+    prev = g;
+    prevCp = cp;
+    prevSpace = space;
+    i = next;
+  }
+  out.count = count;
+  out.pageCount = pageCount;
+  let width = 0;
+  const lines = out.lineCount;
+  for (let l = 0; l < lines; l++) if (out.lineWidth[l] > width) width = out.lineWidth[l];
+  const height = lines > 0 ? (font.ascent - font.descent) * size + (lines - 1) * lineAdvance : 0;
+  const left = -anchorX * width;
+  const bottom = -anchorY * height;
+  const top = bottom + height;
+  for (let l = 0; l < lines; l++) {
+    const dx = left + (width - out.lineWidth[l]) * alignFactor;
+    const baseline = top - font.ascent * size - l * lineAdvance;
+    const end = l + 1 < lines ? out.lineQuad[l + 1] : count;
+    for (let q = out.lineQuad[l]; q < end; q++) {
+      quads[q * 4] = quads[q * 4] + dx;
+      quads[q * 4 + 1] = quads[q * 4 + 1] + baseline;
+    }
+  }
+  out.width = width;
+  out.height = height;
+  out.left = left;
+  out.bottom = bottom;
+  return out;
+}
+function pushLine(out, start, end, width, quad) {
+  const l = out.lineCount;
+  if (l >= out.lineStart.length) {
+    out.lineStart = grow(out.lineStart, l + 1);
+    out.lineEnd = grow(out.lineEnd, l + 1);
+    out.lineWidth = grow(out.lineWidth, l + 1);
+    out.lineQuad = grow(out.lineQuad, l + 1);
+  }
+  out.lineStart[l] = start;
+  out.lineEnd[l] = end;
+  out.lineWidth[l] = width;
+  out.lineQuad[l] = quad;
+  return l + 1;
+}
+function measureText(font, value, options = {}) {
+  const layout = layoutText(font, value, options, scratch);
+  return { width: layout.width, height: layout.height, lines: layout.lines() };
+}
+export {
+  TextLayout,
+  isCjk,
+  layoutText,
+  measureText
+};