devflow-kit 2.0.1 → 2.1.0

package/dist/cli/flags-view/state.js

@@ -0,0 +1,478 @@
+/**
+ * Pure keypress reducer for the devflow flags TUI.
+ *
+ * applies ADR-013: CLI-layer view module; consumes src/core/ imports only.
+ * applies ADR-016: one syntax, one semantic — value vocabulary.
+ * avoids PF-014: pure functions only — no process.exit(), no I/O.
+ * avoids PF-017: generic shell in tui/terminal.ts; this module is pure logic.
+ *
+ * viewMode GLUE RULE: view-mode's neutralValue ('default') maps to null in the TUI.
+ * `buildFlagRows` maps record value 'default' → null via `recordToTui` (core/flags.ts);
+ * `collectFlagRecord` maps null → 'default' via `tuiToRecord` (core/flags.ts).
+ * Number 0 is ACTIVE — null ≠ 0. Both functions live next to neutralValueOf, their
+ * definition dependency (PF-017 one-shared-definition corollary).
+ *
+ * Strict number parsing: leading/trailing whitespace and leading zeros are
+ * invalid ('007' → error, ' 8' → error). This rejects pathological inputs
+ * before they reach coerceFlagValue (applies PF-023).
+ *
+ * Buffer hard cap: BUFFER_MAX_LEN = 64 chars (paste-flood guard).
+ *
+ * allowUnset semantics:
+ *   - boolean: false — no null stop, 'u' is noop
+ *   - enum/number/string: true — 'u' sets null; enum with neutralValue includes
+ *     null in the cycle as the first stop (round-trips through collectFlagRecord).
+ *
+ * FlagRow invariant: all rows are built by buildFlagRows from FLAG_REGISTRY.
+ * Every row.id maps to a known flag definition (row.def). collectFlagRecord and
+ * commitEdit rely on this — there is no unknown-flag fallback.
+ */
+import { FLAG_REGISTRY, defaultValueOf, coerceFlagValue, parseFlagValueInput, recordToTui, tuiToRecord, } from '../../core/flags.js';
+// ─── Constants ────────────────────────────────────────────────────────────────
+/** Hard cap on edit buffer length — protects against paste floods. */
+export const BUFFER_MAX_LEN = 64;
+// ─── Viewport helpers ─────────────────────────────────────────────────────────
+/** Adjust viewport offset so cursor stays visible. */
+function adjustViewport(cursor, viewportOffset, viewportHeight, rowCount) {
+    if (viewportHeight <= 0 || rowCount === 0)
+        return 0;
+    let offset = viewportOffset;
+    if (cursor < offset)
+        offset = cursor;
+    if (cursor >= offset + viewportHeight)
+        offset = cursor - viewportHeight + 1;
+    const maxOffset = Math.max(0, rowCount - viewportHeight);
+    return Math.max(0, Math.min(offset, maxOffset));
+}
+// ─── Row building ─────────────────────────────────────────────────────────────
+/** Compute the cycle stops for a flag in TUI coordinates. */
+function buildStops(flag) {
+    switch (flag.kind) {
+        case 'boolean':
+            return [true, false];
+        case 'enum': {
+            if (flag.neutralValue !== undefined) {
+                // null is the TUI representation of neutralValue
+                const nonNeutral = flag.values.filter(v => v !== flag.neutralValue);
+                return [null, ...nonNeutral];
+            }
+            // No neutralValue: cycle over the declared values
+            return [...flag.values];
+        }
+        case 'number':
+        case 'string':
+            return []; // text edit mode
+    }
+}
+/** Compute the devflow default in TUI coordinates. */
+function buildDevflowDefault(flag) {
+    const base = defaultValueOf(flag); // single default-rule source (CONS-M2)
+    if (flag.kind === 'boolean')
+        return base;
+    if (base === null)
+        return null; // undefined defaultValue → null
+    // Apply the same neutralValue mapping used for record values
+    return recordToTui(flag, base);
+}
+/** Build the initial TUI value for a row from a FlagsRecord. */
+function buildConfiguredValue(flag, record) {
+    const id = flag.id;
+    if (!(id in record)) {
+        // Key absent from record — fall back to devflow default
+        return buildDevflowDefault(flag);
+    }
+    const raw = record[id];
+    return recordToTui(flag, raw);
+}
+/**
+ * Build the FlagRow array from FLAG_REGISTRY and an existing record.
+ *
+ * Row order matches FLAG_REGISTRY order. Every produced row embeds its registry
+ * definition as `row.def` — this is the FlagRow invariant: collectFlagRecord and
+ * commitEdit use row.def directly and assume all row ids are registry-derived.
+ * There is no unknown-flag fallback (ARCH-M4, CONS-S1).
+ *
+ * viewMode GLUE: record value 'default' → configuredValue null (via recordToTui).
+ * devflowDefault for view-mode = null (maps from neutralValue 'default').
+ */
+export function buildFlagRows(record) {
+    return FLAG_REGISTRY.map((flag) => {
+        const stops = buildStops(flag);
+        const allowUnset = flag.kind !== 'boolean';
+        const devflowDefault = buildDevflowDefault(flag);
+        const configuredValue = buildConfiguredValue(flag, record);
+        return {
+            id: flag.id,
+            label: flag.label,
+            hint: flag.hint,
+            blurb: flag.blurb,
+            def: flag,
+            kind: flag.kind,
+            stops,
+            allowUnset,
+            configuredValue,
+            originalValue: configuredValue,
+            devflowDefault,
+            recommended: flag.recommended,
+        };
+    });
+}
+/**
+ * Collect the current TUI row values back into a FlagsRecord.
+ *
+ * FlagRow invariant (see buildFlagRows): every row embeds its registry definition
+ * as row.def. There is no unknown-flag path — rows are always produced by
+ * buildFlagRows from FLAG_REGISTRY (ARCH-M4, CONS-S1).
+ *
+ * viewMode GLUE: null → neutralValue (e.g. 'default') for enum flags with neutralValue,
+ * via tuiToRecord (core/flags.ts). All other null values pass through as null.
+ */
+export function collectFlagRecord(rows) {
+    const record = {};
+    for (const row of rows) {
+        record[row.id] = tuiToRecord(row.def, row.configuredValue);
+    }
+    return record;
+}
+// ─── Cycle helpers ────────────────────────────────────────────────────────────
+function cycleForward(stops, current) {
+    // Use === rather than Object.is: -0 vs 0 doesn't survive the JSON round-trip so the
+    // distinction is unreachable in practice. Keeps parity with render.ts dirty-detection (!==/!==).
+    const idx = stops.findIndex(s => s === current);
+    if (idx === -1)
+        return stops[0];
+    return stops[(idx + 1) % stops.length];
+}
+function cycleBackward(stops, current) {
+    // See cycleForward: === over Object.is for the same reason.
+    const idx = stops.findIndex(s => s === current);
+    if (idx === -1)
+        return stops[stops.length - 1];
+    return stops[(idx - 1 + stops.length) % stops.length];
+}
+/** Update a single row in the rows array (all other rows unchanged). */
+function updateRow(rows, cursor, patch) {
+    return rows.map((r, i) => (i === cursor ? { ...r, ...patch } : r));
+}
+/** Move cursor by delta (+1 = down, -1 = up) and adjust the viewport. */
+function move(state, delta) {
+    const n = state.rows.length;
+    const newCursor = Math.max(0, Math.min(n - 1, state.cursor + delta));
+    const newOffset = adjustViewport(newCursor, state.viewportOffset, state.viewportHeight, n);
+    if (newCursor === state.cursor && newOffset === state.viewportOffset) {
+        return { state, intent: 'none' };
+    }
+    return { state: { ...state, cursor: newCursor, viewportOffset: newOffset }, intent: 'none' };
+}
+/** Advance or retreat the cycle stop for a cycling row. */
+function cycle(state, row, dir) {
+    const next = dir === 'forward'
+        ? cycleForward(row.stops, row.configuredValue)
+        : cycleBackward(row.stops, row.configuredValue);
+    return {
+        state: { ...state, rows: updateRow(state.rows, state.cursor, { configuredValue: next }) },
+        intent: 'none',
+    };
+}
+// ─── Edit mode helpers ────────────────────────────────────────────────────────
+/** Format a value as an edit buffer string. */
+function valueToBuffer(value) {
+    if (value === null)
+        return '';
+    return String(value);
+}
+/** Enter edit mode for the current row — pre-fill buffer with current value. */
+function enterEdit(state) {
+    const row = state.rows[state.cursor];
+    if (row.stops.length !== 0)
+        return state; // not a text row
+    const buffer = valueToBuffer(row.configuredValue);
+    return {
+        ...state,
+        editing: { buffer, caret: buffer.length, error: null },
+    };
+}
+/**
+ * Commit the current edit buffer for a text row.
+ *
+ * Contract:
+ *   - Empty buffer + allowUnset → commit null (unset)
+ *   - Empty buffer + !allowUnset → error "Value is required"
+ *   - For number/string flags: delegate to parseFlagValueInput (applies PF-023 —
+ *     strict grammar enforced at the core sink, not per-caller). Error messages
+ *     distinguish format failures (padded/hex/leading-zeros) from bounds failures.
+ *   - parseFlagValueInput returns null on invalid input → stay editing + error
+ */
+function commitEdit(state) {
+    const { editing, rows, cursor } = state;
+    if (!editing)
+        return state;
+    const row = rows[cursor];
+    // row.def is always defined — FlagRow invariant: all rows are built from FLAG_REGISTRY (ARCH-M4).
+    const flagDef = row.def;
+    if (flagDef.kind === 'boolean' || flagDef.kind === 'enum')
+        return state;
+    const buf = editing.buffer;
+    // Empty buffer
+    if (buf === '') {
+        if (row.allowUnset) {
+            // Commit as null (unset)
+            return {
+                ...state,
+                editing: null,
+                rows: updateRow(rows, cursor, { configuredValue: null }),
+            };
+        }
+        else {
+            return {
+                ...state,
+                editing: { ...editing, error: 'Value is required' },
+            };
+        }
+    }
+    // Number flag: parseFlagValueInput enforces strict decimal grammar (avoids PF-023).
+    // Provide specific error messages to distinguish format from bounds failures.
+    if (flagDef.kind === 'number') {
+        if (buf !== buf.trim()) {
+            return { ...state, editing: { ...editing, error: 'No leading or trailing spaces allowed' } };
+        }
+        if (/^[+-]?0\d/.test(buf)) {
+            return { ...state, editing: { ...editing, error: 'Leading zeros are not allowed (e.g. use 7, not 007)' } };
+        }
+        const coerced = parseFlagValueInput(flagDef, buf);
+        if (coerced === null) {
+            const parts = [];
+            if (flagDef.min !== undefined)
+                parts.push(`min ${flagDef.min}`);
+            if (flagDef.max !== undefined)
+                parts.push(`max ${flagDef.max}`);
+            if (flagDef.integer)
+                parts.push('must be an integer');
+            return {
+                ...state,
+                editing: { ...editing, error: parts.length ? `Invalid value (${parts.join(', ')})` : 'Must be a valid number' },
+            };
+        }
+        return {
+            ...state,
+            editing: null,
+            rows: updateRow(rows, cursor, { configuredValue: coerced }),
+        };
+    }
+    // String flag: coerceFlagValue handles maxLength and control-char rejection.
+    // At this point flagDef.kind is 'string' (boolean and enum are guarded above,
+    // number returned in its own branch).
+    const coerced = coerceFlagValue(flagDef, buf);
+    if (coerced === null) {
+        const msg = flagDef.maxLength !== undefined ? `Max ${flagDef.maxLength} characters` : 'Invalid value';
+        return { ...state, editing: { ...editing, error: msg } };
+    }
+    return {
+        ...state,
+        editing: null,
+        rows: updateRow(rows, cursor, { configuredValue: coerced }),
+    };
+}
+/**
+ * ASCII control characters (C0 + DEL). These must never enter the edit buffer:
+ *   - coerceFlagValue rejects any string containing them, so a buffer holding one
+ *     can only ever fail to commit — and the failure message would name length,
+ *     not the real cause.
+ *   - renderBuffer strips them for display, so the rendered string and the buffer
+ *     would have different lengths and the caret would land on the wrong character.
+ * normalizeKey passes ctrl-modified keys through as their raw control byte
+ * (e.g. ctrl-a → \x01), so this is reachable by ordinary typing, not just hostile input.
+ */
+const CONTROL_CHAR = /[\x00-\x1f\x7f]/;
+/** Insert a printable character at the caret position (bounded by BUFFER_MAX_LEN). */
+function insertChar(editing, char) {
+    if (editing.buffer.length >= BUFFER_MAX_LEN)
+        return editing;
+    if (CONTROL_CHAR.test(char))
+        return editing; // never buffer an uncommittable char
+    const { buffer, caret } = editing;
+    const next = buffer.slice(0, caret) + char + buffer.slice(caret);
+    return { buffer: next, caret: caret + 1, error: null };
+}
+/**
+ * Handle a key while in edit mode. Returns the new state.
+ *
+ * `editing` is passed as a parameter so callers can pass the already-narrowed
+ * `EditState` value (callers guard `state.editing !== null` before calling),
+ * eliminating the non-null assertion (TS-S1).
+ */
+function reduceEditMode(state, key, editing) {
+    switch (key) {
+        case 'enter':
+            return commitEdit(state);
+        case 'escape':
+            // Discard edit — restore without changing configuredValue
+            return { ...state, editing: null };
+        case 'backspace': {
+            if (editing.caret === 0)
+                return { ...state, editing: { ...editing, error: null } };
+            const buf = editing.buffer;
+            const next = buf.slice(0, editing.caret - 1) + buf.slice(editing.caret);
+            return {
+                ...state,
+                editing: { buffer: next, caret: editing.caret - 1, error: null },
+            };
+        }
+        case 'delete': {
+            const buf = editing.buffer;
+            if (editing.caret >= buf.length)
+                return { ...state, editing: { ...editing, error: null } };
+            const next = buf.slice(0, editing.caret) + buf.slice(editing.caret + 1);
+            return {
+                ...state,
+                editing: { buffer: next, caret: editing.caret, error: null },
+            };
+        }
+        case 'home':
+            return { ...state, editing: { ...editing, caret: 0, error: null } };
+        case 'end':
+            return {
+                ...state,
+                editing: { ...editing, caret: editing.buffer.length, error: null },
+            };
+        case 'left': {
+            const next = Math.max(0, editing.caret - 1);
+            return { ...state, editing: { ...editing, caret: next, error: null } };
+        }
+        case 'right': {
+            const next = Math.min(editing.buffer.length, editing.caret + 1);
+            return { ...state, editing: { ...editing, caret: next, error: null } };
+        }
+        // up/down: ignored while editing; j/k intentionally NOT listed here so they
+        // insert literally (spec: literal q d u j k — default-model and spellcheck
+        // may contain 'j'/'k' as part of a command or path).
+        case 'up':
+        case 'down':
+            return state;
+        // normalizeKey maps the space bar to the NAME 'space', not to ' '. Without this
+        // case the default branch below drops it (5 chars, not 1), so a space could never
+        // be typed — silently. spellcheck's whole purpose is to hold a shell command
+        // ("aspell list"), and default-model likewise; both were unenterable as multi-word
+        // values, with no error and no visual cue that the key had been ignored.
+        case 'space':
+            return { ...state, editing: insertChar(editing, ' ') };
+        default: {
+            // Printable character: single char, not ctrl
+            if (key.length === 1) {
+                return { ...state, editing: insertChar(editing, key) };
+            }
+            return state;
+        }
+    }
+}
+/**
+ * Apply a new viewport height (terminal resize) and re-clamp the scroll offset.
+ *
+ * adjustViewport otherwise only runs on up/down, so a resize alone changed the
+ * height without moving the offset: shrinking a tall terminal with the cursor
+ * below the new fold left the cursor outside the visible slice, and renderFrame
+ * draws the `❯` marker only for rows inside that slice — so the selection marker
+ * vanished entirely until the user pressed an arrow key.
+ *
+ * Pure — returns a new state.
+ */
+export function resizeViewport(state, viewportHeight) {
+    return {
+        ...state,
+        viewportHeight,
+        viewportOffset: adjustViewport(state.cursor, state.viewportOffset, viewportHeight, state.rows.length),
+    };
+}
+// ─── reduce ───────────────────────────────────────────────────────────────────
+/**
+ * Pure keypress reducer.
+ *
+ * Key dispatch:
+ *   Editing mode (editing !== null): all keys handled by reduceEditMode.
+ *     - enter → commitEdit
+ *     - escape → discard edit (exit edit mode, value unchanged)
+ *     - backspace/delete/home/end/left/right → buffer manipulation
+ *     - up/down/j/k → noop (navigation suppressed while editing)
+ *     - single char → insertChar (bounded at BUFFER_MAX_LEN)
+ *
+ *   Browse mode (editing === null):
+ *     - up/k, down/j → navigate, adjust viewport
+ *     - space: text row → enterEdit; cycling row → cycleForward
+ *     - left → cycleBackward (cycling rows only; noop on text rows)
+ *     - right → cycleForward (cycling rows only; noop on text rows)
+ *     - enter: text row → enterEdit; cycling row → save intent
+ *     - e: text row → enterEdit; cycling row → noop
+ *     - d → set devflowDefault
+ *     - u → setNull (allowUnset only; noop for boolean)
+ *     - escape/q → cancel intent
+ *     - ctrl-c → abort intent
+ */
+export function reduce(state, key) {
+    const n = state.rows.length;
+    // Delegate to edit mode handler.
+    // ctrl-c is handled BEFORE delegating: reduceEditMode has no case for it, so it
+    // would fall through to 'none' and be swallowed. Raw mode suppresses the SIGINT
+    // that would otherwise rescue the user, so ctrl-c was completely dead while
+    // editing — the only way out was to discover escape first.
+    if (state.editing !== null) {
+        if (key === 'ctrl-c')
+            return { state, intent: 'abort' };
+        // Pass the narrowed editing (not null) — eliminates state.editing! inside reduceEditMode (TS-S1).
+        const next = reduceEditMode(state, key, state.editing);
+        return { state: next, intent: 'none' };
+    }
+    // Browse mode
+    //
+    // Keys that produce an intent regardless of row count come first. escape/q and
+    // ctrl-c already had no emptiness guard; enter must still save on an empty list
+    // (the one deliberate exception — do not fold into the unified guard below).
+    if (key === 'escape' || key === 'q')
+        return { state, intent: 'cancel' };
+    if (key === 'ctrl-c')
+        return { state, intent: 'abort' };
+    if (key === 'enter' && n === 0)
+        return { state, intent: 'save' };
+    // Unified emptiness guard: all remaining browse-mode keys are no-ops on an empty list.
+    if (n === 0)
+        return { state, intent: 'none' };
+    const row = state.rows[state.cursor];
+    switch (key) {
+        case 'up':
+        case 'k':
+            return move(state, -1);
+        case 'down':
+        case 'j':
+            return move(state, +1);
+        case 'space':
+            return row.stops.length === 0
+                ? { state: enterEdit(state), intent: 'none' }
+                : cycle(state, row, 'forward');
+        case 'left':
+            return row.stops.length === 0 ? { state, intent: 'none' } : cycle(state, row, 'backward');
+        case 'right':
+            return row.stops.length === 0 ? { state, intent: 'none' } : cycle(state, row, 'forward');
+        case 'enter':
+            return row.stops.length === 0
+                ? { state: enterEdit(state), intent: 'none' }
+                : { state, intent: 'save' };
+        case 'e':
+            return row.stops.length === 0
+                ? { state: enterEdit(state), intent: 'none' }
+                : { state, intent: 'none' };
+        case 'd':
+            return {
+                state: { ...state, rows: updateRow(state.rows, state.cursor, { configuredValue: row.devflowDefault }) },
+                intent: 'none',
+            };
+        case 'u':
+            if (!row.allowUnset)
+                return { state, intent: 'none' };
+            return {
+                state: { ...state, rows: updateRow(state.rows, state.cursor, { configuredValue: null }) },
+                intent: 'none',
+            };
+        default:
+            return { state, intent: 'none' };
+    }
+}
+//# sourceMappingURL=state.js.map

package/dist/cli/flags-view/terminal.js

@@ -0,0 +1,63 @@
+/**
+ * Thin adapter — devflow flags TUI shell over the generic runTui driver.
+ *
+ * applies ADR-013: impure I/O shell in CLI layer; pure logic lives in state.ts/render.ts.
+ * avoids PF-014: cleanup wired via Promise resolve — never process.exit() inside
+ *   a finally-guarded scope.
+ * avoids PF-017: thin adapter over the generic shell (src/cli/tui/terminal.ts).
+ *
+ * Public API:
+ *   - runFlagsTui(initialRows, io?) → Promise<FlagsTuiResult>
+ *
+ * Bounded: MAX_KEYPRESSES = 50_000 hard limit (re-exported from src/cli/tui/terminal.ts).
+ */
+import { reduce, resizeViewport } from './state.js';
+import { renderFrame, computeViewportHeight } from './render.js';
+import { runTui } from '../tui/terminal.js';
+export { MAX_KEYPRESSES } from '../tui/terminal.js';
+// ---------------------------------------------------------------------------
+// runFlagsTui
+// ---------------------------------------------------------------------------
+/**
+ * Launch the interactive flags TUI.
+ *
+ * @param initialRows - Initial flag rows (built by buildFlagRows).
+ * @param io - Optional I/O override (defaults to process.stdin/stdout). Pass fake
+ *   streams in tests to drive the TUI without a real TTY.
+ * @returns Promise resolving to { action, rows } when the user saves, cancels, or aborts.
+ */
+export async function runFlagsTui(initialRows, io) {
+    const initialState = {
+        rows: initialRows,
+        cursor: 0,
+        viewportOffset: 0,
+        // Placeholder height — onResize overwrites this at startup with actual terminal dims
+        viewportHeight: 10,
+        editing: null,
+    };
+    // C='none' makes runTui return Promise<{ intent: Exclude<FlagsIntent,'none'>; state }>.
+    // Exclude<FlagsIntent,'none'> = 'save' | 'cancel' | 'abort', which matches
+    // FlagsTuiResult.action exactly — no casts needed, and adding a new FlagsIntent member
+    // is a compile error here (exhaustiveness enforced at the type level).
+    //
+    // D-INLINE: flags editor uses inline mode — renders in-place in the scroll buffer
+    // without entering the alt screen. This is friendlier for devflow init's wizard
+    // context where the flags editor is embedded in a multi-step interactive flow.
+    const result = await runTui({
+        initialState,
+        reduce,
+        renderFrame,
+        // resizeViewport re-clamps viewportOffset for the new height — setting the
+        // height alone can strand the cursor outside the visible slice.
+        onResize: (state, dims) => resizeViewport(state, computeViewportHeight(dims.rows)),
+        signalAction: 'abort',
+        continueIntent: 'none',
+        screen: 'inline',
+        io,
+    });
+    return {
+        action: result.intent,
+        rows: result.state.rows,
+    };
+}
+//# sourceMappingURL=terminal.js.map

package/dist/cli/tui/cells.js

@@ -0,0 +1,47 @@
+/**
+ * Shared TUI cell helpers — shared by agents-view and flags-view.
+ *
+ * Applies PF-017: generified into a shared module rather than copy-adapted per consumer.
+ * Pure functions, no I/O.
+ */
+import { stripAnsi, truncate } from '../../core/ansi.js';
+// ---------------------------------------------------------------------------
+// Cell padding and truncation
+// ---------------------------------------------------------------------------
+/**
+ * Pad a string to `width` visible characters.
+ * Padding is measured against the ANSI-stripped visible length.
+ */
+export function padToVisible(s, width) {
+    const visible = stripAnsi(s);
+    const padding = Math.max(0, width - visible.length);
+    return s + ' '.repeat(padding);
+}
+/**
+ * Truncate a string to at most `maxWidth` visible characters.
+ * Uses the ANSI-stripped length for measurement; rebuilds from the stripped value
+ * so styling is not carried across the truncation boundary.
+ */
+export function truncateVisible(s, maxWidth) {
+    const raw = stripAnsi(s);
+    if (raw.length <= maxWidth)
+        return s;
+    // Re-truncate the unstyled version — simpler than ANSI-aware slice.
+    return truncate(raw, maxWidth);
+}
+/**
+ * Sanitize an untrusted string for a fixed-width TUI cell.
+ *
+ * stripAnsi strips escape sequences and C0 controls but, by contract, KEEPS
+ * TAB (\x09) and LF (\x0a). Both are layout-breaking in a fixed-width frame:
+ *   - LF emits a newline inside a frame line, breaking the one-string-per-
+ *     terminal-line contract and desyncing the cursor arithmetic in the shell.
+ *   - TAB measures as one visible character but occupies up to eight terminal
+ *     columns, misaligning every column to its right.
+ * Both collapse to a single space; raw key is untouched for save-path merges.
+ */
+const LAYOUT_BREAKING_WS = /[\t\n]/g;
+export function sanitizeCell(s) {
+    return stripAnsi(s).replace(LAYOUT_BREAKING_WS, ' ');
+}
+//# sourceMappingURL=cells.js.map