linegauge 0.5.3 → 1.0.0

package/README.md

@@ -8,11 +8,34 @@
 </p>
 
 <p align="center">
-  Docs: <a href="https://linegauge.interlace.tools">https://linegauge.interlace.tools</a>
+  Measuring, wrapping, truncating and slicing styled terminal text — without the edge fraying.
 </p>
 
-**Measuring, wrapping, truncating and slicing styled terminal text — without the edge
-fraying.**
+<p align="center">
+  <a href="https://www.npmjs.com/package/linegauge"><img src="https://img.shields.io/npm/v/linegauge?style=flat-square&color=0a6b47" alt="linegauge on npm: the latest version" /></a>
+  <a href="https://www.npmjs.com/package/linegauge"><img src="https://img.shields.io/npm/dm/linegauge?style=flat-square" alt="linegauge downloads per month on npm" /></a>
+  <a href="https://github.com/ofri-peretz/burgee/actions/workflows/quality.yml?query=branch%3Amain"><img src="https://img.shields.io/github/actions/workflow/status/ofri-peretz/burgee/quality.yml?branch=main&style=flat-square&label=Quality%20Gate" alt="Quality Gate: the CI status of main" /></a>
+  <a href="https://app.codecov.io/gh/ofri-peretz/burgee/components"><img src="https://img.shields.io/codecov/c/github/ofri-peretz/burgee/main?component=linegauge&style=flat-square" alt="linegauge line coverage: its Codecov component" /></a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/ofri-peretz/burgee"><img src="https://img.shields.io/ossf-scorecard/github.com/ofri-peretz/burgee?style=flat-square&label=OpenSSF%20Scorecard" alt="OpenSSF Scorecard for the repository" /></a>
+  <a href="https://www.npmjs.com/package/linegauge?activeTab=code"><img src="https://img.shields.io/npm/unpacked-size/linegauge?style=flat-square" alt="Unpacked size of the latest linegauge release on npm" /></a>
+  <a href="https://github.com/ofri-peretz/burgee/blob/main/packages/linegauge/package.json"><img src="https://img.shields.io/badge/dependencies-0-0a6b47?style=flat-square" alt="Zero dependencies" /></a>
+  <a href="https://github.com/ofri-peretz/burgee/blob/main/packages/linegauge/package.json"><img src="https://img.shields.io/badge/types-included-blue?style=flat-square" alt="TypeScript types included for every entry point" /></a>
+  <a href="https://github.com/ofri-peretz/burgee/blob/main/packages/linegauge/package.json"><img src="https://img.shields.io/badge/Node.js-20.19%2B%20%7C%2022.13%2B-green?style=flat-square" alt="Node.js 20.19+ or 22.13+" /></a>
+  <a href="https://github.com/ofri-peretz/burgee/blob/main/packages/linegauge/LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue?style=flat-square" alt="License: MIT" /></a>
+  <a href="https://www.npmjs.com/package/linegauge#provenance"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fregistry.npmjs.org%2Flinegauge%2Flatest&query=%24.dist.attestations.provenance~&label=npm&style=flat-square&color=0a6b47" alt="npm provenance of the latest release, read live from its registry attestation" /></a>
+</p>
+
+<p align="center">
+  <a href="https://burgee.interlace.tools/docs/compatibility"><img src="https://img.shields.io/badge/slice--ansi%20suite-104%2F104-0a6b47?style=flat-square" alt="linegauge/slice passes 104 of 104 cases of the slice-ansi test suite" /></a>
+  <a href="https://burgee.interlace.tools/docs/compatibility"><img src="https://img.shields.io/badge/string--width%20suite-233%2F233-0a6b47?style=flat-square" alt="linegauge passes 233 of 233 cases of the string-width test suite" /></a>
+  <a href="https://burgee.interlace.tools/docs/compatibility"><img src="https://img.shields.io/badge/strip--ansi%20suite-8%2F8-0a6b47?style=flat-square" alt="linegauge/strip passes 8 of 8 cases of the strip-ansi test suite" /></a>
+  <a href="https://burgee.interlace.tools/docs/compatibility"><img src="https://img.shields.io/badge/wrap--ansi%20suite-85%2F85-0a6b47?style=flat-square" alt="linegauge/wrap passes 85 of 85 cases of the wrap-ansi test suite" /></a>
+</p>
+
+<p align="center">
+  Docs: <a href="https://linegauge.interlace.tools">https://linegauge.interlace.tools</a><br />
+  Migrating from: <a href="https://linegauge.interlace.tools/docs/coming-from/string-width">string-width</a> · <a href="https://linegauge.interlace.tools/docs/coming-from/wrap-ansi">wrap-ansi</a> · <a href="https://linegauge.interlace.tools/docs/coming-from/strip-ansi">strip-ansi</a> · <a href="https://linegauge.interlace.tools/docs/coming-from/slice-ansi">slice-ansi</a>
+</p>
 
 A printer's line gauge is the steel rule marked in picas and points: a compositor holds it
 against a line of type and checks it fits the measure it was set to.
@@ -23,25 +46,16 @@ Drop-in paths for **string-width** (the default export), **wrap-ansi**, **strip-
 **slice-ansi**. Nothing here reads `process`, so a pipe, `--json` and an agent get the same
 columns a terminal does — burgee, caique and flagstaff measure their output with it.
 
+## Install
+
 ```bash
-npm i linegauge
+npm install linegauge
+pnpm add linegauge
+yarn add linegauge
+bun add linegauge
 ```
 
-## One problem wearing five names
-
-`width` · `wrap` · `truncate` · `slice` · `widest`
-
-They look like five utilities. They are one: **cutting styled text without letting the edge
-come apart** — no dangling escape sequence, no half a grapheme, no severed emoji cluster.
-Each has to know where the ANSI is and where the cluster boundaries are, and once you know
-that, you may as well answer all five.
-
-The ecosystem splits it across twelve packages — `strip-ansi`, `string-width`,
-`ansi-regex`, `wrap-ansi`, `emoji-regex`, `slice-ansi`, `get-east-asian-width`,
-`eastasianwidth`, `string-length`, `wcwidth`, `cli-truncate` and `widest-line` — which
-between them sit under most of the terminal ecosystem.
-
-## Use
+## Quick start
 
 ```js
 import { width, wrap, truncate, slice, widest } from 'linegauge';
@@ -55,13 +69,19 @@ slice(styled, 2, 4); // columns 2 and 3, styles intact
 widest(['a', 'bbb', 'cc']); // 3
 ```
 
-### The default export is `string-width`
+## One problem wearing five names
 
-Byte-for-byte call-compatible, so this resolves without a code change:
+`width` · `wrap` · `truncate` · `slice` · `widest`
 
-```json
-{ "overrides": { "string-width": "npm:linegauge@^0.5" } }
-```
+They look like five utilities. They are one: **cutting styled text without letting the edge
+come apart** — no dangling escape sequence, no half a grapheme, no severed emoji cluster.
+Each has to know where the ANSI is and where the cluster boundaries are, and once you know
+that, you may as well answer all five.
+
+The ecosystem splits it across twelve packages — `strip-ansi`, `string-width`,
+`ansi-regex`, `wrap-ansi`, `emoji-regex`, `slice-ansi`, `get-east-asian-width`,
+`eastasianwidth`, `string-length`, `wcwidth`, `cli-truncate` and `widest-line` — which
+between them sit under most of the terminal ecosystem.
 
 ## What "without the edge fraying" means
 
@@ -80,27 +100,6 @@ it wrong is how a layout gains a phantom column under one input.
 **`widest` takes lines, not a blob.** It accepts any iterable of strings, so the caller says
 where the boundaries are rather than having a newline convention assumed for them.
 
-## Graded by the packages it replaces
-
-The incumbent is the specification. `width` runs against `string-width`, `wrap` against
-`wrap-ansi`, `slice` against `slice-ansi` and `truncate` against `cli-truncate`.
-
-## API
-
-| | |
-| :-- | :-- |
-| `width(text, { ambiguousIsNarrow, countAnsiEscapeCodes })` | terminal columns the text occupies |
-| `wrap(text, columns, options)` | fold to a width, styles preserved across rows |
-| `truncate(text, columns, { position, ellipsis })` | cut to a budget, ellipsis counted inside it |
-| `slice(text, start, end)` | the columns `[start, end)`, self-contained |
-| `strip(text)` | the text with its escape sequences removed (`linegauge/strip`) |
-| `widest(lines)` | the width of the widest line of any iterable |
-| `lineCount(text, columns)` | rows the text occupies at that width |
-| `measure(text)` | columns of plain text, no escape scan |
-
-Non-strings answer `0` rather than throwing, because a width function is usually reached
-with whatever a template produced.
-
 ## Design notes
 
 **Ambiguous-width characters count narrow by default**, which is what a terminal does unless
@@ -121,64 +120,167 @@ so the segmenter is reached only when it earns its cost.
 
 ## Plugins
 
-**linegauge hosts no plugin key, and that is a decision rather than an omission.** Every
-other package in the family hosts one — `tokens` in roundel, `spinners` and `borders` and
-`glyphs` and `components` in flagstaff, `capabilities` in paratext, `sources` in seniority,
-`handlers` in closeout, `resolvers` in bellpull, `widgets` in caique. Each of those keys sits
-over a question with more than one right answer: which colour, which glyph, which terminal,
-where configuration lives, how an executable is found. A plugin settles it for one program
-without making anybody else wrong.
-
-These six functions are not that kind of question. `width('古代')` is 4 because Unicode
-classes those code points East Asian Wide and a terminal gives each of them two columns;
-`slice` returns the columns it was asked for or it returns the wrong string. A plugin key
-here would not extend what linegauge does — it would let a caller redefine what the terminal
-does, silently, for everything above it. The failure would not even surface as an error: a
-box comes out a column short, a table gains a phantom column, and nothing throws.
-
-There is a second reason, and it is the one that decides it. This package's correctness is
-differential — `width` is graded against `string-width`, `wrap` against `wrap-ansi`, `slice`
-against `slice-ansi`, `truncate` against `cli-truncate`. A registered contribution would put
-answers under the published pass rate that no grader ever saw, so the number would stop
-meaning what it says.
-
-The two things that genuinely vary are already handled without a registry:
-
-- **The Unicode data.** The Wide and Fullwidth table is Unicode's, and cluster boundaries
-  come from the platform's `Intl.Segmenter`. When Unicode ships a version the table changes —
-  that is a release of this package, re-graded, not a registration a caller can make.
-- **The environment.** How wide the terminal is, and whether there is one, are the caller's
-  to pass; nothing here reads `process`. That is a parameter, not a plugin.
-
-The family's plugin contract records this refusal next to the other layers' keys (R5a), so
-"no key" is one of the contract's answers rather than a hole in it. The one real second
-answer so far — the ambiguous-width policy a CJK terminal needs — landed that way: as
-`ambiguousIsNarrow`, an option with tests behind it, not a registration.
+linegauge hosts one key, **`widths`**, and it answers one question: how many columns a code
+point occupies *on this terminal*, when that terminal disagrees with Unicode.
+
+```js
+import { register } from 'linegauge/plugin';
+
+register({
+  name: 'nerd-font',
+  widths: {
+    icons: { ranges: [[0xe000, 0xf8ff]], columns: 2, why: 'this Nerd Font draws Private Use icons two columns wide' },
+  },
+});
+```
+
+The disagreements it exists for are real and local: a Nerd Font that put a two-column icon in
+the Private Use Area, a code point newer than the table compiled into this release, a font that
+draws box-drawing characters wide. Each is a fact about one terminal, so the honest shape for it
+is data the user supplies rather than a constant somebody argues about upstream.
+
+- **Plain data, no functions.** `{ ranges, columns, why }` — inclusive code-point pairs, a
+  column count of 0, 1 or 2, and a sentence — so a plugin can arrive as JSON, be diffed, and be
+  printed by `npx linegauge check` without running its author's code.
+- **`why` is required**, which no other key in the family asks for: a width table with no
+  provenance cannot be audited when it turns out wrong, and for ambiguous width, wrong is the
+  normal outcome.
+- **Later registrations win**, over earlier ones and over the built-in table — the user is the
+  authority on their terminal. A reversed range or a column count of 3 is refused at
+  `register()` with a code and a fix.
+- **Nothing is registered by default**, and the seam is installed only while something is, so
+  what the incumbent suites grade is Unicode's answer, and a program with no plugin pays nothing.
+
+The ambiguous-width policy a CJK terminal needs is not a plugin: it is `ambiguousIsNarrow`, an
+option with tests behind it.
+
+## Migrating
+
+One import per incumbent — each default export is the incumbent's:
+
+```diff
+- import stringWidth from 'string-width';
++ import stringWidth from 'linegauge';
+```
+
+```diff
+- import wrapAnsi from 'wrap-ansi';
++ import wrapAnsi from 'linegauge/wrap';
+```
+
+```diff
+- import stripAnsi from 'strip-ansi';
++ import stripAnsi from 'linegauge/strip';
+```
+
+```diff
+- import sliceAnsi from 'slice-ansi';
++ import sliceAnsi from 'linegauge/slice';
+```
+
+The default export is `string-width`, byte-for-byte call-compatible, so a transitive copy
+resolves without a code change too:
+
+```json
+{ "overrides": { "string-width": "npm:linegauge@^1" } }
+```
+
+Or let the codemod make the import change: `npx burgee migrate --dry-run` lists every import it
+would rewrite — only drop-ins graded level with their incumbent — and `npx burgee migrate` makes
+it ([Migrate](https://burgee.interlace.tools/docs/migrate)).
+
+## Compatibility
+
+The incumbent is the specification. `width` runs against `string-width`, `wrap` against
+`wrap-ansi`, `slice` against `slice-ansi` and `truncate` against `cli-truncate`.
+
+The four drop-in paths are graded by each incumbent's own suite, unedited, through
+`compat-oracle`; the grades are generated under *Benchmarks* below and published on the
+[compatibility page](https://burgee.interlace.tools/docs/compatibility). `truncate`, which has no
+drop-in path, is checked case by case against `cli-truncate` in `truncate.test.ts`.
 
 ## Benchmarks
 
-Every number here is produced by `npm run bench` and published at [/docs/benchmarks](/docs/benchmarks).
+Every number here is produced by `npm run bench` and published at [burgee.interlace.tools/docs/benchmarks](https://burgee.interlace.tools/docs/benchmarks).
 
 Graded by the incumbent's own test suite:
 
 | suite | passing |
 | :-- | --: |
-| `slice-ansi` | 15 / 15 ¹ |
-| `string-width` | 229 / 229 |
+| `slice-ansi` | 104 / 104 |
+| `string-width` | 233 / 233 |
 | `strip-ansi` | 8 / 8 |
-| `wrap-ansi` | 80 / 80 |
+| `wrap-ansi` | 85 / 85 |
+
+Weight, installed and tree-inclusive: **102,653 bytes** against **194,329** for the incumbents it replaces — a ratio of **0.5282**.
 
-¹ A case the incumbent marks `test.failing()` — it cannot do the thing and says so in
-its own suite — which this package passes. The runner reports that as a failure, because
-to the incumbent an unexpected pass means a stale annotation; it is counted here as the
-pass it is, and marked rather than left to look like the ones beside it.
+## For agents
+
+- **The same columns everywhere.** Nothing here reads `process`, so a pipe, `--json` and an agent
+  get the columns a terminal does — which is why burgee, caique and flagstaff measure their
+  output with it.
+- **Non-strings answer `0`** rather than throwing, so a width call reached with whatever a
+  template produced never takes a program down.
+- **A width plugin can be checked before it ships.** `npx linegauge check ./widths.mjs`
+  validates it against the family schema and exits 0, 1 with a code and a fix, or 2 on a usage
+  error.
+- **The docs are machine-readable** at
+  [linegauge.interlace.tools/llms.txt](https://linegauge.interlace.tools/llms.txt) and
+  [llms-full.txt](https://linegauge.interlace.tools/llms-full.txt).
+
+## API
+
+| | |
+| :-- | :-- |
+| `width(text, { ambiguousIsNarrow, countAnsiEscapeCodes })` | terminal columns the text occupies |
+| `wrap(text, columns, options)` | fold to a width, styles preserved across rows |
+| `truncate(text, columns, { position, ellipsis })` | cut to a budget, ellipsis counted inside it |
+| `slice(text, start, end)` | the columns `[start, end)`, self-contained |
+| `strip(text)` | the text with its escape sequences removed (`linegauge/strip`) |
+| `widest(lines)` | the width of the widest line of any iterable |
+| `lineCount(text, columns)` | rows the text occupies at that width |
+| `measure(text)` | columns of plain text, no escape scan |
+
+Non-strings answer `0` rather than throwing, because a width function is usually reached
+with whatever a template produced.
+
+Every export, with its types, is on [linegauge.interlace.tools](https://linegauge.interlace.tools/docs).
 
-Weight, installed and tree-inclusive: **86,081 bytes** against **194,329** for the incumbents it replaces — a ratio of **0.4430**.
 ## Where it sits
 
 Plugins register under the `widths` key, against the one schema the whole family shares.
 
 `burgee`, `caique`, `flagstaff` build on it, and it builds on nothing in this family.
+
+## The family
+
+Ten packages, one repository, one release pipeline. A CLI on burgee declares what it is, roundel
+carries its colours, flagstaff flies it and caique answers back; each installs on its own, and none
+takes a dependency from outside the family.
+
+| Package | What it is | Replaces |
+| :-- | :-- | :-- |
+| [burgee](https://burgee.interlace.tools/docs/packages/burgee) | The CLI framework: one declaration, every surface | commander and yargs |
+| [roundel](https://roundel.interlace.tools/docs) | Colour: one output policy, semantic tokens, a theme | chalk |
+| [flagstaff](https://flagstaff.interlace.tools/docs) | The frame loop: spinners, progress, boxes and tables | ora, log-update, boxen and cli-table3 |
+| [caique](https://caique.interlace.tools/docs) | Prompts that are flags first, and never hang | inquirer and clack |
+| **linegauge** (this package) | Measuring, wrapping, truncating and slicing styled text | string-width, wrap-ansi, strip-ansi and slice-ansi |
+| [paratext](https://paratext.interlace.tools/docs) | Hyperlinks, images, title, clipboard and notifications | ansi-escapes, terminal-link and term-img |
+| [seniority](https://seniority.interlace.tools/docs) | Configuration precedence and discovery, with provenance | cosmiconfig, dotenv and rc |
+| [closeout](https://closeout.interlace.tools/docs) | Exit handlers, terminal restore and a bounded shutdown | signal-exit, exit-hook and restore-cursor |
+| [bellpull](https://bellpull.interlace.tools/docs) | Subprocesses, and which executable actually ran | cross-spawn and which |
+| [controlroom](https://burgee.interlace.tools/docs/packages/controlroom) | Reserved, not usable yet — planned: full-screen, keyboard-driven terminal screens | ink, planned |
+
+Every migration guide, and the family-wide [compatibility](https://burgee.interlace.tools/docs/compatibility)
+and [benchmarks](https://burgee.interlace.tools/docs/benchmarks) pages, are on
+[burgee.interlace.tools](https://burgee.interlace.tools/docs/packages).
+
+## Contributing
+
+Issues and pull requests are welcome at [ofri-peretz/burgee](https://github.com/ofri-peretz/burgee/issues); read
+[CONTRIBUTING.md](https://github.com/ofri-peretz/burgee/blob/main/CONTRIBUTING.md) first. Report a vulnerability privately, as
+[SECURITY.md](https://github.com/ofri-peretz/burgee/blob/main/SECURITY.md) describes — never in a public issue.
+
 ## Licence
 
-MIT
+MIT © Ofri Peretz — see [LICENSE](https://github.com/ofri-peretz/burgee/blob/main/packages/linegauge/LICENSE).

package/dist/check.js

@@ -45,7 +45,6 @@ const overridesOf = (plugin) => {
     return typeof widths === 'object' && widths !== null ? Object.entries(widths) : [];
 };
 const firstOf = (plugin) => overridesOf(plugin).flatMap(([, o]) => (o.ranges ?? []).map(([low]) => low));
-const shadows = (names) => (names.length === 0 ? '' : ` (replaces ${names.join(', ')})`);
 export async function check(argv, write) {
     try {
         return await inspect(argv, write);
@@ -68,9 +67,9 @@ async function inspect(argv, write) {
     validate(plugin);
     register(plugin);
     const name = plugin.name;
-    const rows = overridesOf(plugin).flatMap(([label, o]) => (o.ranges ?? []).map(([low, high]) => {
+    const rows = overridesOf(plugin).flatMap(([label, o]) => o.ranges.map(([low, high]) => {
         const span = low === high ? codePoint(low) : `${codePoint(low)}..${codePoint(high)}`;
-        return `${label}  ${span}  built-in ${String(builtIn.get(low) ?? '?')} → ${String(width(String.fromCodePoint(low)))}  — ${o.why}`;
+        return `${label}  ${span}  built-in ${String(builtIn.get(low))} → ${String(width(String.fromCodePoint(low)))}  — ${o.why}`;
     }));
     write(`${name} — ${String(rows.length)} widths\n`);
     if (rows.length === 0) {

package/dist/index.d.ts

@@ -26,7 +26,7 @@
  * 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 { slice } from './slice.js';
+export * from './slice.js';
 export { strip } from './strip.js';
 export { truncate, type TruncateOptions } from './truncate.js';
 export { widest } from './widest.js';

package/dist/index.js

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

package/dist/slice.d.ts

@@ -6,6 +6,11 @@
 /**
  * `[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.
+ *
+ * The walk's state is locals of this function rather than fields of an object, and that is
+ * measured, not taste: a minifier renames a local and cannot touch a property name, and the
+ * object form — `cut.pendingAt`, `cut.linkAt` and eight more, each spelled out on every use —
+ * cost the bundled `linegauge/slice` more than this does (see `ceilings.json`).
  */
 export declare function slice(string: string, start?: number, end?: number): string;
 /**

package/dist/slice.js

@@ -1,57 +1,278 @@
-import { applyParameters, closingSequence, hyperlink, matchEscape, openingSequence, segmenter } from './style.js';
+import { applyParameters, applyToken, ASCII_PRINTABLE, closingSequence, segmenter, sgrTokens } from './style.js';
 import { measure } from './width.js';
-function open(cut) {
-    if (cut.started)
-        return;
-    cut.started = true;
-    cut.body += openingSequence(cut.active);
-    if (cut.link !== undefined)
-        cut.body += hyperlink(cut.link.uri, cut.link.parameters);
-}
-function takeEscape(cut, escape, end) {
-    const groups = escape.groups ?? {};
-    if (groups['sgr'] !== undefined)
-        applyParameters(groups['sgr'], cut.active);
-    else if (groups['uri'] !== undefined)
-        cut.link = groups['uri'].length === 0 ? undefined : { parameters: groups['parameters'] ?? '', uri: groups['uri'] };
-    if (cut.started && cut.column < end)
-        cut.body += escape[0];
-}
-function takeText(cut, run, start, end) {
-    for (const { segment } of segmenter().segment(run)) {
-        const columns = measure(segment);
-        if (cut.column + Math.max(columns, 1) > start && cut.column < end) {
-            open(cut);
-            cut.body += segment;
-        }
-        cut.column += columns;
-        if (cut.column >= end && columns > 0)
-            return true;
-    }
-    return cut.column >= end;
+const ESC = '\u001B';
+const BELL = '\u0007';
+const C1_DCS = '\u0090';
+const C1_SOS = '\u0098';
+const C1_CSI = '\u009B';
+const C1_ST = '\u009C';
+const C1_OSC = '\u009D';
+const C1_PM = '\u009E';
+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;
+const CSI_INTERMEDIATE = /[ -/]/u;
+const CSI_FINAL = /[@-~]/u;
+const SGR_PARAMETER = /[\d:;]/u;
+const control = (code) => ({ kind: 'control', code });
+function parseLink(string, index) {
+    const prefix = LINK_PREFIXES.find((candidate) => string.startsWith(candidate, index));
+    if (prefix === undefined)
+        return undefined;
+    const uri = string.indexOf(';', index + prefix.length);
+    if (uri === -1)
+        return control(string.slice(index));
+    for (let at = uri + 1; at < string.length; at += 1) {
+        const terminator = string[at] === BELL || string[at] === C1_ST ? string[at] : string.startsWith(ST, at) ? ST : undefined;
+        if (terminator !== undefined) {
+            return { kind: 'link', code: string.slice(index, at + terminator.length), open: at !== uri + 1, close: `${prefix};${terminator}` };
+        }
+    }
+    return control(string.slice(index));
 }
-export function slice(string, start = 0, end = Number.POSITIVE_INFINITY) {
-    if (end <= start || string.length === 0)
-        return '';
-    const cut = { active: [], link: undefined, column: 0, body: '', started: false };
+function parseControlString(string, index) {
+    const first = string[index];
+    let body;
+    let bell = false;
+    if (first === ESC) {
+        const command = string[index + 1] ?? '';
+        if (command === '\\')
+            return control(ST);
+        if (!STRING_COMMANDS.has(command))
+            return undefined;
+        body = index + 2;
+        bell = command === ']';
+    }
+    else if (first === C1_ST) {
+        return control(C1_ST);
+    }
+    else if (first === C1_OSC || C1_STRINGS.has(first)) {
+        body = index + 1;
+        bell = first === C1_OSC;
+    }
+    else {
+        return undefined;
+    }
+    for (let at = body; at < string.length; at += 1) {
+        if ((bell && string[at] === BELL) || string[at] === C1_ST)
+            return control(string.slice(index, at + 1));
+        if (string.startsWith(ST, at))
+            return control(string.slice(index, at + ST.length));
+    }
+    return control(string.slice(index));
+}
+function parseCsi(string, index) {
+    let prefix;
+    if (string.startsWith(ESC_CSI, index))
+        prefix = ESC_CSI;
+    else if (string[index] === C1_CSI)
+        prefix = C1_CSI;
+    else
+        return undefined;
+    let canonical = true;
+    for (let at = index + prefix.length; at < string.length; at += 1) {
+        const character = string[at];
+        if (CSI_FINAL.test(character)) {
+            const code = string.slice(index, at + 1);
+            if (character !== 'm' || !canonical)
+                return control(code);
+            return { kind: 'sgr', code, prefix, parameters: string.slice(index + prefix.length, at) };
+        }
+        if (CSI_PARAMETER.test(character)) {
+            canonical &&= SGR_PARAMETER.test(character);
+            continue;
+        }
+        if (CSI_INTERMEDIATE.test(character)) {
+            canonical = false;
+            continue;
+        }
+        return control(string.slice(index, at));
+    }
+    return control(string.slice(index));
+}
+function parseEscape(string, index) {
+    return parseLink(string, index) ?? parseControlString(string, index) ?? parseCsi(string, index);
+}
+const LONE_REGIONAL_INDICATOR = /^[\u{1F1E6}-\u{1F1FF}]$/u;
+function positions(cluster) {
+    const columns = measure(cluster);
+    if (columns === 0)
+        return 1;
+    return LONE_REGIONAL_INDICATOR.test(cluster) ? 2 : columns;
+}
+function tokenize(string) {
+    const tokens = [];
+    const visible = [];
+    let text = '';
     let index = 0;
     while (index < string.length) {
-        const escape = matchEscape(string, index);
-        if (escape !== undefined) {
-            takeEscape(cut, escape, end);
-            index += escape[0].length;
+        const escape = INTRODUCERS.has(string[index]) ? parseEscape(string, index) : undefined;
+        if (escape) {
+            tokens.push(escape);
+            index += escape.code.length;
             continue;
         }
-        let run = '';
-        while (index < string.length && matchEscape(string, index) === undefined) {
-            run += string[index];
-            index += 1;
+        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;
+    }
+    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;
         }
-        if (takeText(cut, run, start, end))
+        at += points;
+    }
+    return tokens;
+}
+function opensStyle(parameters) {
+    return sgrTokens(parameters).some((token) => {
+        const probe = [];
+        applyToken(token, probe);
+        return probe.length > 0;
+    });
+}
+function closesStyle(parameters, active) {
+    const after = [...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;
+    let linkAt = 0;
+    let pendingAt;
+    let pendingActive = active;
+    let column = 0;
+    let body = '';
+    let started = false;
+    const forgetLink = () => {
+        link = undefined;
+        linked = false;
+    };
+    const discardLink = (open) => {
+        const length = open.code.length;
+        body = body.slice(0, linkAt) + body.slice(linkAt + length);
+        if (pendingAt !== undefined && pendingAt > linkAt)
+            pendingAt -= length;
+        forgetLink();
+    };
+    const settleLink = (open) => {
+        if (linked)
+            body += open.close;
+        else
+            discardLink(open);
+    };
+    const takeSgr = (token, pastEnd) => {
+        const opens = opensStyle(token.parameters);
+        if (pastEnd && (opens || !closesStyle(token.parameters, active)))
+            return;
+        if (started && opens && pendingAt === undefined) {
+            pendingAt = body.length;
+            pendingActive = [...active];
+        }
+        const before = new Set(active);
+        applyParameters(token.parameters, active);
+        if (token.prefix.length === 1) {
+            for (const style of active)
+                if (!before.has(style))
+                    style.prefix = token.prefix;
+        }
+        if (started)
+            body += token.code;
+    };
+    const takeLink = (token, pastEnd) => {
+        if (pastEnd && (token.open || link === undefined))
+            return;
+        if (token.open) {
+            if (link !== undefined)
+                settleLink(link);
+            link = token;
+            linked = false;
+            linkAt = body.length;
+        }
+        else if (started && link !== undefined && !linked) {
+            discardLink(link);
+            return;
+        }
+        else {
+            forgetLink();
+        }
+        if (started)
+            body += token.code;
+    };
+    const takeText = (token) => {
+        if (!started && column >= start && !token.continuation) {
+            started = true;
+            body = active.map((style) => `${style.prefix ?? ESC_CSI}${style.open}m`).join('');
+            if (link !== undefined) {
+                linkAt = body.length;
+                body += link.code;
+            }
+        }
+        if (started) {
+            body += token.value;
+            pendingAt = undefined;
+            if (link !== undefined)
+                linked = true;
+        }
+        column += token.columns;
+    };
+    for (const [index, token] of tokens.entries()) {
+        const cluster = token.kind === 'text' && !token.continuation;
+        let pastEnd = column >= end || (cluster && column + token.columns > end);
+        if (pastEnd && token.kind !== 'text' && ahead[index] === true)
+            pastEnd = false;
+        if (pastEnd && cluster) {
+            if (pendingAt !== undefined) {
+                body = body.slice(0, pendingAt);
+                active = pendingActive;
+            }
             break;
+        }
+        if (token.kind === 'sgr')
+            takeSgr(token, pastEnd);
+        else if (token.kind === 'link')
+            takeLink(token, pastEnd);
+        else if (token.kind === 'text')
+            takeText(token);
+        else if (!pastEnd && started)
+            body += token.code;
     }
-    if (!cut.started)
+    if (!started)
         return '';
-    return cut.body + (cut.link === undefined ? '' : hyperlink('')) + closingSequence(cut.active);
+    if (link !== undefined)
+        settleLink(link);
+    return body + closingSequence(active);
 }
 export { slice as default };

package/dist/style.d.ts

@@ -61,6 +61,14 @@ export interface ActiveStyle {
     family: string;
     open: string;
     close: number;
+    /**
+     * The introducer the opener arrived with, when it was not `ESC [`. Only `slice` sets and
+     * reads it — a C1 `CSI` (`U+009B`) opener is reopened as it was written, which is what
+     * `slice-ansi` 9 does and grades (`keeps C1 SGR CSI behavior`) — so it is a field here and
+     * a branch in `slice.ts`, not in `openingSequence`: every entry reaches this file, and
+     * the branch would have cost `plugin.js` 81 bytes for a case only `slice` meets.
+     */
+    prefix?: string;
 }
 export declare function sgrTokens(parameters: string): SgrToken[];
 export declare function applyToken(token: SgrToken, active: ActiveStyle[]): void;

package/dist/style.js

@@ -53,7 +53,7 @@ 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}`;
 export function matchEscape(string, index) {
-    if (!ESCAPES.has(string[index] ?? ''))
+    if (!ESCAPES.has(string[index]))
         return undefined;
     ANSI_ESCAPE.lastIndex = index;
     return ANSI_ESCAPE.exec(string) ?? undefined;
@@ -83,11 +83,11 @@ export function forEachSegment(string, onPlainText, onEscape = () => undefined)
 const isDigits = (value) => /^\d+$/.test(value);
 function colonColorToken(parameter) {
     const parts = parameter.split(':');
-    const code = Number.parseInt(parts[0] ?? '', 10);
-    const mode = Number.parseInt(parts[1] ?? '', 10);
+    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] ?? '')) {
+    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)
@@ -118,7 +118,7 @@ export function sgrTokens(parameters) {
     const parts = parameters.split(';');
     const tokens = [];
     for (let index = 0; index < parts.length; index += 1) {
-        const parameter = parts[index] ?? '';
+        const parameter = parts[index];
         if (parameter.includes(':')) {
             const token = colonColorToken(parameter);
             if (token !== undefined)
@@ -129,8 +129,6 @@ export function sgrTokens(parameters) {
         if (!Number.isFinite(code))
             continue;
         if (isExtendedColor(code)) {
-            if (index + 1 >= parts.length)
-                break;
             const extended = extendedColorToken(code, parts, index);
             if (extended === undefined)
                 break;

package/dist/truncate.js

@@ -1,5 +1,20 @@
 import { slice } from './slice.js';
 import { width } from './width.js';
+function fit(string, keep, end, total) {
+    const head = end === 'head';
+    const cut = (at) => (head ? slice(string, 0, at) : slice(string, at));
+    let low = head ? keep : total - keep;
+    let high = string.length * 2;
+    while (low < high) {
+        const mid = (low + high + (head ? 1 : 0)) >> 1;
+        const fits = width(cut(mid)) <= keep;
+        if (head === fits)
+            low = head ? mid : mid + 1;
+        else
+            high = head ? mid - 1 : mid;
+    }
+    return cut(low);
+}
 export function truncate(string, columns, options = {}) {
     const { position = 'end', ellipsis = '\u2026' } = options;
     if (columns <= 0)
@@ -12,9 +27,9 @@ export function truncate(string, columns, options = {}) {
         return mark === columns ? ellipsis : '';
     const keep = columns - mark;
     if (position === 'start')
-        return ellipsis + slice(string, total - keep);
+        return ellipsis + fit(string, keep, 'tail', total);
     if (position === 'end')
-        return slice(string, 0, keep) + ellipsis;
+        return fit(string, keep, 'head', total) + ellipsis;
     const left = Math.ceil(keep / 2);
-    return slice(string, 0, left) + ellipsis + slice(string, total - (keep - left));
+    return fit(string, left, 'head', total) + ellipsis + fit(string, keep - left, 'tail', total);
 }

package/dist/width.d.ts

@@ -1,3 +1,30 @@
+/**
+ * The ignorable/control/format/mark/surrogate set: the code points that occupy no column.
+ *
+ * Exported for `width.test.ts`, which grades `leadingInvisible` against the two regexes this
+ * set used to be spelled as. Joined with nothing, because it goes inside `[…]`: joined with
+ * `|` it once made the class match a literal pipe, and `width()` answered 15 for a
+ * three-column string.
+ */
+export declare const INVISIBLE_CLASSES: readonly ["\\p{Default_Ignorable_Code_Point}", "\\p{Control}", "\\p{Format}", "\\p{Nonspacing_Mark}", "\\p{Enclosing_Mark}", "\\p{Surrogate}"];
+/**
+ * How many code units at the start of `text` are invisible — a code point loop, linear in the
+ * length, where this used to be two regexes.
+ *
+ * **The regexes could hang `width()`.** A cluster was zero-width when it matched
+ * `^(?:DI|Control|Format|Mn|Me|Surrogate)+$`, and the six classes overlap: `U+034F`
+ * COMBINING GRAPHEME JOINER is both Default_Ignorable and Nonspacing_Mark, so a run of them
+ * followed by one visible character made the engine try every way of assigning each joiner
+ * to one of its two alternatives before failing. Measured on Node 24: 24 joiners took 0.6 s,
+ * 26 took 2.4 s, 1,000 did not finish in ten minutes. `Intl.Segmenter` hands the whole run
+ * to this function as one cluster, because every joiner extends it. string-width 8.3.0's
+ * suite added the case (1,000 and 3,000,000 joiners), which is how it was found. The
+ * character-class spelling, `^[…]+`, does not backtrack like that but grows V8's backtrack
+ * stack by one entry per code point and threw `RangeError` at three million. Asking about one
+ * code point at a time has neither problem, and answers the same on every input either regex
+ * finishes on — `width.test.ts` compares them exhaustively over short strings.
+ */
+export declare function leadingInvisible(text: string): number;
 /** Installed by `plugin.ts` when the first override registers, and cleared when the last one goes. */
 export declare function setClaim(fn: ((code: number) => number | undefined) | undefined): void;
 /**

package/dist/width.js

@@ -12,19 +12,20 @@ const WIDE = [
     0x3190, 0x31E5, 0x31EF, 0x321E, 0x3220, 0x3247, 0x3250, 0xA48C, 0xA490, 0xA4C6,
     0xA960, 0xA97C, 0xAC00, 0xD7A3, 0xF900, 0xFAFF, 0xFE10, 0xFE19, 0xFE30, 0xFE52,
     0xFE54, 0xFE66, 0xFE68, 0xFE6B, 0xFF01, 0xFF60, 0xFFE0, 0xFFE6, 0x16FE0, 0x16FE4,
-    0x16FF0, 0x16FF1, 0x17000, 0x187F7, 0x18800, 0x18CD5, 0x18CFF, 0x18D08, 0x1AFF0, 0x1AFF3,
-    0x1AFF5, 0x1AFFB, 0x1AFFD, 0x1AFFE, 0x1B000, 0x1B122, 0x1B132, 0x1B132, 0x1B150, 0x1B152,
-    0x1B155, 0x1B155, 0x1B164, 0x1B167, 0x1B170, 0x1B2FB, 0x1D300, 0x1D356, 0x1D360, 0x1D376,
-    0x1F004, 0x1F004, 0x1F0CF, 0x1F0CF, 0x1F18E, 0x1F18E, 0x1F191, 0x1F19A, 0x1F200, 0x1F202,
-    0x1F210, 0x1F23B, 0x1F240, 0x1F248, 0x1F250, 0x1F251, 0x1F260, 0x1F265, 0x1F300, 0x1F320,
-    0x1F32D, 0x1F335, 0x1F337, 0x1F37C, 0x1F37E, 0x1F393, 0x1F3A0, 0x1F3CA, 0x1F3CF, 0x1F3D3,
-    0x1F3E0, 0x1F3F0, 0x1F3F4, 0x1F3F4, 0x1F3F8, 0x1F43E, 0x1F440, 0x1F440, 0x1F442, 0x1F4FC,
-    0x1F4FF, 0x1F53D, 0x1F54B, 0x1F54E, 0x1F550, 0x1F567, 0x1F57A, 0x1F57A, 0x1F595, 0x1F596,
-    0x1F5A4, 0x1F5A4, 0x1F5FB, 0x1F64F, 0x1F680, 0x1F6C5, 0x1F6CC, 0x1F6CC, 0x1F6D0, 0x1F6D2,
-    0x1F6D5, 0x1F6D7, 0x1F6DC, 0x1F6DF, 0x1F6EB, 0x1F6EC, 0x1F6F4, 0x1F6FC, 0x1F7E0, 0x1F7EB,
-    0x1F7F0, 0x1F7F0, 0x1F90C, 0x1F93A, 0x1F93C, 0x1F945, 0x1F947, 0x1F9FF, 0x1FA70, 0x1FA7C,
-    0x1FA80, 0x1FA89, 0x1FA8F, 0x1FAC6, 0x1FACE, 0x1FADC, 0x1FADF, 0x1FAE9, 0x1FAF0, 0x1FAF8,
-    0x20000, 0x2FFFD, 0x30000, 0x3FFFD,
+    0x16FF0, 0x16FF6, 0x17000, 0x18CDA, 0x18CFF, 0x18D20, 0x18D80, 0x18DF2, 0x18E00, 0x19191,
+    0x191A0, 0x191D2, 0x1AFF0, 0x1AFF3, 0x1AFF5, 0x1AFFB, 0x1AFFD, 0x1AFFE, 0x1B000, 0x1B128,
+    0x1B132, 0x1B132, 0x1B150, 0x1B152, 0x1B155, 0x1B155, 0x1B164, 0x1B168, 0x1B170, 0x1B2FB,
+    0x1D300, 0x1D356, 0x1D360, 0x1D376, 0x1F004, 0x1F004, 0x1F0CF, 0x1F0CF, 0x1F18E, 0x1F18E,
+    0x1F191, 0x1F19A, 0x1F1AE, 0x1F1AE, 0x1F200, 0x1F202, 0x1F210, 0x1F23B, 0x1F240, 0x1F248,
+    0x1F250, 0x1F251, 0x1F260, 0x1F265, 0x1F300, 0x1F320, 0x1F32D, 0x1F335, 0x1F337, 0x1F37C,
+    0x1F37E, 0x1F393, 0x1F3A0, 0x1F3CA, 0x1F3CF, 0x1F3D3, 0x1F3E0, 0x1F3F0, 0x1F3F4, 0x1F3F4,
+    0x1F3F8, 0x1F43E, 0x1F440, 0x1F440, 0x1F442, 0x1F4FC, 0x1F4FF, 0x1F53D, 0x1F54B, 0x1F54E,
+    0x1F550, 0x1F567, 0x1F57A, 0x1F57A, 0x1F595, 0x1F596, 0x1F5A4, 0x1F5A4, 0x1F5FB, 0x1F64F,
+    0x1F680, 0x1F6C5, 0x1F6CC, 0x1F6CC, 0x1F6D0, 0x1F6D2, 0x1F6D5, 0x1F6D9, 0x1F6DC, 0x1F6DF,
+    0x1F6EB, 0x1F6EC, 0x1F6F4, 0x1F6FC, 0x1F7DA, 0x1F7DA, 0x1F7E0, 0x1F7EB, 0x1F7F0, 0x1F7F0,
+    0x1F90C, 0x1F93A, 0x1F93C, 0x1F945, 0x1F947, 0x1F9FF, 0x1FA70, 0x1FA7C, 0x1FA80, 0x1FAC6,
+    0x1FAC8, 0x1FAC8, 0x1FACC, 0x1FADD, 0x1FADF, 0x1FAEB, 0x1FAEF, 0x1FAFA, 0x20000, 0x2FFFD,
+    0x30000, 0x3FFFD,
 ];
 const NARROW = 1;
 const WIDE_COLUMNS = 2;
@@ -89,19 +90,25 @@ function isWide(codePoint) {
 function isAmbiguous(codePoint) {
     return inTable(AMBIGUOUS, codePoint);
 }
-let zeroWidthClass;
-let leadingClass;
+let invisibleClass;
 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('|');
+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 ZERO_WIDTH_CLUSTER = () => (zeroWidthClass ??= new RegExp(`^(?:${INVISIBLE_ALTERNATION})+$`, 'v'));
-const LEADING_NON_PRINTING = () => (leadingClass ??= new RegExp(`^[${INVISIBLE_SET}]+`, 'v'));
+const INVISIBLE = () => (invisibleClass ??= 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 UNQUALIFIED_KEYCAP = /^[\d#*]\u20E3$/u;
 const ZWJ = '\u200D';
 const EMOJI_ZWJ_PICTOGRAPHS = 2;
@@ -155,7 +162,7 @@ function isJamo(codePoint) {
 function hangulColumns(visible, ambiguousIsWide) {
     const codePoints = [];
     for (const character of visible) {
-        if (ZERO_WIDTH_CLUSTER().test(character))
+        if (INVISIBLE().test(character))
             continue;
         codePoints.push(character.codePointAt(0) ?? 0);
     }
@@ -190,13 +197,14 @@ export function measure(text, ambiguousIsWide = false) {
             columns += claimed;
             continue;
         }
-        if (ZERO_WIDTH_CLUSTER().test(segment))
+        const skipped = leadingInvisible(segment);
+        if (skipped === segment.length)
             continue;
         if (RGI_EMOJI().test(segment) || isUnqualifiedEmojiSequence(segment)) {
             columns += WIDE_COLUMNS;
             continue;
         }
-        const visible = segment.replace(LEADING_NON_PRINTING(), '');
+        const visible = segment.slice(skipped);
         const hangul = hangulColumns(visible, ambiguousIsWide);
         if (hangul !== undefined) {
             columns += hangul;

package/dist/wrap.js

@@ -213,9 +213,17 @@ function wrapLine(string, columns, options) {
         rows = rows.map((row) => trimVisibleEnd(row));
     return restoreStylesAcrossRows(rows.join('\n'));
 }
+function normalizeText(string) {
+    let normalized = '';
+    forEachSegment(string, (text) => {
+        normalized += text.normalize();
+    }, (escape) => {
+        normalized += escape;
+    });
+    return normalized;
+}
 export function wrap(string, columns, options = {}) {
-    return String(string)
-        .normalize()
+    return normalizeText(String(string))
         .replaceAll('\r\n', '\n')
         .split('\n')
         .map((line) => wrapLine(expandTabs(line), columns, options))

package/package.json

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