@kerebron/editor-kits 0.4.1

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

@@ -0,0 +1,380 @@
+export function escapeMarkdown(token) {
+    const markdownChars = [
+        { char: '\\', escape: '\\\\' },
+        // { char: '*', escape: '\\*' },
+        // { char: '_', escape: '\\_' },
+        { char: '#', escape: '\\#' },
+        // { char: '[', escape: '\\[' },
+        // { char: ']', escape: '\\]' },
+        // { char: '(', escape: '\\(' },
+        // { char: ')', escape: '\\)' },
+        // { char: '`', escape: '\\`' },
+        // { char: '>', escape: '\\>' },
+        { char: '<', escape: '\\<' },
+        // { char: '.', escape: '\\.' },
+        // { char: '!', escape: '\\!' },
+        // { char: '|', escape: '\\|' },
+        // { char: '{', escape: '\\{' },
+        // { char: '}', escape: '\\}' },
+        { char: '…', escape: '...' },
+        { char: '©', escape: '(c)' },
+        { char: '®', escape: '(r)' },
+        { char: '™', escape: '(tm)' },
+        { char: '±', escape: '+-' },
+        { char: '—', escape: '---' },
+    ];
+    const startPos = token.map && token.map.length > 0 ? token.map[0] : 0;
+    if (!startPos) {
+        let escapedText = token.content;
+        for (const { char, escape } of markdownChars) {
+            escapedText = escapedText.replaceAll(char, escape);
+        }
+        return [[escapedText, token]];
+    }
+    const charArr = token.content.split('');
+    const retVal = [];
+    const markdownCharsMap = Object.fromEntries(markdownChars.map((c) => [c.char, c.escape]));
+    let offset = 0;
+    let inStr = '';
+    let currentOutStr = '';
+    const flush = () => {
+        if (currentOutStr.length > 0) {
+            const tok = structuredClone(token);
+            tok.map = [startPos + offset];
+            retVal.push([
+                currentOutStr,
+                tok,
+            ]);
+            offset = inStr.length;
+        }
+        currentOutStr = '';
+    };
+    for (let idx = 0; idx < charArr.length; idx++) {
+        const char = charArr[idx];
+        inStr += char;
+        if (markdownCharsMap[char]) {
+            flush();
+        }
+        currentOutStr += markdownCharsMap[char] || char;
+        if (markdownCharsMap[char]) {
+            flush();
+        }
+    }
+    flush();
+    return retVal;
+}
+function getLinkTokensHandlers() {
+    return {
+        'text': [
+            (token, ctx) => {
+                ctx.current.meta['link_text'] += token.content;
+                if (token.content && !ctx.current.meta['link_token_token']) {
+                    ctx.current.meta['link_token_token'] = token;
+                }
+            },
+        ],
+        'link_close': [
+            (token, ctx) => {
+                {
+                    const lastStackToken = ctx.current.meta['link_open_token'];
+                    const href = lastStackToken.attrGet('href') || '';
+                    const title = lastStackToken.attrGet('title') || '';
+                    if (!title && ctx.current.meta['link_text'] === href) {
+                        ctx.current.log(href, token);
+                    }
+                    else if (!title && !href) {
+                        ctx.current.log('[', token);
+                        ctx.current.log(ctx.current.meta['link_text'], ctx.current.meta['link_token_token']);
+                        ctx.current.log(`]${title}`, token);
+                    }
+                    else {
+                        ctx.current.log('[', token);
+                        ctx.current.log(ctx.current.meta['link_text'], ctx.current.meta['link_token_token']);
+                        if (title) {
+                            ctx.current.log(`](${href} ${title})`, token);
+                        }
+                        else {
+                            ctx.current.log(`](${href})`, token);
+                        }
+                    }
+                    ctx.unstash('getLinkTokensHandlers.link_close');
+                }
+            },
+        ],
+        default: [
+            (token, ctx) => {
+                // Ignore other stuff
+                // TODO: images?
+            },
+        ],
+    };
+}
+export function getInlineTokensHandlers() {
+    return {
+        'text': [
+            (token, ctx) => {
+                if (token.meta === 'noEscText') {
+                    for (const pair of escapeMarkdown(token)) {
+                        ctx.current.log(token.content);
+                    }
+                }
+                else {
+                    for (const pair of escapeMarkdown(token)) {
+                        ctx.current.log(pair[0], pair[1]);
+                    }
+                }
+            },
+        ],
+        'strong_open': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '**', token);
+            },
+        ],
+        'strong_close': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '**', token);
+            },
+        ],
+        'em_open': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '*', token);
+            },
+        ],
+        'em_close': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '*', token);
+            },
+        ],
+        'underline_open': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '_', token);
+            },
+        ],
+        'underline_close': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '_', token);
+            },
+        ],
+        'strike_open': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '~', token);
+            },
+        ],
+        'strike_close': [
+            (token, ctx) => {
+                ctx.current.log(token.markup || '~', token);
+            },
+        ],
+        'link_open': [
+            (token, ctx) => {
+                ctx.stash('getInlineTokensHandlers.link_open');
+                ctx.current.handlers = getLinkTokensHandlers();
+                ctx.current.meta['link_open_token'] = token;
+                ctx.current.meta['link_text'] = '';
+                ctx.current.meta['link_token_token'] = null;
+            },
+        ],
+        'code_open': [
+            (token, ctx) => {
+                ctx.current.log('`', token);
+            },
+        ],
+        'code_close': [
+            (token, ctx) => {
+                ctx.current.log('`', token);
+            },
+        ],
+        'code_inline': [
+            (token, ctx) => {
+                ctx.current.log('`' + token.content + '`', token);
+            },
+        ],
+        'math': [
+            (token, ctx) => {
+                ctx.current.log('$' + token.content + '$', token);
+            },
+        ],
+        'hardbreak': [
+            (token, ctx) => {
+                ctx.current.log('\n', token);
+            },
+        ],
+        'softbreak': [
+            (token, ctx) => {
+                ctx.current.log('\n', token);
+            },
+        ],
+        'image': [
+            (token, ctx) => {
+                {
+                    const src = token.attrGet('src');
+                    const altAttr = token.attrGet('alt');
+                    let alt = altAttr || '';
+                    if (token.children) {
+                        for (const child of token.children) {
+                            if (child.type === 'text') {
+                                alt += child.content;
+                            }
+                        }
+                    }
+                    ctx.current.log(`![${alt}]`, token);
+                    // ctx.current.log(
+                    //   `(${src})`,
+                    //   token,
+                    // );
+                    const title = token.attrGet('title');
+                    if (src) {
+                        ctx.current.log(`(${src}${title ? ' ' + title : ''})`, token);
+                    }
+                }
+            },
+        ],
+        'html_block': [
+            (token, ctx) => {
+                ctx.current.log(token.content, token);
+            },
+        ],
+        'footnote_ref': [
+            (token, ctx) => {
+                if (token.meta.label) {
+                    ctx.current.log(`[^${token.meta.label}]`, token);
+                }
+                else {
+                    ctx.current.log(`[^footnote_${token.meta.id}]`, token);
+                }
+            },
+        ],
+    };
+}
+function escapeHtml(text) {
+    return text; // TODO
+}
+export function getHtmlInlineTokensHandlers() {
+    return {
+        'text': [
+            (token, ctx) => {
+                ctx.current.log(escapeHtml(token.content), token);
+            },
+        ],
+        'strong_open': [
+            (token, ctx) => {
+                const tag = token.tag || 'strong';
+                ctx.current.log(`<${tag}>`, token);
+            },
+        ],
+        'strong_close': [
+            (token, ctx) => {
+                const tag = token.tag || 'strong';
+                ctx.current.log(`</${tag}>`, token);
+            },
+        ],
+        'em_open': [
+            (token, ctx) => {
+                const tag = token.tag || 'em';
+                ctx.current.log(`<${tag}>`, token);
+            },
+        ],
+        'em_close': [
+            (token, ctx) => {
+                const tag = token.tag || 'em';
+                ctx.current.log(`</${tag}>`, token);
+            },
+        ],
+        'strike_open': [
+            (token, ctx) => {
+                const tag = token.tag || 'strike';
+                ctx.current.log(`<${tag}>`, token);
+            },
+        ],
+        'strike_close': [
+            (token, ctx) => {
+                const tag = token.tag || 'strike';
+                ctx.current.log(`</${tag}>`, token);
+            },
+        ],
+        'link_open': [
+            (token, ctx) => {
+                ctx.stash('getHtmlInlineTokensHandlers.link_open');
+                const href = token.attrGet('href') || '';
+                const titleValue = token.attrGet('title');
+                const title = titleValue ? ' "' + titleValue + '"' : '';
+                ctx.current.log(`<a href="${href}">`, token);
+            },
+        ],
+        'link_close': [
+            (token, ctx) => {
+                {
+                    ctx.current.log('</a>', token);
+                    ctx.unstash('getHtmlInlineTokensHandlers.link_close');
+                }
+            },
+        ],
+        'code_open': [
+            (token, ctx) => {
+                const tag = token.tag || 'code';
+                ctx.current.log(`<${tag}>`, token);
+            },
+        ],
+        'code_close': [
+            (token, ctx) => {
+                const tag = token.tag || 'code';
+                ctx.current.log(`<${tag}>`, token);
+            },
+        ],
+        // 'code_inline': [
+        //   (token: Token, ctx: ContextStash) => {
+        //     const tag = token.tag || 'code';
+        //     ctx.current.log(`<${tag}>`, token);
+        //     ctx.current.log(token.content || '', token);
+        //     ctx.current.log(`</${tag}>`, token);
+        //   },
+        // ],
+        'hardbreak': [
+            (token, ctx) => {
+                const tag = token.tag || 'br';
+                ctx.current.log(`<${tag} />`, token);
+            },
+        ],
+        'softbreak': [
+            (token, ctx) => {
+                const tag = token.tag || 'br';
+                ctx.current.log(`<${tag} />`, token);
+            },
+        ],
+        'image': [
+            (token, ctx) => {
+                {
+                    // const src = token.attrGet('src');
+                    // const alt = token.attrGet('alt');
+                    let alt = '';
+                    if (token.children) {
+                        for (const child of token.children) {
+                            if (child.type === 'text') {
+                                alt += child.content;
+                            }
+                        }
+                    }
+                    // const title = token.attrGet('title');
+                    // ctx.current.log(`![${alt}]`, token);
+                    // if (src) {
+                    //   ctx.current.log(
+                    //     `(${src}${title ? ' "' + title + '"' : ''})`, token
+                    //   );
+                    // }
+                    // TODO
+                    const tag = token.tag || 'img';
+                    ctx.current.log(`<${tag} />`, token);
+                }
+            },
+        ],
+        'html_block': [
+            (token, ctx) => {
+                ctx.current.log(token.content, token);
+            },
+        ],
+        'footnote_ref': [
+            (token, ctx) => {
+            },
+        ],
+    };
+}

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

@@ -0,0 +1,3 @@
+import { type TokenHandler } from '../MarkdownSerializer.js';
+export declare function getListsTokensHandlers(): Record<string, Array<TokenHandler>>;
+//# sourceMappingURL=lists_token_handlers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lists_token_handlers.d.ts","sourceRoot":"","sources":["../../../../src/extension-markdown/src/token_handlers/lists_token_handlers.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,0BAA0B,CAAC;AA2NlC,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAmK5E"}