linegauge 0.1.0 → 0.3.0

package/dist/width.js

@@ -8,7 +8,10 @@
  * worth a dependency tree (U5).
  *
  * The rules, in the order a cluster meets them:
- *   1. ANSI and other control sequences are not printed — `stripVTControlCharacters`.
+ *   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.
@@ -19,7 +22,7 @@
  * 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 { stripVTControlCharacters } from 'node:util';
+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
@@ -57,13 +60,62 @@ const NARROW = 1;
 const WIDE_COLUMNS = 2;
 /** Half the flat array is lows, so a step over pairs. */
 const PAIR = 2;
-function isWide(codePoint) {
+/**
+ * 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,
+    0x00D7, 0x00D8, 0x00DE, 0x00E1, 0x00E6, 0x00E6, 0x00E8, 0x00EA, 0x00EC, 0x00ED,
+    0x00F0, 0x00F0, 0x00F2, 0x00F3, 0x00F7, 0x00FA, 0x00FC, 0x00FC, 0x00FE, 0x00FE,
+    0x0101, 0x0101, 0x0111, 0x0111, 0x0113, 0x0113, 0x011B, 0x011B, 0x0126, 0x0127,
+    0x012B, 0x012B, 0x0131, 0x0133, 0x0138, 0x0138, 0x013F, 0x0142, 0x0144, 0x0144,
+    0x0148, 0x014B, 0x014D, 0x014D, 0x0152, 0x0153, 0x0166, 0x0167, 0x016B, 0x016B,
+    0x01CE, 0x01CE, 0x01D0, 0x01D0, 0x01D2, 0x01D2, 0x01D4, 0x01D4, 0x01D6, 0x01D6,
+    0x01D8, 0x01D8, 0x01DA, 0x01DA, 0x01DC, 0x01DC, 0x0251, 0x0251, 0x0261, 0x0261,
+    0x02C4, 0x02C4, 0x02C7, 0x02C7, 0x02C9, 0x02CB, 0x02CD, 0x02CD, 0x02D0, 0x02D0,
+    0x02D8, 0x02DB, 0x02DD, 0x02DD, 0x02DF, 0x02DF, 0x0300, 0x036F, 0x0391, 0x03A1,
+    0x03A3, 0x03A9, 0x03B1, 0x03C1, 0x03C3, 0x03C9, 0x0401, 0x0401, 0x0410, 0x044F,
+    0x0451, 0x0451, 0x2010, 0x2010, 0x2013, 0x2016, 0x2018, 0x2019, 0x201C, 0x201D,
+    0x2020, 0x2022, 0x2024, 0x2027, 0x2030, 0x2030, 0x2032, 0x2033, 0x2035, 0x2035,
+    0x203B, 0x203B, 0x203E, 0x203E, 0x2074, 0x2074, 0x207F, 0x207F, 0x2081, 0x2084,
+    0x20AC, 0x20AC, 0x2103, 0x2103, 0x2105, 0x2105, 0x2109, 0x2109, 0x2113, 0x2113,
+    0x2116, 0x2116, 0x2121, 0x2122, 0x2126, 0x2126, 0x212B, 0x212B, 0x2153, 0x2154,
+    0x215B, 0x215E, 0x2160, 0x216B, 0x2170, 0x2179, 0x2189, 0x2189, 0x2190, 0x2199,
+    0x21B8, 0x21B9, 0x21D2, 0x21D2, 0x21D4, 0x21D4, 0x21E7, 0x21E7, 0x2200, 0x2200,
+    0x2202, 0x2203, 0x2207, 0x2208, 0x220B, 0x220B, 0x220F, 0x220F, 0x2211, 0x2211,
+    0x2215, 0x2215, 0x221A, 0x221A, 0x221D, 0x2220, 0x2223, 0x2223, 0x2225, 0x2225,
+    0x2227, 0x222C, 0x222E, 0x222E, 0x2234, 0x2237, 0x223C, 0x223D, 0x2248, 0x2248,
+    0x224C, 0x224C, 0x2252, 0x2252, 0x2260, 0x2261, 0x2264, 0x2267, 0x226A, 0x226B,
+    0x226E, 0x226F, 0x2282, 0x2283, 0x2286, 0x2287, 0x2295, 0x2295, 0x2299, 0x2299,
+    0x22A5, 0x22A5, 0x22BF, 0x22BF, 0x2312, 0x2312, 0x2460, 0x24E9, 0x24EB, 0x254B,
+    0x2550, 0x2573, 0x2580, 0x258F, 0x2592, 0x2595, 0x25A0, 0x25A1, 0x25A3, 0x25A9,
+    0x25B2, 0x25B3, 0x25B6, 0x25B7, 0x25BC, 0x25BD, 0x25C0, 0x25C1, 0x25C6, 0x25C8,
+    0x25CB, 0x25CB, 0x25CE, 0x25D1, 0x25E2, 0x25E5, 0x25EF, 0x25EF, 0x2605, 0x2606,
+    0x2609, 0x2609, 0x260E, 0x260F, 0x261C, 0x261C, 0x261E, 0x261E, 0x2640, 0x2640,
+    0x2642, 0x2642, 0x2660, 0x2661, 0x2663, 0x2665, 0x2667, 0x266A, 0x266C, 0x266D,
+    0x266F, 0x266F, 0x269E, 0x269F, 0x26BF, 0x26BF, 0x26C6, 0x26CD, 0x26CF, 0x26D3,
+    0x26D5, 0x26E1, 0x26E3, 0x26E3, 0x26E8, 0x26E9, 0x26EB, 0x26F1, 0x26F4, 0x26F4,
+    0x26F6, 0x26F9, 0x26FB, 0x26FC, 0x26FE, 0x26FF, 0x273D, 0x273D, 0x2776, 0x277F,
+    0x2B56, 0x2B59, 0x3248, 0x324F, 0xE000, 0xF8FF, 0xFE00, 0xFE0F, 0xFFFD, 0xFFFD,
+    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 = WIDE.length / PAIR - 1;
+    let high = table.length / PAIR - 1;
     while (low <= high) {
         const mid = (low + high) >> 1;
-        const start = WIDE[mid * PAIR] ?? 0;
-        const end = WIDE[mid * PAIR + 1] ?? 0;
+        const start = table[mid * PAIR] ?? 0;
+        const end = table[mid * PAIR + 1] ?? 0;
         if (codePoint < start)
             high = mid - 1;
         else if (codePoint > end)
@@ -73,47 +125,227 @@ function isWide(codePoint) {
     }
     return false;
 }
-// `v`-mode properties: the whole point of using them is that Node ships the tables.
-const ZERO_WIDTH_CLUSTER = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
-const LEADING_NON_PRINTING = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+function isWide(codePoint) {
+    return inTable(WIDE, 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.
+ */
+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();
-/** Columns a cluster's trailing fullwidth forms add — `ｶﾞ` is a base plus a wide mark. */
-function trailingForms(cluster) {
+/** East Asian Width of one code point, in columns, under the caller's ambiguous policy. */
+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 [...cluster].slice(1)) {
+    for (const character of [...visible].slice(1)) {
         const codePoint = character.codePointAt(0) ?? 0;
-        if (codePoint >= FORMS_FIRST && codePoint <= FORMS_LAST)
-            extra += isWide(codePoint) ? WIDE_COLUMNS : NARROW;
+        const isForm = codePoint >= FORMS_FIRST && codePoint <= FORMS_LAST;
+        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;
+    if (UNQUALIFIED_KEYCAP.test(cluster))
+        return true;
+    if (!cluster.includes(ZWJ))
+        return false;
+    let pictographs = 0;
+    for (const character of cluster) {
+        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))
+            return true;
+    }
+    return false;
+}
+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))
+            continue;
+        codePoints.push(character.codePointAt(0) ?? 0);
+    }
+    if (codePoints.length === 0 || !isJamo(codePoints[0] ?? 0))
+        return undefined;
+    let columns = 0;
+    for (let index = 0; index < codePoints.length; index += 1) {
+        const codePoint = codePoints[index] ?? 0;
+        if (!isJamo(codePoint)) {
+            for (let rest = index; rest < codePoints.length; rest += 1)
+                columns += columnsOf(codePoints[rest] ?? 0, ambiguousIsWide);
+            return columns;
+        }
+        if (inPairs(JAMO_LEADING, codePoint) && inPairs(JAMO_VOWEL, codePoints[index + 1] ?? -1)) {
+            columns += WIDE_COLUMNS;
+            index += inPairs(JAMO_TRAILING, codePoints[index + PAIR] ?? -1) ? PAIR : 1;
+            continue;
+        }
+        columns += columnsOf(codePoint, 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) {
+export function measure(text, ambiguousIsWide = false) {
     let columns = 0;
     for (const { segment } of segmenter.segment(text)) {
         if (ZERO_WIDTH_CLUSTER.test(segment))
             continue;
-        if (RGI_EMOJI.test(segment)) {
+        if (RGI_EMOJI.test(segment) || isUnqualifiedEmojiSequence(segment)) {
             columns += WIDE_COLUMNS;
             continue;
         }
-        const codePoint = segment.replace(LEADING_NON_PRINTING, '').codePointAt(0) ?? 0;
-        columns += isWide(codePoint) ? WIDE_COLUMNS : NARROW;
-        columns += trailingForms(segment);
+        const visible = segment.replace(LEADING_NON_PRINTING, '');
+        const hangul = hangulColumns(visible, ambiguousIsWide);
+        if (hangul !== undefined) {
+            columns += hangul;
+            continue;
+        }
+        columns += columnsOf(visible.codePointAt(0) ?? 0, ambiguousIsWide);
+        columns += trailingColumns(visible, ambiguousIsWide);
     }
     return columns;
 }
-/** How many terminal columns `input` occupies once its escape sequences are removed. */
-export function width(input) {
-    return input === '' ? 0 : measure(stripVTControlCharacters(input));
+/**
+ * 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
@@ -121,7 +353,7 @@ export function width(input) {
  */
 export function lineCount(text, columns) {
     let count = 0;
-    for (const line of stripVTControlCharacters(text).split('\n'))
+    for (const line of strip(text).split('\n'))
         count += Math.max(1, Math.ceil(width(line) / columns));
     return count;
 }

package/dist/wrap.d.ts

@@ -1,3 +1,5 @@
+/** The visible width of a string, escape sequences ignored. */
+export declare function visibleWidth(string: string): number;
 export interface WrapOptions {
     /** Trim leading and trailing whitespace from each row. Default true. */
     trim?: boolean;
@@ -8,3 +10,13 @@ export interface WrapOptions {
 }
 /** Wrap `string` to `columns`, keeping its ANSI intact and each row self-contained. */
 export declare function wrap(string: string, columns: number, options?: WrapOptions): string;
+/**
+ * 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.
+ */
+export { wrap as default };

package/dist/wrap.js

@@ -1,3 +1,4 @@
+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).
@@ -13,112 +14,8 @@
  * is graded against `string-width`: the incumbent is the specification.
  */
 import { measure } from './width.js';
-const ESC = '\u001B';
-const BELL = '\u0007';
-/** The single-byte C1 form of `ESC [`, which a terminal accepts and a suite will send. */
-const C1_CSI = '\u009B';
-const CSI = '[';
-const OSC = ']';
-const SGR_TERMINATOR = 'm';
-const SGR_RESET = 0;
-const SGR_RESET_FOREGROUND = 39;
-const SGR_RESET_BACKGROUND = 49;
-const SGR_RESET_UNDERLINE_COLOR = 59;
-const SGR_FOREGROUND_EXTENDED = 38;
-const SGR_BACKGROUND_EXTENDED = 48;
-const SGR_UNDERLINE_COLOR_EXTENDED = 58;
-const SGR_COLOR_MODE_RGB = 2;
-const SGR_COLOR_MODE_256 = 5;
-const FOREGROUND_FIRST = 30;
-const FOREGROUND_LAST = 37;
-const FOREGROUND_BRIGHT_FIRST = 90;
-const FOREGROUND_BRIGHT_LAST = 97;
-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. */
-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;
-const ESCAPES = new Set([ESC, C1_CSI]);
-const ESCAPE_CHARACTERS = [...ESCAPES].join('');
-const CSI_INTRODUCER = `(?:${ESC}\\${CSI}|${C1_CSI})`;
-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.
-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');
-const ROW_BOUNDARY = new RegExp(`[\\n${ESCAPE_CHARACTERS}]`, 'g');
-/** Every printable ASCII character is its own cluster of width one — skip the segmenter. */
-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.
- */
-const MODIFIER_CLOSE = new Map([
-    [1, 22],
-    [2, 22],
-    [3, 23],
-    [4, 24],
-    [7, 27],
-    [8, 28],
-    [9, 29],
-    [53, 55],
-]);
-const MODIFIER_CLOSE_CODES = new Set(MODIFIER_CLOSE.values());
-const segmenter = new Intl.Segmenter();
-const sgr = (code) => `${ESC}${CSI}${code}${SGR_TERMINATOR}`;
-const hyperlink = (url, parameters = '') => `${ESC}${OSC}8;${parameters};${url}${BELL}`;
-/** The complete escape sequence starting at `index`, or nothing when none starts there. */
-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.
- */
-function forEachSegment(string, onPlainText, onEscape = () => undefined) {
-    let plainStart = 0;
-    let index = 0;
-    while (index < string.length) {
-        ESCAPE_INTRODUCER.lastIndex = index;
-        const introducer = ESCAPE_INTRODUCER.exec(string);
-        if (introducer === null)
-            break;
-        const escape = matchEscape(string, introducer.index);
-        if (escape === undefined) {
-            index = introducer.index + 1;
-            continue;
-        }
-        if (introducer.index > plainStart)
-            onPlainText(string.slice(plainStart, introducer.index));
-        onEscape(escape[0]);
-        index = introducer.index + escape[0].length;
-        plainStart = index;
-    }
-    if (plainStart < string.length)
-        onPlainText(string.slice(plainStart));
-}
 /** The visible width of a string, escape sequences ignored. */
-function visibleWidth(string) {
+export function visibleWidth(string) {
     let plainText = '';
     forEachSegment(string, (part) => {
         plainText += part;
@@ -164,155 +61,6 @@ function splitWords(string) {
         word.width = measure(word.plainText);
     return words;
 }
-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);
-    const mode = Number.parseInt(parts[1] ?? '', 10);
-    if (![SGR_FOREGROUND_EXTENDED, SGR_BACKGROUND_EXTENDED, SGR_UNDERLINE_COLOR_EXTENDED].includes(code))
-        return undefined;
-    if (mode === SGR_COLOR_MODE_256 && parts.length === COLOR_256_PARTS && isDigits(parts[2] ?? '')) {
-        return { code, open: parameter, hasArguments: true };
-    }
-    if (mode !== SGR_COLOR_MODE_RGB)
-        return undefined;
-    const withSpace = parts.length === COLON_RGB_WITH_SPACE;
-    const components = withSpace ? parts.slice(3) : parts.slice(2);
-    const colorSpace = withSpace ? parts[2] : undefined;
-    if (components.length === COLOR_RGB_PARTS && components.every(isDigits) && (colorSpace === undefined || /^\d*$/.test(colorSpace))) {
-        return { code, open: parameter, hasArguments: true };
-    }
-    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);
-    if (mode === SGR_COLOR_MODE_256 && Number.isFinite(first)) {
-        return { token: { code, open: [code, mode, first].join(';'), hasArguments: true }, consumed: 2 };
-    }
-    const green = Number.parseInt(parameters[index + 3] ?? '', 10);
-    const blue = Number.parseInt(parameters[index + 4] ?? '', 10);
-    if (mode === SGR_COLOR_MODE_RGB && Number.isFinite(first) && Number.isFinite(green) && Number.isFinite(blue)) {
-        return { token: { code, open: [code, mode, first, green, blue].join(';'), hasArguments: true }, consumed: 4 };
-    }
-    return undefined;
-}
-const isExtendedColor = (code) => code === SGR_FOREGROUND_EXTENDED || code === SGR_BACKGROUND_EXTENDED || code === SGR_UNDERLINE_COLOR_EXTENDED;
-function sgrTokens(parameters) {
-    const parts = parameters.split(';');
-    const tokens = [];
-    for (let index = 0; index < parts.length; index += 1) {
-        const parameter = parts[index] ?? '';
-        if (parameter.includes(':')) {
-            const token = colonColorToken(parameter);
-            if (token !== undefined)
-                tokens.push(token);
-            continue;
-        }
-        const code = parameter === '' ? SGR_RESET : Number.parseInt(parameter, 10);
-        if (!Number.isFinite(code))
-            continue;
-        if (isExtendedColor(code)) {
-            if (index + 1 >= parts.length)
-                break;
-            const extended = extendedColorToken(code, parts, index);
-            if (extended === undefined)
-                break;
-            tokens.push(extended.token);
-            index += extended.consumed;
-            continue;
-        }
-        tokens.push({ code, open: String(code), hasArguments: false });
-    }
-    return tokens;
-}
-function removeFamily(active, family) {
-    const at = active.findIndex((style) => style.family === family);
-    if (at !== -1)
-        active.splice(at, 1);
-}
-function colorStyle(token) {
-    const { code, open, hasArguments } = token;
-    if ((code >= FOREGROUND_FIRST && code <= FOREGROUND_LAST) || (code >= FOREGROUND_BRIGHT_FIRST && code <= FOREGROUND_BRIGHT_LAST) || (code === SGR_FOREGROUND_EXTENDED && hasArguments)) {
-        return { family: 'foreground', open, close: SGR_RESET_FOREGROUND };
-    }
-    if ((code >= BACKGROUND_FIRST && code <= BACKGROUND_LAST) || (code >= BACKGROUND_BRIGHT_FIRST && code <= BACKGROUND_BRIGHT_LAST) || (code === SGR_BACKGROUND_EXTENDED && hasArguments)) {
-        return { family: 'background', open, close: SGR_RESET_BACKGROUND };
-    }
-    if (code === SGR_UNDERLINE_COLOR_EXTENDED && hasArguments) {
-        return { family: 'underlineColor', open, close: SGR_RESET_UNDERLINE_COLOR };
-    }
-    return undefined;
-}
-/** True when the code closed something rather than opening it. */
-function applyResetCode(code, active) {
-    if (code === SGR_RESET) {
-        active.length = 0;
-        return true;
-    }
-    if (code === SGR_RESET_FOREGROUND) {
-        removeFamily(active, 'foreground');
-        return true;
-    }
-    if (code === SGR_RESET_BACKGROUND) {
-        removeFamily(active, 'background');
-        return true;
-    }
-    if (code === SGR_RESET_UNDERLINE_COLOR) {
-        removeFamily(active, 'underlineColor');
-        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)
-                active.splice(index, 1);
-        }
-        return true;
-    }
-    return false;
-}
-function applyToken(token, active) {
-    if (applyResetCode(token.code, active))
-        return;
-    const color = colorStyle(token);
-    if (color !== undefined) {
-        removeFamily(active, color.family);
-        active.push(color);
-        return;
-    }
-    const close = MODIFIER_CLOSE.get(token.code);
-    if (close !== undefined && close !== SGR_RESET) {
-        const family = `modifier-${token.code}`;
-        removeFamily(active, family);
-        active.push({ family, open: token.open, close });
-    }
-}
-const applyParameters = (parameters, active) => {
-    for (const token of sgrTokens(parameters))
-        applyToken(token, active);
-};
-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. */
-function applyLeadingResets(string, startIndex, active) {
-    let index = startIndex;
-    while (index < string.length) {
-        const match = matchEscape(string, index);
-        if (match === undefined)
-            break;
-        if (match.groups?.['sgr'] !== undefined)
-            applyResets(match.groups['sgr'], active);
-        index += match[0].length;
-    }
-}
-const closingSequence = (active) => [...active].reverse().map((style) => sgr(style.close)).join('');
-const openingSequence = (active) => active.map((style) => sgr(style.open)).join('');
 /**
  * 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.
@@ -520,4 +268,15 @@ 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