@kerebron/editor-kits 0.4.1

package/esm/extension-codejar/src/ExtensionCodeJar.js

@@ -0,0 +1,75 @@
+import { Extension, } from '../../editor/src/mod.js';
+import { createNodeFromObject } from '../../editor/src/utilities/mod.js';
+import { NodeCodeJar } from './NodeCodeJar.js';
+export * from './NodeCodeJar.js';
+export class ExtensionCodeJar extends Extension {
+    constructor(config = {}) {
+        super(config);
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'code-jar'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.requires = [
+            new NodeCodeJar({
+                languageWhitelist: config.languageWhitelist,
+                // theme: config.theme,
+            }),
+        ];
+    }
+    getConverters(editor, schema) {
+        return {
+            'text/code-only': {
+                fromDoc: async (document) => {
+                    const retVal = [];
+                    if (document.content) {
+                        for (const node of document.content.toJSON()) {
+                            if ('code_block' === node.type && Array.isArray(node.content)) {
+                                for (const content of node.content) {
+                                    retVal.push(content.text);
+                                }
+                            }
+                        }
+                    }
+                    return new TextEncoder().encode(retVal.join(''));
+                },
+                toDoc: async (buffer) => {
+                    const code = new TextDecoder().decode(buffer);
+                    const content = {
+                        'type': 'doc_code',
+                        'content': [
+                            {
+                                'type': 'code_block',
+                                'attrs': {
+                                    'lang': schema.topNodeType.spec.defaultAttrs?.lang,
+                                },
+                                'content': [
+                                    {
+                                        'type': 'text',
+                                        'text': code,
+                                    },
+                                ],
+                            },
+                        ],
+                    };
+                    return createNodeFromObject(content, schema, {
+                        errorOnInvalidContent: false,
+                    });
+                },
+            },
+        };
+    }
+}

package/esm/extension-codejar/src/NodeCodeJar.d.ts

@@ -0,0 +1,18 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import type { NodeType } from 'prosemirror-model';
+import { type CoreEditor } from '../../editor/src/mod.js';
+import { type CommandFactories, type CommandShortcuts } from '../../editor/src/commands/mod.js';
+import { NodeCodeBlock } from '../../extension-basic-editor/src/NodeCodeBlock.js';
+export declare const codeJarBlockKey: PluginKey<any>;
+export interface NodeCodeJarConfig {
+    readOnly?: any;
+    languageWhitelist?: string[];
+}
+export declare class NodeCodeJar extends NodeCodeBlock {
+    config: NodeCodeJarConfig;
+    constructor(config: NodeCodeJarConfig);
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+    getProseMirrorPlugins(): Plugin[];
+}
+//# sourceMappingURL=NodeCodeJar.d.ts.map

package/esm/extension-codejar/src/NodeCodeJar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeCodeJar.d.ts","sourceRoot":"","sources":["../../../src/extension-codejar/src/NodeCodeJar.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,MAAM,EACN,SAAS,EAGV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,aAAa,EAAE,MAAM,mDAAmD,CAAC;AAIlF,eAAO,MAAM,eAAe,gBAAkC,CAAC;AAwB/D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,qBAAa,WAAY,SAAQ,aAAa;IACvB,MAAM,EAAE,iBAAiB;gBAAzB,MAAM,EAAE,iBAAiB;IAIrC,mBAAmB,CAC1B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAWnB,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAUjD,qBAAqB,IAAI,MAAM,EAAE;CA6B3C"}

package/esm/extension-codejar/src/NodeCodeJar.js

@@ -0,0 +1,76 @@
+import { Plugin, PluginKey, Selection, } from 'prosemirror-state';
+import { getShadowRoot } from '../../editor/src/utilities/mod.js';
+import { getLangsList } from '../../wasm/src/mod.js';
+import { NodeCodeBlock } from '../../extension-basic-editor/src/NodeCodeBlock.js';
+import { codeJarBlockNodeView } from './codeJarBlockNodeView.js';
+export const codeJarBlockKey = new PluginKey('code-jar-block');
+function arrowHandler(dir) {
+    return (state, dispatch, view) => {
+        if (state.selection.empty && view.endOfTextblock(dir)) {
+            let side = dir == 'left' || dir == 'up' ? -1 : 1;
+            let $head = state.selection.$head;
+            let nextPos = Selection.near(state.doc.resolve(side > 0 ? $head.after() : $head.before()), side);
+            if (nextPos.$head && nextPos.$head.parent.type.name == 'code_block') {
+                dispatch(state.tr.setSelection(nextPos));
+                return true;
+            }
+        }
+        return false;
+    };
+}
+export class NodeCodeJar extends NodeCodeBlock {
+    constructor(config) {
+        super(config);
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+    }
+    getCommandFactories(editor, type) {
+        return {
+            'setCodeBlock': (lang) => editor.commandFactories.setBlockType(type, { lang }),
+            // ArrowLeft: () => arrowHandler('left'),
+            // ArrowRight: () => arrowHandler('right'),
+            // ArrowUp: () => arrowHandler('up'),
+            // ArrowDown: () => arrowHandler('down'),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Shift-Ctrl-"': 'setCodeBlock',
+            'ArrowLeft': 'ArrowLeft',
+            'ArrowRight': 'ArrowRight',
+            'ArrowUp': 'ArrowUp',
+            'ArrowDown': 'ArrowDown',
+        };
+    }
+    getProseMirrorPlugins() {
+        const shadowRoot = getShadowRoot(this.editor.config.element);
+        const settings = {
+            languageWhitelist: this.config.languageWhitelist || getLangsList(),
+            shadowRoot,
+            // ...defaultSettings,
+            readOnly: this.config.readOnly,
+            // languageLoaders: { ...languageLoaders, ...legacyLanguageLoaders },
+            undo: () => {
+                this.editor.chain().undo().run();
+            },
+            redo: () => {
+                this.editor.chain().redo().run();
+            },
+            // theme: [...(this.config.theme || [])],
+        };
+        return [
+            new Plugin({
+                key: codeJarBlockKey,
+                props: {
+                    nodeViews: {
+                        [this.name]: codeJarBlockNodeView(settings, this.editor),
+                    },
+                },
+            }),
+        ];
+    }
+}

package/esm/extension-codejar/src/TreeSitterHighlighter.d.ts

@@ -0,0 +1,10 @@
+import { Parser } from '../../tree-sitter-shim/src/tree_sitter/parser.js';
+import { Decorator } from './Decorator.js';
+export declare class TreeSitterHighlighter {
+    parser: Parser | undefined;
+    hightligtScm: string | undefined;
+    cdnUrl?: string | undefined;
+    init(lang: string): Promise<boolean>;
+    highlight(code: string, decorator: Decorator): string;
+}
+//# sourceMappingURL=TreeSitterHighlighter.d.ts.map

package/esm/extension-codejar/src/TreeSitterHighlighter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeSitterHighlighter.d.ts","sourceRoot":"","sources":["../../../src/extension-codejar/src/TreeSitterHighlighter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,kDAAkD,CAAC;AAS1E,OAAO,EAAoB,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE7D,qBAAa,qBAAqB;IAChC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,MAAM,CAAC,qBAAiC;IAElC,IAAI,CAAC,IAAI,EAAE,MAAM;IA+BvB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS;CAmC7C"}

package/esm/extension-codejar/src/TreeSitterHighlighter.js

@@ -0,0 +1,76 @@
+import { Parser } from '../../tree-sitter-shim/src/tree_sitter/parser.js';
+import { Language } from '../../tree-sitter-shim/src/tree_sitter/language.js';
+import { fetchTextResource, fetchWasm, getLangTreeSitter, } from '../../wasm/src/mod.js';
+export class TreeSitterHighlighter {
+    constructor() {
+        Object.defineProperty(this, "parser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hightligtScm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cdnUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'http://localhost:8000/wasm/'
+        });
+    }
+    async init(lang) {
+        const treeSitterConfig = getLangTreeSitter(lang, this.cdnUrl);
+        const wasmUrl = treeSitterConfig.files[0]; // TODO add support for split parsers like markdown
+        const highlightUrl = treeSitterConfig.queries['highlights.scm'];
+        try {
+            const wasm = await fetchWasm(wasmUrl);
+            await Parser.init();
+            const Lang = await Language.load(wasm);
+            this.parser = new Parser();
+            this.parser.setLanguage(Lang);
+            // this.parser = await createParser(wasm);
+            this.hightligtScm = await fetchTextResource(highlightUrl);
+        }
+        catch (err) {
+            console.error('Error init highlight for: ' + lang, err);
+        }
+        if (!this.parser) {
+            console.warn('Parser not inited');
+            return false;
+        }
+        if (!this.hightligtScm) {
+            console.warn('hightligtScm not inited');
+            return false;
+        }
+        return true;
+    }
+    highlight(code, decorator) {
+        if (!this.parser || !this.hightligtScm) {
+            return decorator.highlight(code);
+        }
+        const tree = this.parser.parse(code);
+        const root = tree.rootNode;
+        const highlightsQuery = root.query(this.hightligtScm);
+        const captures = [];
+        for (const item of highlightsQuery) {
+            captures.push(...item.captures);
+        }
+        const decorations = [];
+        for (const capture of captures) {
+            const { node, name } = capture; // name is the capture like "@string"
+            const startIndex = node.startIndex;
+            const endIndex = node.endIndex;
+            decorations.push({
+                startIndex,
+                endIndex,
+                className: 'ts-' + name,
+            });
+        }
+        decorator.decorationGroups['highlight'] = decorations;
+        return decorator.highlight(code);
+    }
+}

package/esm/extension-codejar/src/codeJarBlockNodeView.d.ts

@@ -0,0 +1,6 @@
+import { Node } from 'prosemirror-model';
+import { Decoration, DecorationSource, EditorView, NodeView } from 'prosemirror-view';
+import { CoreEditor } from '../../editor/src/mod.js';
+import { NodeCodeJarConfig } from './NodeCodeJar.js';
+export declare const codeJarBlockNodeView: (settings: NodeCodeJarConfig, editor: CoreEditor) => (node: Node, view: EditorView, getPos: () => number | undefined, decorations: readonly Decoration[], innerDecorations: DecorationSource) => NodeView;
+//# sourceMappingURL=codeJarBlockNodeView.d.ts.map

package/esm/extension-codejar/src/codeJarBlockNodeView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeJarBlockNodeView.d.ts","sourceRoot":"","sources":["../../../src/extension-codejar/src/codeJarBlockNodeView.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,UAAU,EAEV,QAAQ,EACT,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,UAAU,EAAiB,MAAM,yBAAyB,CAAC;AAcpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAgUrD,eAAO,MAAM,oBAAoB,EAAE,CACjC,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,UAAU,KACf,CACH,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,MAAM,GAAG,SAAS,EAChC,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,gBAAgB,EAAE,gBAAgB,KAC/B,QAgBJ,CAAC"}

package/esm/extension-codejar/src/codeJarBlockNodeView.js

@@ -0,0 +1,335 @@
+import { PositionMapper } from '../../extension-markdown/src/PositionMapper.js';
+import { toRawTextResult } from '../../editor/src/utilities/mod.js';
+import { CodeJar } from './CodeJar.js';
+import { computeChange, forwardSelection, valueChanged } from './utils.js';
+import { TreeSitterHighlighter } from './TreeSitterHighlighter.js';
+import { Decorator } from './Decorator.js';
+import { initLineNumbers, lineNumberOptions, refreshNumbers, } from './codeJarLineNumbers.js';
+class CodeJarBlockNodeView {
+    constructor(node, view, getPos, config, editor) {
+        Object.defineProperty(this, "node", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: node
+        });
+        Object.defineProperty(this, "view", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: view
+        });
+        Object.defineProperty(this, "getPos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getPos
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: editor
+        });
+        Object.defineProperty(this, "dom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codeJar", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "updating", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "element", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "highlighter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "decorator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "languageDropDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lineNumbers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensionLsp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lang", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'plaintext'
+        });
+        Object.defineProperty(this, "uri", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'file:///' + Math.random() + '.ts'
+        });
+        Object.defineProperty(this, "diagListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.updating = false;
+        const dom = document.createElement('div');
+        this.dom = dom;
+        dom.className = 'codejar-root';
+        this.languageDropDown = this.addLanguageDropDown();
+        const root = (editor.view && 'root' in editor.view)
+            ? editor.view.root
+            : document || document;
+        this.element = document.createElement('div');
+        this.element.classList.add('codejar');
+        this.codeJar = new CodeJar(this.element, (element) => this.highlight(element), {
+            tab: '  ',
+            indentOn: new RegExp('^(?!)'),
+            moveToNewLine: new RegExp('^(?!)'),
+            history: false,
+        });
+        this.codeJar.onUpdate(() => {
+            if (!this.updating) {
+                const textUpdate = this.codeJar.toString();
+                valueChanged(textUpdate, this.node, getPos, view);
+                if (document.activeElement === this.element) {
+                    forwardSelection(this.codeJar, view, getPos);
+                }
+            }
+            const client = this.extensionLsp?.getClient(this.lang);
+            if (client) {
+                client.workspace.changedFile(this.uri);
+            }
+        });
+        this.highlighter = new TreeSitterHighlighter();
+        this.highlighter.cdnUrl = this.editor.config.cdnUrl;
+        this.decorator = new Decorator();
+        dom.append(this.element);
+        this.lineNumbers = initLineNumbers(this.element, lineNumberOptions);
+        this.source = {
+            ui: this.editor.ui,
+            getMappedContent: () => {
+                const editor = this.editor;
+                const result = toRawTextResult(this.codeJar.toString(), 0);
+                const mapper = new PositionMapper(editor, result.rawTextMap);
+                return {
+                    ...result,
+                    mapper,
+                };
+            },
+        };
+        this.extensionLsp = editor.getExtension('lsp');
+        let lastDiag = 0;
+        this.diagListener = (event) => {
+            const detail = event.detail;
+            if (detail.params.uri !== this.uri) {
+                return;
+            }
+            event.preventDefault();
+            lastDiag = +Date();
+            const client = this.extensionLsp?.getClient(this.lang);
+            if (client) {
+                const file = client.workspace.getFile(this.uri);
+                if (file) {
+                    const { mapper } = file;
+                    console.log({
+                        diagnostics: detail.params.diagnostics,
+                        mapper,
+                    });
+                    const diagnostics = detail.params.diagnostics;
+                    const decors = [];
+                    for (const diag of diagnostics) {
+                        const startIndex = mapper.fromLineChar(diag.range.start.line, diag.range.start.character);
+                        const endIndex = mapper.fromLineChar(diag.range.end.line, diag.range.end.character);
+                        decors.push({
+                            startIndex,
+                            endIndex,
+                            className: 'kb-lsp__error',
+                            title: diag.message || '',
+                        });
+                    }
+                    this.decorator.decorationGroups.innerDiag = decors;
+                    this.highlight(this.element);
+                }
+            }
+        };
+    }
+    addLanguageDropDown() {
+        const select = document.createElement('select');
+        select.classList.add('codejar-select');
+        for (const lang of [''].concat(this.config.languageWhitelist || [])) {
+            const option = document.createElement('option');
+            option.value = lang;
+            option.innerText = lang;
+            select.appendChild(option);
+        }
+        this.dom.appendChild(select);
+        select.addEventListener('change', async () => {
+            const lang = select.value;
+            const pos = this.getPos();
+            if (pos) {
+                this.view.dispatch(this.view.state.tr.setNodeMarkup(pos, undefined, {
+                    ...this.node.attrs,
+                    lang,
+                }));
+            }
+            await this.setLang(lang);
+        });
+        return select;
+    }
+    async setLang(lang) {
+        await this.highlighter.init(this.node.attrs.lang);
+        this.languageDropDown.value = this.node.attrs.lang || '';
+        this.highlight(this.element);
+        this.lang = lang;
+        const client = this.extensionLsp?.getClient(this.lang);
+        if (client) {
+            client.addEventListener('textDocument/publishDiagnostics', this.diagListener);
+            client.connect(this.uri, this.source);
+            client.workspace.openFile(this.uri, lang, this.source);
+        }
+    }
+    async init() {
+        this.codeJar.updateCode(this.node.textContent, false);
+        if (this.node.attrs.lang) {
+            await this.setLang(this.node.attrs.lang);
+        }
+    }
+    setSelection(anchor, head) {
+        this.element.focus();
+        this.updating = true;
+        const pos = this.getPos();
+        if (pos) {
+            anchor -= pos;
+            head -= pos;
+            const posJar = {
+                start: Math.min(anchor, head),
+                end: Math.max(anchor, head),
+                dir: (anchor <= head) ? '->' : '<-',
+            };
+            this.codeJar.restore(posJar);
+        }
+        this.updating = false;
+    }
+    highlight(editor) {
+        // const highlight = withLineNumbers((element) => this.highlight(element));
+        if (!this.highlighter) {
+            editor.innerHTML = editor.textContent;
+        }
+        else {
+            const content = editor.textContent;
+            editor.innerHTML = this.highlighter.highlight(content, this.decorator) ||
+                content;
+        }
+        refreshNumbers(this.lineNumbers, editor);
+    }
+    update(updateNode, _decorations, innerDecorations) {
+        const codeDecorations = [];
+        innerDecorations
+            .forEachSet((set) => set.find()
+            .map((d) => {
+            codeDecorations.push(d);
+        }));
+        const decors = [];
+        for (const cd of codeDecorations) {
+            if ('type' in cd) {
+                const type = cd.type;
+                decors.push({
+                    startIndex: cd.from,
+                    endIndex: cd.to,
+                    className: type?.attrs?.class || '',
+                    title: type?.attrs?.title || '',
+                });
+            }
+        }
+        this.decorator.decorationGroups.diag = decors;
+        const oldNode = this.node;
+        const content = this.codeJar.toString();
+        const change = computeChange(content, updateNode.textContent);
+        if (change) {
+            const pos = this.codeJar.save();
+            this.updating = true;
+            this.codeJar.updateCode(updateNode.textContent, true);
+            this.updating = false;
+            // TODO fix for yjs collab
+            // change.from, change.to, change.text.length
+            this.codeJar.restore(pos);
+        }
+        this.node = updateNode;
+        if (updateNode.attrs.lang !== oldNode.attrs.lang) {
+            this.setLang(updateNode.attrs.lang);
+        }
+        return true;
+    }
+    selectNode() {
+        this.element.focus();
+    }
+    stopEvent(_e) {
+        return true;
+    }
+    ignoreMutation() {
+        return true;
+    }
+    destroy() {
+        const client = this.extensionLsp?.getClient(this.lang);
+        if (client) {
+            if (this.uri) {
+                client.disconnect(this.uri);
+            }
+            if (this.diagListener) {
+                client.removeEventListener('textDocument/publishDiagnostics', this.diagListener);
+            }
+        }
+        this.codeJar.destroy();
+    }
+}
+export const codeJarBlockNodeView = (settings, editor) => {
+    return (pmNode, view, getPos) => {
+        const plugin = new CodeJarBlockNodeView(pmNode, view, getPos, settings, editor);
+        plugin.init();
+        return plugin;
+    };
+};

package/esm/extension-codejar/src/codeJarLineNumbers.d.ts

@@ -0,0 +1,13 @@
+type Options = {
+    class: string;
+    wrapClass: string;
+    width: string;
+    backgroundColor: string;
+    color: string;
+};
+export declare const lineNumberOptions: Options;
+export declare function withLineNumbers(highlight: (e: HTMLElement) => void, options?: Partial<Options>): (editor: HTMLElement) => void;
+export declare function refreshNumbers(lineNumbers: HTMLElement, editor: HTMLElement): void;
+export declare function initLineNumbers(editor: HTMLElement, opts: Options): HTMLElement;
+export {};
+//# sourceMappingURL=codeJarLineNumbers.d.ts.map

package/esm/extension-codejar/src/codeJarLineNumbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeJarLineNumbers.d.ts","sourceRoot":"","sources":["../../../src/extension-codejar/src/codeJarLineNumbers.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,OAM/B,CAAC;AAEF,wBAAgB,eAAe,CAC7B,SAAS,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,EACnC,OAAO,GAAE,OAAO,CAAC,OAAO,CAAM,IAGb,QAAQ,WAAW,UAwBrC;AAED,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,WAAW,QAapB;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,OAAO,GACZ,WAAW,CA0Db"}