monowind 0.1.0 → 0.1.2

package/dist/wrap.d.ts

@@ -1,27 +1,77 @@
 /**
- * Greedy word-wrap for monospace text.
+ * Greedy word-wrap for monospace text on the cell grid.
  *
- * Words are runs of non-whitespace; whitespace runs collapse to single spaces
- * between fitting words. Browsers also treat a hyphen inside a word as a
- * break opportunity (break after `-`, no hyphen added) — except before a
- * digit, per UAX #14 (`2026-08` doesn't break) — so words are further split
- * into breakable segments. A segment longer than `width` breaks at cell
- * boundaries. `\n` in the input is a HARD line break — the wrap restarts on
- * a new line (the source of these is `<br>` elements, converted to `\n` by
- * the tree builder). A blank hard line still occupies one row.
+ * Text is a string plus optional per-character `advances` (cells each
+ * character occupies — 1 by default, `1 + tracking` for letter-spaced text;
+ * see specs/cell-model.md). Words are runs of non-whitespace; whitespace
+ * runs collapse to single spaces between fitting words. Browsers also treat
+ * a hyphen inside a word as a break opportunity (break after `-`, no hyphen
+ * added) — except before a digit, per UAX #14 (`2026-08` doesn't break) —
+ * so words are further split into breakable segments. A segment wider than
+ * `width` breaks at cell boundaries. `\n` in the input is a HARD line break
+ * — the wrap restarts on a new line (the source of these is `<br>`
+ * elements, converted to `\n` by the tree builder). A blank hard line still
+ * occupies one row.
  *
  * Matches how a browser wraps `white-space: normal; overflow-wrap: anywhere`
  * text in a fixed-width monospace container — we set that in styles.css so
  * the two agree.
  */
-export declare function wrapLines(text: string, width: number): string[];
+/** A wrapped line as an index range into the text (`end` exclusive). */
+export interface LineSpan {
+    start: number;
+    end: number;
+}
+/**
+ * Wrap options: per-character `advances` for tracked text (cells each
+ * character occupies, `1 + tracking` of its innermost element), and the
+ * leaf's own `tracking` — the trailing gap it absorbs at line ends (see
+ * `lineAdvance`). Defaults: plain 1-cell characters, no tracking.
+ */
+export interface WrapOptions {
+    advances?: number[] | undefined;
+    tracking?: number;
+}
+export declare function wrapLines(text: string, width: number, options?: WrapOptions): string[];
 /** Number of rows `text` occupies at `width` (see wrapLines). */
-export declare function wrapLineCount(text: string, width: number): number;
+export declare function wrapLineCount(text: string, width: number, options?: WrapOptions): number;
+/** Split at hard `\n` breaks only (the `white-space: nowrap` line model). */
+export declare function hardLineSpans(text: string): LineSpan[];
+export declare function wrapLineSpans(text: string, width: number, options?: WrapOptions): LineSpan[];
+/** Cells spanned by `text[start, end)`, every character's gap included. */
+export declare function advanceOf(start: number, end: number, advances?: number[]): number;
+/**
+ * Cells `text[start, end)` occupies AS A LINE (specs/cell-model.md): up to
+ * `tracking` (the leaf's own tracking) cells of the last character's gap
+ * are trailing and don't count — the leaf's box reserves that room. A
+ * tracked inline element's larger gap stays counted: browsers keep it at a
+ * line end, and the engine doesn't cancel it (uniform across engines).
+ */
+export declare function lineAdvance(start: number, end: number, advances?: number[], tracking?: number): number;
+/** Widest unbreakable unit (breakable segment) in the text — the
+ * min-content width of a wrapping leaf. */
+export declare function longestSegmentAdvance(text: string, options?: WrapOptions): number;
 /**
  * Split a word at its internal break opportunities: after each hyphen run,
  * unless the next character is a digit (UAX #14: no break between a hyphen
  * and a following number). `"mx-auto"` → `["mx-", "auto"]`;
- * `"2026-08"` → `["2026-08"]`. Also the unit of min-content width.
+ * `"2026-08"` → `["2026-08"]`.
  */
 export declare function breakableSegments(word: string): string[];
+/** U+FFFC marks an embedded atomic inline box (see LayoutNode.inlineBox):
+ * unbreakable itself, but with break opportunities on BOTH sides, like
+ * browsers give replaced elements. */
+export declare const OBJECT_REPLACEMENT = "\uFFFC";
+/** U+2060 (word joiner) marks ONE CELL of inline-element horizontal
+ * padding in a run (specs/cell-model.md): pure blank space glued to its
+ * neighbors — not collapsible white space, no break opportunity — so it
+ * travels with the padded element's edge across wraps exactly like the
+ * browser's `box-decoration-break: slice` padding. Multi-cell padding is
+ * several 1-cell markers, keeping every gap/advance invariant intact.
+ * (Escape form on purpose: the character is invisible.) */
+export declare const INLINE_PAD = "\u2060";
+/** Visit each object-replacement marker in a run, pairing its character
+ * index with its ordinal (= index into the leaf's box list, which is in
+ * run order). */
+export declare function eachObjectMarker(text: ArrayLike<string>, visit: (charIndex: number, boxIndex: number) => void): void;
 //# sourceMappingURL=wrap.d.ts.map

package/dist/wrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../src/wrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAG/D;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAcxD"}
+{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../src/wrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wEAAwE;AACxE,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,MAAM,EAAE,CAE1F;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,MAAM,CAE5F;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAUtD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,QAAQ,EAAE,CAahG;AAED,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAKjF;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,SAAI,GAAG,MAAM,CAGjG;AAMD;2CAC2C;AAC3C,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,MAAM,CASrF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAExD;AAED;;sCAEsC;AACtC,eAAO,MAAM,kBAAkB,WAAW,CAAC;AAE3C;;;;;;2DAM2D;AAC3D,eAAO,MAAM,UAAU,WAAW,CAAC;AAEnC;;iBAEiB;AACjB,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EACvB,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GACnD,IAAI,CAON"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monowind",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Text-based user interfaces (TUI) on the web, from ordinary HTML and Tailwind utility classes",
   "keywords": [
     "ascii",
@@ -31,11 +31,12 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./styles.css": "./src/styles.css"
+    "./styles.css": "./src/styles.css",
+    "./package.json": "./package.json"
   },
   "devDependencies": {
     "@tailwindcss/browser": "^4.3.3",
-    "happy-dom": "^20.11.6",
+    "happy-dom": "^20.11.13",
     "typescript": "^7.0.2",
     "vite": "^8.2.2",
     "vitest": "^4.1.11"

package/src/styles.css

@@ -55,24 +55,52 @@ mono-wind:not([data-mw-ready]) {
   visibility: hidden !important;
 }
 
-/* Lock typography on descendants so the grid metrics stay consistent —
+/* Lock the font on descendants so the grid metrics stay consistent —
  * `!important` because user classes (`.text-2xl` etc.) would otherwise beat
  * these element-selector rules on specificity. */
 mono-wind * {
   font-family: inherit !important;
   font-size: inherit !important;
-  line-height: inherit !important;
-  letter-spacing: inherit !important;
   vertical-align: baseline !important;
 }
 
-/* Match the engine's greedy word-wrap: break at spaces, and break long
- * words at cell boundaries when they overflow. Gated on `measuring` (unlike
- * the font lock above) so the style reader sees the authored `white-space`
- * — that's how `nowrap` is detected. */
+/* Grid-template read assist (specs/grid.md), no-Typed-OM engines only
+ * (Firefox pre-157): getComputedStyle on a live grid container returns
+ * the USED `grid-template-*` track list (expanded px) — the authored
+ * fr/repeat/minmax structure is gone. The style reader sets this
+ * attribute for the duration of the read; blockifying the element makes
+ * getComputedStyle return the COMPUTED value, structure intact.
+ * `!important` so inline `style="display: grid"` can't defeat the read. */
+mono-wind[measuring] [data-mw-degrid] {
+  display: block !important;
+}
+
+/* Grid-quantized typography and the wrap model (specs/cell-model.md). Gated
+ * on `measuring` (unlike the font lock above) so the style reader sees the
+ * AUTHORED white-space / letter-spacing / line-height — that's how nowrap,
+ * tracking, and leading are detected without echoing our own output.
+ *
+ * letter-spacing: the root's own (`--mw-rls`, part of the cell) plus
+ * `--mw-ls` extra cells per character, which the engine writes on every
+ * element it visits; an element without the var makes this declaration
+ * invalid at computed-value time, so the property falls back to inheriting
+ * the parent's grid-exact value. line-height is inherited from the
+ * laid-out ancestor (which sets the row multiple below) — `leading-*` on
+ * inline elements is ignored by design. */
 mono-wind:not([measuring]) * {
   white-space: normal !important;
   overflow-wrap: anywhere !important;
+  letter-spacing: calc(var(--mw-rls, 0px) + var(--mw-ls) * var(--mw-cw, 1px)) !important;
+  line-height: inherit !important;
+  /* Inline-element horizontal padding, quantized: the engine writes
+   * `--mw-ipl`/`--mw-ipr` (whole cells) on inline elements whose authored
+   * padding it reserved in the run; everything else gets 0, so raw
+   * off-grid padding never renders. Laid-out elements and atomic inline
+   * boxes override this with their own engine-owned padding rule (higher
+   * specificity). Vertical inline padding never moves layout, per CSS,
+   * and passes through untouched. */
+  padding-left: calc(var(--mw-ipl, 0) * var(--mw-cw, 1px)) !important;
+  padding-right: calc(var(--mw-ipr, 0) * var(--mw-cw, 1px)) !important;
 }
 
 /* Author-requested `white-space: nowrap` (or `pre`) — the engine sized this
@@ -82,6 +110,16 @@ mono-wind:not([measuring]) [data-mw-nowrap] {
   white-space: nowrap !important;
 }
 
+/* `white-space: pre` leaves (specs/cell-model.md): the tree builder kept
+ * the source's spaces and newlines in the run, so the browser must render
+ * them too — on the leaf AND its inline descendants (the lock above would
+ * collapse text inside nested spans). Later than the nowrap rule, so it
+ * wins on the leaf itself at equal specificity. */
+mono-wind:not([measuring]) [data-mw-pre],
+mono-wind:not([measuring]) [data-mw-pre] * {
+  white-space: pre !important;
+}
+
 /* Truncation (`truncate` = nowrap + clip + text-overflow: ellipsis): use
  * `hidden` rather than the normalized `clip` for this combo — some engines
  * only apply `text-overflow` to scroll containers, which `clip` boxes are
@@ -113,10 +151,52 @@ mono-wind:not([measuring]) [data-mw-nowrap][data-mw-clip] {
  * position:absolute (out of flow), so nothing consumes them anyway. */
 mono-wind:not([measuring]) [data-mw-laid-out] {
   position: absolute !important;
-  box-sizing: border-box !important;
   left: calc(var(--mw-x, 0) * var(--mw-cw, 1px)) !important;
   top: calc(var(--mw-y, 0) * var(--mw-ch, 1px)) !important;
-  width: calc(var(--mw-w, 0) * var(--mw-cw, 1px)) !important;
+  /* Neutralize the browser's residual grid machinery (specs/grid.md).
+   * grid-area: per CSS §10.1 an ABSOLUTE child of a grid container with
+   * placement properties uses its grid area as containing block — our
+   * left/top would resolve against that area and double-offset the
+   * element (the engine already placed it). The template and content/item
+   * alignment resets make a laid-out container's own grid/flex inert for
+   * the one box the browser still lays out: the anonymous item holding a
+   * leaf's direct text (a template would trap it in track 1; the
+   * browser's place-* offsets are FRACTIONAL, off the cell grid — the
+   * engine applies the quantized offsets through its owned padding
+   * instead, specs/cell-model.md). */
+  grid-area: auto !important;
+  grid-template-columns: none !important;
+  grid-template-rows: none !important;
+  place-content: start !important;
+  place-items: stretch !important;
+  /* `leading-*` on the grid: `--mw-lh` rows per wrapped line. CSS puts half
+   * the extra leading ABOVE the first line; `--mw-lhs` (−(rows − 1)/2)
+   * shifts the box back so every line starts on its own row. */
+  translate: 0 calc(var(--mw-lhs, 0) * var(--mw-ch, 1px)) !important;
+}
+
+/* Shared cell geometry for engine-sized boxes — both engine-POSITIONED
+ * elements and in-flow atomic inline boxes (below). */
+mono-wind:not([measuring]) [data-mw-laid-out],
+mono-wind:not([measuring]) [data-mw-inline-box] {
+  box-sizing: border-box !important;
+  /* Trailing-gap allowance: a tracked box's lines end with a phantom
+   * `--mw-ls`-cell gap the engine doesn't count. Give the content box that
+   * room by carving it out of the engine-owned right padding/border cells;
+   * only when those are fewer than the gap does the element box itself
+   * widen (invisibly — the decorated border stays where the engine put it).
+   * The extra 1/32px is one layout unit of headroom: engines store lengths
+   * on a fixed grid by flooring (1/64px in Chromium and WebKit, 1/60px in
+   * Firefox), so `cells × cw` can land one unit BELOW the shaped advance of
+   * a line that fits exactly, and the browser would wrap it. Adding at
+   * least one unit before the floor guarantees the stored width is ≥ the
+   * exact product; 1/32px covers every engine's unit and is far below a
+   * cell (and below a device pixel), so it changes neither cell math nor
+   * paint. */
+  width: calc(
+    (var(--mw-w, 0) + max(0, var(--mw-ls, 0) - var(--mw-pr, 0) - var(--mw-br, 0))) *
+      var(--mw-cw, 1px) + 0.03125px
+  ) !important;
   height: calc(var(--mw-h, 0) * var(--mw-ch, 1px)) !important;
   min-width: 0 !important;
   min-height: 0 !important;
@@ -124,10 +204,26 @@ mono-wind:not([measuring]) [data-mw-laid-out] {
   max-height: none !important;
   border-width: 0 !important;
   padding-top: calc((var(--mw-pt, 0) + var(--mw-bt, 0)) * var(--mw-ch, 1px)) !important;
-  padding-right: calc((var(--mw-pr, 0) + var(--mw-br, 0)) * var(--mw-cw, 1px)) !important;
+  padding-right: calc(
+    max(0, var(--mw-pr, 0) + var(--mw-br, 0) - var(--mw-ls, 0)) * var(--mw-cw, 1px)
+  ) !important;
   padding-bottom: calc((var(--mw-pb, 0) + var(--mw-bb, 0)) * var(--mw-ch, 1px)) !important;
   padding-left: calc((var(--mw-pl, 0) + var(--mw-bl, 0)) * var(--mw-cw, 1px)) !important;
   margin: 0 !important;
+  line-height: calc(var(--mw-lh, 1) * var(--mw-ch, 1px)) !important;
+}
+
+/* Atomic inline boxes (`inline-flex`/`inline-block`/`inline-grid` riding a
+ * text run, specs/cell-model.md): the box stays IN FLOW — the browser's
+ * own line layout places it, and both models agree because the engine
+ * sizes it to exactly the cells its U+FFFC marker occupies in the wrap.
+ * `position: relative` makes it the containing block for its laid-out
+ * children; `vertical-align: top` pins the box's top to its line's first
+ * row (the global baseline lock would hang an abspos-only box below the
+ * line) — a box taller than one row grows its line, per CSS. */
+mono-wind:not([measuring]) [data-mw-inline-box] {
+  position: relative !important;
+  vertical-align: top !important;
 }
 
 /* Author-requested `overflow: hidden` or `overflow: clip` — both keep
@@ -137,6 +233,37 @@ mono-wind [data-mw-clip] {
   overflow: clip !important;
 }
 
+/* Inline (relative/sticky) elements with authored relative insets
+ * (specs/positioning.md): the engine writes the cell-rounded offsets into
+ * `--mw-it/ir/ib/il` and this rule applies them on the grid. A side
+ * without its var is invalid at computed-value time and falls back to
+ * `auto` — so authored subsets work and the author's raw off-grid values
+ * never apply. Gated on `measuring` so the style reader sees the authored
+ * values (no echo loop). Also pins `position: relative` — sticky behaves
+ * as relative until the scrolling milestone. */
+mono-wind:not([measuring]) [data-mw-inline-inset] {
+  position: relative !important;
+  top: calc(var(--mw-it) * var(--mw-ch, 1px)) !important;
+  right: calc(var(--mw-ir) * var(--mw-cw, 1px)) !important;
+  bottom: calc(var(--mw-ib) * var(--mw-ch, 1px)) !important;
+  left: calc(var(--mw-il) * var(--mw-cw, 1px)) !important;
+}
+
+/* A container whose direct text was dropped (mixed text + block children,
+ * cell-model deviation): the browser would paint that text unpositioned
+ * over the laid-out children, so hide it. `visibility` is inherited AND
+ * resettable, so the container's laid-out children come back — only in
+ * this warned state, which is why the reset may also override an authored
+ * `invisible` utility there. */
+mono-wind:not([measuring])[data-mw-dropped-text],
+mono-wind:not([measuring]) [data-mw-dropped-text] {
+  visibility: hidden !important;
+}
+mono-wind:not([measuring])[data-mw-dropped-text] > [data-mw-laid-out],
+mono-wind:not([measuring]) [data-mw-dropped-text] > [data-mw-laid-out] {
+  visibility: visible !important;
+}
+
 /* Force off-grid text alignments back to `start`. `text-left`/`right`/`start`/
  * `end` all land on whole cells (offset = (W - N) × cell width); `center` and
  * `justify` produce fractional per-line offsets we can't snap to the grid. */