@weasel-js/text 1.6.1 → 1.7.1

package/dist/{test-seams-CeRWeyMm.d.ts → test-seams-DbGu8K5F.d.ts}

@@ -1,5 +1,5 @@
 import { ScreenLength, FillStyle, Stroke } from '@weasel-js/paint';
-import { FontStyle } from '@weasel-js/font';
+import { FaceMetrics, FontStyle, FaceRuleMetrics } from '@weasel-js/font';
 
 /**
  * CSS `text-transform` over styled runs: `uppercase`, `lowercase` and
@@ -44,6 +44,49 @@ interface TransformedRunText {
  */
 declare function transformRunTexts(texts: readonly string[], transforms: readonly TextTransform[]): TransformedRunText[];
 
+/**
+ * Synthetic small caps: lowercase drawn as capitals at a smaller size, the
+ * way a browser synthesizes `font-variant: small-caps` for a face with no
+ * `smcp` feature. It is the one run style that sizes characters within a run
+ * differently, so it reports a per-unit size map beside the text.
+ *
+ * It reads the text *after* `textTransform`, as CSS does: `uppercase` leaves
+ * nothing to shrink, and `lowercase` shrinks everything.
+ */
+
+/** The CSS `font-variant-caps` keywords the run model carries. `normal` is an
+ *  explicit override: a run can turn off small caps it would inherit. */
+type FontVariantCaps = 'normal' | 'small-caps';
+/**
+ * The small-caps size, as a fraction of the run's, for a face that states no
+ * x-height and cap height. 0.7 is the factor Chromium and WebKit synthesize
+ * with.
+ */
+declare const SMALL_CAPS_SCALE = 0.7;
+/** The small-caps size for a face: its x-height over its cap height, so a
+ *  small capital stands as tall as its lowercase letters do, or
+ *  {@link SMALL_CAPS_SCALE} where the face lacks either. */
+declare function smallCapsScale(face?: FaceMetrics): number;
+/** The small-caps scale a run set in `(family, weight, style)` gets —
+ *  resolved through the font registry exactly as layout resolves the run. */
+declare function smallCapsScaleFor(family: string, weight: number, style: FontStyle): number;
+/** Whether small caps draws `ch` as a smaller capital: whether it has a
+ *  capital other than itself. */
+declare function isSmallCapsLetter(ch: string): boolean;
+/** A run's drawn text under small caps. `small[i]` says whether UTF-16 unit
+ *  `i` of `text` draws at the small size; absent when none does. */
+interface SmallCapsText {
+    text: string;
+    srcMap?: RunSourceMap;
+    small?: readonly boolean[];
+}
+/**
+ * Apply small caps to a run's drawn text. `srcMap` is the map `textTransform`
+ * already produced for it, if any; the result's map composes the two, so
+ * each drawn unit still names the source character it came from.
+ */
+declare function smallCapsText(text: string, srcMap?: RunSourceMap): SmallCapsText;
+
 /**
  * Canonical inline-styling primitive for text nodes. A node's text is
  * either a plain `string` (treated as a single-run, default-styled fragment)
@@ -51,8 +94,8 @@ declare function transformRunTexts(texts: readonly string[], transforms: readonl
  * either form into the array shape used by the renderer.
  *
  * Every field except `text` is optional; missing fields fall back to the
- * node-level `TextStyle`. `bold`/`italic` are toggles; richer weight axes
- * (300/500/900) are out of scope for slice 1.
+ * node-level `TextStyle`. `bold`/`italic` are toggles; `fontWeight` is the
+ * numeric weight `bold` is a preset over.
  */
 
 /** A span of text with its own styling, as authored. Fields left absent
@@ -60,7 +103,11 @@ declare function transformRunTexts(texts: readonly string[], transforms: readonl
  *  and a fully resolved one. */
 interface StyledRun {
     text: string;
+    /** Draw at weight 700. A preset over `fontWeight`, which wins when both
+     *  are present. */
     bold?: boolean;
+    /** Numeric weight, 100–900. Overrides the node's weight and `bold`. */
+    fontWeight?: number;
     italic?: boolean;
     fontFamily?: string;
     /** World units, or `{ px }` for screen pixels — resolved against the view
@@ -82,8 +129,9 @@ interface StyledRun {
      *
      * A preset over the two primitives below, not a third mechanism: it supplies
      * a `baselineShift` and a `fontScale`, and naming either of those directly
-     * overrides that half while leaving the other alone. The numbers are in
-     * {@link SCRIPT_METRICS}.
+     * overrides that half while leaving the other alone. The numbers are the
+     * face's own `OS/2` script metrics, or {@link SCRIPT_METRICS} for a face
+     * that states none — `scriptMetricsFor` answers which.
      */
     script?: 'super' | 'sub';
     /**
@@ -105,6 +153,13 @@ interface StyledRun {
      * off.
      */
     textTransform?: TextTransform;
+    /**
+     * `'small-caps'` draws this run's lowercase letters as capitals at a
+     * smaller size — synthesized, at the face's x-height over its cap height.
+     * Like `textTransform`, only what is drawn changes. Overrides the node's
+     * own; `'normal'` turns an inherited one off.
+     */
+    fontVariantCaps?: FontVariantCaps;
 }
 /** Normalize the two accepted spellings of text content — a plain string or
  *  an array of runs — to runs. Throws on a run with no string `text`. */
@@ -172,17 +227,20 @@ declare function markdownToRuns(input: string, grammar?: RunGrammar): StyledRun[
 
 /**
  * Horizontal alignment. `start` / `end` resolve against the reading direction;
- * `left` / `right` are absolute. Same five values as CSS `text-align`, with
- * the same split between the relative pair and the absolute pair.
+ * `left` / `right` are absolute. `justify` spreads every wrapped line across
+ * the box by widening its word gaps, and sets a paragraph's last line at the
+ * start edge. The same values as CSS `text-align`, with the same meanings.
  */
-type TextAlign = 'left' | 'center' | 'right' | 'start' | 'end';
+type TextAlign = 'left' | 'center' | 'right' | 'start' | 'end' | 'justify';
 /** Reading direction, which is what gives `start` / `end` their meaning. */
 type TextDirection = 'ltr' | 'rtl';
 /**
  * Collapse a possibly reading-order-relative alignment to an absolute edge.
  *
  * Layout works in absolute edges, so this runs once at its entry and `start` /
- * `end` never reach the geometry.
+ * `end` never reach the geometry. `justify` collapses to the start edge, which
+ * is where it sets every line it does not spread; whether to spread is carried
+ * separately, as `LayoutRunsOpts.justify`.
  */
 declare function resolveAlign(align: TextAlign, direction: TextDirection): 'left' | 'center' | 'right';
 /** User-facing text style. All fields optional; defaults applied at render time via `resolveTextStyle`. */
@@ -206,7 +264,9 @@ interface TextStyle {
     /** Multiplier applied to `fontSize`. Default 1.2. */
     lineHeight?: number;
     /**
-     * Break lines between words where they would pass the box width. Default
+     * Break lines where they would pass the box width, at the break
+     * opportunities of Unicode's line breaking algorithm (UAX #14) — between
+     * words, after a hyphen, between CJK characters. Default
      * `false`: a line runs as long as its text, and the box width only resolves
      * `align`. A word longer than the box is never broken.
      */
@@ -236,6 +296,16 @@ interface TextStyle {
     /** CSS `text-transform` for display; the text itself is not rewritten.
      *  Default `'none'`. */
     textTransform?: TextTransform;
+    /** `'small-caps'` draws lowercase as smaller capitals; the text itself is
+     *  not rewritten. Default `'normal'`. */
+    fontVariantCaps?: FontVariantCaps;
+    /**
+     * Set the node's text as a superscript or subscript — the default every run
+     * inherits, exactly as a run's own `StyledRun.script` is for that run. The
+     * lines keep the height and baseline the unscripted text would have had.
+     * Absent is ordinary text.
+     */
+    script?: 'super' | 'sub';
 }
 /** `TextStyle` with all fields filled in from defaults — what the renderer actually consumes. */
 interface ResolvedTextStyle {
@@ -259,6 +329,9 @@ interface ResolvedTextStyle {
     strikethrough: boolean;
     overline: boolean;
     textTransform: TextTransform;
+    fontVariantCaps: FontVariantCaps;
+    /** Absent is ordinary text. */
+    script?: 'super' | 'sub';
     /** Absent means no outline — unlike the other fields, this one has no
      *  default to fall back to. See {@link TextPaint.stroke}. */
     stroke?: Stroke;
@@ -310,7 +383,9 @@ declare function fontString(s: ResolvedTextStyle): string;
  * canonical shape the renderer consumes.
  *
  * `bold`/`italic` toggles on a run are folded into `fontWeight`/`fontStyle`:
- * `bold: true` → fontWeight 700, `italic: true` → fontStyle 'italic'.
+ * `bold: true` → fontWeight 700, `italic: true` → fontStyle 'italic'. A run's
+ * own numeric `fontWeight` is the primitive `bold` is a preset over, so it
+ * wins over both the flag and the node weight.
  * Explicit `fontFamily` / `fontSize` / `fill` / `letterSpacing` on the run
  * override the node-level value (`letterSpacing: 0` on a run is an override,
  * not an absence — it zeroes inherited tracking).
@@ -328,6 +403,10 @@ declare function fontString(s: ResolvedTextStyle): string;
  * `textTransform` is applied here too, so `text` is what gets drawn. When a
  * transform changes a length, `srcMap` says which source characters each
  * drawn one came from; see `textTransform.ts`.
+ *
+ * `fontVariantCaps: 'small-caps'` is applied after it, over the transformed
+ * text: lowercase becomes capitals, and `sizeMap` gives those their smaller
+ * size. See `smallCaps.ts`.
  */
 
 /** A run with every style resolved against the node's text style — no
@@ -341,7 +420,12 @@ interface ResolvedRun {
      *  means `text`'s offsets are the source's. */
     srcMap?: RunSourceMap;
     fontFamily: string;
+    /** The run's size — what its line and its rules are set at, and what
+     *  every glyph is drawn at unless `sizeMap` says otherwise. */
     fontSize: number;
+    /** Present when not every glyph is drawn at `fontSize`: the size each
+     *  UTF-16 unit of `text` is drawn at. Small caps is what produces one. */
+    sizeMap?: readonly number[];
     fontWeight: number;
     fontStyle: 'normal' | 'italic';
     /** `null` is an explicit no-fill: the glyphs are painted by `stroke` alone,
@@ -368,35 +452,83 @@ interface ResolvedRun {
      * asks nothing about where it came from.
      */
     baselineShift: number;
+    /**
+     * The size this run holds its line open at, when a relative size shrank it
+     * below the size it inherited — so a superscript alone on its line keeps the
+     * line's height and baseline instead of collapsing them. Absent means
+     * `fontSize`.
+     */
+    strutSize?: number;
 }
+/** What one script preset expands to. */
+type ScriptPreset = Readonly<{
+    size: number;
+    shift: number;
+}>;
 /**
- * What `script: 'super'` and `script: 'sub'` expand to, as fractions of the
- * inherited font size: `size` scales it, `shift` raises (positive) or lowers
- * (negative) the baseline.
+ * What `script: 'super'` and `script: 'sub'` expand to for a face that states
+ * no script metrics of its own, as fractions of the inherited font size:
+ * `size` scales it, `shift` raises (positive) or lowers (negative) the
+ * baseline.
  *
  * These are Adobe's defaults — InDesign and Illustrator ship 58.3% size and
- * 33.3% position for both — chosen because a drawing tool's users have those
- * numbers in their fingers already. They are not read from the font: the
- * `OS/2` table carries real `ySuperscript*` / `ySubscript*` metrics, but the
- * baked atlas tier has no slot for them (see `layoutRuns`'s note on the
- * decoration constants, which are derived for the same reason), and metrics
- * that applied on one glyph tier and not the other would reflow text as it
- * crossed the size threshold.
- *
- * Exported so a consumer building a character panel can show the percentages
- * it is about to apply. Override either half per run with `baselineShift` /
+ * 33.3% position for both. A face that carries `OS/2` script metrics uses
+ * those instead; {@link scriptMetricsFor} is what a run actually gets.
+ */
+declare const SCRIPT_METRICS: Readonly<Record<'super' | 'sub', ScriptPreset>>;
+/** The script presets for a face: its own `OS/2` values where it states
+ *  them, {@link SCRIPT_METRICS} per half where it does not. */
+declare function scriptMetrics(face?: FaceMetrics): Readonly<Record<'super' | 'sub', ScriptPreset>>;
+/**
+ * The script presets a run set in `(family, weight, style)` gets — resolved
+ * through the font registry exactly as layout resolves the run, so a
+ * character panel, an SVG export and the DOM edit overlay read the numbers
+ * the canvas draws with. Override either half per run with `baselineShift` /
  * `fontScale`.
  */
-declare const SCRIPT_METRICS: Readonly<Record<'super' | 'sub', Readonly<{
-    size: number;
-    shift: number;
-}>>>;
+declare function scriptMetricsFor(family: string, weight: number, style: FontStyle): Readonly<Record<'super' | 'sub', ScriptPreset>>;
+/** A `TextStyle.fontWeight` as a number: the CSS keywords `bold` and
+ *  `normal` read as 700 and 400, anything unparseable as 400. */
+declare function numericWeight(w: number | string): number;
+/** Whether a weight reads as bold — 600 and up, the same line the font
+ *  registry draws between its regular and bold buckets. */
+declare function isBoldWeight(w: number | string): boolean;
+/** The face a run is set in — its family, weight and style, each falling
+ *  back to the node's. Reads no font registry, so asking loads nothing. */
+declare function resolveRunFace(run: StyledRun, style: Pick<ResolvedTextStyle, 'fontFamily' | 'fontWeight' | 'fontStyle'>): {
+    fontFamily: string;
+    fontWeight: number;
+    fontStyle: FontStyle;
+};
 /** Resolve each run's styling against the node's text style, filling in
  *  everything the run left inherited. `viewScale` resolves a run's own
  *  `{ px }` size or spacing; the inherited ones arrived already resolved on
  *  `style`. */
 declare function resolveRuns(runs: readonly StyledRun[], style: ResolvedTextStyle, viewScale?: number): ResolvedRun[];
 
+/** The three text decoration rules, in the order every tier paints them. */
+type DecorationKind = 'underline' | 'strikethrough' | 'overline';
+/**
+ * Decoration placement and weight for a face that states none, as fractions
+ * of the run's `fontSize`. Offsets are the *top* edge of the rule, measured
+ * down from the baseline — so the two rules that sit above it are negative.
+ *
+ * Derived, not measured: they apply to an atlas baked before `gen-font`
+ * recorded `faceMetrics`, a custom outline parser that reports none, and the
+ * canvas tier, which has no font tables to read.
+ */
+declare const DEFAULT_DECORATION_METRICS: Readonly<Record<DecorationKind, FaceRuleMetrics>>;
+/**
+ * Where each rule sits for a face, in ems: the face's own underline and
+ * strikeout where it states them, the defaults where it does not. No font
+ * table places an overline, so it keeps the default offset and takes the
+ * underline's weight, as browsers draw it.
+ *
+ * Every text tier places its rules through this, so one face puts a rule in
+ * the same place whichever tier paints it.
+ */
+declare function decorationMetrics(face?: FaceMetrics): Readonly<Record<DecorationKind, FaceRuleMetrics>>;
+
 /**
  * The bidi contract, declared here and implemented elsewhere.
  *
@@ -411,6 +543,7 @@ declare function resolveRuns(runs: readonly StyledRun[], style: ResolvedTextStyl
  */
 /** Opaque to this package — whatever the engine needs to carry between calls. */
 type BidiAnalysis = unknown;
+/** One line's visual order, as {@link BidiResolver.reorder} returns it. */
 interface BidiReordering {
     /**
      * Positions in the analysed sequence, in visual order, left to right.
@@ -420,6 +553,11 @@ interface BidiReordering {
     /** Resolved embedding level per position in the line's range. */
     levels: ArrayLike<number>;
 }
+/**
+ * A bidi engine, passed to `layoutRuns` as `opts.bidi`. `@weasel-js/bidi`'s
+ * `bidi` object satisfies it. `reorder`'s `start` / `end` index the code points
+ * `analyze` was given.
+ */
 interface BidiResolver {
     analyze(codePoints: readonly number[], direction?: 'ltr' | 'rtl' | 'auto'): BidiAnalysis;
     reorder(analysis: BidiAnalysis, start: number, end: number): BidiReordering;
@@ -427,9 +565,6 @@ interface BidiResolver {
     mirror(cp: number): number | null;
 }
 
-/** The three text decoration rules, in the order every tier paints them. */
-type DecorationKind = 'underline' | 'strikethrough' | 'overline';
-
 /**
  * Runs-aware MSDF layout. Walks `ResolvedRun[]` codepoint-by-codepoint,
  * switching atlas per run via `resolveFontVariant`, applying kerning
@@ -439,21 +574,28 @@ type DecorationKind = 'underline' | 'strikethrough' | 'overline';
  * so the renderer issues one draw call per atlas+color group.
  *
  * A run's `letterSpacing` (world units, so it does not scale with `fontSize`)
- * is added to the advance *after* every character of that run, including the
- * last one on a line — the CSS `letter-spacing` rule, chosen so a DOM overlay
- * rendering the same text can be made to agree. Trailing tracking therefore
- * widens the measured line width and counts toward wrapping. Spaces are
- * tracked like any other character; a newline is not (it consumes no advance).
- * One caveat against CSS: tracking is applied per *code point*, not per
- * grapheme cluster, so `e` + U+0301 takes tracking twice where CSS would
- * space the cluster once.
- *
- * Word wrap is applied when `maxWidth` is finite: words are committed to
- * a new line when they would exceed the current line width. Forced line
- * breaks are emitted for `\n` codepoints. Every run on a line shares one
- * baseline, sunk to clear the tallest run's ascent, so mixing sizes or faces
- * aligns them the way inline text aligns everywhere else; line height is
- * `max(fontSize * lineHeight)` across the line.
+ * is added to the advance *after* every grapheme cluster of that run,
+ * including the last one on a line — the CSS `letter-spacing` rule, chosen so
+ * a DOM overlay rendering the same text can be made to agree. The last code
+ * point of a cluster carries it, so a combining mark hangs off its base
+ * before the gap opens. Clusters are segmented per run. Trailing tracking
+ * therefore widens the measured line width and counts toward wrapping. Spaces
+ * are tracked like any other character; a newline is not (it consumes no
+ * advance).
+ *
+ * Word wrap is applied when `maxWidth` is finite: words — the text between
+ * UAX #14 break opportunities — are committed to a new line when they would
+ * exceed the current line width. Forced line breaks are emitted at UAX #14's
+ * hard breaks — `\n`, CR, CRLF as one, VT, FF, NEL, U+2028 and U+2029 — none
+ * of which lays out a cell. Every run on a line shares one baseline, sunk to
+ * clear whichever run reaches highest above it, so mixing sizes or faces aligns
+ * them the way inline text aligns everywhere else; line height is
+ * `max(fontSize * lineHeight)` across the line. A face that states its ascent
+ * and descent sits in its line the way CSS sets it — half the leading above the
+ * ascent, negative when the face is taller than the line, so its glyphs overflow
+ * the box rather than growing it. A run a relative size shrank
+ * measures at its `strutSize` for both, the way a CSS line keeps its parent's
+ * strut under a `<sup>`.
  *
  * A run may also sit off that shared baseline: `ResolvedRun.baselineShift`
  * displaces it, which is what `script: 'super' | 'sub'` resolves to. The shift
@@ -519,6 +661,7 @@ interface LaidOutOutlineGlyph {
     /** World units per em — the run's `fontSize`, since em space is unit-scale. */
     scale: number;
 }
+/** Glyphs that share a resolved face, glyph source and paint — one draw call's worth. */
 interface LaidOutGroup {
     /** Resolved atlas family — may differ from the requested family when the
      *  cross-family fallback policy substituted a default. This is what the
@@ -590,7 +733,8 @@ interface LaidOutCell {
      *  stay in logical order and their x values do not. Sort on `x` for visual
      *  order; never assume `cells[i + 1].x` is this cell's right edge. */
     x: number;
-    /** Width of the cell: its glyph's advance plus its run's tracking. */
+    /** Width of the cell: its glyph's advance, plus its run's tracking when it
+     *  closes a grapheme cluster, plus a justified gap's share of the slack. */
     advance: number;
     /** Resolved bidi embedding level — even reads left-to-right. 0 with no
      *  engine, which is the same as saying the text was laid out logically. */
@@ -645,6 +789,7 @@ interface LaidOutLineBox {
      */
     srcEnd: number;
 }
+/** What {@link layoutRuns} returns. Every coordinate is relative to the text's own top-left. */
 interface LaidOutRuns {
     groups: LaidOutGroup[];
     /** Decoration rules, in line order; within a span, underline then
@@ -663,6 +808,7 @@ interface LaidOutRuns {
         height: number;
     };
 }
+/** Options for {@link layoutRuns}. */
 interface LayoutRunsOpts {
     /** Wrap width. `Infinity` never wraps. */
     maxWidth: number;
@@ -676,9 +822,18 @@ interface LayoutRunsOpts {
     lineHeight: number;
     /**
      * `start` / `end` resolve against `direction`; `left` / `right` are absolute
-     * and ignore it, the way CSS `text-align` treats the same five values.
+     * and ignore it, the way CSS `text-align` treats the same values. `justify`
+     * is `justify: true` with the start edge.
      */
     align: TextAlign;
+    /**
+     * Spread each line that wrapped across `alignWidth`, widening its word gaps
+     * (spaces between words; not leading or hanging trailing ones) by equal
+     * shares of the slack. A line that closes its paragraph, or has no gap, or
+     * no slack, keeps `align` — so `align` is CSS `text-align-last` here.
+     * Implied by `align: 'justify'`. Default `false`.
+     */
+    justify?: boolean;
     /**
      * Bidi engine. Omit and the text lays out in logical order, which is correct
      * for left-to-right text and wrong for right-to-left text — see the warning
@@ -713,6 +868,10 @@ interface LayoutRunsOpts {
      */
     outlineMinSize?: number;
 }
+/**
+ * Lay out `runs` into draw groups, decoration rules and line boxes. Wrapping,
+ * baselines, tracking and decorations follow the rules in this file's module doc.
+ */
 declare function layoutRuns(runs: readonly ResolvedRun[], opts: LayoutRunsOpts): LaidOutRuns;
 
 /**
@@ -796,4 +955,4 @@ declare function cachedLayoutRuns(runs: readonly ResolvedRun[], opts: LayoutRuns
 /** Test helper. Do not call from product code. */
 declare function _resetLayoutCacheForTests(): void;
 
-export { resolveAlign as A, type BidiAnalysis as B, resolveRuns as C, DEFAULT_TEXT_STYLE as D, resolveTextStyle as E, runsToMarkdown as F, runsToPlainText as G, toRuns as H, transformRunTexts as I, type LaidOutRuns as L, MARKDOWN_RUN_GRAMMAR as M, type ResolvedTextStyle as R, type StyledRun as S, type TextStyle as T, _resetLayoutCacheForTests as _, type ResolvedRun as a, type LayoutRunsOpts as b, type BidiReordering as c, type BidiResolver as d, LAYOUT_CACHE_STRUCTURAL_LIMIT as e, LAYOUT_CACHE_VARIANT_LIMIT as f, type LaidOutCell as g, type LaidOutDecoration as h, type LaidOutGroup as i, type LaidOutLineBox as j, type LaidOutOutlineGlyph as k, type LaidOutQuad as l, type RunFlag as m, type RunGrammar as n, type RunMarker as o, type RunSourceMap as p, SCRIPT_METRICS as q, type TextAlign as r, type TextDirection as s, type TextPaint as t, type TextTransform as u, type TransformedRunText as v, cachedLayoutRuns as w, fontString as x, layoutRuns as y, markdownToRuns as z };
+export { smallCapsText as $, type TransformedRunText as A, type BidiAnalysis as B, cachedLayoutRuns as C, DEFAULT_DECORATION_METRICS as D, decorationMetrics as E, type FontVariantCaps as F, fontString as G, isBoldWeight as H, isSmallCapsLetter as I, layoutRuns as J, markdownToRuns as K, type LaidOutRuns as L, MARKDOWN_RUN_GRAMMAR as M, numericWeight as N, resolveAlign as O, resolveRunFace as P, resolveRuns as Q, type ResolvedTextStyle as R, type StyledRun as S, type TextStyle as T, resolveTextStyle as U, runsToMarkdown as V, runsToPlainText as W, scriptMetrics as X, scriptMetricsFor as Y, smallCapsScale as Z, smallCapsScaleFor as _, type ResolvedRun as a, toRuns as a0, transformRunTexts as a1, _resetLayoutCacheForTests as a2, type LayoutRunsOpts as b, type BidiReordering as c, type BidiResolver as d, DEFAULT_TEXT_STYLE as e, type DecorationKind as f, LAYOUT_CACHE_STRUCTURAL_LIMIT as g, LAYOUT_CACHE_VARIANT_LIMIT as h, type LaidOutCell as i, type LaidOutDecoration as j, type LaidOutGroup as k, type LaidOutLineBox as l, type LaidOutOutlineGlyph as m, type LaidOutQuad as n, type RunFlag as o, type RunGrammar as p, type RunMarker as q, type RunSourceMap as r, SCRIPT_METRICS as s, SMALL_CAPS_SCALE as t, type ScriptPreset as u, type SmallCapsText as v, type TextAlign as w, type TextDirection as x, type TextPaint as y, type TextTransform as z };

package/dist/test-seams.d.ts

@@ -1,3 +1,3 @@
-export { _ as _resetLayoutCacheForTests } from './test-seams-CeRWeyMm.js';
+export { a2 as _resetLayoutCacheForTests } from './test-seams-DbGu8K5F.js';
 import '@weasel-js/paint';
 import '@weasel-js/font';

package/dist/test-seams.js

@@ -1,3 +1,3 @@
-export { _resetLayoutCacheForTests } from './chunk-GNAAPRO5.js';
+export { _resetLayoutCacheForTests } from './chunk-JQPOFIGT.js';
 //# sourceMappingURL=test-seams.js.map
 //# sourceMappingURL=test-seams.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/text",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "description": "Typography for weasel: styled runs, style resolution, kerned glyph layout, wrap and measurement. No scene graph, no React.",
   "license": "MIT",
   "type": "module",
@@ -20,8 +20,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@weasel-js/geom": "1.6.1",
-    "@weasel-js/paint": "1.6.1"
+    "@weasel-js/geom": "1.7.1",
+    "@weasel-js/paint": "1.7.1"
   },
   "scripts": {
     "test": "vitest run",
@@ -50,9 +50,9 @@
     "provenance": true
   },
   "devDependencies": {
-    "@weasel-js/bidi": "1.6.1"
+    "@weasel-js/bidi": "1.7.1"
   },
   "peerDependencies": {
-    "@weasel-js/font": "1.6.1"
+    "@weasel-js/font": "1.7.1"
   }
 }