@loomcli/core 0.2.0 → 0.4.0

package/dist/rendering.d.ts

@@ -0,0 +1,21 @@
+import type { Host } from './types.js';
+type SwitchPolicy = 'auto' | 'always' | 'never';
+interface RenderingPolicy {
+    color?: SwitchPolicy | undefined;
+    modifiers?: SwitchPolicy | undefined;
+    hyperlinks?: SwitchPolicy | undefined;
+    terminalControls?: 'strip' | 'preserve' | undefined;
+}
+interface Capabilities {
+    color: boolean;
+    modifiers: boolean;
+    hyperlinks: boolean;
+    terminalControls: boolean;
+    depth: 16 | 256 | 'truecolor';
+    mainGlyphs: boolean;
+}
+declare function renderingPolicy(value: unknown): RenderingPolicy;
+/** A run owns captured facts; stdout and stderr each resolve this one policy independently. */
+declare function capabilities(host: Host, destination: 'stdout' | 'stderr', policy: RenderingPolicy): Capabilities;
+export type { Capabilities, RenderingPolicy };
+export { capabilities, renderingPolicy };

package/dist/rendering.js

@@ -0,0 +1,72 @@
+import { DeclarationError } from './errors.js';
+import { isPlainObject } from './facts.js';
+function renderingPolicy(value) {
+    if (value === undefined) {
+        return {};
+    }
+    if (!isPlainObject(value)) {
+        throw new DeclarationError('The rendering policy must be an object.');
+    }
+    const result = {};
+    for (const field of ['color', 'modifiers', 'hyperlinks']) {
+        const policy = value[field];
+        if (policy !== undefined && policy !== 'auto' && policy !== 'always' && policy !== 'never') {
+            throw new DeclarationError(`Rendering ${field} must be auto, always, or never.`);
+        }
+        if (policy !== undefined) {
+            result[field] = policy;
+        }
+    }
+    const controls = value.terminalControls;
+    if (controls !== undefined && controls !== 'strip' && controls !== 'preserve') {
+        throw new DeclarationError('Rendering terminalControls must be strip or preserve.');
+    }
+    if (controls !== undefined) {
+        result.terminalControls = controls;
+    }
+    return result;
+}
+function colorDepth(env) {
+    if (env.COLORTERM === 'truecolor' ||
+        env.COLORTERM === '24bit' ||
+        ['xterm-kitty', 'xterm-ghostty', 'wezterm'].includes(env.TERM ?? '')) {
+        return 'truecolor';
+    }
+    if (env.TERM_PROGRAM === 'iTerm.app') {
+        const major = /^\d+/u.exec(env.TERM_PROGRAM_VERSION ?? '')?.[0];
+        return major !== undefined && Number(major) >= 3 ? 'truecolor' : 256;
+    }
+    return env.TERM_PROGRAM === 'Apple_Terminal' || /-256(?:color)?$/iu.test(env.TERM ?? '')
+        ? 256
+        : 16;
+}
+function mainGlyphs({ env, platform }) {
+    if (platform !== 'win32') {
+        return env.TERM !== 'linux';
+    }
+    return (Boolean(env.CI || env.WT_SESSION || env.TERMINUS_SUBLIME) ||
+        env.ConEmuTask === '{cmd::Cmder}' ||
+        env.TERM_PROGRAM === 'Terminus-Sublime' ||
+        env.TERM_PROGRAM === 'vscode' ||
+        env.TERM === 'xterm-256color' ||
+        env.TERM === 'alacritty' ||
+        env.TERMINAL_EMULATOR === 'JetBrains-JediTerm');
+}
+function enabled(policy, automatic) {
+    return policy === 'always' || (policy !== 'never' && automatic);
+}
+/** A run owns captured facts; stdout and stderr each resolve this one policy independently. */
+function capabilities(host, destination, policy) {
+    const tty = host.terminal[destination].isTTY;
+    const capable = tty && host.env.TERM !== 'dumb';
+    const forced = Boolean(host.env.FORCE_COLOR);
+    return {
+        color: enabled(policy.color, forced || (!host.env.NO_COLOR && capable)),
+        depth: colorDepth(host.env),
+        hyperlinks: enabled(policy.hyperlinks, tty),
+        mainGlyphs: mainGlyphs(host),
+        modifiers: enabled(policy.modifiers, forced || capable),
+        terminalControls: policy.terminalControls === 'preserve',
+    };
+}
+export { capabilities, renderingPolicy };

package/dist/sequence.d.ts

@@ -0,0 +1,41 @@
+import type { IncompleteResult } from './lanes.js';
+import type { ViewContext } from './types.js';
+import type { ResolvedRowView } from './view.js';
+/**
+ * The view one sequence writes through. A row view writes each row as the source yields it; a
+ * whole view collects every row and renders once at the end of the source.
+ */
+type SequenceView<Row> = {
+    kind: 'rows';
+    view: ResolvedRowView<Row>;
+} | {
+    kind: 'whole';
+    render: (rows: readonly Row[], context: ViewContext) => unknown;
+};
+/** What one sequence writes through, supplied by the output that reserved its place. */
+interface SequenceWriter<Row> {
+    /** The context of the destination the pieces reach. */
+    context: ViewContext;
+    /** Ends the reservation, so later output to that destination writes after this sequence. */
+    close: () => void;
+    /** Writes the incomplete-result line on stderr, before the fault's own report. */
+    incomplete: (facts: IncompleteResult) => void;
+    path: readonly string[];
+    /** Resolves and queues one piece on the reserved place, rejecting on a view or write fault. */
+    piece: (produce: () => unknown) => Promise<void>;
+    signal: AbortSignal;
+    source: Iterable<Row> | AsyncIterable<Row>;
+    /** Records a source failure, which this invocation reports after its primary outcome. */
+    stopped: (cause: unknown) => void;
+    view: SequenceView<Row>;
+}
+/** One sequence in flight: the promise its call answers with, and the switch that ends it early. */
+interface LiveSequence {
+    pending: Promise<void>;
+    /** Ends the sequence where it next would go on. A finished sequence answers it with nothing. */
+    stop: () => void;
+}
+/** One sequence, started here and stoppable from the invocation that issued it. */
+declare function writeSequence<Row>(writer: SequenceWriter<Row>): LiveSequence;
+export type { LiveSequence, SequenceView, SequenceWriter };
+export { writeSequence };

package/dist/sequence.js

@@ -0,0 +1,225 @@
+import { InternalError, routedSubject } from './errors.js';
+/**
+ * A failure the source raised, so the writer tells it apart from the view and write faults its own
+ * pieces raise, which the output path has accounted for already.
+ */
+class SourceFault {
+    cause;
+    constructor(cause) {
+        this.cause = cause;
+    }
+}
+/**
+ * The value a stopped writer unwinds with, compared by identity where the sequence ends. The
+ * invocation that stopped it has a primary failure of its own, so this value reports nothing.
+ */
+const stopRequested = Symbol('stopped');
+/**
+ * The steps one source answers with, under whichever protocol it carries. The asynchronous one
+ * answers first, as the language's own `for await` does.
+ * A value that iterates neither way answers with nothing, and its caller reports the fault.
+ */
+function iterate(source) {
+    const asynchronous = source?.[Symbol.asyncIterator];
+    if (typeof asynchronous === 'function') {
+        return asynchronous.call(source);
+    }
+    const synchronous = source?.[Symbol.iterator];
+    if (typeof synchronous === 'function') {
+        return synchronous.call(source);
+    }
+    return undefined;
+}
+/**
+ * The steps one source answers with, with whatever the protocol raised marked as the source's own
+ * failure. A value that iterates neither way is the same fault, named for the Command that emitted
+ * it, because the types reject it and a JavaScript author alone reaches it.
+ */
+function stepsOf(writer) {
+    let steps = undefined;
+    try {
+        steps = iterate(writer.source);
+    }
+    catch (error) {
+        throw new SourceFault(error);
+    }
+    if (!steps) {
+        throw new SourceFault(new InternalError(`The result of ${routedSubject(writer.path)} is not iterable.`, undefined));
+    }
+    return steps;
+}
+/** One request of the source, with whatever it raised marked as the source's own failure. */
+async function pull(steps) {
+    try {
+        const result = await steps.next();
+        return result.done === true ? { done: true } : { done: false, value: result.value };
+    }
+    catch (error) {
+        throw new SourceFault(error);
+    }
+}
+/**
+ * The stop, read before the writer requests the next row and before it writes the piece it holds.
+ * A cancelled run stops here too, so core requests no further rows and writes no further pieces
+ * from the moment the signal aborted.
+ */
+function halt(reading) {
+    if (reading.live.stopped || reading.signal.aborted) {
+        throw stopRequested;
+    }
+}
+/** One step, counted where the source produced a row. A stopped writer requests none. */
+async function step(reading) {
+    halt(reading);
+    const result = await pull(reading.steps);
+    if (!result.done) {
+        reading.counts.yielded += 1;
+    }
+    // A row an in-flight request delivered after the stop is counted, and nothing is written for it.
+    halt(reading);
+    return result;
+}
+/**
+ * The source is told the writer wants no more rows, so a generator runs its own cleanup.
+ * The settlement is never awaited: a cleanup that never settles would pin the destination's tail,
+ * and the failure that stopped the sequence would never be reported.
+ * Whatever that cleanup raises is the source's business, and it is observed here alone, because the
+ * stop is reported through the fault that raised it and a second failure would replace it.
+ */
+function endSteps(steps) {
+    try {
+        const ended = steps.return?.();
+        void Promise.resolve(ended).catch(() => undefined);
+    }
+    catch {
+        // A cleanup that throws outright is the same business, and it ends here too.
+    }
+}
+/** The opening piece, skipped where the view supplies no `head` function. */
+async function writeHead(writer, produce) {
+    if (produce) {
+        await writer.piece(() => produce(writer.context));
+    }
+}
+/** The closing piece, skipped where the view supplies no `tail` function. */
+async function writeTail(writer, produce, count) {
+    if (produce) {
+        await writer.piece(() => produce(count, writer.context));
+    }
+}
+/**
+ * Every piece but `tail`: `head`, then each row as the source yields it. Each piece is awaited
+ * before the next row is requested, so a slow destination applies back-pressure to the source.
+ */
+async function writeEachRow(writer, view, reading) {
+    halt(reading);
+    await writeHead(writer, view.head);
+    for (;;) {
+        const next = await step(reading);
+        if (next.done) {
+            return;
+        }
+        const index = reading.counts.yielded - 1;
+        await writer.piece(() => view.row(next.value, index, writer.context));
+        reading.counts.written += 1;
+    }
+}
+/** Every row the source produced, which a whole view renders once at the end of the source. */
+async function collectRows(reading) {
+    const collected = [];
+    for (;;) {
+        const next = await step(reading);
+        if (next.done) {
+            return collected;
+        }
+        collected.push(next.value);
+    }
+}
+/**
+ * Every piece the source decides, and the closing piece a complete sequence ends with: `head` and
+ * each row under a row view, whose closing piece is `tail`, and the collected rows under a whole
+ * view, whose closing piece is its one render. A whole view queues nothing before the source ends,
+ * so `written` counts no row under it.
+ */
+async function writePieces(writer, reading) {
+    if (writer.view.kind === 'whole') {
+        const { render } = writer.view;
+        const collected = await collectRows(reading);
+        return () => writer.piece(() => render(collected, writer.context));
+    }
+    const { view } = writer.view;
+    await writeEachRow(writer, view, reading);
+    return () => writeTail(writer, view.tail, reading.counts.written);
+}
+/** The same pieces, with the source told to stop where one of them raised. */
+async function closingPiece(writer, reading) {
+    try {
+        return await writePieces(writer, reading);
+    }
+    catch (error) {
+        endSteps(reading.steps);
+        throw error;
+    }
+}
+/**
+ * The sequence itself: every piece the source decides, then the closing piece. Every piece is
+ * awaited before the next row is requested, so a slow destination applies back-pressure to the
+ * source. The stop is read once more between the source's end and the closing piece, so a run
+ * cancelled there, and an action that failed there, never write it and a truncated result never
+ * reads as a complete one.
+ */
+async function writeRows(writer, live, counts) {
+    const reading = { counts, live, signal: writer.signal, steps: stepsOf(writer) };
+    const close = await closingPiece(writer, reading);
+    if (live.stopped || writer.signal.aborted) {
+        return false;
+    }
+    await close();
+    return true;
+}
+/**
+ * One sequence written on the place its call reserved. A stop before the end retracts nothing, adds
+ * no `tail`, and writes one incomplete-result line on stderr before the fault's own report; a
+ * source failure is recorded there, because a call the action never awaited observes none.
+ */
+async function runSequence(writer, live) {
+    const counts = { written: 0, yielded: 0 };
+    try {
+        if (!(await writeRows(writer, live, counts))) {
+            writer.incomplete({ path: writer.path, ...counts });
+        }
+    }
+    catch (error) {
+        writer.incomplete({ path: writer.path, ...counts });
+        raise(writer, error);
+    }
+    finally {
+        writer.close();
+    }
+}
+/**
+ * What one stop leaves behind once its line is written: nothing, where the invocation asked for
+ * the stop and reports its own failure, the source's failure recorded and raised, or the fault of
+ * a piece, which the output path has accounted for already.
+ */
+function raise(writer, error) {
+    if (error === stopRequested) {
+        return;
+    }
+    if (error instanceof SourceFault) {
+        writer.stopped(error.cause);
+        throw error.cause;
+    }
+    throw error;
+}
+/** One sequence, started here and stoppable from the invocation that issued it. */
+function writeSequence(writer) {
+    const live = { stopped: false };
+    return {
+        pending: runSequence(writer, live),
+        stop: () => {
+            live.stopped = true;
+        },
+    };
+}
+export { writeSequence };

package/dist/style-ansi.d.ts

@@ -0,0 +1,13 @@
+import type { Capabilities } from './rendering.js';
+import type { Attributes } from './style-state.js';
+import type { Boundary, ParsedText } from './style-wire.js';
+interface TextUnit {
+    kind: 'text' | 'control' | 'hyperlink' | 'sgr';
+    text: string;
+    attributes: Attributes;
+}
+type Unit = TextUnit | Boundary;
+/** Scans the full decoded stream before emitting padding or generated terminal bytes. */
+declare function scanAnsi(parsed: ParsedText, caps: Capabilities): Unit[];
+export type { TextUnit, Unit };
+export { scanAnsi };

package/dist/style-ansi.js

@@ -0,0 +1,306 @@
+import { applyOperations, emptyAttributes } from './style-state.js';
+import { colors, isColorName } from './style.js';
+/** Control strings are opaque through their terminator; payload bytes are never rescanned. */
+function controlString(text, start, osc) {
+    for (let cursor = start; cursor < text.length; cursor += 1) {
+        const character = text.charCodeAt(cursor);
+        if ((osc && character === 7) || character === 156) {
+            return { body: text.slice(start, cursor), end: cursor + 1, kind: osc ? 'osc' : 'control' };
+        }
+        if (character === 27 && text[cursor + 1] === '\\') {
+            return { body: text.slice(start, cursor), end: cursor + 2, kind: osc ? 'osc' : 'control' };
+        }
+    }
+    return { body: '', end: text.length, kind: 'incomplete' };
+}
+function csi(text, start) {
+    for (let cursor = start; cursor < text.length; cursor += 1) {
+        const character = text.charCodeAt(cursor);
+        if (character >= 64 && character <= 126) {
+            return {
+                body: text.slice(start, cursor),
+                end: cursor + 1,
+                kind: character === 109 ? 'sgr' : 'control',
+            };
+        }
+        if (character < 32 || character > 63) {
+            return { body: '', end: cursor, kind: 'incomplete' };
+        }
+    }
+    return { body: '', end: text.length, kind: 'incomplete' };
+}
+function command(text, cursor) {
+    const code = text.charCodeAt(cursor);
+    if (code === 27) {
+        const next = text[cursor + 1];
+        if (next === '[') {
+            return csi(text, cursor + 2);
+        }
+        if (next === ']') {
+            return controlString(text, cursor + 2, true);
+        }
+        if (next === 'P' || next === 'X' || next === '^' || next === '_') {
+            return controlString(text, cursor + 2, false);
+        }
+        for (let end = cursor + 1; end < text.length; end += 1) {
+            const value = text.charCodeAt(end);
+            if (value >= 48 && value <= 126) {
+                return { body: '', end: end + 1, kind: 'control' };
+            }
+            if (value < 32 || value > 47) {
+                return { body: '', end, kind: 'incomplete' };
+            }
+        }
+        return { body: '', end: text.length, kind: 'incomplete' };
+    }
+    if (code === 155) {
+        return csi(text, cursor + 1);
+    }
+    if (code === 157) {
+        return controlString(text, cursor + 1, true);
+    }
+    if (code === 144 || code === 152 || code === 158 || code === 159) {
+        return controlString(text, cursor + 1, false);
+    }
+    if ((code < 32 && code !== 9 && code !== 10 && !(code === 13 && text[cursor + 1] === '\n')) ||
+        (code >= 127 && code <= 159)) {
+        return { body: '', end: cursor + 1, kind: 'control' };
+    }
+    return undefined;
+}
+const enableModifiers = new Map([
+    [1, 'bold'],
+    [2, 'faint'],
+    [3, 'italic'],
+    [4, 'underline'],
+    [7, 'inverse'],
+    [8, 'hidden'],
+    [9, 'strikethrough'],
+    [53, 'overline'],
+]);
+const disableModifiers = new Map([
+    [22, ['bold', 'faint']],
+    [23, ['italic']],
+    [24, ['underline']],
+    [27, ['inverse']],
+    [28, ['hidden']],
+    [29, ['strikethrough']],
+    [55, ['overline']],
+]);
+/** Raw ANSI overrides participate in Loom's scoped attributes, and resets restore their base. */
+class AnsiState {
+    base = emptyAttributes;
+    foreground;
+    background;
+    modifiers = new Map();
+    scope;
+    computed;
+    saved = new WeakMap();
+    palette;
+    constructor(root, palette) {
+        this.palette = palette;
+        this.scope = root;
+        this.saved.set(root, emptyAttributes);
+    }
+    sync(scope) {
+        if (scope === this.scope) {
+            return;
+        }
+        this.saved.set(this.scope, this.attributes());
+        const entering = [];
+        let ancestor = scope;
+        while (ancestor && !this.saved.has(ancestor)) {
+            entering.push(ancestor);
+            ancestor = ancestor.parent;
+        }
+        let effective = ancestor ? (this.saved.get(ancestor) ?? emptyAttributes) : emptyAttributes;
+        for (let index = entering.length - 1; index >= 0; index -= 1) {
+            const next = entering[index];
+            if (next) {
+                effective = applyOperations(effective, next.operations, this.palette);
+                this.saved.set(next, effective);
+            }
+        }
+        this.scope = scope;
+        this.base = scope.attributes;
+        this.foreground = effective.foreground;
+        this.background = effective.background;
+        this.modifiers.clear();
+        for (const key of this.base.modifiers) {
+            this.modifiers.set(key, false);
+        }
+        for (const key of effective.modifiers) {
+            this.modifiers.set(key, true);
+        }
+        this.computed = undefined;
+    }
+    attributes() {
+        if (this.computed !== undefined) {
+            return this.computed;
+        }
+        if (this.foreground === undefined &&
+            this.background === undefined &&
+            this.modifiers.size === 0) {
+            return this.base;
+        }
+        const modifiers = new Set(this.base.modifiers);
+        for (const [name, on] of this.modifiers) {
+            if (on) {
+                modifiers.add(name);
+            }
+            else {
+                modifiers.delete(name);
+            }
+        }
+        this.computed = {
+            background: this.background ?? this.base.background,
+            foreground: this.foreground ?? this.base.foreground,
+            modifiers,
+        };
+        return this.computed;
+    }
+    sgr(body) {
+        this.computed = undefined;
+        if (!/^[\d;:]*$/u.test(body)) {
+            return '';
+        }
+        const parameters = body.split(';');
+        const unknown = [];
+        for (let index = 0; index < parameters.length; index += 1) {
+            const raw = parameters[index] ?? '';
+            const colon = raw.split(':');
+            const code = Number(colon[0]);
+            if (code === 0) {
+                this.foreground = undefined;
+                this.background = undefined;
+                this.modifiers.clear();
+                continue;
+            }
+            if (code === 39 || code === 49) {
+                this[code === 39 ? 'foreground' : 'background'] = undefined;
+                continue;
+            }
+            const enabled = enableModifiers.get(code);
+            if (enabled) {
+                this.modifiers.set(enabled, true);
+                continue;
+            }
+            const disabled = disableModifiers.get(code);
+            if (disabled) {
+                for (const name of disabled) {
+                    this.modifiers.delete(name);
+                }
+                continue;
+            }
+            const background = (code >= 40 && code <= 47) || (code >= 100 && code <= 107) || code === 48;
+            const paletteIndex = code >= 30 && code <= 47
+                ? code - (background ? 40 : 30)
+                : code - (background ? 100 : 90) + 8;
+            if ((code >= 30 && code <= 37) ||
+                (code >= 40 && code <= 47) ||
+                (code >= 90 && code <= 97) ||
+                (code >= 100 && code <= 107)) {
+                const name = Object.keys(colors).find((key) => isColorName(key) && colors[key] === paletteIndex);
+                if (isColorName(name)) {
+                    this[background ? 'background' : 'foreground'] = name;
+                }
+                continue;
+            }
+            if (code === 38 || code === 48) {
+                const mode = Number(colon.length > 1 ? colon[1] : parameters[index + 1]);
+                let count = 0;
+                if (mode === 2) {
+                    count = 3;
+                }
+                else if (mode === 5) {
+                    count = 1;
+                }
+                const values = colon.length > 1
+                    ? colon.slice(colon.length - count).map(Number)
+                    : parameters.slice(index + 2, index + 2 + count).map(Number);
+                if (colon.length === 1) {
+                    index += 1 + count;
+                }
+                if (values.length !== count ||
+                    !values.every((value) => Number.isInteger(value) && value >= 0 && value <= 255)) {
+                    continue;
+                }
+                const [red, green, blue] = values;
+                let color = undefined;
+                if (mode === 5 && red !== undefined) {
+                    color = ['ansi256', red];
+                }
+                else if (mode === 2 && red !== undefined && green !== undefined && blue !== undefined) {
+                    color = ['rgb', red, green, blue];
+                }
+                if (color !== undefined) {
+                    this[background ? 'background' : 'foreground'] = color;
+                }
+                continue;
+            }
+            unknown.push(raw);
+        }
+        return unknown.length ? `\u001b[${unknown.join(';')}m` : '';
+    }
+}
+/** Scans the full decoded stream before emitting padding or generated terminal bytes. */
+function scanAnsi(parsed, caps) {
+    const result = [];
+    const state = new AnsiState(parsed.root, parsed.palette);
+    let hyperlinkOpen = false;
+    function boundaries(start, end) {
+        for (let cursor = start; cursor < end; cursor += 1) {
+            for (const boundary of parsed.boundaries.get(cursor) ?? []) {
+                if (boundary.kind === 'open') {
+                    state.sync(boundary.scope);
+                    result.push({ ...boundary, attributes: state.attributes() });
+                }
+                else {
+                    result.push(boundary);
+                }
+            }
+        }
+    }
+    for (let cursor = 0; cursor < parsed.text.length;) {
+        state.sync(parsed.scopes[cursor] ?? parsed.root);
+        const found = command(parsed.text, cursor);
+        if (found) {
+            boundaries(cursor, found.end);
+            state.sync(parsed.scopes[found.end - 1] ?? parsed.root);
+            const raw = parsed.text.slice(cursor, found.end);
+            if (found.kind === 'sgr') {
+                const unknown = state.sgr(found.body);
+                if (caps.terminalControls && unknown) {
+                    result.push({ attributes: state.attributes(), kind: 'sgr', text: unknown });
+                }
+            }
+            else if (found.kind === 'osc' && found.body.startsWith('8;')) {
+                const separator = found.body.indexOf(';', 2);
+                if (separator !== -1 && caps.hyperlinks) {
+                    hyperlinkOpen = found.body.slice(separator + 1) !== '';
+                    result.push({ attributes: state.attributes(), kind: 'hyperlink', text: raw });
+                }
+            }
+            else if (found.kind !== 'incomplete' && caps.terminalControls) {
+                result.push({ attributes: state.attributes(), kind: 'control', text: raw });
+            }
+            cursor = found.end;
+            continue;
+        }
+        boundaries(cursor, cursor + 1);
+        state.sync(parsed.scopes[cursor] ?? parsed.root);
+        const character = parsed.text[cursor] ?? '';
+        // The LF owns the complete line-ending atom, so deferred spaces cannot split CRLF.
+        if (!(character === '\r' && parsed.text[cursor + 1] === '\n')) {
+            const text = character === '\n' && parsed.text[cursor - 1] === '\r' ? '\r\n' : character;
+            result.push({ attributes: state.attributes(), kind: 'text', text });
+        }
+        cursor += 1;
+    }
+    boundaries(parsed.text.length, parsed.text.length + 1);
+    if (hyperlinkOpen) {
+        result.push({ attributes: emptyAttributes, kind: 'hyperlink', text: '\u001b]8;;\u001b\\' });
+    }
+    return result;
+}
+export { scanAnsi };