@kerebron/editor-kits 0.4.1

package/esm/extension-menu-legacy/src/prompt.js

@@ -0,0 +1,158 @@
+const CSS_PREFIX = 'kb-prompt';
+export function openPrompt(options) {
+    let wrapper = document.body.appendChild(document.createElement('div'));
+    wrapper.className = CSS_PREFIX;
+    let mouseOutside = (e) => {
+        if (!wrapper.contains(e.target))
+            close();
+    };
+    setTimeout(() => globalThis.addEventListener('mousedown', mouseOutside), 50);
+    let close = () => {
+        globalThis.removeEventListener('mousedown', mouseOutside);
+        if (wrapper.parentNode)
+            wrapper.parentNode.removeChild(wrapper);
+    };
+    let domFields = [];
+    for (let name in options.fields) {
+        domFields.push(options.fields[name].render());
+    }
+    let submitButton = document.createElement('button');
+    submitButton.type = 'submit';
+    submitButton.className = CSS_PREFIX + '--submit';
+    submitButton.textContent = 'OK';
+    let cancelButton = document.createElement('button');
+    cancelButton.type = 'button';
+    cancelButton.className = CSS_PREFIX + '--cancel';
+    cancelButton.textContent = 'Cancel';
+    cancelButton.addEventListener('click', close);
+    let form = wrapper.appendChild(document.createElement('form'));
+    if (options.title) {
+        form.appendChild(document.createElement('h5')).textContent = options.title;
+    }
+    domFields.forEach((field) => {
+        form.appendChild(document.createElement('div')).appendChild(field);
+    });
+    let buttons = form.appendChild(document.createElement('div'));
+    buttons.className = CSS_PREFIX + '__buttons';
+    buttons.appendChild(submitButton);
+    buttons.appendChild(document.createTextNode(' '));
+    buttons.appendChild(cancelButton);
+    let box = wrapper.getBoundingClientRect();
+    wrapper.style.top = ((globalThis.innerHeight - box.height) / 2) + 'px';
+    wrapper.style.left = ((globalThis.innerWidth - box.width) / 2) + 'px';
+    let submit = () => {
+        let params = getValues(options.fields, domFields);
+        if (params) {
+            close();
+            options.callback(params);
+        }
+    };
+    form.addEventListener('submit', (e) => {
+        e.preventDefault();
+        submit();
+    });
+    form.addEventListener('keydown', (e) => {
+        if (e.keyCode == 27) {
+            e.preventDefault();
+            close();
+        }
+        else if (e.keyCode == 13 && !(e.ctrlKey || e.metaKey || e.shiftKey)) {
+            e.preventDefault();
+            submit();
+        }
+        else if (e.keyCode == 9) {
+            globalThis.setTimeout(() => {
+                if (!wrapper.contains(document.activeElement))
+                    close();
+            }, 500);
+        }
+    });
+    let input = form.elements[0];
+    if (input)
+        input.focus();
+}
+function getValues(fields, domFields) {
+    let result = Object.create(null), i = 0;
+    for (let name in fields) {
+        let field = fields[name], dom = domFields[i++];
+        let value = field.read(dom), bad = field.validate(value);
+        if (bad) {
+            reportInvalid(dom, bad);
+            return null;
+        }
+        result[name] = field.clean(value);
+    }
+    return result;
+}
+function reportInvalid(dom, message) {
+    // FIXME this is awful and needs a lot more work
+    let parent = dom.parentNode;
+    let msg = parent.appendChild(document.createElement('div'));
+    msg.style.left = (dom.offsetLeft + dom.offsetWidth + 2) + 'px';
+    msg.style.top = (dom.offsetTop - 5) + 'px';
+    msg.className = 'kb-invalid';
+    msg.textContent = message;
+    setTimeout(() => parent.removeChild(msg), 1500);
+}
+/// The type of field that `openPrompt` expects to be passed to it.
+export class Field {
+    /// Create a field with the given options. Options support by all
+    /// field types are:
+    constructor(
+    /// @internal
+    options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+    }
+    /// Read the field's value from its DOM node.
+    read(dom) {
+        return dom.value;
+    }
+    /// A field-type-specific validation function.
+    validateType(value) {
+        return null;
+    }
+    /// @internal
+    validate(value) {
+        if (!value && this.options.required) {
+            return 'Required field';
+        }
+        return this.validateType(value) ||
+            (this.options.validate ? this.options.validate(value) : null);
+    }
+    clean(value) {
+        return this.options.clean ? this.options.clean(value) : value;
+    }
+}
+/// A field class for single-line text fields.
+export class TextField extends Field {
+    render() {
+        let input = document.createElement('input');
+        input.type = 'text';
+        input.placeholder = this.options.label;
+        input.value = this.options.value || '';
+        input.autocomplete = 'off';
+        return input;
+    }
+}
+/// A field class for dropdown fields based on a plain `<select>`
+/// tag. Expects an option `options`, which should be an array of
+/// `{value: string, label: string}` objects, or a function taking a
+/// `ProseMirror` instance and returning such an array.
+export class SelectField extends Field {
+    render() {
+        let select = document.createElement('select');
+        this.options.options
+            .forEach((o) => {
+            let opt = select.appendChild(document.createElement('option'));
+            opt.value = o.value;
+            opt.selected = o.value == this.options.value;
+            opt.label = o.label;
+        });
+        return select;
+    }
+}

package/esm/extension-odt/src/ExtensionOdt.d.ts

@@ -0,0 +1,11 @@
+import type { Schema } from 'prosemirror-model';
+import { type Converter, type CoreEditor, Extension } from '../../editor/src/mod.js';
+export interface OdtConfig {
+    linkFromRewriter?(href: string): string;
+}
+export declare class ExtensionOdt extends Extension {
+    name: string;
+    constructor(config?: OdtConfig);
+    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
+}
+//# sourceMappingURL=ExtensionOdt.d.ts.map

package/esm/extension-odt/src/ExtensionOdt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionOdt.d.ts","sourceRoot":"","sources":["../../../src/extension-odt/src/ExtensionOdt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAMrF,MAAM,WAAW,SAAS;IACxB,gBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACzC;AAED,qBAAa,YAAa,SAAQ,SAAS;IACzC,IAAI,SAAS;gBAED,MAAM,GAAE,SAAc;IAIzB,aAAa,CACpB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;CAiD7B"}

package/esm/extension-odt/src/ExtensionOdt.js

@@ -0,0 +1,51 @@
+import { Extension } from '../../editor/src/mod.js';
+import { parse_content, parse_styles, unzip } from '@kerebron/odt-wasm';
+import { OdtParser } from './OdtParser.js';
+import { getDefaultsPostProcessFilters } from './postprocess/postProcess.js';
+export class ExtensionOdt extends Extension {
+    constructor(config = {}) {
+        super(config);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'odt'
+        });
+    }
+    getConverters(editor, schema) {
+        const config = this.config;
+        const odtConverter = {
+            fromDoc: async (document) => {
+                throw new Error('Not implemented');
+            },
+            toDoc: async (buffer) => {
+                const doc = await odtConverter.odtToJson(buffer);
+                const filterCommands = getDefaultsPostProcessFilters();
+                if (filterCommands.length > 0) {
+                    const subEditor = editor.clone();
+                    subEditor.setDocument(doc.toJSON());
+                    for (const filter of filterCommands) {
+                        filter(subEditor.state, (tr) => subEditor.dispatchTransaction(tr));
+                    }
+                    return subEditor.getDocument();
+                }
+                return doc;
+            },
+            odtToJson: async (buffer) => {
+                const files = unzip(buffer);
+                const filesMap = {};
+                for (const k of files.keys()) {
+                    filesMap[k] = Uint8Array.from(files.get(k));
+                }
+                const stylesTree = parse_styles(files.get('styles.xml'));
+                const contentTree = parse_content(files.get('content.xml'));
+                const parser = new OdtParser(editor.schema, config);
+                const doc = parser.parse({ ...filesMap, contentTree, stylesTree });
+                return doc;
+            },
+        };
+        return {
+            'application/vnd.oasis.opendocument.text': odtConverter,
+        };
+    }
+}

package/esm/extension-odt/src/OdtParser.d.ts

@@ -0,0 +1,70 @@
+import { Mark, Node, Schema } from 'prosemirror-model';
+import { ListTracker } from './lists.js';
+export interface OdtElement {
+    $value: 'TODO';
+}
+export type NodeHandler = (ctx: OdtStashContext, value: any) => void;
+interface ListStyle {
+    '@name': string;
+}
+interface Style {
+    '@name': string;
+    '@parent-style-name'?: string;
+    styles: string[];
+}
+interface StylesTree {
+    styles: {
+        'list-style': Array<ListStyle>;
+        'style': Array<Style>;
+    };
+}
+interface AutomaticStyles {
+    'style': Array<Style>;
+}
+export declare function resolveStyle(stylesTree: StylesTree, automaticStyles: AutomaticStyles, name: string): Style;
+export interface TaggedEnum {
+    tag: string;
+    value: any;
+}
+export declare function tagEnum(item: any): {
+    tag: string;
+    value: unknown;
+};
+export declare function iterateChildren(nodes: unknown[], callback: (item: TaggedEnum) => void): void;
+export declare function iterateEnum($value: unknown[]): Array<TaggedEnum>;
+interface Config {
+    linkFromRewriter?(href: string): string;
+}
+export interface OdtContext {
+    handlers: Record<string, NodeHandler>;
+    content: Node[];
+    marks: Mark[];
+    meta: Record<string, any>;
+}
+export declare class OdtStashContext {
+    readonly schema: Schema;
+    readonly stylesTree: StylesTree;
+    readonly automaticStyles: AutomaticStyles;
+    private ctxStash;
+    private currentCtx;
+    listTracker: ListTracker;
+    constructor(schema: Schema, handlers: Record<string, NodeHandler>, stylesTree: StylesTree, automaticStyles: AutomaticStyles);
+    stash(): number;
+    unstash(): void;
+    openNode(): void;
+    closeNode(type: string, attrs?: {}, marks?: readonly Mark[]): Node;
+    private createNode;
+    createText(text: string): Node | undefined;
+    styleToMarks(style: Style): Mark[];
+    handle(nodeType: string, value: any): void;
+    getElementStyle(element: any): Style;
+    get current(): OdtContext;
+}
+export declare class OdtParser {
+    private readonly schema;
+    private readonly config;
+    constructor(schema: Schema, config?: Config);
+    parse(files: any): Node;
+}
+export {};
+//# sourceMappingURL=OdtParser.d.ts.map

package/esm/extension-odt/src/OdtParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OdtParser.d.ts","sourceRoot":"","sources":["../../../src/extension-odt/src/OdtParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAOvD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIzC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;AAErE,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,KAAK;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,UAAU,UAAU;IAClB,MAAM,EAAE;QACN,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QAC/B,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;KACvB,CAAC;CACH;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;CACvB;AAED,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE,MAAM,GACX,KAAK,CA4CP;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,GAAG,CAAC;CACZ;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,GAAG;;;EAkBhC;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EAAE,EAChB,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,QAWrC;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC,CAKhE;AAED,UAAU,MAAM;IACd,gBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACzC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACtC,OAAO,EAAE,IAAI,EAAE,CAAC;IAChB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC3B;AAED,qBAAa,eAAe;IAMxB,QAAQ,CAAC,MAAM,EAAE,MAAM;IAEvB,QAAQ,CAAC,UAAU,EAAE,UAAU;IAC/B,QAAQ,CAAC,eAAe,EAAE,eAAe;IAR3C,OAAO,CAAC,QAAQ,CAAyB;IACzC,OAAO,CAAC,UAAU,CAAa;IACxB,WAAW,cAAqB;gBAG5B,MAAM,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAC5B,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,eAAe;IAWpC,KAAK,IAAI,MAAM;IAsBf,OAAO;IAQP,QAAQ;IAKR,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,KAAK,kBAAY;IAS5D,OAAO,CAAC,UAAU;IAYlB,UAAU,CAAC,IAAI,EAAE,MAAM;IAKhB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE;IAqBlC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAWnC,eAAe,CAAC,OAAO,EAAE,GAAG,GAAG,KAAK;IAY3C,IAAI,OAAO,eAEV;CACF;AAED,qBAAa,SAAS;IAElB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAAW;IAGtC,KAAK,CAAC,KAAK,EAAE,GAAG;CAoEjB"}

package/esm/extension-odt/src/OdtParser.js

@@ -0,0 +1,285 @@
+import { Mark } from 'prosemirror-model';
+import { getBasicNodesHandlers, getInlineNodesHandlers, } from './node_handlers/basic_node_handlers.js';
+import { getListNodesHandlers } from './node_handlers/list_node_handlers.js';
+import { getTableNodesHandlers } from './node_handlers/table_node_handlers.js';
+import { ListTracker } from './lists.js';
+const COURIER_FONTS = ['Courier New', 'Courier', 'Roboto Mono'];
+export function resolveStyle(stylesTree, automaticStyles, name) {
+    let style;
+    if (!style) {
+        style = stylesTree.styles['list-style'].find((item) => item['@name'] === name);
+    }
+    if (!style) {
+        style = stylesTree.styles['style'].find((item) => item['@name'] === name);
+    }
+    if (!style) {
+        style = automaticStyles.style.find((item) => item['@name'] === name);
+    }
+    if (!style) {
+        style = {
+            '@name': name,
+        };
+    }
+    style['styles'] = [name];
+    if (style['@parent-style-name']) {
+        const parentStyle = resolveStyle(stylesTree, automaticStyles, style['@parent-style-name']);
+        if (parentStyle) {
+            const styles = [...style['styles'], ...parentStyle['styles']];
+            for (const key in style) {
+                if (typeof style[key] === 'undefined') {
+                    delete style[key];
+                }
+            }
+            style = {
+                ...parentStyle,
+                ...style,
+                styles,
+            };
+        }
+    }
+    return style;
+}
+export function tagEnum(item) {
+    if ('string' === typeof item) {
+        return {
+            tag: item, // '$text',
+            value: item,
+        };
+    }
+    if ('object' === typeof item) {
+        const entries = Object.entries(item);
+        if (entries.length === 1) {
+            return {
+                tag: entries[0][0],
+                value: entries[0][1],
+            };
+        }
+    }
+    throw new Error('Incorrect enum: ' + JSON.stringify(item));
+}
+export function iterateChildren(nodes, callback) {
+    for (const child of nodes) {
+        if ('Unknown' === child) {
+            continue;
+        }
+        const item = tagEnum(child);
+        callback(item);
+    }
+}
+export function iterateEnum($value) {
+    if (!$value) {
+        return [];
+    }
+    return $value.map(tagEnum);
+}
+export class OdtStashContext {
+    constructor(schema, handlers, stylesTree, automaticStyles) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "stylesTree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: stylesTree
+        });
+        Object.defineProperty(this, "automaticStyles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: automaticStyles
+        });
+        Object.defineProperty(this, "ctxStash", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "currentCtx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listTracker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new ListTracker()
+        });
+        this.currentCtx = {
+            handlers,
+            content: [],
+            marks: [],
+            meta: {},
+        };
+        this.stash();
+    }
+    stash() {
+        this.ctxStash.push(this.currentCtx);
+        const funcs = {};
+        const handlers = { ...this.currentCtx.handlers };
+        const content = this.currentCtx.content;
+        const marks = this.currentCtx.marks;
+        this.currentCtx = {
+            ...structuredClone({
+                ...this.currentCtx,
+                content: undefined,
+                marks: undefined,
+                handlers: undefined,
+            }),
+            ...funcs,
+            content,
+            marks,
+            handlers,
+        };
+        return this.ctxStash.length - 1;
+    }
+    unstash() {
+        const ctx = this.ctxStash.pop();
+        if (!ctx) {
+            throw new Error('Unstash failed');
+        }
+        this.currentCtx = ctx;
+    }
+    openNode() {
+        this.stash();
+        this.current.content = [];
+    }
+    closeNode(type, attrs = {}, marks = Mark.none) {
+        const node = this.createNode(type, attrs, marks);
+        this.unstash();
+        if (node) {
+            this.current.content.push(node);
+        }
+        return node;
+    }
+    createNode(type, attrs = {}, marks = Mark.none) {
+        const nodeType = this.schema.nodes[type];
+        if (!nodeType) {
+            throw new Error('Invalid node type: ' + type);
+        }
+        const node = nodeType.createAndFill(attrs, this.current.content, marks);
+        if (!node) {
+            throw new Error('Error creating node: ' + type);
+        }
+        return node;
+    }
+    createText(text) {
+        if (!text)
+            return;
+        return this.schema.text(text, this.current.marks);
+    }
+    styleToMarks(style) {
+        const marks = [];
+        const textProperties = style && style['text-properties'] || {};
+        if (COURIER_FONTS.indexOf(textProperties['@font-name'] || '') > -1) {
+            const markType = this.schema.mark('code');
+            marks.push(markType);
+        }
+        if (textProperties['@font-style'] === 'italic') {
+            const markType = this.schema.mark('em');
+            marks.push(markType);
+        }
+        if (textProperties['@font-weight'] === 'bold') {
+            const markType = this.schema.mark('strong');
+            marks.push(markType);
+        }
+        return marks;
+    }
+    handle(nodeType, value) {
+        if (!this.current.handlers[nodeType]) {
+            throw new Error('No handler for node: ' + nodeType);
+        }
+        if ('function' !== typeof this.current.handlers[nodeType]) {
+            throw new Error('Invalid handler for node: ' + nodeType);
+        }
+        this.current.handlers[nodeType](this, value);
+    }
+    getElementStyle(element) {
+        const style = ('object' === typeof element && element['@style-name'])
+            ? resolveStyle(this.stylesTree, this.automaticStyles, element['@style-name'])
+            : {};
+        return style;
+    }
+    get current() {
+        return this.currentCtx;
+    }
+}
+export class OdtParser {
+    constructor(schema, config = {}) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+    }
+    parse(files) {
+        const contentTree = files.contentTree;
+        const stylesTree = files.stylesTree;
+        const handlers = {
+            ...getInlineNodesHandlers(),
+            ...getBasicNodesHandlers(),
+            ...getListNodesHandlers(),
+            ...getTableNodesHandlers(),
+            'change-start': {
+            // custom(state) {
+            //   state.textMarks.add({
+            //     markName: 'change',
+            //     markAttributes: {},
+            //   });
+            // },
+            },
+            'change-end': {
+            // custom(state) {
+            //   state.textMarks.forEach((x) =>
+            //     x.markName === 'change' ? state.textMarks.delete(x) : x
+            //   );
+            // },
+            },
+            'frame': (ctx, odtElement) => {
+                if (odtElement.object && odtElement.object['@href']) {
+                    const fullPath = odtElement.object['@href'].replace(/^\.\//, '') +
+                        '/content.xml';
+                    if (files[fullPath]) {
+                        const content = new TextDecoder().decode(files[fullPath]);
+                        ctx.openNode();
+                        ctx.closeNode('math', {
+                            type: 'mathml',
+                            content,
+                        });
+                        return;
+                    }
+                }
+                if (odtElement.image && odtElement.image['@href']) { // TODO links rewrite
+                    const alt = odtElement.description?.value || '';
+                    ctx.openNode();
+                    ctx.closeNode('image', {
+                        src: odtElement.image['@href'],
+                        alt,
+                    });
+                }
+            },
+            'rect': () => {
+                // ignore: true,
+            },
+            'annotation': () => {
+                // ignore: true,
+            },
+        };
+        const ctx = new OdtStashContext(this.schema, handlers, stylesTree, contentTree['automatic-styles']);
+        ctx.openNode();
+        ctx.handle('body', contentTree.body);
+        return ctx.closeNode('doc');
+    }
+}

package/esm/extension-odt/src/lists.d.ts

@@ -0,0 +1,23 @@
+import { OdtElement } from './OdtParser.js';
+export declare class ListNumbering {
+    levels: {
+        [level: number]: number;
+    };
+    levelNodes: {
+        [level: number]: Node;
+    };
+    constructor();
+    clearAbove(level: number): void;
+    setLevelNode(level: number, node: Node): void;
+}
+export interface List {
+    level: number;
+    odtElement: OdtElement;
+}
+export declare class ListTracker {
+    listStack: List[];
+    listNumberings: Map<string, ListNumbering>;
+    lastNumbering?: ListNumbering;
+    preserveMinLevel: number;
+}
+//# sourceMappingURL=lists.d.ts.map

package/esm/extension-odt/src/lists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lists.d.ts","sourceRoot":"","sources":["../../../src/extension-odt/src/lists.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5C,qBAAa,aAAa;IACxB,MAAM,EAAE;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAM;IACzC,UAAU,EAAE;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAM;;IAQ3C,UAAU,CAAC,KAAK,EAAE,MAAM;IAMxB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI;CAGvC;AAED,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,qBAAa,WAAW;IACtB,SAAS,EAAE,IAAI,EAAE,CAAM;IAEvB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAoC;IAC9E,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,gBAAgB,SAAO;CACxB"}

package/esm/extension-odt/src/lists.js

@@ -0,0 +1,55 @@
+export class ListNumbering {
+    constructor() {
+        Object.defineProperty(this, "levels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "levelNodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        for (let i = 0; i < 20; i++) {
+            this.levels[i] = 1;
+        }
+    }
+    clearAbove(level) {
+        for (let i = level + 1; i < 20; i++) {
+            this.levels[i] = 1;
+        }
+    }
+    setLevelNode(level, node) {
+        this.levelNodes[level] = node;
+    }
+}
+export class ListTracker {
+    constructor() {
+        Object.defineProperty(this, "listStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "listNumberings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "lastNumbering", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "preserveMinLevel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 999
+        });
+    }
+}

package/esm/extension-odt/src/node_handlers/basic_node_handlers.d.ts

@@ -0,0 +1,4 @@
+import { NodeHandler } from '../OdtParser.js';
+export declare function getInlineNodesHandlers(): Record<string, NodeHandler>;
+export declare function getBasicNodesHandlers(): Record<string, NodeHandler>;
+//# sourceMappingURL=basic_node_handlers.d.ts.map

package/esm/extension-odt/src/node_handlers/basic_node_handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic_node_handlers.d.ts","sourceRoot":"","sources":["../../../../src/extension-odt/src/node_handlers/basic_node_handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,WAAW,EAAmB,MAAM,iBAAiB,CAAC;AAEhF,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAiEpE;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CA2FnE"}