@kerebron/editor-kits 0.4.1

package/esm/extension-markdown/src/token_handlers/lists_token_handlers.js

@@ -0,0 +1,323 @@
+import { writeIndented, } from '../MarkdownSerializer.js';
+import { getHtmlInlineTokensHandlers, getInlineTokensHandlers, } from './inline_token_handlers.js';
+import { numberString } from '../utils.js';
+function getLongDefinitionTokensHandlers() {
+    return {
+        ...getInlineTokensHandlers(),
+        'hardbreak': [
+            (token, ctx) => {
+                ctx.current.log('\n');
+                if (ctx.current.meta['para_hidden']) {
+                    ctx.current.itemSymbol = '';
+                }
+                ctx.current.itemRow++;
+            },
+        ],
+        'code_block': [
+            (token, ctx) => {
+                if (ctx.current.itemRow === 0) {
+                    ctx.current.itemRow++;
+                }
+                if (ctx.output.colPos > 0) {
+                    ctx.current.log('\n');
+                }
+                if (!ctx.output.endsWith('\n\n')) {
+                    ctx.current.log('\n');
+                }
+                ctx.stash('getLongDefinitionTokensHandlers.code_block');
+                ctx.current.log = (txt) => {
+                    writeIndented(ctx.output, txt, ctx.current, token);
+                };
+                ctx.current.log(token.content
+                    .split('\n')
+                    .map((t) => t.trim() ? ('  ' + t) : '')
+                    .join('\n') + '\n');
+                ctx.unstash('getLongDefinitionTokensHandlers.code_block');
+                ctx.current.itemRow++;
+            },
+        ],
+        'paragraph_open': [
+            (token, ctx) => {
+                ctx.stash('getLongDefinitionTokensHandlers.paragraph_open');
+                ctx.current.meta['para_hidden'] = token.hidden;
+            },
+        ],
+        'paragraph_close': [
+            (token, ctx) => {
+                ctx.unstash('getLongDefinitionTokensHandlers.paragraph_close');
+                if (ctx.output.colPos !== 0) {
+                    // ctx.current.log('\n');
+                }
+                ctx.current.itemRow++;
+            },
+        ],
+        'dt_open': [
+            (token, ctx) => {
+                ctx.current.itemSymbol = '';
+                ctx.current.itemRow = 0;
+            },
+        ],
+        'dt_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'dd_open': [
+            (token, ctx) => {
+                if (!ctx.output.endsWith('\n\n')) {
+                    ctx.current.log('\n');
+                }
+                ctx.current.itemSymbol = ':   ';
+                ctx.current.itemRow = 0;
+            },
+        ],
+        'dd_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'dl_open': [
+            (token, ctx) => {
+                ctx.stash('getLongDefinitionTokensHandlers.dl_open');
+                ctx.current.listPath.push('dl');
+                ctx.current.listType = 'dl';
+            },
+        ],
+        'dl_close': [
+            (token, ctx) => {
+                ctx.unstash('getLongDefinitionTokensHandlers.dl_close');
+            },
+        ],
+    };
+}
+function getShortDefinitionTokensHandlers() {
+    const rollbackList = (token, ctx, tokenSource) => {
+        const rollbackPos = ctx.current.meta['def_rollback'];
+        if (!ctx.current.meta['def_token_start']) {
+            throw new Error('No def_token_start');
+        }
+        const outputPos = ctx.current.meta['def_output_pos'];
+        if (!ctx.current.meta['def_output_pos']) {
+            throw new Error('No def_output_pos');
+        }
+        tokenSource.rewind(ctx.current.meta['def_token_start']);
+        ctx.rollback(rollbackPos, 'rollbackList, ' + token.type);
+        ctx.output.rollback(outputPos);
+        ctx.stash('getShortDefinitionTokensHandlers.rollbackList');
+        ctx.current.listPath.push('dl');
+        ctx.current.listType = 'dl';
+        ctx.current.handlers = getLongDefinitionTokensHandlers();
+    };
+    return {
+        'dl_open': [
+            (token, ctx, tokenSource) => {
+                const rollbackPos = ctx.stash('getShortDefinitionTokensHandlers.dl_open');
+                ctx.current.meta['def_rollback'] = rollbackPos;
+                ctx.current.meta['def_token_start'] = tokenSource.pos;
+                ctx.current.meta['def_output_pos'] = ctx.output.chunkPos;
+                ctx.current.listPath.push('dl');
+                ctx.current.listType = 'dl';
+                ctx.current.handlers = getShortDefinitionTokensHandlers();
+            },
+        ],
+        'dl_close': [
+            (token, ctx) => {
+                ctx.unstash('getShortDefinitionTokensHandlers.dl_close');
+            },
+        ],
+        ...getInlineTokensHandlers(),
+        'hardbreak': [
+            rollbackList,
+        ],
+        'code_block': [
+            rollbackList,
+        ],
+        'paragraph_open': [
+            (token, ctx) => {
+                // Skip, as paragraphs are implied by newlines
+            },
+        ],
+        'paragraph_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    // ctx.current.log('\n');
+                }
+            },
+        ],
+        'dt_open': [
+            (token, ctx) => {
+                ctx.current.itemSymbol = '';
+                ctx.current.itemRow = 0;
+            },
+        ],
+        'dt_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'dd_open': [
+            (token, ctx) => {
+                ctx.current.itemSymbol = '  ~ ';
+                ctx.current.itemRow = 0;
+            },
+        ],
+        'dd_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+    };
+}
+export function getListsTokensHandlers() {
+    return {
+        'dl_open': getShortDefinitionTokensHandlers()['dl_open'],
+        'paragraph_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n', token);
+                }
+                ctx.current.itemRow++;
+            },
+        ],
+        'task_list_open': [
+            (token, ctx) => {
+                ctx.stash('getListsTokensHandlers.task_list_open');
+                ctx.current.listPath.push('tl');
+                ctx.current.listType = 'tl';
+                ctx.current.itemSymbol = '';
+                ctx.current.itemNumber = 0;
+            },
+        ],
+        'task_list_close': [
+            (token, ctx) => {
+                ctx.unstash('getListsTokensHandlers.task_list_close');
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'task_item_open': [
+            (token, ctx) => {
+                ctx.current.itemRow = 0;
+                ctx.current.itemNumber++;
+                ctx.current.itemSymbol = token.attrGet('checked') ? 'x' : '';
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'task_item_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'bullet_list_open': [
+            (token, ctx) => {
+                ctx.stash('getListsTokensHandlers.bullet_list_open');
+                ctx.current.listPath.push('ul');
+                ctx.current.listType = 'ul';
+                ctx.current.itemSymbol = '';
+                ctx.current.itemNumber = 0;
+            },
+        ],
+        'bullet_list_close': [
+            (token, ctx) => {
+                ctx.unstash('getListsTokensHandlers.bullet_list_close');
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'ordered_list_open': [
+            (token, ctx) => {
+                {
+                    ctx.stash('getListsTokensHandlers.ordered_list_open');
+                    ctx.current.listPath.push('ol');
+                    ctx.current.listType = 'ol';
+                    const htmlInlineHandlers = Object.entries(getHtmlInlineTokensHandlers())
+                        .filter((a) => [
+                        'strong_open',
+                        'strong_close',
+                        'em_open',
+                        'em_close',
+                        'underline_open',
+                        'underline_close',
+                        'strike_open',
+                        'strike_close',
+                    ].includes(a[0]));
+                    ctx.current.handlers = {
+                        ...ctx.current.handlers,
+                        ...Object.fromEntries(htmlInlineHandlers),
+                    };
+                    ctx.current.itemSymbol = '';
+                    const symbol = token.attrGet('symbol');
+                    if (symbol) {
+                        ctx.current.meta['list_symbol'] = symbol;
+                    }
+                    else {
+                        ctx.current.meta['list_symbol'] = '1';
+                    }
+                    const start = token.attrGet('start');
+                    if (start) {
+                        ctx.current.itemNumber = (+start || 1) - 1;
+                    }
+                    else {
+                        ctx.current.itemNumber = 0;
+                    }
+                }
+            },
+        ],
+        'ordered_list_close': [
+            (token, ctx) => {
+                ctx.unstash('getListsTokensHandlers.ordered_list_close');
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'list_item_open': [
+            (token, ctx) => {
+                ctx.current.itemRow = 0;
+                ctx.current.itemNumber++;
+                ctx.current.itemSymbol = token.info || token.markup;
+                if (!ctx.current.itemSymbol) {
+                    ctx.current.itemSymbol = numberString(ctx.current.itemNumber, ctx.current.meta['list_symbol'] || '1');
+                }
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'list_item_close': [
+            (token, ctx) => {
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'blockquote_open': [
+            (token, ctx) => {
+                ctx.stash('getListsTokensHandlers.blockquote_open');
+                ctx.current.blockquoteCnt++;
+                if (ctx.output.colPos !== 0) {
+                    ctx.current.log('\n');
+                }
+            },
+        ],
+        'blockquote_close': [
+            (token, ctx) => {
+                ctx.unstash('getListsTokensHandlers.blockquote_close');
+            },
+        ],
+    };
+}

package/esm/extension-markdown/src/token_handlers/table_token_handlers.d.ts

@@ -0,0 +1,9 @@
+import type { TokenHandler } from '../MarkdownSerializer.js';
+export type TextAlign = 'left' | 'right';
+export interface RollbackData {
+    sourcePos: number;
+    outputPos: number;
+    ctxDepth: number;
+}
+export declare function getTableTokensHandlers(): Record<string, Array<TokenHandler>>;
+//# sourceMappingURL=table_token_handlers.d.ts.map

package/esm/extension-markdown/src/token_handlers/table_token_handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table_token_handlers.d.ts","sourceRoot":"","sources":["../../../../src/extension-markdown/src/token_handlers/table_token_handlers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,YAAY,EACb,MAAM,0BAA0B,CAAC;AAIlC,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAuNzC,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAsID,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAI5E"}

package/esm/extension-markdown/src/token_handlers/table_token_handlers.js

@@ -0,0 +1,308 @@
+import { getHtmlInlineTokensHandlers } from './inline_token_handlers.js';
+function getHtmlTableTokensHandlers() {
+    return {
+        // ...getHtmlBasicTokensHandlers(), // TODO html
+        ...getHtmlInlineTokensHandlers(),
+        'paragraph_open': [],
+        'paragraph_close': [],
+        'table_open': [
+            (token, ctx) => {
+                ctx.stash('getHtmlTableTokensHandlers.table_open');
+                ctx.current.meta['html_mode'] = true;
+                ctx.current.log('<table>\n', token);
+            },
+        ],
+        'table_close': [
+            (token, ctx) => {
+                ctx.current.log('</table>\n', token);
+                ctx.unstash('getHtmlTableTokensHandlers.table_close');
+            },
+        ],
+        'thead_open': [
+            (token, ctx) => {
+                ctx.current.log('<thead>\n', token);
+            },
+        ],
+        'thead_close': [
+            (token, ctx) => {
+                ctx.current.log('</thead>\n', token);
+            },
+        ],
+        'tr_open': [
+            (token, ctx) => {
+                ctx.current.log('<tr>\n', token);
+            },
+        ],
+        'tr_close': [
+            (token, ctx) => {
+                ctx.current.log('</tr>\n', token);
+            },
+        ],
+        'th_open': [
+            (token, ctx) => {
+                ctx.current.log('<th>', token);
+            },
+        ],
+        'th_close': [
+            (token, ctx) => {
+                ctx.current.log('</th>\n', token);
+            },
+        ],
+        'tbody_open': [
+            (token, ctx) => {
+                ctx.current.log('<tbody>\n', token);
+            },
+        ],
+        'tbody_close': [
+            (token, ctx) => {
+                ctx.current.log('</tbody>\n', token);
+            },
+        ],
+        'td_open': [
+            (token, ctx) => {
+                ctx.current.log('<td>', token);
+            },
+        ],
+        'td_close': [
+            (token, ctx) => {
+                ctx.current.log('</td>\n', token);
+            },
+        ],
+    };
+}
+class TableBuilder {
+    constructor() {
+        Object.defineProperty(this, "rows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.currentType = 'body';
+        this.rows = [];
+    }
+    appendRow() {
+        this.rows.push({
+            type: this.currentType,
+            cells: [],
+        });
+    }
+    appendCell(align, token) {
+        const lastRow = this.rows[this.rows.length - 1];
+        const startPos = token.map && token.map.length > 0 ? token.map[0] : 0;
+        lastRow.cells.push({
+            value: [],
+            startPos,
+            align,
+        });
+    }
+    appendText(content, token) {
+        const lastRow = this.rows[this.rows.length - 1];
+        if (lastRow.cells.length > 0) {
+            lastRow.cells[lastRow.cells.length - 1].value.push([content, token]);
+        }
+    }
+    render(log) {
+        let prevType = '';
+        let lastHeader = [];
+        const columnsWidth = [];
+        for (let rowNo = 0; rowNo < this.rows.length; rowNo++) {
+            const row = this.rows[rowNo];
+            for (let cellNo = 0; cellNo < row.cells.length; cellNo++) {
+                while (columnsWidth.length <= cellNo) {
+                    columnsWidth.push(1);
+                }
+                const headCell = lastHeader[cellNo];
+                const cell = row.cells[cellNo];
+                const textLen = cell.value.reduce((prev, current) => prev + current[0].length, 0);
+                if (columnsWidth[cellNo] < textLen + 1) {
+                    columnsWidth[cellNo] = textLen + 1;
+                }
+            }
+        }
+        for (let rowNo = 0; rowNo < this.rows.length; rowNo++) {
+            const row = this.rows[rowNo];
+            if (prevType === 'header' && prevType !== row.type) {
+                log('|');
+                for (let cellNo = 0; cellNo < lastHeader.length; cellNo++) {
+                    const cell = lastHeader[cellNo];
+                    log(' ');
+                    if (cell.align === 'right') {
+                        log('-'.repeat(columnsWidth[cellNo] - 2));
+                        log(': |');
+                    }
+                    else {
+                        log('-'.repeat(columnsWidth[cellNo] - 1));
+                        log(' |');
+                    }
+                }
+                log('\n');
+            }
+            log('|');
+            for (let cellNo = 0; cellNo < row.cells.length; cellNo++) {
+                const cell = row.cells[cellNo];
+                const textLen = cell.value.reduce((prev, current) => prev + current[0].length, 0);
+                if (cell.align === 'right') {
+                    if (textLen === 0 && cell.startPos) {
+                        log(' '.repeat(columnsWidth[cellNo] - textLen), { map: [cell.startPos + 2] });
+                    }
+                    else {
+                        log(' '.repeat(columnsWidth[cellNo] - textLen));
+                    }
+                }
+                else {
+                    log(' '.repeat(1));
+                }
+                for (const pair of cell.value) {
+                    log(pair[0], pair[1]);
+                }
+                if (textLen < columnsWidth[cellNo]) {
+                    if (cell.align === 'right') {
+                        log(' '.repeat(1));
+                    }
+                    else {
+                        if (textLen === 0 && cell.startPos) {
+                            log(' '.repeat(columnsWidth[cellNo] - textLen), { map: [cell.startPos + 2] });
+                        }
+                        else {
+                            log(' '.repeat(columnsWidth[cellNo] - textLen));
+                        }
+                    }
+                }
+                log('|');
+            }
+            log('\n');
+            if (row.type === 'header') {
+                lastHeader = row.cells;
+            }
+            prevType = row.type;
+        }
+    }
+}
+function getMdTableTokensHandler() {
+    const rollbackMdTable = (token, ctx, tokenSource) => {
+        if (!ctx.current.meta['html_rollback']) {
+            throw new Error('No html_rollback');
+        }
+        const rollback = ctx.current.meta['html_rollback'];
+        tokenSource.rewind(rollback.sourcePos);
+        ctx.rollback(rollback.ctxDepth, 'rollbackMdTable, ' + token.type);
+        ctx.output.rollback(rollback.outputPos);
+        ctx.stash('getMdTableTokensHandler.rollbackTable');
+        ctx.current.meta['html_mode'] = true;
+        ctx.current.log('<table>\n', token);
+        ctx.current.handlers = getHtmlTableTokensHandlers();
+    };
+    return {
+        'text': [
+            (token, ctx) => {
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.appendText(token.content, token);
+            },
+        ],
+        'paragraph_open': [],
+        'paragraph_close': [
+            (token, ctx, tokenSource) => {
+                ctx.current.meta['table_cell_para_count'] =
+                    +ctx.current.meta['table_cell_para_count'] + 1;
+                if (ctx.current.meta['table_cell_para_count'] > 1) { // Only 1 line in markdown pipe table
+                    rollbackMdTable(token, ctx, tokenSource);
+                }
+            },
+        ],
+        'default': [
+            rollbackMdTable,
+        ],
+        'table_open': [
+            (token, ctx, tokenSource) => {
+                const rollbackDepth = ctx.stash('getMdTableTokensHandler.table_open');
+                if (!ctx.current.meta['html_rollback']) {
+                    const rollback = {
+                        sourcePos: tokenSource.pos,
+                        outputPos: ctx.output.chunkPos,
+                        ctxDepth: rollbackDepth,
+                    };
+                    ctx.current.meta['html_rollback'] = rollback;
+                }
+                ctx.current.metaObj['table_builder'] = new TableBuilder();
+                ctx.current.handlers = getMdTableTokensHandler();
+            },
+        ],
+        'table_close': [
+            (token, ctx) => {
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.render(ctx.current.log);
+                ctx.unstash('getMdTableTokensHandler.table_close');
+            },
+        ],
+        'thead_open': [
+            (token, ctx) => {
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.currentType = 'header';
+            },
+        ],
+        'thead_close': [
+            (token, ctx) => {
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.currentType = 'body';
+            },
+        ],
+        'tr_open': [
+            (token, ctx) => {
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.appendRow();
+            },
+        ],
+        'tr_close': [
+            (token, ctx) => {
+            },
+        ],
+        'th_open': [
+            (token, ctx) => {
+                // const style = token.attrGet('style');
+                // const align = style === 'text-align:right' ? 'right' : 'left';
+                const align = token.attrGet('align') || 'left';
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.appendCell(align, token);
+                ctx.current.meta['table_cell_para_count'] = 0;
+            },
+        ],
+        'th_close': [
+            (token, ctx) => {
+            },
+        ],
+        'tbody_open': [
+            (token, ctx) => {
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.currentType = 'body';
+            },
+        ],
+        'tbody_close': [
+            (token, ctx) => {
+            },
+        ],
+        'td_open': [
+            (token, ctx) => {
+                const align = token.attrGet('align') || 'left';
+                const tableBuilder = ctx.current.metaObj['table_builder'];
+                tableBuilder.appendCell(align, token);
+                ctx.current.meta['table_cell_para_count'] = 0;
+            },
+        ],
+        'td_close': [
+            (token, ctx) => {
+            },
+        ],
+    };
+}
+export function getTableTokensHandlers() {
+    return {
+        'table_open': getMdTableTokensHandler()['table_open'],
+    };
+}

package/esm/extension-markdown/src/treeSitterTokenizer.d.ts

@@ -0,0 +1,5 @@
+import { Token } from './types.js';
+export declare function sitterTokenizer(cdnUrl?: string): Promise<{
+    parse: (source: string) => Array<Token>;
+}>;
+//# sourceMappingURL=treeSitterTokenizer.d.ts.map

package/esm/extension-markdown/src/treeSitterTokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeSitterTokenizer.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/treeSitterTokenizer.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,EACN,MAAM,YAAY,CAAC;AA4kCpB,wBAAsB,eAAe,CAAC,MAAM,SAAK;oBAkB7B,MAAM,KAAG,KAAK,CAAC,KAAK,CAAC;GASxC"}