@mark1russell7/typeset 0.1.1 → 0.1.3

package/src/fonts/tables.ts

@@ -0,0 +1,162 @@
+import type { Reader } from "./binary.ts";
+
+/** The fields of `head`, `hhea` and `maxp` that the width uses. */
+export interface Header {
+  readonly unitsPerEm: number;
+  /** The revision of the font, as the raw 16.16 number. */
+  readonly revision: number;
+  readonly checksumAdjustment: number;
+  readonly numberOfHMetrics: number;
+  readonly numGlyphs: number;
+}
+
+/** This function reads the header fields from `head`, `hhea` and `maxp`. */
+export function readHeader(head: Reader, hhea: Reader, maxp: Reader): Header {
+  if (head.u32(12) !== 0x5f0f3cf5) throw new Error("the head table has a bad magic number");
+  return { revision: head.u32(4), checksumAdjustment: head.u32(8), unitsPerEm: head.u16(18), numberOfHMetrics: hhea.u16(34), numGlyphs: maxp.u16(4) };
+}
+
+/** This function gives the advance of each glyph in font units, from `hmtx`. */
+export function readAdvances(hmtx: Reader, header: Header): Uint16Array {
+  const advances = new Uint16Array(header.numGlyphs);
+  let last = 0;
+  for (let glyph = 0; glyph < header.numGlyphs; glyph++) {
+    if (glyph < header.numberOfHMetrics) last = hmtx.u16(glyph * 4);
+    advances[glyph] = last;
+  }
+  return advances;
+}
+
+/** This function gives the map from code points to glyphs of `cmap`. It uses a format 12 subtable if there is one, else a format 4 subtable. */
+export function readCharacterMap(cmap: Reader): Map<number, number> {
+  const count = cmap.u16(2);
+  let best: { rank: number; offset: number } | undefined;
+  for (let i = 0; i < count; i++) {
+    const record = 4 + i * 8;
+    const platform = cmap.u16(record);
+    const encoding = cmap.u16(record + 2);
+    const offset = cmap.u32(record + 4);
+    const format = cmap.u16(offset);
+    const unicode = platform === 0 || (platform === 3 && (encoding === 1 || encoding === 10));
+    if (!unicode) continue;
+    const rank = format === 12 ? 2 : format === 4 ? 1 : 0;
+    if (rank > 0 && (best === undefined || rank > best.rank)) best = { rank, offset };
+  }
+  if (best === undefined) throw new Error("the cmap table has no Unicode subtable of format 4 or 12");
+  const table = cmap.part(best.offset);
+  const map = new Map<number, number>();
+  if (best.rank === 2) {
+    const groups = table.u32(12);
+    for (let g = 0; g < groups; g++) {
+      const at = 16 + g * 12;
+      const start = table.u32(at);
+      const end = table.u32(at + 4);
+      const glyph = table.u32(at + 8);
+      for (let c = start; c <= end; c++) map.set(c, glyph + c - start);
+    }
+    return map;
+  }
+  const segments = table.u16(6) / 2;
+  const ends = 14;
+  const starts = ends + segments * 2 + 2;
+  const deltas = starts + segments * 2;
+  const ranges = deltas + segments * 2;
+  for (let s = 0; s < segments; s++) {
+    const start = table.u16(starts + s * 2);
+    const end = table.u16(ends + s * 2);
+    const delta = table.u16(deltas + s * 2);
+    const range = table.u16(ranges + s * 2);
+    for (let c = start; c <= end && c !== 0xffff; c++) {
+      let glyph: number;
+      if (range === 0) glyph = (c + delta) & 0xffff;
+      else {
+        glyph = table.u16(ranges + s * 2 + range + (c - start) * 2);
+        if (glyph !== 0) glyph = (glyph + delta) & 0xffff;
+      }
+      if (glyph !== 0) map.set(c, glyph);
+    }
+  }
+  return map;
+}
+
+/** This function gives the class of a glyph in a ClassDef table. A glyph that the table does not list has the class 0. */
+export function classOf(table: Reader, glyph: number): number {
+  const format = table.u16(0);
+  if (format === 1) {
+    const start = table.u16(2);
+    const count = table.u16(4);
+    return glyph >= start && glyph < start + count ? table.u16(6 + (glyph - start) * 2) : 0;
+  }
+  if (format === 2) {
+    let low = 0;
+    let high = table.u16(2) - 1;
+    while (low <= high) {
+      const middle = (low + high) >> 1;
+      const at = 4 + middle * 6;
+      if (glyph < table.u16(at)) high = middle - 1;
+      else if (glyph > table.u16(at + 2)) low = middle + 1;
+      else return table.u16(at + 4);
+    }
+    return 0;
+  }
+  throw new Error(`the ClassDef format ${format} is unknown`);
+}
+
+/** This function gives the index of a glyph in a Coverage table, or -1 when the table does not cover the glyph. */
+export function coverageIndex(table: Reader, glyph: number): number {
+  const format = table.u16(0);
+  let low = 0;
+  let high = table.u16(2) - 1;
+  if (format === 1) {
+    while (low <= high) {
+      const middle = (low + high) >> 1;
+      const value = table.u16(4 + middle * 2);
+      if (glyph < value) high = middle - 1;
+      else if (glyph > value) low = middle + 1;
+      else return middle;
+    }
+    return -1;
+  }
+  if (format === 2) {
+    while (low <= high) {
+      const middle = (low + high) >> 1;
+      const at = 4 + middle * 6;
+      if (glyph < table.u16(at)) high = middle - 1;
+      else if (glyph > table.u16(at + 2)) low = middle + 1;
+      else return table.u16(at + 4) + glyph - table.u16(at);
+    }
+    return -1;
+  }
+  throw new Error(`the Coverage format ${format} is unknown`);
+}
+
+/** This function gives each glyph of a Coverage table with its coverage index, in the order of the table. */
+export function coverageGlyphs(table: Reader): (readonly [glyph: number, index: number])[] {
+  const format = table.u16(0);
+  const count = table.u16(2);
+  const glyphs: (readonly [number, number])[] = [];
+  if (format === 1) {
+    for (let k = 0; k < count; k++) glyphs.push([table.u16(4 + k * 2), k]);
+    return glyphs;
+  }
+  if (format === 2) {
+    for (let k = 0; k < count; k++) {
+      const at = 4 + k * 6;
+      const start = table.u16(at);
+      const end = table.u16(at + 2);
+      const index = table.u16(at + 4);
+      for (let glyph = start; glyph <= end; glyph++) glyphs.push([glyph, index + glyph - start]);
+    }
+    return glyphs;
+  }
+  throw new Error(`the Coverage format ${format} is unknown`);
+}
+
+/** The GDEF glyph classes: 1 base, 2 ligature, 3 mark, 4 component. */
+export function readGlyphClasses(gdef: Reader | undefined): ((glyph: number) => number) {
+  if (gdef === undefined) return () => 0;
+  const offset = gdef.u16(4);
+  if (offset === 0) return () => 0;
+  const table = gdef.part(offset);
+  return (glyph) => classOf(table, glyph);
+}

package/src/fonts/variations.ts

@@ -0,0 +1,175 @@
+import type { Reader } from "./binary.ts";
+
+/** One axis of `fvar`, in the user units of the axis. */
+export interface Axis {
+  readonly tag: string;
+  readonly min: number;
+  readonly default: number;
+  readonly max: number;
+}
+
+/** The coordinates of an instance in user units, by axis tag. An axis that is absent has its default value. */
+export type Instance = Readonly<Record<string, number>>;
+
+/** This function reads a 16.16 fixed number. */
+function fixed(table: Reader, offset: number): number {
+  return (table.u16(offset) << 16 >> 16) + table.u16(offset + 2) / 65536;
+}
+
+/** This function reads a 2.14 fixed number. */
+function f2dot14(table: Reader, offset: number): number {
+  return table.i16(offset) / 16384;
+}
+
+/** This function rounds a number to the 2.14 grid, as HarfBuzz and FreeType do with each normalized coordinate. */
+function toF2dot14(value: number): number {
+  return Math.round(value * 16384) / 16384;
+}
+
+/** This function gives the axes of `fvar`. */
+export function readAxes(fvar: Reader): Axis[] {
+  const offset = fvar.u16(4);
+  const count = fvar.u16(8);
+  const size = fvar.u16(10);
+  const axes: Axis[] = [];
+  for (let i = 0; i < count; i++) {
+    const at = offset + i * size;
+    axes.push({ tag: fvar.tag(at), min: fixed(fvar, at + 4), default: fixed(fvar, at + 8), max: fixed(fvar, at + 12) });
+  }
+  return axes;
+}
+
+/**
+ * This function gives the normalized coordinates of an instance. Each coordinate is in -1 to 1, on the 2.14 grid. The
+ * segment maps of `avar` change it when the font has them. A value outside the range of an axis is clamped to the range.
+ */
+export function normalize(axes: readonly Axis[], avar: Reader | undefined, instance: Instance): number[] {
+  const coordinates = axes.map((axis) => {
+    const value = Math.min(axis.max, Math.max(axis.min, instance[axis.tag] ?? axis.default));
+    if (value < axis.default) return toF2dot14(axis.default === axis.min ? 0 : (value - axis.default) / (axis.default - axis.min));
+    if (value > axis.default) return toF2dot14(axis.max === axis.default ? 0 : (value - axis.default) / (axis.max - axis.default));
+    return 0;
+  });
+  if (avar === undefined || avar.u16(0) !== 1) return coordinates;
+  let at = 8;
+  const count = Math.min(avar.u16(6), axes.length);
+  for (let a = 0; a < count; a++) {
+    const pairs = avar.u16(at);
+    const from: number[] = [];
+    const to: number[] = [];
+    for (let p = 0; p < pairs; p++) {
+      from.push(f2dot14(avar, at + 2 + p * 4));
+      to.push(f2dot14(avar, at + 4 + p * 4));
+    }
+    at += 2 + pairs * 4;
+    coordinates[a] = toF2dot14(mapSegment(from, to, coordinates[a]!));
+  }
+  return coordinates;
+}
+
+/** This function maps a coordinate through one segment map of `avar`, by linear interpolation between its points. */
+function mapSegment(from: readonly number[], to: readonly number[], value: number): number {
+  if (from.length === 0) return value;
+  if (value <= from[0]!) return to[0]! + value - from[0]!;
+  for (let i = 1; i < from.length; i++) {
+    if (value === from[i]) return to[i]!;
+    if (value < from[i]!) return to[i - 1]! + ((value - from[i - 1]!) * (to[i]! - to[i - 1]!)) / (from[i]! - from[i - 1]!);
+  }
+  return to[to.length - 1]! + value - from[from.length - 1]!;
+}
+
+/** An ItemVariationStore at fixed coordinates. */
+export interface VariationStore {
+  /** This function gives the delta of the item `inner` of the data `outer`, in font units, not rounded. */
+  delta(outer: number, inner: number): number;
+}
+
+/** This function reads an ItemVariationStore and computes the scalar of each region at the coordinates. */
+export function readVariationStore(store: Reader, coordinates: readonly number[]): VariationStore {
+  const regions = store.part(store.u32(2));
+  const axisCount = regions.u16(0);
+  const regionCount = regions.u16(2);
+  const scalars: number[] = [];
+  for (let r = 0; r < regionCount; r++) {
+    let scalar = 1;
+    for (let a = 0; a < axisCount && scalar !== 0; a++) {
+      const at = 4 + (r * axisCount + a) * 6;
+      scalar *= axisScalar(f2dot14(regions, at), f2dot14(regions, at + 2), f2dot14(regions, at + 4), coordinates[a] ?? 0);
+    }
+    scalars.push(scalar);
+  }
+  const dataCount = store.u16(6);
+  const data = Array.from({ length: dataCount }, (_, i) => store.part(store.u32(8 + i * 4)));
+  return {
+    delta(outer, inner) {
+      const table = data[outer];
+      if (table === undefined || inner >= table.u16(0)) return 0;
+      const wordField = table.u16(2);
+      const longWords = (wordField & 0x8000) !== 0;
+      const words = wordField & 0x7fff;
+      const count = table.u16(4);
+      const wordSize = longWords ? 4 : 2;
+      const smallSize = longWords ? 2 : 1;
+      const rowSize = words * wordSize + (count - words) * smallSize;
+      let at = 6 + count * 2 + inner * rowSize;
+      let sum = 0;
+      for (let i = 0; i < count; i++) {
+        let value: number;
+        if (i < words) {
+          value = longWords ? table.u32(at) | 0 : table.i16(at);
+          at += wordSize;
+        } else {
+          value = longWords ? table.i16(at) : (table.u8(at) << 24) >> 24;
+          at += smallSize;
+        }
+        const scalar = scalars[table.u16(6 + i * 2)] ?? 0;
+        if (scalar !== 0) sum += scalar * value;
+      }
+      return sum;
+    },
+  };
+}
+
+/** This function gives the scalar of one axis of a region, as the OpenType specification defines it. */
+export function axisScalar(start: number, peak: number, end: number, value: number): number {
+  if (start > peak || peak > end) return 1;
+  if (start < 0 && end > 0 && peak !== 0) return 1;
+  if (peak === 0 || value === peak) return 1;
+  if (value <= start || value >= end) return 0;
+  return value < peak ? (value - start) / (peak - start) : (end - value) / (end - peak);
+}
+
+/** This function gives the outer and inner index of a glyph in a DeltaSetIndexMap. A glyph after the end uses the last entry. */
+export function mapIndex(map: Reader, index: number): [outer: number, inner: number] {
+  const format = map.u8(0);
+  const entryFormat = map.u8(1);
+  const count = format === 0 ? map.u16(2) : map.u32(2);
+  const start = format === 0 ? 4 : 6;
+  if (count === 0) return [0, index];
+  const size = ((entryFormat >> 4) & 3) + 1;
+  const innerBits = (entryFormat & 0xf) + 1;
+  const at = start + Math.min(index, count - 1) * size;
+  let entry = 0;
+  for (let i = 0; i < size; i++) entry = entry * 256 + map.u8(at + i);
+  const innerCount = 2 ** innerBits;
+  return [Math.floor(entry / innerCount), entry % innerCount];
+}
+
+/**
+ * This function gives the advances of an instance. With `round`, each delta of `HVAR` is rounded to whole font units, as
+ * FreeType rounds it: a half goes up. With `exact`, the delta keeps its fraction. The advances stay as they are when the
+ * font has no `HVAR` table.
+ */
+export function instanceAdvances(advances: Uint16Array, hvar: Reader | undefined, coordinates: readonly number[], deltas: "round" | "exact" = "round"): Float64Array {
+  const result = Float64Array.from(advances);
+  if (hvar === undefined || coordinates.every((value) => value === 0)) return result;
+  const store = readVariationStore(hvar.part(hvar.u32(4)), coordinates);
+  const mapOffset = hvar.u32(8);
+  const map = mapOffset === 0 ? undefined : hvar.part(mapOffset);
+  for (let glyph = 0; glyph < result.length; glyph++) {
+    const [outer, inner] = map === undefined ? [0, glyph] : mapIndex(map, glyph);
+    const delta = store.delta(outer, inner);
+    result[glyph] = advances[glyph]! + (deltas === "round" ? Math.round(delta) : delta);
+  }
+  return result;
+}

package/src/fonts/words.ts

@@ -0,0 +1,119 @@
+/**
+ * The words of the text of a canvas. Blink shapes the text of `fillText` and `measureText` one word at a time, so no GSUB
+ * context and no pair kerning goes across two words. This module follows `NextWordEndIndex` of
+ * `third_party/blink/renderer/platform/fonts/plain_text_node.cc` and the CJK table of `character_property_data.h`.
+ * The Chromium Authors wrote these files under a BSD-style license.
+ */
+import { bidiLevels, visualOrder } from "./bidi.ts";
+
+/** The single code points of the CJK table of Blink. */
+const cjkValues: ReadonlySet<number> = new Set([
+  0x2c7, 0x2ca, 0x2cb, 0x2d9, 0x2020, 0x2021, 0x2030, 0x203b, 0x203c, 0x2042, 0x2047, 0x2048, 0x2049, 0x2051, 0x20dd, 0x20de, 0x2100, 0x2103,
+  0x2105, 0x2109, 0x210a, 0x2113, 0x2116, 0x2121, 0x212b, 0x213b, 0x2150, 0x2151, 0x2152, 0x217f, 0x2189, 0x2307, 0x2312, 0x23ce, 0x2423, 0x25a0,
+  0x25a1, 0x25a2, 0x25aa, 0x25ab, 0x25b1, 0x25b2, 0x25b3, 0x25b6, 0x25b7, 0x25bc, 0x25bd, 0x25c0, 0x25c1, 0x25c6, 0x25c7, 0x25c9, 0x25cb, 0x25cc,
+  0x25ef, 0x2605, 0x2606, 0x260e, 0x2616, 0x2617, 0x26a0, 0x2713, 0x271a, 0x273f, 0x2740, 0x2756, 0x2763, 0x2b1a, 0xfe10, 0xfe11, 0xfe12, 0xfe19,
+  0xff1d, 0x1f100, 0x1f200, 0x1f237, 0x1f32c, 0x1f336, 0x1f37d, 0x1f43f, 0x1f54f, 0x1f93b, 0x1f946,
+]);
+
+/** The ranges of the CJK table of Blink, as pairs of the first and the last code point. */
+const cjkRanges: readonly number[] = [
+  0x2e80, 0x2fdf, 0x31c0, 0x31ef, 0x3400, 0x4dbf, 0x4e00, 0x9fff, 0xf900, 0xfaff, 0x20000, 0x2ffff, 0x2156, 0x215a, 0x2160, 0x216b, 0x2170, 0x217b,
+  0x23be, 0x23cc, 0x2460, 0x2492, 0x249c, 0x24ff, 0x25ce, 0x25d3, 0x25e2, 0x25e6, 0x2600, 0x2603, 0x2660, 0x266f, 0x2672, 0x267d, 0x2776, 0x277f,
+  0x2ff0, 0x302d, 0x3031, 0x312f, 0x3190, 0x31bf, 0x3200, 0x33ff, 0x4dc0, 0x4dff, 0xf860, 0xf862, 0xfe30, 0xfe6f, 0xff00, 0xff0c, 0xff0e, 0xff1a,
+  0xff1f, 0xffef, 0x16fe0, 0x16fff, 0x17000, 0x187ff, 0x18800, 0x18aff, 0x1b000, 0x1b0ff, 0x1b100, 0x1b12f, 0x1b170, 0x1b2ff, 0x1f110, 0x1f129,
+  0x1f130, 0x1f149, 0x1f150, 0x1f169, 0x1f170, 0x1f189, 0x1f202, 0x1f219, 0x1f21b, 0x1f22e, 0x1f230, 0x1f231, 0x1f23b, 0x1f24f, 0x1f252, 0x1f2ff,
+  0x1f321, 0x1f32a, 0x1f394, 0x1f39f, 0x1f3cd, 0x1f3ce, 0x1f3d4, 0x1f3df, 0x1f3f1, 0x1f3f2, 0x1f3f5, 0x1f3f7, 0x1f4fd, 0x1f4fe, 0x1f53e, 0x1f54a,
+  0x1f568, 0x1f573, 0x1f576, 0x1f579, 0x1f57b, 0x1f58f, 0x1f591, 0x1f594, 0x1f597, 0x1f5a3, 0x1f5a5, 0x1f5e7, 0x1f5e9, 0x1f5fa, 0x1f650, 0x1f67f,
+  0x1f6c6, 0x1f6cb, 0x1f6cd, 0x1f6cf, 0x1f6d3, 0x1f6d4, 0x1f6d9, 0x1f6db, 0x1f6e0, 0x1f6ea, 0x1f6ed, 0x1f6f3, 0x1f6fd, 0x1f6ff, 0x1f900, 0x1f90b,
+  0x1fac9, 0x1facc,
+];
+
+const emojiPresentation = /\p{Emoji_Presentation}/u;
+const modifierLike = /[\p{M}\p{Lm}\p{Sk}]/u;
+const continuesEmoji = /[‍\p{Emoji_Component}\p{Extended_Pictographic}]/u;
+const commonOrInherited = /[\p{Script=Common}\p{Script=Inherited}]/u;
+
+/**
+ * This function tells if Blink starts a CJK word at the code point `codePoint`. Blink also marks the pictographs of the
+ * RGI emoji sequences. This function uses `Emoji_Presentation` for them, so some text-style pictographs are missing.
+ */
+export function isCjkIdeographOrSymbol(codePoint: number): boolean {
+  if (codePoint < 0x2c7) return false;
+  if (cjkValues.has(codePoint)) return true;
+  for (let i = 0; i < cjkRanges.length; i += 2) if (codePoint >= cjkRanges[i]! && codePoint <= cjkRanges[i + 1]!) return true;
+  return emojiPresentation.test(String.fromCodePoint(codePoint));
+}
+
+/** This function tells if Blink ends a word before the character `character`: a space, a tab or a zero width space. */
+function isDelimiter(character: string): boolean {
+  return character === " " || character === "\t" || character === "​";
+}
+
+/**
+ * This function divides the text of a canvas into the words that Blink shapes one at a time. Each space, tab and zero
+ * width space is a word alone. Each CJK character starts a word, with its marks and the CJK characters of the script
+ * Common after it.
+ */
+export function canvasWords(text: string): string[] {
+  const characters = [...text];
+  const words: string[] = [];
+  let start = 0;
+  while (start < characters.length) {
+    const end = wordEnd(characters, start);
+    words.push(characters.slice(start, end).join(""));
+    start = end;
+  }
+  return words;
+}
+
+/**
+ * This function gives the segments of the text of a canvas in the visual order. A segment is a word of `canvasWords`, or a
+ * part of a word where the bidi level changes. Blink shapes each bidi run alone and adds the widths of the words in this order.
+ */
+export function canvasSegments(text: string): string[] {
+  const characters = [...text];
+  const levels = bidiLevels(text);
+  const segments: string[] = [];
+  const segmentLevels: number[] = [];
+  let at = 0;
+  for (const word of canvasWords(text)) {
+    const end = at + [...word].length;
+    let start = at;
+    for (let i = at + 1; i <= end; i++) {
+      if (i < end && levels[i] === levels[start]) continue;
+      segments.push(characters.slice(start, i).join(""));
+      segmentLevels.push(levels[start]!);
+      start = i;
+    }
+    at = end;
+  }
+  return visualOrder(segments, segmentLevels);
+}
+
+/** This function gives the index after the last character of the word that starts at `start`. */
+function wordEnd(characters: readonly string[], start: number): number {
+  const first = characters[start]!;
+  if (start + 1 === characters.length || isDelimiter(first)) return start + 1;
+  let end = start + 1;
+  if (!isCjkIdeographOrSymbol(first.codePointAt(0)!)) {
+    for (; end < characters.length; end++) {
+      const character = characters[end]!;
+      if (isDelimiter(character) || (isCjkIdeographOrSymbol(character.codePointAt(0)!) && !modifierLike.test(character))) return end;
+    }
+    return end;
+  }
+  let hasScript = !commonOrInherited.test(first);
+  for (; end < characters.length; end++) {
+    const character = characters[end]!;
+    if (modifierLike.test(character) || continuesEmoji.test(character)) continue;
+    if (isCjkIdeographOrSymbol(character.codePointAt(0)!)) {
+      if (commonOrInherited.test(character)) continue;
+      if (!hasScript) {
+        hasScript = true;
+        continue;
+      }
+    }
+    return end;
+  }
+  return end;
+}

package/src/fonts-inspect.ts

@@ -0,0 +1,8 @@
+/**
+ * The subpath `./fonts/inspect`: the parts of the font model that a tool uses to examine a width. They give the glyphs,
+ * the shaping words, the default features and the tables of a font file.
+ */
+export { glyphAdvances, shapingWords } from "./fonts/font.ts";
+export { canvasWords } from "./fonts/words.ts";
+export { defaultFeatures } from "./fonts/substitution.ts";
+export { readTables } from "./fonts/sfnt.ts";

package/src/fonts.ts

@@ -0,0 +1,9 @@
+/**
+ * The subpath `./fonts`: the font model of typeset. It reads the tables of a TrueType, OpenType or WOFF2 file. It gives
+ * the width of a text as the text engine of a browser gives it. The host gives the bytes of the font files.
+ */
+export { measureWidth, readFont, type Font, type MeasureOptions, type ReadOptions } from "./fonts/font.ts";
+export { widthBound, type WidthBound } from "./fonts/bound.ts";
+export { engines, isEngineName, type EngineName, type EngineRules } from "./fonts/engines.ts";
+export type { Decompress } from "./fonts/sfnt.ts";
+export type { Axis, Instance } from "./fonts/variations.ts";

package/src/index.ts

@@ -3,4 +3,6 @@
  * `@mark1russell7/typeset/breaking`. This entry gives each area as one namespace.
  */
 export * as breaking from "./breaking.ts";
+export * as fonts from "./fonts.ts";
+export * as measurer from "./measurer.ts";
 export * as text from "./text.ts";