@jrichman/ink 6.5.1-beta.2 → 6.5.1-beta.5

package/build/styled-line.js

@@ -1,52 +1,52 @@
-import { FULL_WIDTH_MASK, BOLD_MASK, DIM_MASK, ITALIC_MASK, UNDERLINE_MASK, STRIKETHROUGH_MASK, INVERSE_MASK, HIDDEN_MASK, } from './tokenize.js';
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FULL_WIDTH_MASK, INVERSE_MASK } from './tokenize.js';
+const MAX_SAFE_OFFSET = 0x7f_ff;
 export class StyledLine {
     static empty(length) {
+        const safeLength = Math.min(length, MAX_SAFE_OFFSET);
+        if (safeLength <= 0) {
+            return new StyledLine();
+        }
+        const cached = StyledLine.emptyCache.get(safeLength);
+        if (cached) {
+            return cached.clone();
+        }
         const line = new StyledLine();
-        line.length = length;
-        line.text = ' '.repeat(length);
-        line.charData = new Uint16Array(Math.max(length, 16));
-        for (let i = 0; i < length; i++) {
+        line.length = safeLength;
+        line.text = ' '.repeat(safeLength);
+        line.charData = new Uint16Array(Math.max(safeLength, 16));
+        for (let i = 0; i < safeLength; i++) {
             line.charData[i] = i;
         }
-        line.spans = length > 0 ? [{ length, formatFlags: 0 }] : [];
+        line.spans = [{ length: safeLength, formatFlags: 0 }];
+        if (StyledLine.emptyCache.size > 100) {
+            StyledLine.emptyCache.clear();
+        }
+        Object.freeze(line.spans[0]);
+        Object.freeze(line.spans);
+        Object.freeze(line);
+        StyledLine.emptyCache.set(safeLength, line);
+        return line.clone();
+    }
+    static legacyCreateStyledLine(values = [], spans = []) {
+        const line = new StyledLine();
+        line.applyValuesAndSpans(values, spans);
         return line;
     }
+    static emptyCache = new Map();
     length;
     text;
     charData;
     spans;
-    constructor(values = [], spans = []) {
-        this.length = values.length;
-        this.text = values.join('');
-        this.charData = new Uint16Array(Math.max(this.length, 16));
-        let currentOffset = 0;
-        let spanIdx = 0;
-        let spanPos = 0;
-        for (let i = 0; i < this.length; i++) {
-            const val = values[i];
-            let isFullWidth = false;
-            if (spans.length > 0 && spanIdx < spans.length) {
-                const span = spans[spanIdx];
-                if ((span.formatFlags & FULL_WIDTH_MASK) !== 0) {
-                    isFullWidth = true;
-                }
-                spanPos++;
-                if (spanPos >= span.length) {
-                    spanIdx++;
-                    spanPos = 0;
-                }
-            }
-            this.charData[i] = currentOffset | (isFullWidth ? 0x80_00 : 0);
-            currentOffset += val.length;
-        }
-        this.spans = spans.map(s => ({
-            ...s,
-            formatFlags: s.formatFlags & ~FULL_WIDTH_MASK,
-        }));
-        this.mergeSpans();
+    constructor() {
+        this.length = 0;
     }
     getValue(index) {
-        if (index < 0 || index >= this.length)
+        if (this.text === undefined || index < 0 || index >= this.length)
             return '';
         const start = this.charData[index] & 0x7f_ff;
         const end = index + 1 < this.length
@@ -55,7 +55,7 @@ export class StyledLine {
         return this.text.slice(start, end);
     }
     getSpan(index) {
-        if (index < 0 || index >= this.length)
+        if (this.spans === undefined || index < 0 || index >= this.length)
             return undefined;
         let current = 0;
         for (const span of this.spans) {
@@ -66,7 +66,7 @@ export class StyledLine {
         return undefined;
     }
     getFullWidth(index) {
-        if (index < 0 || index >= this.length)
+        if (this.charData === undefined || index < 0 || index >= this.length)
             return false;
         return (this.charData[index] & 0x80_00) !== 0;
     }
@@ -95,10 +95,64 @@ export class StyledLine {
     getLink(index) {
         return this.getSpan(index)?.link;
     }
+    setInverted(index, inverted) {
+        if (index < 0 || index >= this.length)
+            return;
+        this.ensureInitialized();
+        this.splitSpansAt(index);
+        this.splitSpansAt(index + 1);
+        let current = 0;
+        for (const span of this.spans) {
+            if (current === index && span.length === 1) {
+                if (inverted) {
+                    span.formatFlags |= INVERSE_MASK;
+                }
+                else {
+                    span.formatFlags &= ~INVERSE_MASK;
+                }
+                break;
+            }
+            current += span.length;
+        }
+        this.mergeSpans();
+    }
+    setBackgroundColor(index, color) {
+        if (index < 0 || index >= this.length)
+            return;
+        this.ensureInitialized();
+        this.splitSpansAt(index);
+        this.splitSpansAt(index + 1);
+        let current = 0;
+        for (const span of this.spans) {
+            if (current === index && span.length === 1) {
+                span.bgColor = color;
+                break;
+            }
+            current += span.length;
+        }
+        this.mergeSpans();
+    }
+    setForegroundColor(index, color) {
+        if (index < 0 || index >= this.length)
+            return;
+        this.ensureInitialized();
+        this.splitSpansAt(index);
+        this.splitSpansAt(index + 1);
+        let current = 0;
+        for (const span of this.spans) {
+            if (current === index && span.length === 1) {
+                span.fgColor = color;
+                break;
+            }
+            current += span.length;
+        }
+        this.mergeSpans();
+    }
     // eslint-disable-next-line max-params
     setChar(index, value, formatFlags, fgColor, bgColor, link) {
         if (index < 0 || index >= this.length)
             return;
+        this.ensureInitialized();
         const isFullWidth = (formatFlags & FULL_WIDTH_MASK) !== 0;
         const cleanFormatFlags = formatFlags & ~FULL_WIDTH_MASK;
         const start = this.charData[index] & 0x7f_ff;
@@ -106,12 +160,16 @@ export class StyledLine {
             ? this.charData[index + 1] & 0x7f_ff
             : this.text.length;
         const oldLen = end - start;
-        const newLen = value.length;
+        let newValue = value;
+        if (this.text.length - oldLen + value.length > MAX_SAFE_OFFSET) {
+            newValue = value.slice(0, Math.max(0, MAX_SAFE_OFFSET - (this.text.length - oldLen)));
+        }
+        const newLen = newValue.length;
         if (oldLen === newLen) {
-            this.text = this.text.slice(0, start) + value + this.text.slice(end);
+            this.text = this.text.slice(0, start) + newValue + this.text.slice(end);
         }
         else {
-            this.text = this.text.slice(0, start) + value + this.text.slice(end);
+            this.text = this.text.slice(0, start) + newValue + this.text.slice(end);
             const diff = newLen - oldLen;
             for (let i = index + 1; i < this.length; i++) {
                 const data = this.charData[i];
@@ -142,9 +200,19 @@ export class StyledLine {
     }
     // eslint-disable-next-line max-params
     pushChar(value, formatFlags, fgColor, bgColor, link) {
+        this.ensureInitialized();
         const isFullWidth = (formatFlags & FULL_WIDTH_MASK) !== 0;
         const cleanFormatFlags = formatFlags & ~FULL_WIDTH_MASK;
         const offset = this.text.length;
+        if (value !== '…' && offset + value.length > MAX_SAFE_OFFSET - 1) {
+            if (offset < MAX_SAFE_OFFSET && !this.text.endsWith('…')) {
+                this.pushChar('…', formatFlags, fgColor, bgColor, link);
+            }
+            return;
+        }
+        if (offset + value.length > MAX_SAFE_OFFSET) {
+            return;
+        }
         this.text += value;
         if (this.length >= this.charData.length) {
             const newData = new Uint16Array(this.charData.length * 2 || 16);
@@ -171,11 +239,26 @@ export class StyledLine {
         }
         this.length++;
     }
+    clone() {
+        if (this.charData === undefined)
+            return new StyledLine();
+        const result = new StyledLine();
+        result.length = this.length;
+        result.text = this.text;
+        result.charData = this.charData.slice(0, Math.max(this.length, 16));
+        result.spans = this.spans.map(span => ({ ...span }));
+        return result;
+    }
     slice(start, end) {
+        if (this.charData === undefined)
+            return new StyledLine();
         const actualStart = Math.max(0, start);
         const actualEnd = end === undefined ? this.length : Math.min(this.length, end);
         if (actualStart >= actualEnd)
-            return new StyledLine([], []);
+            return new StyledLine();
+        if (actualStart === 0 && actualEnd === this.length) {
+            return this.clone();
+        }
         const result = new StyledLine();
         result.length = actualEnd - actualStart;
         result.charData = new Uint16Array(Math.max(result.length, 16));
@@ -211,65 +294,143 @@ export class StyledLine {
         result.mergeSpans();
         return result;
     }
-    concat(other) {
+    combine(...others) {
+        if (others.length === 0)
+            return this.clone();
+        const allLines = [this, ...others].filter(l => l.length > 0);
+        if (allLines.length === 0)
+            return new StyledLine();
+        if (allLines.length === 1)
+            return allLines[0].clone();
+        let totalTextLen = 0;
+        let totalChars = 0;
+        for (const line of allLines) {
+            totalTextLen += line.getText().length;
+            totalChars += line.length;
+        }
+        if (totalTextLen > MAX_SAFE_OFFSET) {
+            let result = this.clone();
+            for (const other of others) {
+                result = result.instanceConcat(other);
+            }
+            return result;
+        }
         const result = new StyledLine();
-        result.length = this.length + other.length;
-        result.text = this.text + other.text;
-        result.charData = new Uint16Array(Math.max(result.length, 16));
-        result.charData.set(this.charData.subarray(0, this.length), 0);
-        const textOffset = this.text.length;
-        for (let i = 0; i < other.length; i++) {
-            const oldData = other.charData[i];
-            const oldOffset = oldData & 0x7f_ff;
-            const fw = oldData & 0x80_00;
-            result.charData[this.length + i] = (oldOffset + textOffset) | fw;
+        result.length = totalChars;
+        result.text = allLines.map(l => l.getText()).join('');
+        result.charData = new Uint16Array(Math.max(totalChars, 16));
+        let currentChar = 0;
+        let currentOffset = 0;
+        for (const line of allLines) {
+            const lineCharData = line.charData;
+            const lineText = line.getText();
+            if (lineCharData) {
+                for (let i = 0; i < line.length; i++) {
+                    const data = lineCharData[i];
+                    const offset = data & 0x7f_ff;
+                    const fw = data & 0x80_00;
+                    result.charData[currentChar + i] = (currentOffset + offset) | fw;
+                }
+            }
+            else {
+                for (let i = 0; i < line.length; i++) {
+                    result.charData[currentChar + i] = currentOffset + i;
+                }
+            }
+            currentChar += line.length;
+            currentOffset += lineText.length;
         }
-        result.spans = [...this.spans, ...other.spans.map(s => ({ ...s }))];
+        result.spans = allLines.flatMap(l => l.getSpans().map(s => ({ ...s })));
         result.mergeSpans();
         return result;
     }
-    trimEnd() {
-        let i = this.length - 1;
-        while (i >= 0 && this.getValue(i) === ' ' && !this.hasStyles(i)) {
-            i--;
+    getTrimmedLength() {
+        if (this.length === 0)
+            return 0;
+        if (this.text === undefined || this.charData === undefined)
+            return 0;
+        let currentIdx = this.length - 1;
+        if (this.spans) {
+            for (let s = this.spans.length - 1; s >= 0; s--) {
+                const span = this.spans[s];
+                const hasStyles = (span.formatFlags & ~FULL_WIDTH_MASK) !== 0 ||
+                    span.fgColor !== undefined ||
+                    span.bgColor !== undefined ||
+                    span.link !== undefined;
+                if (hasStyles) {
+                    return currentIdx + 1;
+                }
+                for (let i = 0; i < span.length; i++) {
+                    const start = this.charData[currentIdx] & 0x7f_ff;
+                    const end = currentIdx + 1 < this.length
+                        ? this.charData[currentIdx + 1] & 0x7f_ff
+                        : this.text.length;
+                    if (end - start !== 1 || this.text[start] !== ' ') {
+                        return currentIdx + 1;
+                    }
+                    currentIdx--;
+                }
+            }
         }
-        return this.slice(0, i + 1);
+        return 0;
+    }
+    trimEnd() {
+        const trimmedLength = this.getTrimmedLength();
+        if (trimmedLength === this.length)
+            return this;
+        if (trimmedLength === 0)
+            return new StyledLine();
+        return this.slice(0, trimmedLength);
     }
     equals(other) {
         if (this.length !== other.length)
             return false;
-        if (this.text !== other.text)
+        if (this.length === 0)
+            return true;
+        if (this.getText() !== other.getText())
             return false;
-        if (this.spans.length !== other.spans.length)
+        const s1 = this.getSpans();
+        const s2 = other.getSpans();
+        if (s1.length !== s2.length)
             return false;
-        for (let i = 0; i < this.spans.length; i++) {
-            const s1 = this.spans[i];
-            const s2 = other.spans[i];
-            if (s1.length !== s2.length ||
-                s1.formatFlags !== s2.formatFlags ||
-                s1.fgColor !== s2.fgColor ||
-                s1.bgColor !== s2.bgColor ||
-                s1.link !== s2.link) {
+        for (let i = 0; i < s1.length; i++) {
+            const sp1 = s1[i];
+            const sp2 = s2[i];
+            if (sp1.length !== sp2.length ||
+                sp1.formatFlags !== sp2.formatFlags ||
+                sp1.fgColor !== sp2.fgColor ||
+                sp1.bgColor !== sp2.bgColor ||
+                sp1.link !== sp2.link) {
                 return false;
             }
         }
-        for (let i = 0; i < this.length; i++) {
-            if (this.charData[i] !== other.charData[i])
-                return false;
+        const thisCharData = this.charData;
+        const otherCharData = other.charData;
+        if (thisCharData && otherCharData) {
+            for (let i = 0; i < this.length; i++) {
+                if (thisCharData[i] !== otherCharData[i])
+                    return false;
+            }
         }
         return true;
     }
+    getText() {
+        return this.text ?? '';
+    }
     getSpans() {
-        return this.spans;
+        return this.spans ?? [];
     }
     getValues() {
         return Array.from({ length: this.length }, (_, i) => this.getValue(i));
     }
     *[Symbol.iterator]() {
+        if (this.length === 0)
+            return;
         let currentSpanIdx = 0;
         let currentSpanPos = 0;
+        const spans = this.getSpans();
         for (let i = 0; i < this.length; i++) {
-            const span = this.spans[currentSpanIdx];
+            const span = spans[currentSpanIdx];
             const formatFlags = span ? span.formatFlags : 0;
             const isFullWidth = this.getFullWidth(i);
             yield {
@@ -293,8 +454,143 @@ export class StyledLine {
             }
         }
     }
+    ensureInitialized(initialCapacity = 16) {
+        if (this.charData === undefined) {
+            this.text = '';
+            this.charData = new Uint16Array(Math.max(this.length, initialCapacity));
+            this.spans =
+                this.length > 0 ? [{ length: this.length, formatFlags: 0 }] : [];
+            if (this.length > 0 && this.text.length === 0) {
+                this.text = ' '.repeat(this.length);
+                for (let i = 0; i < this.length; i++) {
+                    this.charData[i] = i;
+                }
+            }
+        }
+    }
+    applyValuesAndSpans(values, spans) {
+        let totalTextLen = 0;
+        let visibleChars = 0;
+        for (const val of values) {
+            if (totalTextLen + val.length > MAX_SAFE_OFFSET - 1) {
+                break;
+            }
+            totalTextLen += val.length;
+            visibleChars++;
+        }
+        const truncated = visibleChars < values.length;
+        this.length = visibleChars + (truncated ? 1 : 0);
+        this.text = values.slice(0, visibleChars).join('') + (truncated ? '…' : '');
+        this.charData = new Uint16Array(Math.max(this.length, 16));
+        let currentOffset = 0;
+        let spanIdx = 0;
+        let spanPos = 0;
+        for (let i = 0; i < visibleChars; i++) {
+            const val = values[i];
+            let isFullWidth = false;
+            if (spans.length > 0 && spanIdx < spans.length) {
+                const span = spans[spanIdx];
+                if ((span.formatFlags & FULL_WIDTH_MASK) !== 0) {
+                    isFullWidth = true;
+                }
+                spanPos++;
+                if (spanPos >= span.length) {
+                    spanIdx++;
+                    spanPos = 0;
+                }
+            }
+            this.charData[i] = currentOffset | (isFullWidth ? 0x80_00 : 0);
+            currentOffset += val.length;
+        }
+        if (truncated) {
+            this.charData[visibleChars] = currentOffset;
+        }
+        if (truncated) {
+            const newSpans = [];
+            let remaining = visibleChars;
+            let sIdx = 0;
+            while (remaining > 0 && sIdx < spans.length) {
+                const span = spans[sIdx];
+                const take = Math.min(remaining, span.length);
+                newSpans.push({ ...span, length: take });
+                remaining -= take;
+                sIdx++;
+            }
+            newSpans.push({ length: 1, formatFlags: 0 });
+            this.spans = newSpans;
+        }
+        else {
+            this.spans = spans.map(s => ({
+                ...s,
+                formatFlags: s.formatFlags & ~FULL_WIDTH_MASK,
+            }));
+        }
+        this.mergeSpans();
+    }
+    instanceConcat(other) {
+        const spaceForOther = MAX_SAFE_OFFSET - 1 - this.getText().length;
+        if (spaceForOther <= 0) {
+            if (this.getText().length < MAX_SAFE_OFFSET &&
+                !this.getText().endsWith('…')) {
+                const result = this.clone();
+                result.pushChar('…', 0);
+                return result;
+            }
+            return this.clone();
+        }
+        let otherTextLenToTake = 0;
+        let otherCharsToTake = 0;
+        for (let i = 0; i < other.length; i++) {
+            const val = other.getValue(i);
+            if (otherTextLenToTake + val.length > spaceForOther) {
+                break;
+            }
+            otherTextLenToTake += val.length;
+            otherCharsToTake++;
+        }
+        const truncated = otherCharsToTake < other.length;
+        const result = new StyledLine();
+        result.length = this.length + otherCharsToTake + (truncated ? 1 : 0);
+        result.text =
+            this.getText() +
+                other.getText().slice(0, otherTextLenToTake) +
+                (truncated ? '…' : '');
+        result.charData = new Uint16Array(Math.max(result.length, 16));
+        if (this.charData) {
+            result.charData.set(this.charData.subarray(0, this.length), 0);
+        }
+        const textOffset = this.getText().length;
+        const otherCharData = other.charData;
+        if (otherCharData) {
+            for (let i = 0; i < otherCharsToTake; i++) {
+                const oldData = otherCharData[i];
+                const oldOffset = oldData & 0x7f_ff;
+                const fw = oldData & 0x80_00;
+                result.charData[this.length + i] = (oldOffset + textOffset) | fw;
+            }
+        }
+        if (truncated) {
+            result.charData[this.length + otherCharsToTake] =
+                this.getText().length + otherTextLenToTake;
+        }
+        const otherSpans = [];
+        let remaining = otherCharsToTake;
+        for (const span of other.getSpans()) {
+            if (remaining <= 0)
+                break;
+            const take = Math.min(remaining, span.length);
+            otherSpans.push({ ...span, length: take });
+            remaining -= take;
+        }
+        result.spans = [...this.getSpans(), ...otherSpans];
+        if (truncated) {
+            result.spans.push({ length: 1, formatFlags: 0 });
+        }
+        result.mergeSpans();
+        return result;
+    }
     splitSpansAt(index) {
-        if (index <= 0 || index >= this.length)
+        if (this.spans === undefined || index <= 0 || index >= this.length)
             return;
         let current = 0;
         for (let i = 0; i < this.spans.length; i++) {
@@ -309,6 +605,8 @@ export class StyledLine {
         }
     }
     mergeSpans() {
+        if (this.spans === undefined)
+            return;
         const newSpans = [];
         for (const span of this.spans) {
             if (span.length === 0)
@@ -328,85 +626,4 @@ export class StyledLine {
         this.spans = newSpans;
     }
 }
-export class StyledChar {
-    _value;
-    _formatFlags;
-    _fgColor;
-    _bgColor;
-    _link;
-    // eslint-disable-next-line max-params
-    constructor(_value, _formatFlags, _fgColor, _bgColor, _link) {
-        this._value = _value;
-        this._formatFlags = _formatFlags;
-        this._fgColor = _fgColor;
-        this._bgColor = _bgColor;
-        this._link = _link;
-    }
-    getValue() {
-        return this._value;
-    }
-    getFullWidth() {
-        return (this._formatFlags & FULL_WIDTH_MASK) !== 0;
-    }
-    getForegroundColor() {
-        return this._fgColor;
-    }
-    getBackgroundColor() {
-        return this._bgColor;
-    }
-    getBold() {
-        return (this._formatFlags & BOLD_MASK) !== 0;
-    }
-    getDim() {
-        return (this._formatFlags & DIM_MASK) !== 0;
-    }
-    getItalic() {
-        return (this._formatFlags & ITALIC_MASK) !== 0;
-    }
-    getUnderline() {
-        return (this._formatFlags & UNDERLINE_MASK) !== 0;
-    }
-    getStrikethrough() {
-        return (this._formatFlags & STRIKETHROUGH_MASK) !== 0;
-    }
-    getInverse() {
-        return (this._formatFlags & INVERSE_MASK) !== 0;
-    }
-    getHidden() {
-        return (this._formatFlags & HIDDEN_MASK) !== 0;
-    }
-    getLink() {
-        return this._link;
-    }
-    get formatFlags() {
-        return this._formatFlags;
-    }
-    get fgColor() {
-        return this._fgColor;
-    }
-    get bgColor() {
-        return this._bgColor;
-    }
-    get link() {
-        return this._link;
-    }
-    setFormatFlag(mask) {
-        this._formatFlags |= mask;
-    }
-    clearFormatFlag(mask) {
-        this._formatFlags &= ~mask;
-    }
-    setBackgroundColor(color) {
-        this._bgColor = color;
-    }
-    hasStyles() {
-        return ((this._formatFlags & ~FULL_WIDTH_MASK) !== 0 ||
-            this._fgColor !== undefined ||
-            this._bgColor !== undefined ||
-            this._link !== undefined);
-    }
-    copyWith(overrides) {
-        return new StyledChar(overrides.value ?? this._value, this._formatFlags, this._fgColor, this._bgColor, this._link);
-    }
-}
 //# sourceMappingURL=styled-line.js.map