@aethervtt/shard-text 0.0.1

package/dist/shape.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Glyph outlines as msdfgen shapes: contours of linear, quadratic, and cubic edge segments, plus
+ * msdfgen's simple edge coloring. Built once per glyph (not a per-pixel path), so plain objects are
+ * fine here; the generator flattens them into typed arrays.
+ */
+/** Edge colors are channel bit masks (red 1, green 2, blue 4). */
+export declare const EdgeColor: {
+    readonly black: 0;
+    readonly red: 1;
+    readonly green: 2;
+    readonly yellow: 3;
+    readonly blue: 4;
+    readonly magenta: 5;
+    readonly cyan: 6;
+    readonly white: 7;
+};
+export type EdgeKind = 1 | 2 | 3;
+export interface Edge {
+    /** 1 linear, 2 quadratic, 3 cubic: the curve's degree. */
+    kind: EdgeKind;
+    /** Control points x0, y0, x1, y1, …: 2, 3, or 4 points. */
+    p: number[];
+    color: number;
+}
+export interface Contour {
+    edges: Edge[];
+}
+export interface Shape {
+    contours: Contour[];
+}
+/** Outline commands in font units, y up (opentype.js `path.commands`). */
+export type OutlineCommand = {
+    type: 'M';
+    x: number;
+    y: number;
+} | {
+    type: 'L';
+    x: number;
+    y: number;
+} | {
+    type: 'Q';
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    type: 'C';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: 'Z';
+};
+export declare function linear(x0: number, y0: number, x1: number, y1: number): Edge;
+/** Builds a shape from path commands, closing open contours and dropping zero-length edges. */
+export declare function shapeFromCommands(commands: readonly OutlineCommand[]): Shape;
+/** A point on the edge at `t`, into `out`. */
+export declare function edgePoint(e: Edge, t: number, out: number[]): void;
+/** The (unnormalized) tangent at `t`, with msdfgen's fallbacks for degenerate control points. */
+export declare function edgeDirection(e: Edge, t: number, out: number[]): void;
+export declare function splitInThirds(e: Edge): [Edge, Edge, Edge];
+export declare function reverseContour(c: Contour): void;
+/** +1 or -1 by orientation (msdfgen's `Contour::winding`), 0 if empty. */
+export declare function contourWinding(c: Contour): number;
+/** Exact bounds [left, bottom, right, top] of the shape, or undefined when it has no edges. */
+export declare function shapeBounds(shape: Shape): [number, number, number, number] | undefined;
+/** Splits single-edge contours in thirds so they can take three colors (msdfgen `normalize`). */
+export declare function normalizeShape(shape: Shape): void;
+/**
+ * msdfgen's `edgeColoringSimple`: corners are where the direction turns by more than
+ * `angleThreshold` radians; edges between corners share a color, and neighbors across a corner
+ * differ, so each corner is where two channels meet.
+ */
+export declare function colorEdgesSimple(shape: Shape, angleThreshold?: number, seedValue?: number): void;

package/dist/shape.js

@@ -0,0 +1,404 @@
+const EdgeColor = {
+  black: 0,
+  red: 1,
+  green: 2,
+  yellow: 3,
+  blue: 4,
+  magenta: 5,
+  cyan: 6,
+  white: 7
+};
+function linear(x0, y0, x1, y1) {
+  return { kind: 1, p: [x0, y0, x1, y1], color: EdgeColor.white };
+}
+function shapeFromCommands(commands) {
+  const contours = [];
+  let edges = [];
+  let sx = 0;
+  let sy = 0;
+  let x = 0;
+  let y = 0;
+  const close = () => {
+    if (edges.length > 0 && (x !== sx || y !== sy)) edges.push(linear(x, y, sx, sy));
+    if (edges.length > 0) contours.push({ edges });
+    edges = [];
+    x = sx;
+    y = sy;
+  };
+  for (const c of commands) {
+    switch (c.type) {
+      case "M":
+        close();
+        sx = x = c.x;
+        sy = y = c.y;
+        break;
+      case "L":
+        if (c.x !== x || c.y !== y) edges.push(linear(x, y, c.x, c.y));
+        x = c.x;
+        y = c.y;
+        break;
+      case "Q":
+        if (c.x !== x || c.y !== y || c.x1 !== x || c.y1 !== y) {
+          edges.push({ kind: 2, p: [x, y, c.x1, c.y1, c.x, c.y], color: EdgeColor.white });
+        }
+        x = c.x;
+        y = c.y;
+        break;
+      case "C":
+        if (c.x !== x || c.y !== y || c.x1 !== x || c.y1 !== y || c.x2 !== x || c.y2 !== y) {
+          edges.push({
+            kind: 3,
+            p: [x, y, c.x1, c.y1, c.x2, c.y2, c.x, c.y],
+            color: EdgeColor.white
+          });
+        }
+        x = c.x;
+        y = c.y;
+        break;
+      case "Z":
+        close();
+        break;
+    }
+  }
+  close();
+  return { contours };
+}
+function edgePoint(e, t, out) {
+  const p = e.p;
+  const s = 1 - t;
+  if (e.kind === 1) {
+    out[0] = s * p[0] + t * p[2];
+    out[1] = s * p[1] + t * p[3];
+  } else if (e.kind === 2) {
+    const a = s * s;
+    const b = 2 * s * t;
+    const c = t * t;
+    out[0] = a * p[0] + b * p[2] + c * p[4];
+    out[1] = a * p[1] + b * p[3] + c * p[5];
+  } else {
+    const a = s * s * s;
+    const b = 3 * s * s * t;
+    const c = 3 * s * t * t;
+    const d = t * t * t;
+    out[0] = a * p[0] + b * p[2] + c * p[4] + d * p[6];
+    out[1] = a * p[1] + b * p[3] + c * p[5] + d * p[7];
+  }
+}
+function edgeDirection(e, t, out) {
+  const p = e.p;
+  if (e.kind === 1) {
+    out[0] = p[2] - p[0];
+    out[1] = p[3] - p[1];
+  } else if (e.kind === 2) {
+    const ax = p[2] - p[0];
+    const ay = p[3] - p[1];
+    const bx = p[4] - p[2];
+    const by = p[5] - p[3];
+    out[0] = ax + (bx - ax) * t;
+    out[1] = ay + (by - ay) * t;
+    if (out[0] === 0 && out[1] === 0) {
+      out[0] = p[4] - p[0];
+      out[1] = p[5] - p[1];
+    }
+  } else {
+    const ax = p[2] - p[0];
+    const ay = p[3] - p[1];
+    const bx = p[4] - p[2];
+    const by = p[5] - p[3];
+    const cx = p[6] - p[4];
+    const cy = p[7] - p[5];
+    const abx = ax + (bx - ax) * t;
+    const aby = ay + (by - ay) * t;
+    const bcx = bx + (cx - bx) * t;
+    const bcy = by + (cy - by) * t;
+    out[0] = abx + (bcx - abx) * t;
+    out[1] = aby + (bcy - aby) * t;
+    if (out[0] === 0 && out[1] === 0) {
+      if (t === 0) {
+        out[0] = p[4] - p[0];
+        out[1] = p[5] - p[1];
+      } else if (t === 1) {
+        out[0] = p[6] - p[2];
+        out[1] = p[7] - p[3];
+      }
+    }
+  }
+}
+function splitAt(e, t) {
+  const p = e.p;
+  const lerp = (a, b) => a + (b - a) * t;
+  if (e.kind === 1) {
+    const mx2 = lerp(p[0], p[2]);
+    const my2 = lerp(p[1], p[3]);
+    return [
+      { kind: 1, p: [p[0], p[1], mx2, my2], color: e.color },
+      { kind: 1, p: [mx2, my2, p[2], p[3]], color: e.color }
+    ];
+  }
+  if (e.kind === 2) {
+    const ax2 = lerp(p[0], p[2]);
+    const ay2 = lerp(p[1], p[3]);
+    const bx2 = lerp(p[2], p[4]);
+    const by2 = lerp(p[3], p[5]);
+    const mx2 = lerp(ax2, bx2);
+    const my2 = lerp(ay2, by2);
+    return [
+      { kind: 2, p: [p[0], p[1], ax2, ay2, mx2, my2], color: e.color },
+      { kind: 2, p: [mx2, my2, bx2, by2, p[4], p[5]], color: e.color }
+    ];
+  }
+  const ax = lerp(p[0], p[2]);
+  const ay = lerp(p[1], p[3]);
+  const bx = lerp(p[2], p[4]);
+  const by = lerp(p[3], p[5]);
+  const cx = lerp(p[4], p[6]);
+  const cy = lerp(p[5], p[7]);
+  const abx = lerp(ax, bx);
+  const aby = lerp(ay, by);
+  const bcx = lerp(bx, cx);
+  const bcy = lerp(by, cy);
+  const mx = lerp(abx, bcx);
+  const my = lerp(aby, bcy);
+  return [
+    { kind: 3, p: [p[0], p[1], ax, ay, abx, aby, mx, my], color: e.color },
+    { kind: 3, p: [mx, my, bcx, bcy, cx, cy, p[6], p[7]], color: e.color }
+  ];
+}
+function splitInThirds(e) {
+  const [a, rest] = splitAt(e, 1 / 3);
+  const [b, c] = splitAt(rest, 0.5);
+  return [a, b, c];
+}
+function reverseEdge(e) {
+  const p = e.p;
+  const n = p.length;
+  for (let i = 0; i < n / 2; i += 2) {
+    const j = n - 2 - i;
+    const x = p[i];
+    const y = p[i + 1];
+    p[i] = p[j];
+    p[i + 1] = p[j + 1];
+    p[j] = x;
+    p[j + 1] = y;
+  }
+}
+function reverseContour(c) {
+  c.edges.reverse();
+  for (const e of c.edges) reverseEdge(e);
+}
+const shoelace = (ax, ay, bx, by) => (bx - ax) * (ay + by);
+function contourWinding(c) {
+  const edges = c.edges;
+  if (edges.length === 0) return 0;
+  let total = 0;
+  const a = [0, 0];
+  const b = [0, 0];
+  const cc = [0, 0];
+  const d = [0, 0];
+  if (edges.length === 1) {
+    edgePoint(edges[0], 0, a);
+    edgePoint(edges[0], 1 / 3, b);
+    edgePoint(edges[0], 2 / 3, cc);
+    total += shoelace(a[0], a[1], b[0], b[1]);
+    total += shoelace(b[0], b[1], cc[0], cc[1]);
+    total += shoelace(cc[0], cc[1], a[0], a[1]);
+  } else if (edges.length === 2) {
+    edgePoint(edges[0], 0, a);
+    edgePoint(edges[0], 0.5, b);
+    edgePoint(edges[1], 0, cc);
+    edgePoint(edges[1], 0.5, d);
+    total += shoelace(a[0], a[1], b[0], b[1]);
+    total += shoelace(b[0], b[1], cc[0], cc[1]);
+    total += shoelace(cc[0], cc[1], d[0], d[1]);
+    total += shoelace(d[0], d[1], a[0], a[1]);
+  } else {
+    const last = edges[edges.length - 1];
+    let px = last.p[0];
+    let py = last.p[1];
+    for (const e of edges) {
+      total += shoelace(px, py, e.p[0], e.p[1]);
+      px = e.p[0];
+      py = e.p[1];
+    }
+  }
+  return total > 0 ? 1 : total < 0 ? -1 : 0;
+}
+function shapeBounds(shape) {
+  let l = Infinity;
+  let b = Infinity;
+  let r = -Infinity;
+  let t = -Infinity;
+  const pt = [0, 0];
+  const add = (x, y) => {
+    if (x < l) l = x;
+    if (x > r) r = x;
+    if (y < b) b = y;
+    if (y > t) t = y;
+  };
+  const extremum = (e, param) => {
+    if (param > 0 && param < 1) {
+      edgePoint(e, param, pt);
+      add(pt[0], pt[1]);
+    }
+  };
+  for (const c of shape.contours) {
+    for (const e of c.edges) {
+      const p = e.p;
+      add(p[0], p[1]);
+      add(p[p.length - 2], p[p.length - 1]);
+      if (e.kind === 2) {
+        for (let k = 0; k < 2; k++) {
+          const den = p[k] - 2 * p[2 + k] + p[4 + k];
+          if (den !== 0) extremum(e, (p[k] - p[2 + k]) / den);
+        }
+      } else if (e.kind === 3) {
+        for (let k = 0; k < 2; k++) {
+          const p0 = p[k];
+          const p1 = p[2 + k];
+          const p2 = p[4 + k];
+          const p3 = p[6 + k];
+          const a = -p0 + 3 * p1 - 3 * p2 + p3;
+          const bb = 2 * (p0 - 2 * p1 + p2);
+          const cc = p1 - p0;
+          if (Math.abs(a) < 1e-12) {
+            if (bb !== 0) extremum(e, -cc / bb);
+          } else {
+            const disc = bb * bb - 4 * a * cc;
+            if (disc >= 0) {
+              const s = Math.sqrt(disc);
+              extremum(e, (-bb + s) / (2 * a));
+              extremum(e, (-bb - s) / (2 * a));
+            }
+          }
+        }
+      }
+    }
+  }
+  return l <= r ? [l, b, r, t] : void 0;
+}
+function normalizeShape(shape) {
+  for (const c of shape.contours) {
+    if (c.edges.length === 1) c.edges = splitInThirds(c.edges[0]);
+  }
+}
+function isCorner(ax, ay, bx, by, crossThreshold) {
+  return ax * bx + ay * by <= 0 || Math.abs(ax * by - ay * bx) > crossThreshold;
+}
+function normalizeInPlace(v) {
+  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+  if (len === 0) {
+    v[0] = 0;
+    v[1] = 1;
+  } else {
+    v[0] = v[0] / len;
+    v[1] = v[1] / len;
+  }
+}
+function switchColor(color, seed, banned = EdgeColor.black) {
+  const combined = color & banned;
+  if (combined === EdgeColor.red || combined === EdgeColor.green || combined === EdgeColor.blue) {
+    return combined ^ EdgeColor.white;
+  }
+  if (color === EdgeColor.black || color === EdgeColor.white) {
+    const start = [EdgeColor.cyan, EdgeColor.magenta, EdgeColor.yellow];
+    const next = start[seed[0] % 3];
+    seed[0] = Math.floor(seed[0] / 3);
+    return next;
+  }
+  const shifted = color << 1 + (seed[0] & 1);
+  seed[0] = Math.floor(seed[0] / 2);
+  return (shifted | shifted >> 3) & EdgeColor.white;
+}
+function symmetricalTrichotomy(position, n) {
+  return Math.trunc(3 + 2.875 * position / (n - 1) - 1.4375 + 0.5) - 3;
+}
+function colorEdgesSimple(shape, angleThreshold = 3, seedValue = 0) {
+  const crossThreshold = Math.sin(angleThreshold);
+  const seed = [seedValue];
+  const initial = [EdgeColor.cyan, EdgeColor.magenta, EdgeColor.yellow];
+  let color = initial[seed[0] % 3];
+  seed[0] = Math.floor(seed[0] / 3);
+  const prev = [0, 0];
+  const dir = [0, 0];
+  for (const contour of shape.contours) {
+    const edges = contour.edges;
+    if (edges.length === 0) continue;
+    const corners = [];
+    edgeDirection(edges[edges.length - 1], 1, prev);
+    for (let i = 0; i < edges.length; i++) {
+      edgeDirection(edges[i], 0, dir);
+      normalizeInPlace(prev);
+      normalizeInPlace(dir);
+      if (isCorner(prev[0], prev[1], dir[0], dir[1], crossThreshold)) corners.push(i);
+      edgeDirection(edges[i], 1, prev);
+    }
+    if (corners.length === 0) {
+      color = switchColor(color, seed);
+      for (const e of edges) e.color = color;
+    } else if (corners.length === 1) {
+      color = switchColor(color, seed);
+      const c0 = color;
+      color = switchColor(color, seed);
+      const colors = [c0, EdgeColor.white, color];
+      const corner = corners[0];
+      if (edges.length >= 3) {
+        const m = edges.length;
+        for (let i = 0; i < m; i++) {
+          edges[(corner + i) % m].color = colors[1 + symmetricalTrichotomy(i, m)];
+        }
+      } else {
+        const parts = new Array(7);
+        const first = splitInThirds(edges[0]);
+        parts[0 + 3 * corner] = first[0];
+        parts[1 + 3 * corner] = first[1];
+        parts[2 + 3 * corner] = first[2];
+        if (edges.length >= 2) {
+          const second = splitInThirds(edges[1]);
+          parts[3 - 3 * corner] = second[0];
+          parts[4 - 3 * corner] = second[1];
+          parts[5 - 3 * corner] = second[2];
+          parts[0].color = parts[1].color = colors[0];
+          parts[2].color = parts[3].color = colors[1];
+          parts[4].color = parts[5].color = colors[2];
+        } else {
+          parts[0].color = colors[0];
+          parts[1].color = colors[1];
+          parts[2].color = colors[2];
+        }
+        contour.edges = parts.filter((p) => p !== void 0);
+      }
+    } else {
+      const cornerCount = corners.length;
+      let spline = 0;
+      const start = corners[0];
+      const m = edges.length;
+      color = switchColor(color, seed);
+      const initialColor = color;
+      for (let i = 0; i < m; i++) {
+        const index = (start + i) % m;
+        if (spline + 1 < cornerCount && corners[spline + 1] === index) {
+          spline++;
+          color = switchColor(
+            color,
+            seed,
+            spline === cornerCount - 1 ? initialColor : EdgeColor.black
+          );
+        }
+        edges[index].color = color;
+      }
+    }
+  }
+}
+export {
+  EdgeColor,
+  colorEdgesSimple,
+  contourWinding,
+  edgeDirection,
+  edgePoint,
+  linear,
+  normalizeShape,
+  reverseContour,
+  shapeBounds,
+  shapeFromCommands,
+  splitInThirds
+};

package/dist/source.d.ts

@@ -0,0 +1,44 @@
+import type { Font as OpentypeFont } from 'opentype.js';
+import { type Shape } from './shape.js';
+/** A parsed font file: outlines, metrics, and kerning, in font units. */
+export declare class FontSource {
+    readonly bytes: Uint8Array;
+    readonly font: OpentypeFont;
+    readonly unitsPerEm: number;
+    readonly ascender: number;
+    readonly descender: number;
+    readonly lineGap: number;
+    readonly name: string;
+    private readonly cmap;
+    constructor(bytes: Uint8Array, path?: string);
+    /** The glyph index for a codepoint; 0 (.notdef) when the font doesn't have it. */
+    glyphIndex(codepoint: number): number;
+    advance(glyph: number): number;
+    /** The glyph's outline as a shape, in font units (y up). */
+    shape(glyph: number): Shape;
+    /** Kerning between the given glyphs, pair key `left * 65536 + right`, in font units. */
+    kerning(glyphs: Iterable<number>): Map<number, number>;
+}
+/** A box glyph for codepoints no font has: an outlined rectangle, in em units. */
+export declare function tofuShape(): Shape;
+export declare const TOFU_ADVANCE = 0.6;
+/** One glyph's MSDF: RGBA pixels (row 0 at the top) and its quad in em units. */
+export interface GlyphBitmap {
+    width: number;
+    height: number;
+    /** RGBA8, alpha 255. Empty for blank glyphs. */
+    pixels: Uint8Array;
+    /** Quad bounds in em units relative to the pen and baseline: left, bottom, right, top. */
+    plane: [number, number, number, number] | undefined;
+}
+export interface GlyphRaster {
+    /** Pixels per em. */
+    size: number;
+    /** Distance range in pixels. */
+    range: number;
+}
+/**
+ * Generates a glyph's MSDF. `shape` is in units where one em is `unitsPerEm` (font units, or 1 for
+ * shapes already in em).
+ */
+export declare function rasterizeGlyph(shape: Shape, unitsPerEm: number, raster: GlyphRaster): GlyphBitmap;

package/dist/source.js

@@ -0,0 +1,108 @@
+import { ShardError } from "@aethervtt/shard-core";
+import * as opentype from "opentype.js";
+const parse = opentype.parse ?? opentype.default.parse;
+import { hasGposKerning, readGposKerning } from "./kerning.js";
+import { blitMsdf, generateMsdf, msdfBox, prepareShape } from "./msdf.js";
+import { linear, shapeBounds, shapeFromCommands } from "./shape.js";
+function fontName(font) {
+  const names = font.names;
+  for (const table of [
+    names.windows,
+    names.macintosh,
+    names.unicode,
+    names
+  ]) {
+    const full = table?.fullName ?? table?.fontFamily;
+    if (full && typeof full === "object") {
+      const value = full.en ?? Object.values(full)[0];
+      if (typeof value === "string") return value;
+    }
+  }
+  return void 0;
+}
+class FontSource {
+  bytes;
+  font;
+  unitsPerEm;
+  ascender;
+  descender;
+  lineGap;
+  name;
+  cmap;
+  constructor(bytes, path = "font") {
+    this.bytes = bytes;
+    try {
+      const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+      this.font = parse(buffer, { lowMemory: true });
+    } catch (cause) {
+      throw new ShardError(
+        "text/font-parse-failed",
+        `${path}: not a font opentype.js can read (${cause.message})`,
+        { path, cause, hint: "Fonts import from .ttf and .otf files (TrueType or CFF outlines)." }
+      );
+    }
+    const f = this.font;
+    this.unitsPerEm = f.unitsPerEm;
+    const hhea = f.tables.hhea;
+    this.ascender = hhea.ascender;
+    this.descender = hhea.descender;
+    this.lineGap = hhea.lineGap;
+    this.cmap = f.tables.cmap.glyphIndexMap;
+    this.name = fontName(f) ?? path;
+  }
+  /** The glyph index for a codepoint; 0 (.notdef) when the font doesn't have it. */
+  glyphIndex(codepoint) {
+    return this.cmap[codepoint] ?? 0;
+  }
+  advance(glyph) {
+    return this.font.glyphs.get(glyph).advanceWidth ?? 0;
+  }
+  /** The glyph's outline as a shape, in font units (y up). */
+  shape(glyph) {
+    return shapeFromCommands(this.font.glyphs.get(glyph).path.commands);
+  }
+  /** Kerning between the given glyphs, pair key `left * 65536 + right`, in font units. */
+  kerning(glyphs) {
+    if (hasGposKerning(this.bytes)) return readGposKerning(this.bytes, glyphs);
+    const out = /* @__PURE__ */ new Map();
+    const wanted = new Set(glyphs);
+    for (const [key, value] of Object.entries(this.font.kerningPairs ?? {})) {
+      const [l, r] = key.split(",").map(Number);
+      if (value !== 0 && wanted.has(l) && wanted.has(r)) out.set(l * 65536 + r, value);
+    }
+    return out;
+  }
+}
+function tofuShape() {
+  const rect = (l, b, r, t, clockwise) => clockwise ? [linear(l, b, l, t), linear(l, t, r, t), linear(r, t, r, b), linear(r, b, l, b)] : [linear(l, b, r, b), linear(r, b, r, t), linear(r, t, l, t), linear(l, t, l, b)];
+  return {
+    contours: [
+      { edges: rect(0.08, 0, 0.52, 0.7, true) },
+      { edges: rect(0.14, 0.06, 0.46, 0.64, false) }
+    ]
+  };
+}
+const TOFU_ADVANCE = 0.6;
+function rasterizeGlyph(shape, unitsPerEm, raster) {
+  const bounds = shapeBounds(shape);
+  if (!bounds) return { width: 0, height: 0, pixels: new Uint8Array(0), plane: void 0 };
+  const scale = raster.size / unitsPerEm;
+  prepareShape(shape);
+  const box = msdfBox(bounds, scale, raster.range);
+  const sdf = generateMsdf(shape, box, { scale, range: raster.range });
+  const pixels = new Uint8Array(box.width * box.height * 4);
+  blitMsdf(sdf, box.width, box.height, pixels, box.width, 0, 0);
+  const inv = 1 / unitsPerEm;
+  return {
+    width: box.width,
+    height: box.height,
+    pixels,
+    plane: [box.plane[0] * inv, box.plane[1] * inv, box.plane[2] * inv, box.plane[3] * inv]
+  };
+}
+export {
+  FontSource,
+  TOFU_ADVANCE,
+  rasterizeGlyph,
+  tofuShape
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@aethervtt/shard-text",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-assets": "0.0.1",
+    "@aethervtt/shard-core": "0.0.1",
+    "@aethervtt/shard-gpu": "0.0.1",
+    "@aethervtt/shard-render": "0.0.1",
+    "@aethervtt/shard-runtime": "0.0.1",
+    "@aethervtt/shard-texture": "0.0.1",
+    "@aethervtt/shard-transform": "0.0.1",
+    "opentype.js": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/text"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+  }
+}