linegauge 0.3.1 → 0.3.3

package/dist/index.js

@@ -1,34 +1,6 @@
-/**
- * Copyright (c) 2026 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
-/**
- * linegauge — how much of a terminal line a string occupies, and how to fold it.
- *
- * F1 of the foundation tier, built by moving rather than by writing: `width` and `wrap`
- * were already in `flagstaff`, already ported, already graded differentially against
- * `string-width` and `wrap-ansi`. This package is where they belong, because measuring a
- * line is not drawing one — a spinner, a box, a table and a status line all need the
- * measurement, and nothing about the measurement needs any of them.
- *
- * The default export is `width`, byte-for-byte call-compatible with `string-width`'s
- * default (R8), so `overrides: { "string-width": "npm:linegauge@^1" }` resolves.
- *
- * `slice`, `truncate` and `widest` came next, built on the style stack `wrap` already
- * carried — which is the consolidation the design is named for: `slice-ansi`, `wrap-ansi`
- * and `cli-truncate` each keep their own copy of it, and they disagree at the edges.
- *
- * `strip` (R3) followed, and it is where the measured divergence from Node's own
- * `stripVTControlCharacters` is recorded — one shape in sixteen, and it was a live bug in
- * `width()`.
- *
- * R2's fast path: locked by `differential.test.ts`.
- */
 export { lineCount, measure, width, width as default } from './width.js';
 export { slice } from './slice.js';
 export { strip } from './strip.js';
 export { truncate } from './truncate.js';
 export { widest } from './widest.js';
 export { wrap } from './wrap.js';
-//# sourceMappingURL=index.js.map

package/dist/slice.js

@@ -1,36 +1,5 @@
-/**
- * Copyright (c) 2026 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
-/**
- * R4 — cut a styled string in **display columns**, never in code units.
- *
- * `"\u001B[31mred\u001B[39m".slice(0, 3)` returns three characters of an escape sequence
- * and no red at all; that is the bug this exists to remove, and it is the same bug in every
- * hand-rolled column-cutter. Three rules, none of which a code-unit slice can honour:
- *
- *   1. **Never split a grapheme cluster.** A cluster that straddles a boundary is included
- *      whole — the cut rounds *outward*, never inward, so a slice can be one column wider
- *      than asked but never returns half a family emoji.
- *   2. **Close what is open at the cut, and reopen it at the start.** A style opened before
- *      `start` is re-emitted at the front of the result, because the caller is going to
- *      print this fragment somewhere the opener never reached.
- *   3. **A hyperlink is a style too** (`OSC 8`), closed and reopened the same way.
- *
- * Built on the same stack `wrap` uses rather than a second copy of it, which is the whole
- * consolidation: `slice-ansi` and `wrap-ansi` each carry their own, and they disagree.
- */
 import { applyParameters, closingSequence, hyperlink, matchEscape, openingSequence, segmenter } from './style.js';
 import { measure } from './width.js';
-/**
- * Rule 2. Deliberately without `wrap`'s `applyLeadingResets`: that optimisation drops a
- * style whose reset immediately follows the cut, which is right for a row boundary and
- * wrong here — by the time the first kept cluster is known the walk has already run past
- * the whole plain-text segment, so the "next" sequence it would inspect belongs to text
- * this slice still contains. Reopening a style that is about to be reset costs bytes;
- * dropping one that is not costs the colour.
- */
 function open(cut) {
     if (cut.started)
         return;
@@ -39,11 +8,6 @@ function open(cut) {
     if (cut.link !== undefined)
         cut.body += hyperlink(cut.link.uri, cut.link.parameters);
 }
-/**
- * An escape sequence: it always moves the stack, and is copied through only when the cut
- * has started and has not finished. The stack is what gets re-emitted at `start`, which is
- * why a sequence outside the range is still read.
- */
 function takeEscape(cut, escape, end) {
     const groups = escape.groups ?? {};
     if (groups['sgr'] !== undefined)
@@ -53,12 +17,9 @@ function takeEscape(cut, escape, end) {
     if (cut.started && cut.column < end)
         cut.body += escape[0];
 }
-/** One run of plain text, cluster by cluster. Returns true when the range has been filled. */
 function takeText(cut, run, start, end) {
-    for (const { segment } of segmenter.segment(run)) {
+    for (const { segment } of segmenter().segment(run)) {
         const columns = measure(segment);
-        // Rule 1: a cluster is in when any column it occupies is in, so a zero-width mark rides
-        // with the cluster it follows rather than falling off the front of a slice.
         if (cut.column + Math.max(columns, 1) > start && cut.column < end) {
             open(cut);
             cut.body += segment;
@@ -69,10 +30,6 @@ function takeText(cut, run, start, end) {
     }
     return cut.column >= end;
 }
-/**
- * `[start, end)` in display columns. A negative or reversed range is empty rather than an
- * error, matching `String.prototype.slice`'s temperament if not its units.
- */
 export function slice(string, start = 0, end = Number.POSITIVE_INFINITY) {
     if (end <= start || string.length === 0)
         return '';
@@ -97,13 +54,4 @@ export function slice(string, start = 0, end = Number.POSITIVE_INFINITY) {
         return '';
     return cut.body + (cut.link === undefined ? '' : hyperlink('')) + closingSequence(cut.active);
 }
-/**
- * The default export, for the reason `strip.ts` gives at length: `slice-ansi`'s suite
- * imports its entry point's **default**, and that suite now grades this file.
- *
- * The specifier is described rather than quoted on purpose — see the note on `wrap`'s
- * default: `subpath-isolation.test.ts` reads the emitted text, comments and all.
- */
-// eslint-disable-next-line import-next/no-default-export -- the incumbent's own suite imports a default; see above. This is the drop-in surface, not a style choice.
 export { slice as default };
-//# sourceMappingURL=slice.js.map

package/dist/strip.js

@@ -1,55 +1,5 @@
-/**
- * Copyright (c) 2026 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
-/**
- * R3 — remove the sequences a terminal consumes, and leave the text it prints.
- *
- * The design says to use `util.stripVTControlCharacters` "where it is exact and a local scan
- * where it is not — measured, and the divergence recorded rather than assumed". Measured, on
- * Node 24 over sixteen sequence shapes: **fifteen agree with `strip-ansi` and one does not.**
- *
- *   ESC[38:2::255:0:0m   node -> ":2::255:0:0m"     strip-ansi -> ""
- *
- * That is the colon form of an extended colour (ITU T.416, which `chalk`, `wrap-ansi` and
- * every 24-bit-colour library emit): Node's scanner stops at the first `:` and leaves the
- * rest of the sequence in the output as text. One shape, and the one that matters most,
- * because it is **not** a rare dialect — it is how a truecolor SGR is written when the
- * sub-parameter form is used.
- *
- * It was a live bug here, not a theoretical one. `width.ts` called
- * `stripVTControlCharacters`, so `width("ESC[38:2::255:0:0mred ESC[39m")` answered **15**
- * where `string-width` answers **3** — and every caller that measures went with it: `wrap`,
- * `slice`, `truncate`, `widest`, and in `flagstaff` the box, the table and the spinner.
- *
- * So the local scan is the whole implementation, over `style.ts`'s `ANSI_ESCAPE` — which has
- * always handled the colon form, because `wrap` needs to reopen those colours across a row.
- * The package understood the syntax in one module and mis-stripped it in another, which is
- * precisely the duplication the consolidation exists to remove.
- */
 import { stripVTControlCharacters as nodeStrip } from 'node:util';
 import { forEachSegment } from './style.js';
-/**
- * Everything a terminal would print, with the escape sequences removed: CSI (SGR and the
- * cursor and erase forms), OSC including `OSC 8` hyperlinks under both terminators, DCS, the
- * charset selections, and the single-character escapes. A lone `ESC` with nothing that parses
- * after it is text and is kept — the same answer `strip-ansi` gives.
- *
- * Two passes, which is the design's prescription taken literally: *"using
- * `util.stripVTControlCharacters` where it is exact and a local scan where it is not."*
- *
- *   1. The local scan, over `style.ts`'s `ANSI_ESCAPE`. It removes CSI and OSC **including
- *      the colon form** of an extended colour, which is the one shape Node gets wrong.
- *   2. Node's stripper on what is left — the single-character escapes (`ESC c`), the charset
- *      selections (`ESC ( B`) and a truncated sequence at the end of a string. `ANSI_ESCAPE`
- *      matches none of those, because `wrap` never needed them: it was built to find the
- *      sequences it has to *reopen*, and a charset selection is not one.
- *
- * Order is load-bearing. Ours runs first so the colon form is already gone by the time Node
- * sees the string; reversed, pass 2 would leave `:2::255:0:0m` behind as text and pass 1
- * would have nothing left to match.
- */
 export function strip(string) {
     if (string === '')
         return '';
@@ -59,23 +9,4 @@ export function strip(string) {
     });
     return nodeStrip(out);
 }
-/**
- * The same function again, as the default export, because `strip-ansi`'s own suite imports
- * a default — and that suite is now this module's grader
- * (`compat-oracle/vendor/strip-ansi`, `baseline/strip-ansi.json`).
- *
- * It is a *subpath* default rather than the package's, and it has to be: R8 spends the root
- * default on `width`, so `overrides: { "string-width": "npm:linegauge@^1" }` resolves. A
- * `strip-ansi` façade can therefore only ever be `linegauge/strip`, and this is the line
- * that makes `import stripAnsi from 'linegauge/strip'` read exactly like the import it
- * replaces. `truncate` and `widest` deliberately do not have one yet: an export is a
- * contract forever, and neither has a vendored suite holding it to the incumbent's shape.
- *
- * Spelled `strip as default` rather than `export default strip` to match how `index.ts`
- * publishes `width as default`: the alias is a live binding to the same declaration, so
- * there is exactly one `strip` in the module however it is imported — which is the property
- * `facade-defaults.test.ts` asserts with `toBe`, not `toEqual`.
- */
-// eslint-disable-next-line import-next/no-default-export -- the incumbent's own suite imports a default; see above. This is the drop-in surface, not a style choice.
 export { strip as default };
-//# sourceMappingURL=strip.js.map

package/dist/style.d.ts

@@ -41,7 +41,7 @@ export declare const ASCII_PRINTABLE: RegExp;
  */
 export declare const MODIFIER_CLOSE: Map<number, number>;
 export declare const MODIFIER_CLOSE_CODES: Set<number>;
-export declare const segmenter: Intl.Segmenter;
+export declare const segmenter: () => Intl.Segmenter;
 export declare const sgr: (code: number | string) => string;
 export declare const hyperlink: (url: string, parameters?: string) => string;
 /** The complete escape sequence starting at `index`, or nothing when none starts there. */

package/dist/style.js

@@ -1,28 +1,5 @@
-/**
- * Copyright (c) 2026 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
-/**
- * The style stack — the part of this package that every cutting operation shares.
- *
- * `wrap`, `slice` and `truncate` are one algorithm wearing three names: walk the string,
- * keep a stack of the SGR parameters a terminal currently has open, emit graphemes while
- * inside the range you were asked for, and at every cut emit the closer for whatever is
- * open and re-emit the openers on resume. The twelve incumbents write that three times
- * between them — `wrap-ansi`, `slice-ansi` and `cli-truncate` each carry their own copy —
- * and disagree at the edges, which is most of the reason this package exists.
- *
- * Extracted from `wrap.ts` when `slice` arrived, with wrap-ansi's own suite as the check:
- * this module is a move, and `wrap.test.ts` grades every case against the real `wrap-ansi`,
- * so a mistake in the extraction is a red suite rather than a subtle divergence.
- *
- * It is not a published subpath. `linegauge/wrap` and `linegauge/slice` each reach it, and
- * R8 keeps them from reaching each other.
- */
 export const ESC = '\u001B';
 export const BELL = '\u0007';
-/** The single-byte C1 form of `ESC [`, which a terminal accepts and a suite will send. */
 const C1_CSI = '\u009B';
 export const CSI = '[';
 export const OSC = ']';
@@ -44,13 +21,9 @@ const BACKGROUND_FIRST = 40;
 const BACKGROUND_LAST = 47;
 const BACKGROUND_BRIGHT_FIRST = 100;
 const BACKGROUND_BRIGHT_LAST = 107;
-/** How many columns a tab advances to the next stop. */
 export const TAB_SIZE = 8;
-/** `38;5;n` — the code, the mode, and one index. */
 const COLOR_256_PARTS = 3;
-/** `38;2;r;g;b` — the code, the mode, and three components. */
 const COLOR_RGB_PARTS = 3;
-/** `38:2::r:g:b` carries a colour space between the mode and the components. */
 const COLON_RGB_WITH_SPACE = 6;
 export const ESCAPES = new Set([ESC, C1_CSI]);
 const ESCAPE_CHARACTERS = [...ESCAPES].join('');
@@ -59,24 +32,11 @@ const CSI_PARAMETERS = '[0-?]*[ -/]*[@-~]';
 const SGR_PARAMETERS = `(?<sgr>[0-9;:]*)${SGR_TERMINATOR}`;
 const OSC_TERMINATOR = `(?:${BELL}|${ESC}\\\\)`;
 const OSC_PAYLOAD = String.raw `[^\u0000-\u001F\u007F-\u009F]*`;
-/** `OSC 8 ; params ; URI ST` — a hyperlink, whose URI is tracked so a row can reopen it. */
 const LINK_PARAMETERS = String.raw `8;(?<parameters>[^;\u0000-\u001F\u007F-\u009F]*);(?<uri>${OSC_PAYLOAD})${OSC_TERMINATOR}`;
-// Deliberately not a terminal emulator: semicolon-delimited SGR, colon-delimited extended
-// colour and OSC 8 links are understood; every other complete CSI or OSC command is carried
-// through as an opaque zero-width unit, and anything that only looks like an introducer
-// stays plain text. `y` (sticky), so a match is anchored where the scan asked.
 export const ANSI_ESCAPE = new RegExp(`${CSI_INTRODUCER}(?:${SGR_PARAMETERS}|${CSI_PARAMETERS})|${ESC}\\${OSC}(?:${LINK_PARAMETERS}|${OSC_PAYLOAD}${OSC_TERMINATOR})`, 'y');
 const ESCAPE_INTRODUCER = new RegExp(`[${ESCAPE_CHARACTERS}]`, 'g');
 export const ROW_BOUNDARY = new RegExp(`[\\n${ESCAPE_CHARACTERS}]`, 'g');
-/** Every printable ASCII character is its own cluster of width one — skip the segmenter. */
 export const ASCII_PRINTABLE = /^[ -~]*$/;
-/**
- * Which SGR code closes which modifier. This is ECMA-48, not any library's table — bold
- * opens with 1 and closes with 22 wherever you read it — so it lives here rather than
- * being imported, which keeps `wrap()` free of `roundel/chalk` and takes 18 KB off every
- * subpath that wraps. The colour families close with 39, 49 and 59 and are handled by name
- * above, before this map is consulted.
- */
 export const MODIFIER_CLOSE = new Map([
     [1, 22],
     [2, 22],
@@ -88,20 +48,16 @@ export const MODIFIER_CLOSE = new Map([
     [53, 55],
 ]);
 export const MODIFIER_CLOSE_CODES = new Set(MODIFIER_CLOSE.values());
-export const segmenter = new Intl.Segmenter();
+let cached;
+export const segmenter = () => (cached ??= new Intl.Segmenter());
 export const sgr = (code) => `${ESC}${CSI}${code}${SGR_TERMINATOR}`;
 export const hyperlink = (url, parameters = '') => `${ESC}${OSC}8;${parameters};${url}${BELL}`;
-/** The complete escape sequence starting at `index`, or nothing when none starts there. */
 export function matchEscape(string, index) {
     if (!ESCAPES.has(string[index] ?? ''))
         return undefined;
     ANSI_ESCAPE.lastIndex = index;
     return ANSI_ESCAPE.exec(string) ?? undefined;
 }
-/**
- * Walk a string as alternating runs of plain text and complete escape sequences. A
- * character that looks like an introducer but starts no valid sequence stays plain text.
- */
 export function forEachSegment(string, onPlainText, onEscape = () => undefined) {
     let plainStart = 0;
     let index = 0;
@@ -125,7 +81,6 @@ export function forEachSegment(string, onPlainText, onEscape = () => undefined)
         onPlainText(string.slice(plainStart));
 }
 const isDigits = (value) => /^\d+$/.test(value);
-/** `38:5:9` and `38:2::r:g:b` — the colon form, which carries its arguments in one parameter. */
 function colonColorToken(parameter) {
     const parts = parameter.split(':');
     const code = Number.parseInt(parts[0] ?? '', 10);
@@ -145,7 +100,6 @@ function colonColorToken(parameter) {
     }
     return undefined;
 }
-/** One extended-colour parameter run, `38;5;n` or `38;2;r;g;b`, or nothing if malformed. */
 function extendedColorToken(code, parameters, index) {
     const mode = Number.parseInt(parameters[index + 1] ?? '', 10);
     const first = Number.parseInt(parameters[index + 2] ?? '', 10);
@@ -206,7 +160,6 @@ function colorStyle(token) {
     }
     return undefined;
 }
-/** True when the code closed something rather than opening it. */
 function applyResetCode(code, active) {
     if (code === SGR_RESET) {
         active.length = 0;
@@ -225,7 +178,6 @@ function applyResetCode(code, active) {
         return true;
     }
     if (MODIFIER_CLOSE_CODES.has(code)) {
-        // One close code can end several modifiers — `22` ends both bold and dim.
         for (let index = active.length - 1; index >= 0; index -= 1) {
             const style = active[index];
             if (style !== undefined && style.family.startsWith('modifier-') && style.close === code)
@@ -251,13 +203,6 @@ export function applyToken(token, active) {
         active.push({ family, open: token.open, close });
         return;
     }
-    // An SGR parameter this file has no close code for — `ESC[20m`, `ESC[1001m`. It used to
-    // be dropped here, which is the one failure on the `slice-ansi` row that was ours
-    // (`spec.md` § R10 category E): the text survived a cut and its style did not, silently.
-    // The sequence is the caller's, not this library's to vet, so it is carried through and
-    // reopened like any other style. `SGR_RESET` is its closer because it is the only one
-    // that is correct for a parameter whose meaning is unknown — there is nothing to derive a
-    // narrower close from — and it is what `slice-ansi` emits for the same input.
     const family = `unknown-${token.open}`;
     removeFamily(active, family);
     active.push({ family, open: token.open, close: SGR_RESET });
@@ -270,7 +215,6 @@ const applyResets = (parameters, active) => {
     for (const { code } of sgrTokens(parameters))
         applyResetCode(code, active);
 };
-/** A row that opens with its own resets should not have them undone by the reopening. */
 export function applyLeadingResets(string, startIndex, active) {
     let index = startIndex;
     while (index < string.length) {
@@ -284,4 +228,3 @@ export function applyLeadingResets(string, startIndex, active) {
 }
 export const closingSequence = (active) => [...active].reverse().map((style) => sgr(style.close)).join('');
 export const openingSequence = (active) => active.map((style) => sgr(style.open)).join('');
-//# sourceMappingURL=style.js.map

package/dist/truncate.js

@@ -1,20 +1,3 @@
-/**
- * Copyright (c) 2026 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
-/**
- * R6 — shorten a styled string to `columns` display columns, with the ellipsis **inside**
- * the budget.
- *
- * That last clause is the whole value and the off-by-one every hand-rolled truncator gets
- * wrong: `truncate(s, 10)` must return something ten columns wide, not ten columns plus an
- * ellipsis. `cli-truncate` exists as a package (36 M/wk) essentially to get this right, and
- * pays `slice-ansi` and `string-width` to do it.
- *
- * The ellipsis is measured with `width`, not assumed to be one column: a caller who passes
- * `"..."` has spent three, and a caller who passes an emoji has spent two.
- */
 import { slice } from './slice.js';
 import { width } from './width.js';
 export function truncate(string, columns, options = {}) {
@@ -25,8 +8,6 @@ export function truncate(string, columns, options = {}) {
     if (total <= columns)
         return string;
     const mark = width(ellipsis);
-    // No room for both. The ellipsis alone is the most informative thing that fits, and when
-    // even that does not fit the honest answer is nothing rather than a cut-up ellipsis.
     if (mark >= columns)
         return mark === columns ? ellipsis : '';
     const keep = columns - mark;
@@ -34,9 +15,6 @@ export function truncate(string, columns, options = {}) {
         return ellipsis + slice(string, total - keep);
     if (position === 'end')
         return slice(string, 0, keep) + ellipsis;
-    // Middle: the left half rounds up, so an odd budget spends its extra column on the text
-    // the reader meets first.
     const left = Math.ceil(keep / 2);
     return slice(string, 0, left) + ellipsis + slice(string, total - (keep - left));
 }
-//# sourceMappingURL=truncate.js.map

package/dist/widest.js

@@ -1,17 +1,3 @@
-/**
- * Copyright (c) 2026 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
-/**
- * R7 — the widest of many lines, in one pass, allocating nothing per line.
- *
- * Every caller that draws a box or a table needs this, and every one of them writes
- * `Math.max(...lines.map(width))` — which builds an array it throws away and blows the call
- * stack on a large enough table, because a spread is an argument list and V8 stops somewhere
- * around 125,000. Taking an `Iterable` also means a generator works, so a caller measuring a
- * file does not have to hold it.
- */
 import { width } from './width.js';
 export function widest(lines) {
     let max = 0;
@@ -22,4 +8,3 @@ export function widest(lines) {
     }
     return max;
 }
-//# sourceMappingURL=widest.js.map

package/dist/width.js

@@ -1,34 +1,4 @@
-/**
- * Display width of a string in terminal columns (R7).
- *
- * A column count is the one measurement the output stack cannot avoid: a spinner has to
- * know how many lines its frame occupied before it can erase them, and a box has to know
- * where its right edge falls. `string-width` does this in four packages; here it is one
- * function over `Intl.Segmenter` and a range table, because a package this size is not
- * worth a dependency tree (U5).
- *
- * The rules, in the order a cluster meets them:
- *   1. ANSI and other control sequences are not printed — `strip()`, which is a local scan
- *      rather than `util.stripVTControlCharacters`: that one leaves the colon form of an
- *      extended colour behind, and this function answered 15 for a three-column string
- *      because of it. See `strip.ts` for the measurement.
- *   2. A grapheme cluster made only of ignorable, control, mark or surrogate code points
- *      occupies no column.
- *   3. An RGI emoji sequence is two columns, however many code points it is made of.
- *   4. Otherwise the East Asian Width of the cluster's first visible code point, plus the
- *      halfwidth-and-fullwidth forms trailing it in the same cluster (a dakuten).
- *
- * Ambiguous-width characters are counted narrow, which is what a terminal does unless it
- * has been told it is rendering an East Asian locale. `string-width` makes that an option;
- * nothing above this function has ever needed the other answer, so it is not one here.
- */
 import { strip } from './strip.js';
-/**
- * East Asian Wide and Fullwidth, as sorted `[low, high]` pairs flattened into one array —
- * Unicode 17's W and F categories, merged where they touch. Generated from the same
- * `EastAsianWidth.txt` derivation everyone uses; a binary search over 122 ranges is the
- * whole lookup.
- */
 const WIDE = [
     0x1100, 0x115F, 0x231A, 0x231B, 0x2329, 0x232A, 0x23E9, 0x23EC, 0x23F0, 0x23F0,
     0x23F3, 0x23F3, 0x25FD, 0x25FE, 0x2614, 0x2615, 0x2630, 0x2637, 0x2648, 0x2653,
@@ -58,18 +28,7 @@ const WIDE = [
 ];
 const NARROW = 1;
 const WIDE_COLUMNS = 2;
-/** Half the flat array is lows, so a step over pairs. */
 const PAIR = 2;
-/**
- * East Asian **Ambiguous** — the characters a terminal renders one column wide in a Latin
- * context and two in a CJK one. `±`, `×`, `÷`, the box-drawing set, Greek and Cyrillic.
- *
- * Unlike WIDE above, this table is **generated**, by `scripts/generate-ambiguous.mjs`: 179
- * ranges is past the size where transcribing a text file by hand is honest work. The sweep
- * reads `get-east-asian-width`, already a devDependency because the suite grades against it,
- * and the result is committed — no dependency at run time, and a Unicode update produces a
- * reviewable diff rather than a silent drift. `--check` fails when the two disagree.
- */
 const AMBIGUOUS = [
     0x00A1, 0x00A1, 0x00A4, 0x00A4, 0x00A7, 0x00A8, 0x00AA, 0x00AA, 0x00AD, 0x00AE,
     0x00B0, 0x00B4, 0x00B6, 0x00BA, 0x00BC, 0x00BF, 0x00C6, 0x00C6, 0x00D0, 0x00D0,
@@ -108,7 +67,6 @@ const AMBIGUOUS = [
     0x1F100, 0x1F10A, 0x1F110, 0x1F12D, 0x1F130, 0x1F169, 0x1F170, 0x1F18D, 0x1F18F, 0x1F190,
     0x1F19B, 0x1F1AC, 0xE0100, 0xE01EF, 0xF0000, 0xFFFFD, 0x100000, 0x10FFFD,
 ];
-/** Binary search over a flat `[low, high]` table. Both tables are laid out for this. */
 function inTable(table, codePoint) {
     let low = 0;
     let high = table.length / PAIR - 1;
@@ -131,86 +89,43 @@ function isWide(codePoint) {
 function isAmbiguous(codePoint) {
     return inTable(AMBIGUOUS, codePoint);
 }
-/**
- * `v`-mode properties: the whole point of using them is that Node ships the tables.
- *
- * The mark classes are spelled out as `Nonspacing_Mark` and `Enclosing_Mark` rather than
- * the `\p{Mark}` that stood here, because `\p{Mark}` is those two **and** `Spacing_Mark` —
- * and a spacing mark is exactly the kind that does occupy a column. `ा`, Devanagari
- * vowel sign AA, answered 0 under the wider class and a terminal draws it one column wide.
- *
- * `\p{Format}` joins the zero-width class for the mirror-image reason. A prepended
- * concatenation mark — `U+0600`, `U+06DD`, `U+070F` — is `Format` but *not*
- * `Default_Ignorable`, so it fell through to the base-scalar path below, which stripped it
- * as leading non-printing, found an empty remainder, read code point 0 and charged a column
- * for it. Charging a column for a character the cursor never advances past is the shape of
- * bug that stays invisible until a box comes out a column short.
- */
-const ZERO_WIDTH_CLUSTER = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Nonspacing_Mark}|\p{Enclosing_Mark}|\p{Surrogate})+$/v;
-const LEADING_NON_PRINTING = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Nonspacing_Mark}\p{Enclosing_Mark}\p{Surrogate}]+/v;
-const RGI_EMOJI = /^\p{RGI_Emoji}$/v;
-const SPACING_MARK = /^\p{Spacing_Mark}$/v;
-const EXTENDED_PICTOGRAPHIC = /^\p{Extended_Pictographic}$/u;
-/**
- * An **unqualified keycap**: the base, then `U+20E3`, with the `U+FE0F` that would have made
- * it fully qualified missing. The base class is explicit — a digit, `#` or `*` — because
- * `U+260E U+FE0F U+20E3` is *not* a keycap, and `string-width`'s suite grades that too.
- */
+let zeroWidthClass;
+let leadingClass;
+let rgiClass;
+let spacingClass;
+let pictographicClass;
+const INVISIBLE_CLASSES = ['\\p{Default_Ignorable_Code_Point}', '\\p{Control}', '\\p{Format}', '\\p{Nonspacing_Mark}', '\\p{Enclosing_Mark}', '\\p{Surrogate}'];
+const INVISIBLE_ALTERNATION = INVISIBLE_CLASSES.join('|');
+const INVISIBLE_SET = INVISIBLE_CLASSES.join('');
+const ZERO_WIDTH_CLUSTER = () => (zeroWidthClass ??= new RegExp(`^(?:${INVISIBLE_ALTERNATION})+$`, 'v'));
+const LEADING_NON_PRINTING = () => (leadingClass ??= new RegExp(`^[${INVISIBLE_SET}]+`, 'v'));
+const RGI_EMOJI = () => (rgiClass ??= new RegExp('^\\p{RGI_Emoji}$', 'v'));
+const SPACING_MARK = () => (spacingClass ??= new RegExp('^\\p{Spacing_Mark}$', 'v'));
+const EXTENDED_PICTOGRAPHIC = () => (pictographicClass ??= new RegExp('^\\p{Extended_Pictographic}$', 'u'));
 const UNQUALIFIED_KEYCAP = /^[\d#*]\u20E3$/u;
 const ZWJ = '\u200D';
-/** Two pictographs is what separates an emoji ZWJ sequence from an Indic conjunct. */
 const EMOJI_ZWJ_PICTOGRAPHS = 2;
-/**
- * Longest cluster worth testing for an emoji sequence. Real ones run well under thirty code
- * units; the cap is here so a pathological cluster cannot turn a width call into a scan.
- */
 const EMOJI_SCAN_LIMIT = 50;
-/** The Halfwidth and Fullwidth Forms block, which a cluster can carry after its base. */
 const FORMS_FIRST = 0xff00;
 const FORMS_LAST = 0xffef;
-/**
- * Conjoining jamo, in the three classes modern Hangul composes from: leading (L), vowel (V)
- * and trailing (T). Each has an archaic extension block beside the main one.
- */
 const JAMO_LEADING = [0x1100, 0x115f, 0xa960, 0xa97c];
 const JAMO_VOWEL = [0x1160, 0x11a7, 0xd7b0, 0xd7c6];
 const JAMO_TRAILING = [0x11a8, 0x11ff, 0xd7cb, 0xd7fb];
-const segmenter = new Intl.Segmenter();
-/** East Asian Width of one code point, in columns, under the caller's ambiguous policy. */
+let cached;
+const segmenter = () => (cached ??= new Intl.Segmenter());
 function columnsOf(codePoint, ambiguousIsWide) {
     return isWide(codePoint) || (ambiguousIsWide && isAmbiguous(codePoint)) ? WIDE_COLUMNS : NARROW;
 }
-/**
- * Columns a cluster's trailing **spacing marks and fullwidth forms** add. `ｶﾞ` is a base
- * plus a wide mark; `क` + `ा` is a base plus a spacing mark. Both advance the cursor past
- * the base, and neither is a separate cluster, so neither can be counted anywhere else.
- *
- * The walk is over the *visible* cluster — what is left after the leading non-printing run
- * has been removed — so that the character being skipped as "the base" is the base, not a
- * format character standing in front of it.
- */
 function trailingColumns(visible, ambiguousIsWide) {
     let extra = 0;
     for (const character of [...visible].slice(1)) {
         const codePoint = character.codePointAt(0) ?? 0;
         const isForm = codePoint >= FORMS_FIRST && codePoint <= FORMS_LAST;
-        if (isForm || SPACING_MARK.test(character))
+        if (isForm || SPACING_MARK().test(character))
             extra += columnsOf(codePoint, ambiguousIsWide);
     }
     return extra;
 }
-/**
- * Whether a cluster is an emoji sequence that `\p{RGI_Emoji}` refuses because it is
- * **minimally qualified or unqualified** — the same sequence with its `U+FE0F` left off.
- * A terminal renders `U+2764 ZWJ U+1F525` as one two-column emoji whether or not the
- * variation selector is there; the regex only matches the fully-qualified spelling.
- *
- * Two shapes, and both need their guard. A ZWJ sequence counts only when **two or more**
- * pictographs are joined, which is what keeps `क् ZWJ ष` — an Indic conjunct using the same
- * joiner — one column. A keycap counts only over a digit, `#` or `*`, which is what keeps
- * the invalid `U+260E U+FE0F U+20E3` one column. Both of those are cases in the suite that
- * grades this file, and both passed before this function existed.
- */
 function isUnqualifiedEmojiSequence(cluster) {
     if (cluster.length > EMOJI_SCAN_LIMIT)
         return false;
@@ -220,14 +135,13 @@ function isUnqualifiedEmojiSequence(cluster) {
         return false;
     let pictographs = 0;
     for (const character of cluster) {
-        if (EXTENDED_PICTOGRAPHIC.test(character))
+        if (EXTENDED_PICTOGRAPHIC().test(character))
             pictographs += 1;
         if (pictographs >= EMOJI_ZWJ_PICTOGRAPHS)
             return true;
     }
     return false;
 }
-/** Whether `codePoint` falls in one of a flat `[low, high]` pair list. */
 function inPairs(pairs, codePoint) {
     for (let i = 0; i < pairs.length; i += PAIR) {
         if (codePoint >= (pairs[i] ?? 0) && codePoint <= (pairs[i + 1] ?? 0))
@@ -238,25 +152,10 @@ function inPairs(pairs, codePoint) {
 function isJamo(codePoint) {
     return inPairs(JAMO_LEADING, codePoint) || inPairs(JAMO_VOWEL, codePoint) || inPairs(JAMO_TRAILING, codePoint);
 }
-/**
- * Columns a cluster of **conjoining Hangul jamo** occupies, or `undefined` when the cluster
- * does not start with one — in which case the caller's ordinary base-scalar path is right.
- *
- * This is the one category that needs a walk rather than a table lookup. `Intl.Segmenter`
- * joins a whole run of jamo into a single grapheme cluster (GB6, GB7, GB8), so measuring the
- * cluster by its first code point answered **2** for a six-jamo run a terminal draws **12**
- * columns wide. Modern Hangul composes L + V, or L + V + T, into one syllable block two
- * columns wide; jamo that find no partner stay additive at their own East Asian Width, which
- * makes a leading jamo 2 and a vowel or trailing jamo 1.
- *
- * A cluster that begins with jamo and then turns into something else — a leading jamo
- * followed by a precomposed syllable — measures the jamo by this rule and the remainder by
- * East Asian Width, which is how `U+1100 U+AC00` comes to 4 rather than 2.
- */
 function hangulColumns(visible, ambiguousIsWide) {
     const codePoints = [];
     for (const character of visible) {
-        if (ZERO_WIDTH_CLUSTER.test(character))
+        if (ZERO_WIDTH_CLUSTER().test(character))
             continue;
         codePoints.push(character.codePointAt(0) ?? 0);
     }
@@ -279,21 +178,16 @@ function hangulColumns(visible, ambiguousIsWide) {
     }
     return columns;
 }
-/**
- * Columns a string of *plain* text occupies — no escape scan. The wrapper below has
- * already split its input into text runs and complete sequences, so rescanning would only
- * give a malformed sequence a second chance to be mistaken for one.
- */
 export function measure(text, ambiguousIsWide = false) {
     let columns = 0;
-    for (const { segment } of segmenter.segment(text)) {
-        if (ZERO_WIDTH_CLUSTER.test(segment))
+    for (const { segment } of segmenter().segment(text)) {
+        if (ZERO_WIDTH_CLUSTER().test(segment))
             continue;
-        if (RGI_EMOJI.test(segment) || isUnqualifiedEmojiSequence(segment)) {
+        if (RGI_EMOJI().test(segment) || isUnqualifiedEmojiSequence(segment)) {
             columns += WIDE_COLUMNS;
             continue;
         }
-        const visible = segment.replace(LEADING_NON_PRINTING, '');
+        const visible = segment.replace(LEADING_NON_PRINTING(), '');
         const hangul = hangulColumns(visible, ambiguousIsWide);
         if (hangul !== undefined) {
             columns += hangul;
@@ -304,57 +198,25 @@ export function measure(text, ambiguousIsWide = false) {
     }
     return columns;
 }
-/**
- * Printable ASCII is one column per code unit, and nothing that makes `measure` correct can
- * change that answer: there are no escape sequences, no combining marks and no emoji between
- * 0x20 and 0x7E. `countAnsiEscapeCodes` cannot change it either — `ESC` is 0x1B, below the
- * range, so a string this accepts has no escapes to count.
- *
- * It is not a micro-optimisation. `widest` over many lines is one `Intl.Segmenter` walk per
- * line, and `truncate.test.ts`'s 200,000-line case — the one proving `widest` survives where
- * `Math.max(...)` throws — timed out at five seconds without this. ASCII is the common line.
- */
 function asciiColumns(text) {
     for (let i = 0; i < text.length; i += 1) {
-        // `codePointAt` over `charCodeAt` (Interlace unicode-safety rule, and it is the right
-        // call): on a surrogate pair this returns the whole code point, which is above 0x7E and
-        // bails to the full path. `charCodeAt` would have seen a lone high surrogate instead.
-        // `?? 0` cannot mislead — 0 is below 0x20, so an out-of-range index also bails.
         const code = text.codePointAt(i) ?? 0;
         if (code < 0x20 || code > 0x7e)
             return undefined;
     }
     return text.length;
 }
-/**
- * How many terminal columns `input` occupies once its escape sequences are removed.
- *
- * **Non-strings measure 0.** `string-width` has always answered `0` for a number, `null` or
- * `undefined` rather than throwing, and callers rely on it — a width function is usually
- * reached with whatever a template produced. Three cases of its suite grade exactly this, and
- * the check is `typeof` rather than a truthiness test so that `0` and `false` are not quietly
- * treated as strings that happen to be empty.
- */
 export function width(input, options = {}) {
     if (typeof input !== 'string' || input === '')
         return 0;
     const ascii = asciiColumns(input);
     if (ascii !== undefined)
         return ascii;
-    // `strip`, not `node:util`'s: Node's scanner stops at the first colon in the ITU T.416
-    // sub-parameter form (`ESC[38:2::255:0:0m`), which chalk and wrap-ansi both emit — it
-    // measured 15 where string-width says 3. The fast path above never reaches here with an
-    // escape in it, so the two fixes are disjoint: 0x1B is below its 0x20 floor.
     return measure(options.countAnsiEscapeCodes === true ? input : strip(input), options.ambiguousIsNarrow === false);
 }
-/**
- * Lines a string occupies in a terminal `columns` wide — the measurement the frame loop
- * actually asks for. An empty line still occupies one.
- */
 export function lineCount(text, columns) {
     let count = 0;
     for (const line of strip(text).split('\n'))
         count += Math.max(1, Math.ceil(width(line) / columns));
     return count;
 }
-//# sourceMappingURL=width.js.map

package/dist/wrap.js

@@ -1,20 +1,5 @@
 import { ASCII_PRINTABLE, ROW_BOUNDARY, TAB_SIZE, applyLeadingResets, applyParameters, closingSequence, forEachSegment, hyperlink, matchEscape, openingSequence, segmenter, sgr } from './style.js';
-/**
- * Wrapping text that carries ANSI, ported from wrap-ansi 10 — the third dependency the
- * render façades share, after the spinner corpus and the width function (R7, R10).
- *
- * The hard part is not the arithmetic, it is that a style opened on one row must not leak
- * into the next: a terminal that reflows, a pager, or an agent reading one line at a time
- * all see rows independently. So every row closes the styles it inherited and the next row
- * reopens them, which has a second use here — after wrapping, **each row is self-contained**,
- * and dropping leading rows needs no ANSI state tracking at all. `flagstaff/log-update`
- * relies on exactly that, which is why it carries no port of `slice-ansi`.
- *
- * Graded differentially against the real `wrap-ansi` in `wrap.test.ts`, the way `width.ts`
- * is graded against `string-width`: the incumbent is the specification.
- */
 import { measure } from './width.js';
-/** The visible width of a string, escape sequences ignored. */
 export function visibleWidth(string) {
     let plainText = '';
     forEachSegment(string, (part) => {
@@ -22,11 +7,6 @@ export function visibleWidth(string) {
     });
     return measure(plainText);
 }
-/**
- * Escape sequences, which are zero width and must never be split, and grapheme clusters.
- * A sequence written *inside* a cluster splits it — the supported boundary is between
- * clusters and sequences, not within one.
- */
 function tokenize(string) {
     const tokens = [];
     forEachSegment(string, (plainText) => {
@@ -35,12 +15,11 @@ function tokenize(string) {
                 tokens.push({ value: character, width: 1 });
             return;
         }
-        for (const { segment } of segmenter.segment(plainText))
+        for (const { segment } of segmenter().segment(plainText))
             tokens.push({ value: segment, width: measure(segment) });
     }, (escape) => tokens.push({ value: escape, width: 0 }));
     return tokens;
 }
-/** Split on spaces, ignoring spaces that appear inside a recognised sequence. */
 function splitWords(string) {
     let current = { value: '', plainText: '', width: 0 };
     const words = [current];
@@ -56,20 +35,14 @@ function splitWords(string) {
     }, (escape) => {
         current.value += escape;
     });
-    // Measured once per word rather than per run, so a cluster an escape splits counts once.
     for (const word of words)
         word.width = measure(word.plainText);
     return words;
 }
-/**
- * Break one long word across rows. Takes the visible width of the row it starts on and
- * returns the width of the row it ends on, so the caller never measures a row itself.
- */
 function wrapWord(rows, word, columns, rowWidth) {
     const tokens = tokenize(word);
     let visible = rowWidth;
     for (const [index, token] of tokens.entries()) {
-        // Sequences and combining marks are zero width, so they stay on the current row.
         if (token.width > 0 && visible > 0 && visible + token.width > columns) {
             rows.push('');
             visible = 0;
@@ -81,15 +54,11 @@ function wrapWord(rows, word, columns, rowWidth) {
             visible = 0;
         }
     }
-    // The last row copied over can be nothing but escape characters.
     const last = rows.at(-1) ?? '';
     if (!visible && last.length > 0 && rows.length > 1)
         rows[rows.length - 2] += rows.pop() ?? '';
-    // Tokens are measured one at a time, so a cluster an escape splits counts once per part.
-    // Only the finished row gives the true width, and it is at most one row to measure.
     return visibleWidth(rows.at(-1) ?? '');
 }
-/** Drop the spaces trailing the last visible character, keeping the sequences among them. */
 function trimVisibleEnd(string) {
     if (!string.includes(' '))
         return string;
@@ -99,7 +68,6 @@ function trimVisibleEnd(string) {
         const segment = segments[index];
         if (segment === undefined || segment.isEscape)
             continue;
-        // Scanned rather than matched: a trailing-space pattern backtracks quadratically.
         let end = segment.value.length;
         while (end > 0 && segment.value[end - 1] === ' ')
             end -= 1;
@@ -133,11 +101,6 @@ function expandTabs(line) {
     });
     return expanded;
 }
-/**
- * Close the active styles and hyperlink before every row break and reopen them after, so
- * each row stands on its own. Only sequences and newlines matter, so the string is scanned
- * directly rather than segmented.
- */
 function restoreStylesAcrossRows(preString) {
     let out = '';
     let activeHyperlink;
@@ -164,9 +127,7 @@ function restoreStylesAcrossRows(preString) {
             index += escape[0].length;
             continue;
         }
-        // Everything up to the row break is copied verbatim, sequences included.
         out += preString.slice(copied, index);
-        // An empty row never reopened anything, so there is nothing to close.
         if (index > copied) {
             if (activeHyperlink !== undefined)
                 out += hyperlink('');
@@ -175,8 +136,6 @@ function restoreStylesAcrossRows(preString) {
         out += '\n';
         index += 1;
         copied = index;
-        // An empty row has nothing to style, so the styles stay closed until the next row with
-        // content; a trailing row break leaves no row at all.
         if (index < preString.length && preString[index] !== '\n') {
             const opening = [...active];
             applyLeadingResets(preString, index, opening);
@@ -187,23 +146,19 @@ function restoreStylesAcrossRows(preString) {
     }
     return out + preString.slice(copied);
 }
-/** Whether a word longer than the row should start on the next row instead of this one. */
 function shouldStartLongWordOnNextRow(wordWidth, columns, rowLength) {
     const remaining = columns - rowLength;
     const breaksStartingThisRow = 1 + Math.floor((wordWidth - remaining - 1) / columns);
     const breaksStartingNextRow = Math.floor((wordWidth - 1) / columns);
     return breaksStartingNextRow < breaksStartingThisRow;
 }
-/** One line of input — the caller has already split on newlines. */
 function wrapLine(string, columns, options) {
     const trim = options.trim !== false;
     if (trim && string.trim() === '')
         return '';
     const words = splitWords(string);
     let rows = [''];
-    // Tracked as rows are built: remeasuring per word makes wrapping quadratic in the line.
     let rowLength = 0;
-    // A row that already starts with content can never become trimmable again.
     let trimmedRowIndex = -1;
     let isFirstWord = true;
     for (const word of words) {
@@ -231,7 +186,6 @@ function wrapLine(string, columns, options) {
                 rowLength += 1;
             }
         }
-        // 'hard': a row is never allowed to extend past `columns`.
         if (options.hard === true && options.wordWrap !== false && word.width > columns) {
             if (shouldStartLongWordOnNextRow(word.width, columns, rowLength)) {
                 rows.push('');
@@ -259,7 +213,6 @@ function wrapLine(string, columns, options) {
         rows = rows.map((row) => trimVisibleEnd(row));
     return restoreStylesAcrossRows(rows.join('\n'));
 }
-/** Wrap `string` to `columns`, keeping its ANSI intact and each row self-contained. */
 export function wrap(string, columns, options = {}) {
     return String(string)
         .normalize()
@@ -268,15 +221,4 @@ export function wrap(string, columns, options = {}) {
         .map((line) => wrapLine(expandTabs(line), columns, options))
         .join('\n');
 }
-/**
- * The default export, for the reason `strip.ts` gives at length: `wrap-ansi` 10's suite
- * imports its entry point's **default**, and that suite now grades this file.
- *
- * Written without quoting the specifier, deliberately. `subpath-isolation.test.ts` scans the
- * *emitted text* of `dist/wrap.js` for relative imports, comments included, so a doc comment
- * that spells one out makes the entry look as though it reaches a sibling. Caught by that
- * lock on 2026-09-14, which is the lock doing exactly its job on the wrong input.
- */
-// eslint-disable-next-line import-next/no-default-export -- the incumbent's own suite imports a default; see above. This is the drop-in surface, not a style choice.
 export { wrap as default };
-//# sourceMappingURL=wrap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linegauge",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "A printer's line gauge \u2014 the steel rule marked in picas and points. Measuring, wrapping, truncating and slicing styled terminal text without the edge fraying \u2014 grapheme-correct over Intl.Segmenter. Drop-in paths for string-width, wrap-ansi, strip-ansi and slice-ansi. Zero dependencies.",
   "license": "MIT",
   "type": "module",
@@ -45,7 +45,7 @@
     "!dist/**/*.test.*"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/strip-comments.mjs dist",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run --passWithNoTests",
     "coverage": "vitest run --coverage.enabled",
@@ -75,6 +75,6 @@
     "unicode"
   ],
   "devDependencies": {
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.1"
   }
 }