mu-harness 0.16.3

package/script/tui/src/layout/cellbuffer.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCellBuffer = createCellBuffer;
+exports.setBackdropColor = setBackdropColor;
+exports.pushOpacity = pushOpacity;
+exports.popOpacity = popOpacity;
+exports.effectiveOpacity = effectiveOpacity;
+exports.getCell = getCell;
+exports.compositeCell = compositeCell;
+exports.fillBackground = fillBackground;
+exports.writeCells = writeCells;
+exports.drawBorderCells = drawBorderCells;
+exports.cellBufferToLines = cellBufferToLines;
+exports.bufferUsedHeight = bufferUsedHeight;
+exports.diffBuffer = diffBuffer;
+const ansi_1 = require("./ansi");
+const cell_1 = require("./cell");
+const color_1 = require("./color");
+const insets_1 = require("./insets");
+const types_1 = require("./types");
+function createCellBuffer(width, height, backdropColor) {
+    const w = Math.max(0, width);
+    const h = Math.max(0, height);
+    const cells = new Array(w * h);
+    for (let i = 0; i < cells.length; i++)
+        cells[i] = (0, cell_1.emptyCell)();
+    return {
+        width: w,
+        height: h,
+        cells,
+        backdropColor: backdropColor ?? color_1.OPAQUE_BLACK,
+        opacityStack: [],
+    };
+}
+function setBackdropColor(buf, color) {
+    buf.backdropColor = { ...color, a: 1 };
+}
+function pushOpacity(buf, opacity) {
+    buf.opacityStack.push(Math.max(0, Math.min(1, opacity)));
+}
+function popOpacity(buf) {
+    buf.opacityStack.pop();
+}
+function effectiveOpacity(buf) {
+    let o = 1;
+    for (const v of buf.opacityStack)
+        o *= v;
+    return o;
+}
+function bufferRect(buf) {
+    return { x: 0, y: 0, width: buf.width, height: buf.height };
+}
+function hasDecoration(style) {
+    return style.reverse || style.underline || style.bold || style.italic || style.dim ||
+        style.strikethrough || style.blink || style.link !== undefined;
+}
+function getIndex(buf, x, y) {
+    return y * buf.width + x;
+}
+function getCell(buf, x, y) {
+    return buf.cells[getIndex(buf, x, y)];
+}
+function compositeCell(buf, x, y, incoming, opacity = 1) {
+    if (x < 0 || x >= buf.width || y < 0 || y >= buf.height)
+        return;
+    if (incoming.width === 0)
+        return;
+    const existing = buf.cells[getIndex(buf, x, y)];
+    const incomingBg = opacity < 1 ? (0, color_1.withOpacity)(incoming.style.bg, opacity) : incoming.style.bg;
+    const incomingFg = opacity < 1 ? (0, color_1.withOpacity)(incoming.style.fg, opacity) : incoming.style.fg;
+    let newBg;
+    if (incomingBg.a <= 0) {
+        newBg = existing.style.bg;
+    }
+    else if (incomingBg.a >= 1) {
+        newBg = incomingBg;
+    }
+    else {
+        const baseBg = existing.style.bg.a <= 0 ? buf.backdropColor : existing.style.bg;
+        newBg = (0, color_1.blendOver)(incomingBg, baseBg);
+    }
+    const isTransparentSpace = incoming.grapheme === ' ' && incomingBg.a < 1 && !hasDecoration(incoming.style);
+    if (isTransparentSpace) {
+        existing.style = { ...existing.style, bg: newBg };
+        return;
+    }
+    const newStyle = {
+        ...incoming.style,
+        fg: incomingFg,
+        bg: newBg,
+    };
+    buf.cells[getIndex(buf, x, y)] = {
+        grapheme: incoming.grapheme,
+        width: incoming.width,
+        style: newStyle,
+    };
+    if (incoming.width === 2 && x + 1 < buf.width) {
+        const cont = (0, cell_1.continuationCell)();
+        cont.style = newStyle;
+        buf.cells[getIndex(buf, x + 1, y)] = cont;
+    }
+}
+function fillBackground(buf, rect, color, clip) {
+    if (color.a <= 0)
+        return;
+    const opacity = effectiveOpacity(buf);
+    const tinted = opacity < 1 ? (0, color_1.withOpacity)(color, opacity) : color;
+    if (tinted.a <= 0)
+        return;
+    const safe = (0, insets_1.intersectRect)((0, insets_1.intersectRect)(rect, clip), bufferRect(buf));
+    if ((0, insets_1.isEmptyRect)(safe))
+        return;
+    for (let y = safe.y; y < safe.y + safe.height; y++) {
+        for (let x = safe.x; x < safe.x + safe.width; x++) {
+            const cell = buf.cells[getIndex(buf, x, y)];
+            const baseBg = cell.style.bg.a <= 0 ? buf.backdropColor : cell.style.bg;
+            cell.style = { ...cell.style, bg: (0, color_1.blendOver)(tinted, baseBg) };
+        }
+    }
+}
+function writeCells(buf, x, y, cells, clip) {
+    if (cells.length === 0)
+        return;
+    const safe = (0, insets_1.intersectRect)(clip, bufferRect(buf));
+    if ((0, insets_1.isEmptyRect)(safe))
+        return;
+    if (y < safe.y || y >= safe.y + safe.height)
+        return;
+    const opacity = effectiveOpacity(buf);
+    let col = x;
+    for (let i = 0; i < cells.length; i++) {
+        const cell = cells[i];
+        if (cell.width === 0)
+            continue;
+        if (col >= safe.x + safe.width)
+            break;
+        if (cell.width === 2) {
+            if (col + 1 >= safe.x + safe.width || col < safe.x) {
+                if (col >= safe.x && col < safe.x + safe.width) {
+                    const sub = {
+                        grapheme: ' ',
+                        width: 1,
+                        style: cell.style,
+                    };
+                    compositeCell(buf, col, y, sub, opacity);
+                }
+                col += cell.width;
+                continue;
+            }
+        }
+        if (col >= safe.x) {
+            compositeCell(buf, col, y, cell, opacity);
+        }
+        col += cell.width;
+    }
+}
+function drawBorderCells(buf, rect, style, clip) {
+    if (rect.width <= 0 || rect.height <= 0)
+        return;
+    const safe = (0, insets_1.intersectRect)(clip, bufferRect(buf));
+    if ((0, insets_1.isEmptyRect)(safe))
+        return;
+    const resolved = resolveBorder(style);
+    const chars = resolved.chars;
+    const top = rect.y;
+    const bottom = rect.y + rect.height - 1;
+    const left = rect.x;
+    const right = rect.x + rect.width - 1;
+    const drawAt = (x, y, grapheme) => {
+        if (x < safe.x || x >= safe.x + safe.width)
+            return;
+        if (y < safe.y || y >= safe.y + safe.height)
+            return;
+        const cell = { grapheme, width: 1, style: (0, cell_1.defaultStyle)() };
+        compositeCell(buf, x, y, cell);
+    };
+    if (resolved.top && rect.height >= 1) {
+        for (let x = left; x <= right; x++) {
+            let ch = chars.horizontal;
+            if (x === left && resolved.left)
+                ch = chars.topLeft;
+            else if (x === right && resolved.right)
+                ch = chars.topRight;
+            drawAt(x, top, ch);
+        }
+    }
+    if (resolved.bottom && rect.height >= 2) {
+        for (let x = left; x <= right; x++) {
+            let ch = chars.horizontal;
+            if (x === left && resolved.left)
+                ch = chars.bottomLeft;
+            else if (x === right && resolved.right)
+                ch = chars.bottomRight;
+            drawAt(x, bottom, ch);
+        }
+    }
+    if (resolved.left && rect.width >= 1) {
+        const startY = resolved.top ? top + 1 : top;
+        const endY = resolved.bottom ? bottom - 1 : bottom;
+        for (let y = startY; y <= endY; y++)
+            drawAt(left, y, chars.vertical);
+    }
+    if (resolved.right && rect.width >= 2) {
+        const startY = resolved.top ? top + 1 : top;
+        const endY = resolved.bottom ? bottom - 1 : bottom;
+        for (let y = startY; y <= endY; y++)
+            drawAt(right, y, chars.vertical);
+    }
+}
+function cellBufferToLines(buf) {
+    const lines = new Array(buf.height);
+    for (let y = 0; y < buf.height; y++) {
+        const row = new Array(buf.width);
+        for (let x = 0; x < buf.width; x++) {
+            row[x] = finalizeCell(buf, buf.cells[getIndex(buf, x, y)]);
+        }
+        lines[y] = (0, ansi_1.cellsToAnsi)(row);
+    }
+    return lines;
+}
+function finalizeCell(buf, cell) {
+    const bg = cell.style.bg;
+    if (bg.a >= 1)
+        return cell;
+    if (bg.a <= 0)
+        return cell;
+    return {
+        grapheme: cell.grapheme,
+        width: cell.width,
+        style: { ...cell.style, bg: (0, color_1.blendOver)(bg, buf.backdropColor) },
+    };
+}
+function resolveBorder(style) {
+    if (style === true) {
+        return { top: true, right: true, bottom: true, left: true, chars: types_1.DEFAULT_BORDER_CHARS };
+    }
+    return {
+        top: style.top !== false,
+        right: style.right !== false,
+        bottom: style.bottom !== false,
+        left: style.left !== false,
+        chars: style.chars ?? types_1.DEFAULT_BORDER_CHARS,
+    };
+}
+function cellIsBlank(cell) {
+    if (cell.grapheme !== ' ' && cell.grapheme !== '')
+        return false;
+    const s = cell.style;
+    if (s.bold || s.dim || s.italic || s.underline || s.strikethrough || s.reverse || s.blink || s.link !== undefined) {
+        return false;
+    }
+    if (s.fg.intent !== 'default')
+        return false;
+    if (s.bg.intent !== 'default' && s.bg.a > 0)
+        return false;
+    return true;
+}
+function isBlankRow(buf, y) {
+    const base = y * buf.width;
+    for (let x = 0; x < buf.width; x++) {
+        if (!cellIsBlank(buf.cells[base + x]))
+            return false;
+    }
+    return true;
+}
+function bufferUsedHeight(buf) {
+    for (let y = buf.height - 1; y >= 0; y--) {
+        if (!isBlankRow(buf, y))
+            return y + 1;
+    }
+    return 0;
+}
+function diffBuffer(prev, next, maxRow, mergeGap = 4) {
+    const runs = [];
+    const width = next.width;
+    const rows = Math.min(maxRow, next.height);
+    for (let y = 0; y < rows; y++) {
+        const base = y * width;
+        if (isBlankRow(next, y)) {
+            if (!isBlankRow(prev, y))
+                runs.push({ y, x: 0, cells: [], clear: true });
+            continue;
+        }
+        let x = 0;
+        let prevEnd = 0;
+        while (x < width) {
+            if ((0, cell_1.cellEqual)(prev.cells[base + x], next.cells[base + x])) {
+                x++;
+                continue;
+            }
+            let start = x;
+            while (start > prevEnd && next.cells[base + start].width === 0)
+                start--;
+            let lastChange = x;
+            let gap = 0;
+            let xi = x + 1;
+            while (xi < width) {
+                if (!(0, cell_1.cellEqual)(prev.cells[base + xi], next.cells[base + xi])) {
+                    lastChange = xi;
+                    gap = 0;
+                }
+                else {
+                    gap++;
+                    if (gap > mergeGap)
+                        break;
+                }
+                xi++;
+            }
+            let end = lastChange + 1;
+            if (end < width && next.cells[base + end].width === 0)
+                end++;
+            const cells = [];
+            for (let i = start; i < end; i++)
+                cells.push(finalizeCell(next, next.cells[base + i]));
+            runs.push({ y, x: start, cells });
+            prevEnd = end;
+            x = end;
+        }
+    }
+    return runs;
+}

package/script/tui/src/layout/color.d.ts

@@ -0,0 +1,22 @@
+import type { Color } from './types';
+export type ColorIntent = 'rgb' | 'indexed' | 'default';
+export interface Rgba {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    intent: ColorIntent;
+    index?: number;
+}
+export declare const DEFAULT_FG: Rgba;
+export declare const DEFAULT_BG: Rgba;
+export declare const TRANSPARENT: Rgba;
+export declare const OPAQUE_BLACK: Rgba;
+export declare function colorToRgba(color: Color, alpha?: number): Rgba;
+export declare function indexedColor(index: number, alpha?: number): Rgba;
+export declare function rgbColor(r: number, g: number, b: number, alpha?: number): Rgba;
+export declare function blendOver(front: Rgba, back: Rgba): Rgba;
+export declare function withOpacity(color: Rgba, opacity: number): Rgba;
+export declare function rgbaEqual(a: Rgba, b: Rgba): boolean;
+export declare function rgbaToSgr(color: Rgba, layer: 'fg' | 'bg'): string;
+export declare function palette256(index: number): [number, number, number];

package/script/tui/src/layout/color.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPAQUE_BLACK = exports.TRANSPARENT = exports.DEFAULT_BG = exports.DEFAULT_FG = void 0;
+exports.colorToRgba = colorToRgba;
+exports.indexedColor = indexedColor;
+exports.rgbColor = rgbColor;
+exports.blendOver = blendOver;
+exports.withOpacity = withOpacity;
+exports.rgbaEqual = rgbaEqual;
+exports.rgbaToSgr = rgbaToSgr;
+exports.palette256 = palette256;
+exports.DEFAULT_FG = { r: 200, g: 200, b: 200, a: 1, intent: 'default' };
+exports.DEFAULT_BG = { r: 0, g: 0, b: 0, a: 0, intent: 'default' };
+exports.TRANSPARENT = { r: 0, g: 0, b: 0, a: 0, intent: 'rgb' };
+exports.OPAQUE_BLACK = { r: 0, g: 0, b: 0, a: 1, intent: 'rgb' };
+const NAMED_COLOR_INDEX = {
+    black: 0,
+    red: 1,
+    green: 2,
+    yellow: 3,
+    blue: 4,
+    magenta: 5,
+    cyan: 6,
+    white: 7,
+    brightBlack: 8,
+    brightRed: 9,
+    brightGreen: 10,
+    brightYellow: 11,
+    brightBlue: 12,
+    brightMagenta: 13,
+    brightCyan: 14,
+    brightWhite: 15,
+};
+const ANSI_16_RGB = [
+    [0, 0, 0],
+    [170, 0, 0],
+    [0, 170, 0],
+    [170, 85, 0],
+    [0, 0, 170],
+    [170, 0, 170],
+    [0, 170, 170],
+    [170, 170, 170],
+    [85, 85, 85],
+    [255, 85, 85],
+    [85, 255, 85],
+    [255, 255, 85],
+    [85, 85, 255],
+    [255, 85, 255],
+    [85, 255, 255],
+    [255, 255, 255],
+];
+function colorToRgba(color, alpha = 1) {
+    if (color === 'default') {
+        return { ...exports.DEFAULT_FG, a: alpha };
+    }
+    if (typeof color === 'string' && color.startsWith('#')) {
+        const parsed = parseHex(color);
+        if (parsed)
+            return { ...parsed, a: alpha * parsed.a };
+    }
+    const index = NAMED_COLOR_INDEX[color];
+    if (index !== undefined) {
+        const [r, g, b] = ANSI_16_RGB[index];
+        return { r, g, b, a: alpha, intent: 'indexed', index };
+    }
+    return { ...exports.TRANSPARENT };
+}
+function indexedColor(index, alpha = 1) {
+    const [r, g, b] = palette256(index);
+    return { r, g, b, a: alpha, intent: 'indexed', index };
+}
+function rgbColor(r, g, b, alpha = 1) {
+    return { r, g, b, a: alpha, intent: 'rgb' };
+}
+function blendOver(front, back) {
+    if (front.a <= 0)
+        return back;
+    if (front.a >= 1)
+        return front;
+    const fa = front.a;
+    const ba = back.a;
+    const outA = fa + ba * (1 - fa);
+    if (outA <= 0)
+        return { ...exports.TRANSPARENT };
+    const r = (front.r * fa + back.r * ba * (1 - fa)) / outA;
+    const g = (front.g * fa + back.g * ba * (1 - fa)) / outA;
+    const b = (front.b * fa + back.b * ba * (1 - fa)) / outA;
+    const intent = front.intent === back.intent ? front.intent : 'rgb';
+    return {
+        r: Math.round(r),
+        g: Math.round(g),
+        b: Math.round(b),
+        a: outA,
+        intent,
+        index: intent === 'indexed' ? (front.index ?? back.index) : undefined,
+    };
+}
+function withOpacity(color, opacity) {
+    if (opacity >= 1)
+        return color;
+    if (opacity <= 0)
+        return { ...color, a: 0 };
+    return { ...color, a: color.a * opacity };
+}
+function rgbaEqual(a, b) {
+    return (a.r === b.r &&
+        a.g === b.g &&
+        a.b === b.b &&
+        a.a === b.a &&
+        a.intent === b.intent &&
+        a.index === b.index);
+}
+function rgbaToSgr(color, layer) {
+    if (color.intent === 'default') {
+        return layer === 'fg' ? '39' : '49';
+    }
+    if (color.intent === 'indexed' && color.index !== undefined && color.a >= 1) {
+        if (color.index < 16) {
+            const base = layer === 'fg' ? 30 : 40;
+            return color.index < 8 ? `${base + color.index}` : `${base + 60 + (color.index - 8)}`;
+        }
+        return `${layer === 'fg' ? 38 : 48};5;${color.index}`;
+    }
+    return `${layer === 'fg' ? 38 : 48};2;${color.r};${color.g};${color.b}`;
+}
+function parseHex(hex) {
+    const body = hex.slice(1);
+    if (/^[0-9a-fA-F]{3}$/.test(body)) {
+        return {
+            r: Number.parseInt(body[0] + body[0], 16),
+            g: Number.parseInt(body[1] + body[1], 16),
+            b: Number.parseInt(body[2] + body[2], 16),
+            a: 1,
+            intent: 'rgb',
+        };
+    }
+    if (/^[0-9a-fA-F]{6}$/.test(body)) {
+        return {
+            r: Number.parseInt(body.slice(0, 2), 16),
+            g: Number.parseInt(body.slice(2, 4), 16),
+            b: Number.parseInt(body.slice(4, 6), 16),
+            a: 1,
+            intent: 'rgb',
+        };
+    }
+    if (/^[0-9a-fA-F]{8}$/.test(body)) {
+        return {
+            r: Number.parseInt(body.slice(0, 2), 16),
+            g: Number.parseInt(body.slice(2, 4), 16),
+            b: Number.parseInt(body.slice(4, 6), 16),
+            a: Number.parseInt(body.slice(6, 8), 16) / 255,
+            intent: 'rgb',
+        };
+    }
+    return undefined;
+}
+function palette256(index) {
+    if (index < 0 || index > 255)
+        return [0, 0, 0];
+    if (index < 16)
+        return ANSI_16_RGB[index];
+    if (index < 232) {
+        const i = index - 16;
+        const r = Math.floor(i / 36);
+        const g = Math.floor((i % 36) / 6);
+        const b = i % 6;
+        return [step6(r), step6(g), step6(b)];
+    }
+    const v = 8 + (index - 232) * 10;
+    return [v, v, v];
+}
+function step6(v) {
+    return v === 0 ? 0 : 55 + v * 40;
+}

package/script/tui/src/layout/insets.d.ts

@@ -0,0 +1,8 @@
+import type { BorderStyle, Insets, Rect } from './types';
+export declare function normalizeInsets(input?: number | Partial<Insets>): Insets;
+export declare function borderInsets(border?: boolean | BorderStyle): Insets;
+export declare function shrinkRect(rect: Rect, insets: Insets): Rect;
+export declare function intersectRect(a: Rect, b: Rect): Rect;
+export declare function containsPoint(rect: Rect, x: number, y: number): boolean;
+export declare function isEmptyRect(rect: Rect): boolean;
+export declare function insetsForAxis(insets: Insets, axis: 'width' | 'height'): number;

package/script/tui/src/layout/insets.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeInsets = normalizeInsets;
+exports.borderInsets = borderInsets;
+exports.shrinkRect = shrinkRect;
+exports.intersectRect = intersectRect;
+exports.containsPoint = containsPoint;
+exports.isEmptyRect = isEmptyRect;
+exports.insetsForAxis = insetsForAxis;
+const ZERO_INSETS = { top: 0, right: 0, bottom: 0, left: 0 };
+function normalizeInsets(input) {
+    if (input === undefined)
+        return { ...ZERO_INSETS };
+    if (typeof input === 'number') {
+        return { top: input, right: input, bottom: input, left: input };
+    }
+    return {
+        top: input.top ?? 0,
+        right: input.right ?? 0,
+        bottom: input.bottom ?? 0,
+        left: input.left ?? 0,
+    };
+}
+function borderInsets(border) {
+    if (!border)
+        return { ...ZERO_INSETS };
+    if (border === true) {
+        return { top: 1, right: 1, bottom: 1, left: 1 };
+    }
+    return {
+        top: border.top === false ? 0 : 1,
+        right: border.right === false ? 0 : 1,
+        bottom: border.bottom === false ? 0 : 1,
+        left: border.left === false ? 0 : 1,
+    };
+}
+function shrinkRect(rect, insets) {
+    const x = rect.x + insets.left;
+    const y = rect.y + insets.top;
+    const width = Math.max(0, rect.width - insets.left - insets.right);
+    const height = Math.max(0, rect.height - insets.top - insets.bottom);
+    return { x, y, width, height };
+}
+function intersectRect(a, b) {
+    const x = Math.max(a.x, b.x);
+    const y = Math.max(a.y, b.y);
+    const right = Math.min(a.x + a.width, b.x + b.width);
+    const bottom = Math.min(a.y + a.height, b.y + b.height);
+    return {
+        x,
+        y,
+        width: Math.max(0, right - x),
+        height: Math.max(0, bottom - y),
+    };
+}
+function containsPoint(rect, x, y) {
+    return x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height;
+}
+function isEmptyRect(rect) {
+    return rect.width <= 0 || rect.height <= 0;
+}
+function insetsForAxis(insets, axis) {
+    return axis === 'width' ? insets.left + insets.right : insets.top + insets.bottom;
+}

package/script/tui/src/layout/types.d.ts

@@ -0,0 +1,33 @@
+export interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface Insets {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+export interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+export type Color = `#${string}` | 'default' | 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'brightBlack' | 'brightRed' | 'brightGreen' | 'brightYellow' | 'brightBlue' | 'brightMagenta' | 'brightCyan' | 'brightWhite';
+export interface BorderChars {
+    horizontal: string;
+    vertical: string;
+    topLeft: string;
+    topRight: string;
+    bottomLeft: string;
+    bottomRight: string;
+}
+export interface BorderStyle {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+    chars?: BorderChars;
+}
+export declare const DEFAULT_BORDER_CHARS: BorderChars;

package/script/tui/src/layout/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BORDER_CHARS = void 0;
+exports.DEFAULT_BORDER_CHARS = {
+    horizontal: '─',
+    vertical: '│',
+    topLeft: '┌',
+    topRight: '┐',
+    bottomLeft: '└',
+    bottomRight: '┘',
+};

package/script/tui/src/parser.d.ts

@@ -0,0 +1,18 @@
+import type { InputEvent } from './events';
+export interface TerminalInputParserOptions {
+    maxBufferBytes?: number;
+    maxPasteBytes?: number;
+}
+export declare class TerminalInputParser {
+    private readonly options;
+    private buffer;
+    private paste;
+    private inPaste;
+    private pasteOverflowed;
+    constructor(options?: TerminalInputParserOptions);
+    feed(data: string): InputEvent[];
+    flushPending(): InputEvent[];
+    hasPending(): boolean;
+    private get maxBufferBytes();
+    private get maxPasteBytes();
+}