flagstaff 0.0.1 → 0.1.0

package/dist/cli-table3.js

@@ -0,0 +1,785 @@
+import chalk from 'roundel/chalk';
+import { measure } from './width.js';
+const ESC = '\u001B';
+const SGR = /\u001B\[(?:\d*;){0,5}\d*m/g;
+const SGR_CAPTURE = /\u001B\[((?:\d*;){0,5}\d*)m/g;
+const HYPERLINK_TAG = `${ESC}]8;;\u0007`;
+const HALF = 2;
+export function strlen(str) {
+    const stripped = String(str).replaceAll(SGR, '');
+    return stripped.split('\n').reduce((memo, s) => Math.max(memo, measure(s)), 0);
+}
+const repeat = (str, times) => (times > 0 ? str.repeat(times) : '');
+export function pad(str, len, padChar, dir) {
+    const length = strlen(str);
+    if (len + 1 < length)
+        return str;
+    const padlen = len - length;
+    if (dir === 'right')
+        return repeat(padChar, padlen) + str;
+    if (dir === 'center') {
+        const right = Math.ceil(padlen / HALF);
+        return repeat(padChar, padlen - right) + str + repeat(padChar, right);
+    }
+    return str + repeat(padChar, padlen);
+}
+const CODE_CACHE = {};
+const CODE_PAIRS = {};
+for (const [name, on, off] of [
+    ['bold', 1, 22],
+    ['italics', 3, 23],
+    ['underline', 4, 24],
+    ['inverse', 7, 27],
+    ['strikethrough', 9, 29],
+]) {
+    const onCode = `${ESC}[${on}m`;
+    const offCode = `${ESC}[${off}m`;
+    CODE_CACHE[onCode] = { set: name, to: true };
+    CODE_CACHE[offCode] = { set: name, to: false };
+    CODE_PAIRS[name] = { on: onCode, off: offCode };
+}
+const FG_LOW = 30;
+const FG_HIGH = 39;
+const BG_LOW = 40;
+const BG_HIGH = 49;
+const FG_BRIGHT_LOW = 90;
+const FG_BRIGHT_HIGH = 97;
+const BG_BRIGHT_LOW = 100;
+const BG_BRIGHT_HIGH = 107;
+const DECIMAL = 10;
+function updateState(state, controlChars) {
+    const code = controlChars[1] ? Number.parseInt(controlChars[1].split(';')[0] ?? '0', DECIMAL) : 0;
+    if ((code >= FG_LOW && code <= FG_HIGH) || (code >= FG_BRIGHT_LOW && code <= FG_BRIGHT_HIGH)) {
+        state['lastForegroundAdded'] = controlChars[0];
+        return;
+    }
+    if ((code >= BG_LOW && code <= BG_HIGH) || (code >= BG_BRIGHT_LOW && code <= BG_BRIGHT_HIGH)) {
+        state['lastBackgroundAdded'] = controlChars[0];
+        return;
+    }
+    if (code === 0) {
+        for (const key of Object.keys(state))
+            delete state[key];
+        return;
+    }
+    const info = CODE_CACHE[controlChars[0]];
+    if (info)
+        state[info.set] = info.to;
+}
+function readState(line) {
+    const code = new RegExp(SGR_CAPTURE.source, 'g');
+    const state = {};
+    let controlChars = code.exec(line);
+    while (controlChars !== null) {
+        updateState(state, controlChars);
+        controlChars = code.exec(line);
+    }
+    return state;
+}
+function unwindState(state, ret) {
+    const lastBackground = state['lastBackgroundAdded'];
+    const lastForeground = state['lastForegroundAdded'];
+    delete state['lastBackgroundAdded'];
+    delete state['lastForegroundAdded'];
+    let out = ret;
+    for (const key of Object.keys(state)) {
+        if (state[key])
+            out += CODE_PAIRS[key]?.off ?? '';
+    }
+    if (lastBackground !== undefined && lastBackground !== `${ESC}[49m`)
+        out += `${ESC}[49m`;
+    if (lastForeground !== undefined && lastForeground !== `${ESC}[39m`)
+        out += `${ESC}[39m`;
+    return out;
+}
+function rewindState(state, ret) {
+    const lastBackground = state['lastBackgroundAdded'];
+    const lastForeground = state['lastForegroundAdded'];
+    delete state['lastBackgroundAdded'];
+    delete state['lastForegroundAdded'];
+    let out = ret;
+    for (const key of Object.keys(state)) {
+        if (state[key])
+            out = (CODE_PAIRS[key]?.on ?? '') + out;
+    }
+    if (typeof lastBackground === 'string' && lastBackground !== `${ESC}[49m`)
+        out = lastBackground + out;
+    if (typeof lastForeground === 'string' && lastForeground !== `${ESC}[39m`)
+        out = lastForeground + out;
+    return out;
+}
+function truncateWidth(str, desiredLength) {
+    if (str.length === strlen(str))
+        return str.slice(0, Math.max(0, desiredLength));
+    let out = str;
+    while (strlen(out) > desiredLength)
+        out = out.slice(0, -1);
+    return out;
+}
+function truncateWidthWithAnsi(str, desiredLength) {
+    const code = new RegExp(SGR_CAPTURE.source, 'g');
+    const split = str.split(SGR);
+    let splitIndex = 0;
+    let retLen = 0;
+    let ret = '';
+    const state = {};
+    while (retLen < desiredLength) {
+        const found = code.exec(str);
+        let toAdd = split[splitIndex] ?? '';
+        splitIndex += 1;
+        if (retLen + strlen(toAdd) > desiredLength)
+            toAdd = truncateWidth(toAdd, desiredLength - retLen);
+        ret += toAdd;
+        retLen += strlen(toAdd);
+        if (retLen < desiredLength) {
+            if (!found)
+                break;
+            ret += found[0];
+            updateState(state, found);
+        }
+    }
+    return unwindState(state, ret);
+}
+export function truncate(str, desiredLength, truncateChar = '…') {
+    if (strlen(str) <= desiredLength)
+        return str;
+    let ret = truncateWidthWithAnsi(str, desiredLength - strlen(truncateChar));
+    ret += truncateChar;
+    if (str.includes(HYPERLINK_TAG) && !ret.includes(HYPERLINK_TAG))
+        ret += HYPERLINK_TAG;
+    return ret;
+}
+const WHITESPACE = /(\s+)/g;
+function wordWrapLine(maxLength, input) {
+    const lines = [];
+    const split = input.split(WHITESPACE);
+    let line = [];
+    let lineLength = 0;
+    let whitespace;
+    for (let i = 0; i < split.length; i += HALF) {
+        const word = split[i] ?? '';
+        let newLength = lineLength + strlen(word);
+        if (lineLength > 0 && whitespace !== undefined)
+            newLength += whitespace.length;
+        if (newLength > maxLength) {
+            if (lineLength !== 0)
+                lines.push(line.join(''));
+            line = [word];
+            lineLength = strlen(word);
+        }
+        else {
+            line.push(whitespace ?? '', word);
+            lineLength = newLength;
+        }
+        whitespace = split[i + 1];
+    }
+    if (lineLength)
+        lines.push(line.join(''));
+    return lines;
+}
+function textWrapLine(maxLength, input) {
+    const lines = [];
+    let line = '';
+    const pushLine = (str, ws) => {
+        if (line.length && ws !== undefined && ws !== '')
+            line += ws;
+        line += str;
+        while (line.length > maxLength) {
+            lines.push(line.slice(0, maxLength));
+            line = line.slice(maxLength);
+        }
+    };
+    const split = input.split(WHITESPACE);
+    for (let i = 0; i < split.length; i += HALF)
+        pushLine(split[i] ?? '', i ? split[i - 1] : undefined);
+    if (line.length)
+        lines.push(line);
+    return lines;
+}
+export function wordWrap(maxLength, input, wrapOnWordBoundary = true) {
+    const handler = wrapOnWordBoundary ? wordWrapLine : textWrapLine;
+    return input.split('\n').flatMap((line) => handler(maxLength, line));
+}
+function colorizeLines(input) {
+    let state = {};
+    return input.map((raw) => {
+        const line = rewindState(state, raw);
+        state = readState(line);
+        return unwindState({ ...state }, line);
+    });
+}
+export function hyperlink(url, text) {
+    const OSC = `${ESC}]`;
+    const BEL = '\u0007';
+    return [OSC, '8', ';', ';', url || text, BEL, text, OSC, '8', ';', ';', BEL].join('');
+}
+const DEBUG_LEVEL = { WARN: 1, INFO: 2, DEBUG: 3 };
+let debugMessages = [];
+let debugLevel = 0;
+const record = (msg, min) => {
+    if (debugLevel >= min)
+        debugMessages.push(msg);
+};
+const warn = (msg) => record(msg, DEBUG_LEVEL.WARN);
+const info = (msg) => record(msg, DEBUG_LEVEL.INFO);
+const debugLog = (msg) => record(msg, DEBUG_LEVEL.DEBUG);
+function defaultOptions() {
+    return {
+        chars: {
+            'top': '─',
+            'top-mid': '┬',
+            'top-left': '┌',
+            'top-right': '┐',
+            'bottom': '─',
+            'bottom-mid': '┴',
+            'bottom-left': '└',
+            'bottom-right': '┘',
+            'left': '│',
+            'left-mid': '├',
+            'mid': '─',
+            'mid-mid': '┼',
+            'right': '│',
+            'right-mid': '┤',
+            'middle': '│',
+        },
+        truncate: '…',
+        colWidths: [],
+        rowHeights: [],
+        colAligns: [],
+        rowAligns: [],
+        style: { 'padding-left': 1, 'padding-right': 1, 'head': ['red'], 'border': ['grey'], 'compact': false },
+        head: [],
+    };
+}
+export function mergeOptions(options, defaults) {
+    const base = defaults ?? defaultOptions();
+    const given = options ?? {};
+    return { ...base, ...given, chars: { ...base.chars, ...given.chars }, style: { ...base.style, ...given.style } };
+}
+const CHAR_NAMES = ['top', 'top-mid', 'top-left', 'top-right', 'bottom', 'bottom-mid', 'bottom-left', 'bottom-right', 'left', 'left-mid', 'mid', 'mid-mid', 'right', 'right-mid', 'middle'];
+const firstDefined = (...args) => args.find((v) => v !== undefined && v !== null);
+function setOption(objA, objB, nameB, target) {
+    const parts = nameB.split('-');
+    if (parts.length > 1) {
+        const nameA = parts[0] + parts.slice(1).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+        target[nameA] = firstDefined(objA[nameA], objA[nameB], objB[nameA], objB[nameB]);
+        return;
+    }
+    target[nameB] = firstDefined(objA[nameB], objB[nameB]);
+}
+const sumPlusOne = (a, b) => a + b + 1;
+function findDimension(table, startingIndex, span) {
+    let ret = table[startingIndex] ?? 0;
+    for (let i = 1; i < span; i += 1)
+        ret += 1 + (table[startingIndex + i] ?? 0);
+    return ret;
+}
+function styled(names, content) {
+    if (!names || names.length === 0)
+        return content;
+    let fn = chalk;
+    for (let i = names.length - 1; i >= 0; i -= 1) {
+        fn = typeof fn === 'function' || typeof fn === 'object' ? Reflect.get(fn, names[i] ?? '') : undefined;
+        if (fn === undefined)
+            return content;
+    }
+    return typeof fn === 'function' ? fn(content) : content;
+}
+export class Cell {
+    x = 0;
+    y = 0;
+    colSpan;
+    rowSpan;
+    content;
+    options;
+    chars = {};
+    truncate = '…';
+    paddingLeft = 0;
+    paddingRight = 0;
+    head;
+    border;
+    fixedWidth;
+    lines = [];
+    desiredWidth = 0;
+    desiredHeight = 0;
+    widths = [];
+    heights = [];
+    width = 0;
+    height = 0;
+    hAlign;
+    vAlign;
+    drawRight = false;
+    cells;
+    href;
+    constructor(options) {
+        const opts = typeof options === 'boolean' || typeof options === 'number' || typeof options === 'bigint' || typeof options === 'string' ? { content: String(options) } : (options ?? {});
+        this.options = opts;
+        const content = opts['content'];
+        if (typeof content === 'boolean' || typeof content === 'number' || typeof content === 'bigint' || typeof content === 'string')
+            this.content = String(content);
+        else if (!content)
+            this.content = opts['href'] ?? '';
+        else
+            throw new Error(`Content needs to be a primitive, got: ${typeof content}`);
+        this.colSpan = opts['colSpan'] ?? 1;
+        this.rowSpan = opts['rowSpan'] ?? 1;
+        if (opts['href'] !== undefined)
+            this.href = opts['href'];
+    }
+    mergeTableOptions(tableOptions, cells) {
+        this.cells = cells;
+        const optionsChars = (this.options['chars'] ?? {});
+        const chars = {};
+        for (const name of CHAR_NAMES)
+            setOption(optionsChars, tableOptions.chars, name, chars);
+        this.chars = chars;
+        this.truncate = this.options['truncate'] ?? tableOptions.truncate ?? '…';
+        const style = (this.options['style'] ?? {});
+        this.options['style'] = style;
+        const tableStyle = tableOptions.style;
+        setOption(style, tableStyle, 'padding-left', this);
+        setOption(style, tableStyle, 'padding-right', this);
+        this.head = (style['head'] ?? tableStyle['head']);
+        this.border = (style['border'] ?? tableStyle['border']);
+        this.fixedWidth = tableOptions.colWidths[this.x];
+        this.lines = this.computeLines(tableOptions);
+        this.desiredWidth = strlen(this.content) + this.paddingLeft + this.paddingRight;
+        this.desiredHeight = this.lines.length;
+    }
+    computeLines(tableOptions) {
+        const tableWordWrap = tableOptions.wordWrap ?? tableOptions.textWrap;
+        const wrap = this.options['wordWrap'] ?? tableWordWrap;
+        if (this.fixedWidth && wrap) {
+            this.fixedWidth -= this.paddingLeft + this.paddingRight;
+            if (this.colSpan) {
+                for (let i = 1; i < this.colSpan; i += 1)
+                    this.fixedWidth += tableOptions.colWidths[this.x + i] ?? 0;
+            }
+            const tableBoundary = tableOptions.wrapOnWordBoundary ?? true;
+            const onBoundary = this.options['wrapOnWordBoundary'] ?? tableBoundary;
+            return this.wrapLines(wordWrap(this.fixedWidth, this.content, onBoundary));
+        }
+        return this.wrapLines(this.content.split('\n'));
+    }
+    wrapLines(computedLines) {
+        return colorizeLines(computedLines);
+    }
+    init(tableOptions) {
+        const { x, y } = this;
+        this.widths = tableOptions.colWidths.slice(x, x + this.colSpan);
+        this.heights = tableOptions.rowHeights.slice(y, y + this.rowSpan);
+        this.width = this.widths.reduce(sumPlusOne, -1);
+        this.height = this.heights.reduce(sumPlusOne, -1);
+        this.hAlign = this.options['hAlign'] ?? tableOptions.colAligns?.[x];
+        this.vAlign = this.options['vAlign'] ?? tableOptions.rowAligns?.[y];
+        this.drawRight = x + this.colSpan === tableOptions.colWidths.length;
+    }
+    draw(lineNum, spanningCell) {
+        if (lineNum === 'top')
+            return this.drawTop(this.drawRight);
+        if (lineNum === 'bottom')
+            return this.drawBottom(this.drawRight);
+        const n0 = lineNum;
+        if (!n0)
+            info(`${this.y}-${this.x}: ${this.rowSpan - n0}x${this.colSpan} Cell ${truncate(this.content, 10, this.truncate)}`);
+        const padLen = Math.max(this.height - this.lines.length, 0);
+        let padTop = 0;
+        if (this.vAlign === 'center')
+            padTop = Math.ceil(padLen / HALF);
+        else if (this.vAlign === 'bottom')
+            padTop = padLen;
+        const n = lineNum;
+        if (n < padTop || n >= padTop + this.lines.length)
+            return this.drawEmpty(this.drawRight, spanningCell);
+        const forceTruncation = this.lines.length > this.height && n + 1 >= this.height;
+        return this.drawLine(n - padTop, this.drawRight, forceTruncation, spanningCell);
+    }
+    drawTop(drawRight) {
+        const content = [];
+        if (this.cells) {
+            this.widths.forEach((width, index) => {
+                content.push(this.topLeftChar(index), repeat(this.chars[this.y === 0 ? 'top' : 'mid'] ?? '', width));
+            });
+        }
+        else {
+            content.push(this.topLeftChar(0), repeat(this.chars[this.y === 0 ? 'top' : 'mid'] ?? '', this.width));
+        }
+        if (drawRight)
+            content.push(this.chars[this.y === 0 ? 'topRight' : 'rightMid'] ?? '');
+        return styled(this.border, content.join(''));
+    }
+    topLeftChar(offset) {
+        const x = this.x + offset;
+        let leftChar;
+        if (this.y === 0) {
+            leftChar = x === 0 ? 'topLeft' : offset === 0 ? 'topMid' : 'top';
+        }
+        else if (x === 0) {
+            leftChar = 'leftMid';
+        }
+        else {
+            leftChar = offset === 0 ? 'midMid' : 'bottomMid';
+            if (this.cells) {
+                if (this.cells[this.y - 1]?.[x] instanceof ColSpanCell)
+                    leftChar = offset === 0 ? 'topMid' : 'mid';
+                if (offset === 0) {
+                    let i = 1;
+                    while (this.cells[this.y]?.[x - i] instanceof ColSpanCell)
+                        i += 1;
+                    if (this.cells[this.y]?.[x - i] instanceof RowSpanCell)
+                        leftChar = 'leftMid';
+                }
+            }
+        }
+        return this.chars[leftChar] ?? '';
+    }
+    leftEdge(spanningCell) {
+        let left = this.chars[this.x === 0 ? 'left' : 'middle'] ?? '';
+        if (this.x && spanningCell !== undefined && this.cells) {
+            let cellLeft = this.cells[this.y + spanningCell]?.[this.x - 1];
+            while (cellLeft instanceof ColSpanCell)
+                cellLeft = this.cells[cellLeft.y]?.[cellLeft.x - 1];
+            if (!(cellLeft instanceof RowSpanCell))
+                left = this.chars['rightMid'] ?? '';
+        }
+        return left;
+    }
+    drawLine(lineNum, drawRight, forceTruncationSymbol, spanningCell) {
+        const left = this.leftEdge(spanningCell);
+        const right = drawRight ? (this.chars['right'] ?? '') : '';
+        let line = this.lines[lineNum] ?? '';
+        const len = this.width - (this.paddingLeft + this.paddingRight);
+        if (forceTruncationSymbol)
+            line += this.truncate;
+        let content = truncate(line, len, this.truncate);
+        if (this.href !== undefined)
+            content = hyperlink(this.href, content);
+        content = pad(content, len, ' ', this.hAlign);
+        content = repeat(' ', this.paddingLeft) + content + repeat(' ', this.paddingRight);
+        return this.stylizeLine(left, content, right);
+    }
+    stylizeLine(left, content, right) {
+        const l = styled(this.border, left);
+        const r = styled(this.border, right);
+        return l + (this.y === 0 ? styled(this.head, content) : content) + r;
+    }
+    drawBottom(drawRight) {
+        const left = this.chars[this.x === 0 ? 'bottomLeft' : 'bottomMid'] ?? '';
+        const content = repeat(this.chars['bottom'] ?? '', this.width);
+        const right = drawRight ? (this.chars['bottomRight'] ?? '') : '';
+        return styled(this.border, left + content + right);
+    }
+    drawEmpty(drawRight, spanningCell) {
+        const left = this.leftEdge(spanningCell);
+        const right = drawRight ? (this.chars['right'] ?? '') : '';
+        return this.stylizeLine(left, repeat(' ', this.width), right);
+    }
+}
+export class ColSpanCell {
+    x = 0;
+    y = 0;
+    colSpan = 1;
+    rowSpan = 1;
+    draw(lineNum) {
+        if (typeof lineNum === 'number')
+            debugLog(`${this.y}-${this.x}: 1x1 ColSpanCell`);
+        return '';
+    }
+    init() {
+    }
+    mergeTableOptions() {
+    }
+}
+export class RowSpanCell {
+    originalCell;
+    x = 0;
+    y = 0;
+    colSpan = 1;
+    rowSpan = 1;
+    cellOffset = 0;
+    offset = 0;
+    constructor(originalCell) {
+        this.originalCell = originalCell;
+    }
+    init(tableOptions) {
+        this.cellOffset = this.y - this.originalCell.y;
+        this.offset = findDimension(tableOptions.rowHeights, this.originalCell.y, this.cellOffset);
+    }
+    draw(lineNum) {
+        if (lineNum === 'top')
+            return this.originalCell.draw(this.offset, this.cellOffset);
+        if (lineNum === 'bottom')
+            return this.originalCell.draw('bottom');
+        debugLog(`${this.y}-${this.x}: 1x${this.colSpan} RowSpanCell for ${this.originalCell.content}`);
+        return this.originalCell.draw(this.offset + 1 + lineNum);
+    }
+    mergeTableOptions() {
+    }
+}
+function nextFree(alloc, col) {
+    let c = col;
+    while ((alloc[c] ?? 0) > 0)
+        c += 1;
+    return c;
+}
+function layoutTable(table) {
+    const alloc = {};
+    table.forEach((row, rowIndex) => {
+        let col = 0;
+        for (const cell of row) {
+            cell.y = rowIndex;
+            cell.x = rowIndex ? nextFree(alloc, col) : col;
+            const rowSpan = cell.rowSpan || 1;
+            const colSpan = cell.colSpan || 1;
+            if (rowSpan > 1) {
+                for (let cs = 0; cs < colSpan; cs += 1)
+                    alloc[cell.x + cs] = rowSpan;
+            }
+            col = cell.x + colSpan;
+        }
+        for (const idx of Object.keys(alloc)) {
+            const key = Number(idx);
+            alloc[key] = (alloc[key] ?? 0) - 1;
+            if ((alloc[key] ?? 0) < 1)
+                delete alloc[key];
+        }
+    });
+}
+const maxWidth = (table) => table.reduce((mw, row) => row.reduce((m, cell) => Math.max(m, cell.x + (cell.colSpan || 1)), mw), 0);
+function cellsConflict(a, b) {
+    const yMax1 = a.y - 1 + (a.rowSpan ?? 1);
+    const yMax2 = b.y - 1 + (b.rowSpan || 1);
+    const yConflict = !(a.y > yMax2 || b.y > yMax1);
+    const xMax1 = a.x - 1 + (a.colSpan ?? 1);
+    const xMax2 = b.x - 1 + (b.colSpan || 1);
+    const xConflict = !(a.x > xMax2 || b.x > xMax1);
+    return yConflict && xConflict;
+}
+function conflictExists(rows, x, y) {
+    const iMax = Math.min(rows.length - 1, y);
+    for (let i = 0; i <= iMax; i += 1) {
+        for (const other of rows[i] ?? []) {
+            if (cellsConflict({ x, y }, other))
+                return true;
+        }
+    }
+    return false;
+}
+const allBlank = (rows, y, xMin, xMax) => {
+    for (let x = xMin; x < xMax; x += 1) {
+        if (conflictExists(rows, x, y))
+            return false;
+    }
+    return true;
+};
+function insertCell(cell, row) {
+    let x = 0;
+    while (x < row.length && (row[x]?.x ?? 0) < cell.x)
+        x += 1;
+    row.splice(x, 0, cell);
+}
+function fillInTable(table) {
+    const hMax = table.length;
+    const wMax = maxWidth(table);
+    debugLog(`Max rows: ${hMax}; Max cols: ${wMax}`);
+    for (let y = 0; y < hMax; y += 1) {
+        for (let x = 0; x < wMax; x += 1) {
+            if (conflictExists(table, x, y))
+                continue;
+            const opts = { x, y, colSpan: 1, rowSpan: 1 };
+            let scan = x + 1;
+            while (scan < wMax && !conflictExists(table, scan, y)) {
+                opts.colSpan += 1;
+                scan += 1;
+            }
+            let y2 = y + 1;
+            while (y2 < hMax && allBlank(table, y2, opts.x, opts.x + opts.colSpan)) {
+                opts.rowSpan += 1;
+                y2 += 1;
+            }
+            const cell = new Cell(opts);
+            cell.x = opts.x;
+            cell.y = opts.y;
+            warn(`Missing cell at ${cell.y}-${cell.x}.`);
+            insertCell(cell, table[y] ?? []);
+            x = scan - 1;
+        }
+    }
+}
+function addRowSpanCells(table) {
+    table.forEach((row, rowIndex) => {
+        for (const cell of row) {
+            for (let i = 1; i < cell.rowSpan; i += 1) {
+                const rowSpanCell = new RowSpanCell(cell);
+                rowSpanCell.x = cell.x;
+                rowSpanCell.y = cell.y + i;
+                rowSpanCell.colSpan = cell.colSpan;
+                insertCell(rowSpanCell, table[rowIndex + i] ?? []);
+            }
+        }
+    });
+}
+function addColSpanCells(cellRows) {
+    for (let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex -= 1) {
+        const columns = cellRows[rowIndex] ?? [];
+        for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+            const cell = columns[columnIndex];
+            if (!cell)
+                continue;
+            for (let k = 1; k < cell.colSpan; k += 1) {
+                const colSpanCell = new ColSpanCell();
+                colSpanCell.x = cell.x + k;
+                colSpanCell.y = cell.y;
+                columns.splice(columnIndex + 1, 0, colSpanCell);
+            }
+        }
+    }
+}
+function generateCells(rows) {
+    return rows.map((raw) => {
+        let row = raw;
+        if (!Array.isArray(row)) {
+            const record = row;
+            const key = Object.keys(record)[0] ?? '';
+            const value = record[key];
+            row = Array.isArray(value) ? [key, ...value] : [key, value];
+        }
+        return row.map((cell) => new Cell(cell));
+    });
+}
+export function makeTableLayout(rows) {
+    const cellRows = generateCells(rows);
+    layoutTable(cellRows);
+    fillInTable(cellRows);
+    addRowSpanCells(cellRows);
+    addColSpanCells(cellRows);
+    return cellRows;
+}
+function makeComputeDimensions(spanKey, desiredKey, axis, forcedMin) {
+    return (vals, table) => {
+        const result = [];
+        const spanners = [];
+        const auto = {};
+        for (const row of table) {
+            for (const cell of row) {
+                if ((cell[spanKey] || 1) > 1)
+                    spanners.push(cell);
+                else
+                    result[cell[axis]] = Math.max(result[cell[axis]] ?? 0, cell[desiredKey] ?? 0, forcedMin);
+            }
+        }
+        vals.forEach((val, index) => {
+            if (typeof val === 'number')
+                result[index] = val;
+        });
+        for (let k = spanners.length - 1; k >= 0; k -= 1) {
+            const cell = spanners[k];
+            if (!cell)
+                continue;
+            const span = cell[spanKey];
+            const col = cell[axis];
+            let existingWidth = result[col];
+            let editableCols = typeof vals[col] === 'number' ? 0 : 1;
+            if (typeof existingWidth === 'number') {
+                for (let i = 1; i < span; i += 1) {
+                    existingWidth += 1 + (result[col + i] ?? 0);
+                    if (typeof vals[col + i] !== 'number')
+                        editableCols += 1;
+                }
+            }
+            else {
+                const own = desiredKey === 'desiredWidth' ? cell.desiredWidth : 1;
+                if (own === undefined)
+                    continue;
+                existingWidth = own - 1;
+                if (!auto[col] || (auto[col] ?? 0) < existingWidth)
+                    auto[col] = existingWidth;
+            }
+            const desired = cell[desiredKey] ?? 0;
+            if (desired > existingWidth) {
+                let i = 0;
+                while (editableCols > 0 && desired > existingWidth) {
+                    if (typeof vals[col + i] !== 'number') {
+                        const dif = Math.round((desired - existingWidth) / editableCols);
+                        existingWidth += dif;
+                        result[col + i] = (result[col + i] ?? 0) + dif;
+                        editableCols -= 1;
+                    }
+                    i += 1;
+                }
+            }
+        }
+        Object.assign(vals, result, auto);
+        for (let j = 0; j < vals.length; j += 1)
+            vals[j] = Math.max(forcedMin, vals[j] || 0);
+    };
+}
+export const computeWidths = makeComputeDimensions('colSpan', 'desiredWidth', 'x', 1);
+export const computeHeights = makeComputeDimensions('rowSpan', 'desiredHeight', 'y', 1);
+function debugLevelFor(debug) {
+    if (typeof debug === 'boolean')
+        return DEBUG_LEVEL.WARN;
+    if (typeof debug === 'number')
+        return debug;
+    if (typeof debug === 'string')
+        return Number.parseInt(debug, DECIMAL);
+    warn(`Debug option is expected to be boolean, number, or string. Received a ${typeof debug}`);
+    return DEBUG_LEVEL.WARN;
+}
+function doDraw(row, lineNum, result) {
+    const str = row.map((cell) => cell.draw(lineNum)).join('');
+    if (str.length)
+        result.push(str);
+}
+export class Table extends Array {
+    constructor(opts) {
+        super();
+        const options = mergeOptions(opts);
+        Object.defineProperty(this, 'options', { value: options, enumerable: Boolean(options.debug) });
+        if (!options.debug)
+            return;
+        debugLevel = debugLevelFor(options.debug);
+        Object.defineProperty(this, 'messages', {
+            get: () => debugMessages,
+        });
+    }
+    static reset() {
+        debugMessages = [];
+    }
+    toString() {
+        let array = [...this];
+        const head = this.options.head ?? [];
+        const headersPresent = head.length > 0;
+        if (headersPresent)
+            array = [head, ...array];
+        else
+            this.options.style.head = [];
+        const cells = makeTableLayout(array);
+        for (const row of cells) {
+            for (const cell of row)
+                cell.mergeTableOptions(this.options, cells);
+        }
+        computeWidths(this.options.colWidths, cells);
+        computeHeights(this.options.rowHeights, cells);
+        for (const row of cells) {
+            for (const cell of row)
+                cell.init(this.options);
+        }
+        const result = [];
+        for (let rowIndex = 0; rowIndex < cells.length; rowIndex += 1) {
+            const row = cells[rowIndex] ?? [];
+            const heightOfRow = this.options.rowHeights[rowIndex] ?? 0;
+            if (rowIndex === 0 || !this.options.style.compact || (rowIndex === 1 && headersPresent))
+                doDraw(row, 'top', result);
+            for (let lineNum = 0; lineNum < heightOfRow; lineNum += 1)
+                doDraw(row, lineNum, result);
+            if (rowIndex + 1 === cells.length)
+                doDraw(row, 'bottom', result);
+        }
+        return result.join('\n');
+    }
+    get width() {
+        return (this.toString().split('\n')[0] ?? '').length;
+    }
+}
+export default Table;