linegauge 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -25,9 +25,9 @@
  *
  * R2's fast path: locked by `differential.test.ts`.
  */
-export { lineCount, measure, width, width as default, type WidthOptions, type WidthOptions as Options } from './width.js';
 export * from './slice.js';
+export { lineCount, measure, width, width as default, type WidthOptions, type WidthOptions as Options } from './width.js';
 export { strip } from './strip.js';
-export { truncate, type TruncateOptions } from './truncate.js';
+export * from './truncate.js';
 export { widest } from './widest.js';
 export { wrap, type WrapOptions } from './wrap.js';

package/dist/index.js

@@ -1,6 +1,6 @@
-export { lineCount, measure, width, width as default } from './width.js';
 export * from './slice.js';
+export { lineCount, measure, width, width as default } from './width.js';
 export { strip } from './strip.js';
-export { truncate } from './truncate.js';
+export * from './truncate.js';
 export { widest } from './widest.js';
 export { wrap } from './wrap.js';

package/dist/slice.js

@@ -1,5 +1,5 @@
 import { applyParameters, applyToken, ASCII_PRINTABLE, closingSequence, segmenter, sgrTokens } from './style.js';
-import { measure } from './width.js';
+import { clusterColumns } from './width.js';
 const ESC = '\u001B';
 const BELL = '\u0007';
 const C1_DCS = '\u0090';
@@ -12,7 +12,6 @@ const C1_APC = '\u009F';
 const ST = `${ESC}\\`;
 const ESC_CSI = `${ESC}[`;
 const LINK_PREFIXES = [`${ESC}]8;`, `${C1_OSC}8;`];
-const INTRODUCERS = new Set([ESC, C1_DCS, C1_SOS, C1_CSI, C1_ST, C1_OSC, C1_PM, C1_APC]);
 const STRING_COMMANDS = new Set([']', 'P', 'X', '^', '_']);
 const C1_STRINGS = new Set([C1_DCS, C1_SOS, C1_PM, C1_APC]);
 const CSI_PARAMETER = /[0-?]/u;
@@ -100,44 +99,66 @@ function parseEscape(string, index) {
 }
 const LONE_REGIONAL_INDICATOR = /^[\u{1F1E6}-\u{1F1FF}]$/u;
 function positions(cluster) {
-    const columns = measure(cluster);
+    const columns = clusterColumns(cluster);
     if (columns === 0)
         return 1;
     return LONE_REGIONAL_INDICATOR.test(cluster) ? 2 : columns;
 }
-function tokenize(string) {
-    const tokens = [];
-    const visible = [];
+const INTRODUCER = /[\u001B\u0090\u0098\u009B-\u009F]/g;
+function walk(string, visit) {
+    const parts = [];
     let text = '';
-    let index = 0;
-    while (index < string.length) {
-        const escape = INTRODUCERS.has(string[index]) ? parseEscape(string, index) : undefined;
-        if (escape) {
-            tokens.push(escape);
-            index += escape.code.length;
+    for (let index = 0, from = 0; index <= string.length;) {
+        INTRODUCER.lastIndex = index;
+        const at = INTRODUCER.exec(string)?.index ?? string.length;
+        const escape = at < string.length ? parseEscape(string, at) : undefined;
+        if (at < string.length && escape === undefined) {
+            index = at + 1;
             continue;
         }
-        const value = String.fromCodePoint(string.codePointAt(index));
-        const token = { kind: 'text', value, columns: 1, continuation: false };
-        tokens.push(token);
-        visible.push(token);
-        text += value;
-        index += value.length;
+        const run = string.slice(from, at);
+        if (run !== '')
+            parts.push(run);
+        text += run;
+        if (escape === undefined)
+            break;
+        parts.push(escape);
+        index = from = at + escape.code.length;
     }
-    if (ASCII_PRINTABLE.test(text))
-        return tokens;
-    let at = 0;
-    for (const { segment } of segmenter().segment(text)) {
-        const points = [...segment].length;
-        const columns = positions(segment);
-        for (let offset = 0; offset < points; offset += 1) {
-            const token = visible[at + offset];
-            token.columns = offset === 0 ? columns : 0;
-            token.continuation = offset > 0;
+    const clusters = ASCII_PRINTABLE.test(text) ? undefined : segmenter().segment(text)[Symbol.iterator]();
+    let part = 0;
+    let run;
+    const unit = () => {
+        for (;;) {
+            const point = run?.next();
+            if (point?.done === false)
+                return point.value;
+            const current = parts[part++];
+            if (typeof current !== 'string')
+                return current;
+            run = current[Symbol.iterator]();
+        }
+    };
+    let next = unit();
+    const escapes = (ahead) => {
+        for (; next !== undefined && typeof next !== 'string'; next = unit())
+            visit({ ...next, ahead });
+    };
+    for (escapes(false); next !== undefined; escapes(false)) {
+        const cluster = clusters?.next();
+        const whole = cluster?.done === false;
+        const segment = whole ? cluster.value.segment : next;
+        const columns = whole ? positions(segment) : 1;
+        let offset = 0;
+        for (const _ of segment) {
+            if (offset > 0)
+                escapes(true);
+            if (visit({ kind: 'text', value: next, columns: offset === 0 ? columns : 0, continuation: offset > 0 }))
+                return;
+            next = unit();
+            offset += 1;
         }
-        at += points;
     }
-    return tokens;
 }
 function opensStyle(parameters) {
     return sgrTokens(parameters).some((token) => {
@@ -151,22 +172,9 @@ function closesStyle(parameters, active) {
     applyParameters(parameters, after);
     return active.some((style) => !after.includes(style));
 }
-function continuationAhead(tokens) {
-    const ahead = [];
-    let next = false;
-    for (let index = tokens.length - 1; index >= 0; index -= 1) {
-        ahead[index] = next;
-        const token = tokens[index];
-        if (token?.kind === 'text')
-            next = token.continuation;
-    }
-    return ahead;
-}
 export function slice(string, start = 0, end = Number.POSITIVE_INFINITY) {
     if (end <= start || string.length === 0)
         return '';
-    const tokens = tokenize(string);
-    const ahead = continuationAhead(tokens);
     let active = [];
     let link;
     let linked = false;
@@ -248,17 +256,17 @@ export function slice(string, start = 0, end = Number.POSITIVE_INFINITY) {
         }
         column += token.columns;
     };
-    for (const [index, token] of tokens.entries()) {
+    walk(string, (token) => {
         const cluster = token.kind === 'text' && !token.continuation;
         let pastEnd = column >= end || (cluster && column + token.columns > end);
-        if (pastEnd && token.kind !== 'text' && ahead[index] === true)
+        if (pastEnd && token.kind !== 'text' && token.ahead)
             pastEnd = false;
         if (pastEnd && cluster) {
             if (pendingAt !== undefined) {
                 body = body.slice(0, pendingAt);
                 active = pendingActive;
             }
-            break;
+            return true;
         }
         if (token.kind === 'sgr')
             takeSgr(token, pastEnd);
@@ -268,7 +276,8 @@ export function slice(string, start = 0, end = Number.POSITIVE_INFINITY) {
             takeText(token);
         else if (!pastEnd && started)
             body += token.code;
-    }
+        return false;
+    });
     if (!started)
         return '';
     if (link !== undefined)

package/dist/strip.d.ts

@@ -5,23 +5,12 @@
  */
 /**
  * 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.
+ * cursor and erase forms), OSC including `OSC 8` hyperlinks under all three terminators, the
+ * C1 introducers, 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, because it is the same
+ * pattern. A string with neither `ESC` nor `0x9B` is returned as it is, without a replace —
+ * strip-ansi's own fast path, including what it leaves alone: a C1 OSC (`0x9D`) with no `ESC`
+ * or `0x9B` beside it is kept by the incumbent, and so it is kept here.
  */
 export declare function strip(string: string): string;
 /**

package/dist/strip.js

@@ -1,12 +1,5 @@
-import { stripVTControlCharacters as nodeStrip } from 'node:util';
-import { forEachSegment } from './style.js';
+const ANSI = /(?:(?:\u001B\]|\u009D)[^\u0007\u001B\u009C\u009D]*(?:\u0007|\u001B\\|\u009C))|[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]/g;
 export function strip(string) {
-    if (string === '')
-        return '';
-    let out = '';
-    forEachSegment(string, (text) => {
-        out += text;
-    });
-    return nodeStrip(out);
+    return string.includes('\u001B') || string.includes('\u009B') ? string.replace(ANSI, '') : string;
 }
 export { strip as default };

package/dist/width.d.ts

@@ -33,6 +33,24 @@ export declare function setClaim(fn: ((code: number) => number | undefined) | un
  * give a malformed sequence a second chance to be mistaken for one.
  */
 export declare function measure(text: string, ambiguousIsWide?: boolean): number;
+/**
+ * Columns one grapheme cluster occupies — `measure`'s body, for callers that already hold a
+ * cluster: `slice` and `wrap` segment their text once and used to hand each cluster back to
+ * `measure`, which segmented it again (B5).
+ */
+export declare function clusterColumns(segment: string, ambiguousIsWide?: boolean): number;
+/**
+ * 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.
+ * A class and not a loop since 2026-09-30: the same answer in a quarter of the bytes, which
+ * `measure` now pays for too (B5).
+ */
 /**
  * What `width` accepts beyond the string. Graded against `string-width`'s own suite, so the
  * names and the defaults are its names and its defaults, not ours.

package/dist/width.js

@@ -90,24 +90,20 @@ function isWide(codePoint) {
 function isAmbiguous(codePoint) {
     return inTable(AMBIGUOUS, codePoint);
 }
-let invisibleClass;
+let visibleClass;
 let rgiClass;
 let spacingClass;
 let pictographicClass;
 export const INVISIBLE_CLASSES = ['\\p{Default_Ignorable_Code_Point}', '\\p{Control}', '\\p{Format}', '\\p{Nonspacing_Mark}', '\\p{Enclosing_Mark}', '\\p{Surrogate}'];
 const INVISIBLE_SET = INVISIBLE_CLASSES.join('');
-const INVISIBLE = () => (invisibleClass ??= new RegExp(`^[${INVISIBLE_SET}]$`, 'v'));
+const ASCII = /^[ -~]*$/u;
+const VISIBLE = () => (visibleClass ??= 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'));
 export function leadingInvisible(text) {
-    let index = 0;
-    for (const character of text) {
-        if (!INVISIBLE().test(character))
-            break;
-        index += character.length;
-    }
-    return index;
+    const at = text.search(VISIBLE());
+    return at === -1 ? text.length : at;
 }
 const UNQUALIFIED_KEYCAP = /^[\d#*]\u20E3$/u;
 const ZWJ = '\u200D';
@@ -160,14 +156,14 @@ function isJamo(codePoint) {
     return inPairs(JAMO_LEADING, codePoint) || inPairs(JAMO_VOWEL, codePoint) || inPairs(JAMO_TRAILING, codePoint);
 }
 function hangulColumns(visible, ambiguousIsWide) {
+    if (!isJamo(visible.codePointAt(0) ?? 0))
+        return undefined;
     const codePoints = [];
     for (const character of visible) {
-        if (INVISIBLE().test(character))
+        if (!VISIBLE().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;
@@ -190,45 +186,31 @@ export function setClaim(fn) {
     claim = fn;
 }
 export function measure(text, ambiguousIsWide = false) {
+    if (claim === undefined && ASCII.test(text))
+        return text.length;
     let columns = 0;
-    for (const { segment } of segmenter().segment(text)) {
-        const claimed = claim?.(segment.codePointAt(0) ?? 0);
-        if (claimed !== undefined) {
-            columns += claimed;
-            continue;
-        }
-        const skipped = leadingInvisible(segment);
-        if (skipped === segment.length)
-            continue;
-        if (RGI_EMOJI().test(segment) || isUnqualifiedEmojiSequence(segment)) {
-            columns += WIDE_COLUMNS;
-            continue;
-        }
-        const visible = segment.slice(skipped);
-        const hangul = hangulColumns(visible, ambiguousIsWide);
-        if (hangul !== undefined) {
-            columns += hangul;
-            continue;
-        }
-        columns += columnsOf(visible.codePointAt(0) ?? 0, ambiguousIsWide);
-        columns += trailingColumns(visible, ambiguousIsWide);
-    }
+    for (const { segment } of segmenter().segment(text))
+        columns += clusterColumns(segment, ambiguousIsWide);
     return columns;
 }
-function asciiColumns(text) {
-    for (let i = 0; i < text.length; i += 1) {
-        const code = text.codePointAt(i) ?? 0;
-        if (code < 0x20 || code > 0x7e)
-            return undefined;
-    }
-    return text.length;
+const MAY_BE_EMOJI = /[\u2000-\u24FF\u25FD-\u2FFF\uD800-\u{10FFFF}]/u;
+export function clusterColumns(segment, ambiguousIsWide = false) {
+    const claimed = claim?.(segment.codePointAt(0) ?? 0);
+    if (claimed !== undefined)
+        return claimed;
+    const skipped = segment.search(VISIBLE());
+    if (skipped === -1)
+        return 0;
+    if (MAY_BE_EMOJI.test(segment) && (RGI_EMOJI().test(segment) || isUnqualifiedEmojiSequence(segment)))
+        return WIDE_COLUMNS;
+    const visible = segment.slice(skipped);
+    return hangulColumns(visible, ambiguousIsWide) ?? columnsOf(visible.codePointAt(0) ?? 0, ambiguousIsWide) + trailingColumns(visible, ambiguousIsWide);
 }
 export function width(input, options = {}) {
     if (typeof input !== 'string' || input === '')
         return 0;
-    const ascii = asciiColumns(input);
-    if (ascii !== undefined)
-        return ascii;
+    if (ASCII.test(input))
+        return input.length;
     return measure(options.countAnsiEscapeCodes === true ? input : strip(input), options.ambiguousIsNarrow === false);
 }
 export function lineCount(text, columns) {

package/dist/wrap.js

@@ -1,5 +1,5 @@
 import { ASCII_PRINTABLE, ROW_BOUNDARY, TAB_SIZE, applyLeadingResets, applyParameters, closingSequence, forEachSegment, hyperlink, matchEscape, openingSequence, segmenter, sgr } from './style.js';
-import { measure } from './width.js';
+import { clusterColumns, measure } from './width.js';
 export function visibleWidth(string) {
     let plainText = '';
     forEachSegment(string, (part) => {
@@ -16,7 +16,7 @@ function tokenize(string) {
             return;
         }
         for (const { segment } of segmenter().segment(plainText))
-            tokens.push({ value: segment, width: measure(segment) });
+            tokens.push({ value: segment, width: clusterColumns(segment) });
     }, (escape) => tokens.push({ value: escape, width: 0 }));
     return tokens;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linegauge",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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",