@kerebron/extension-odt 0.0.8

package/esm/editor/src/mod.d.ts

@@ -0,0 +1,5 @@
+export * from './CoreEditor.js';
+export * from './Extension.js';
+export * from './Mark.js';
+export * from './Node.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/editor/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/editor/src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}

package/esm/editor/src/mod.js

@@ -0,0 +1,4 @@
+export * from './CoreEditor.js';
+export * from './Extension.js';
+export * from './Mark.js';
+export * from './Node.js';

package/esm/editor/src/plugins/input-rules/InputRulesPlugin.d.ts

@@ -0,0 +1,23 @@
+import { Command, EditorState, Plugin, Transaction } from 'prosemirror-state';
+export declare class InputRule {
+    readonly match: RegExp;
+    handler: (state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null;
+    undoable: boolean;
+    inCode: boolean | 'only';
+    constructor(match: RegExp, handler: string | ((state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null), options?: {
+        undoable?: boolean;
+        inCode?: boolean | 'only';
+    });
+}
+type PluginState = {
+    transform: Transaction;
+    from: number;
+    to: number;
+    text: string;
+} | null;
+export declare class InputRulesPlugin extends Plugin<PluginState> {
+    constructor(rules: readonly InputRule[]);
+}
+export declare const undoInputRule: Command;
+export {};
+//# sourceMappingURL=InputRulesPlugin.d.ts.map

package/esm/editor/src/plugins/input-rules/InputRulesPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputRulesPlugin.d.ts","sourceRoot":"","sources":["../../../../../src/editor/src/plugins/input-rules/InputRulesPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,WAAW,EACX,MAAM,EAEN,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAO3B,qBAAa,SAAS;IA8BlB,QAAQ,CAAC,KAAK,EAAE,MAAM;IA5BxB,OAAO,EAAE,CACP,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,KACR,WAAW,GAAG,IAAI,CAAC;IAGxB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;gBAmBd,KAAK,EAAE,MAAM,EACtB,OAAO,EACH,MAAM,GACN,CAAC,CACD,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,KACR,WAAW,GAAG,IAAI,CAAC,EAC1B,OAAO,GAAE;QAIP,QAAQ,CAAC,EAAE,OAAO,CAAC;QAInB,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;KACtB;CAST;AA0BD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,WAAW,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,IAAI,CAAC;AAKT,qBAAa,gBAAiB,SAAQ,MAAM,CAAC,WAAW,CAAC;gBAC3C,KAAK,EAAE,SAAS,SAAS,EAAE;CAgCxC;AAsCD,eAAO,MAAM,aAAa,EAAE,OA4B3B,CAAC"}

package/esm/editor/src/plugins/input-rules/InputRulesPlugin.js

@@ -0,0 +1,163 @@
+import { Plugin, } from 'prosemirror-state';
+/// Input rules are regular expressions describing a piece of text
+/// that, when typed, causes something to happen. This might be
+/// changing two dashes into an emdash, wrapping a paragraph starting
+/// with `"> "` into a blockquote, or something entirely different.
+export class InputRule {
+    // :: (RegExp, union<string, (state: EditorState, match: [string], start: number, end: number) → ?Transaction>)
+    /// Create an input rule. The rule applies when the user typed
+    /// something and the text directly in front of the cursor matches
+    /// `match`, which should end with `$`.
+    ///
+    /// The `handler` can be a string, in which case the matched text, or
+    /// the first matched group in the regexp, is replaced by that
+    /// string.
+    ///
+    /// Or a it can be a function, which will be called with the match
+    /// array produced by
+    /// [`RegExp.exec`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec),
+    /// as well as the start and end of the matched range, and which can
+    /// return a [transaction](#state.Transaction) that describes the
+    /// rule's effect, or null to indicate the input was not handled.
+    constructor(
+    /// @internal
+    match, handler, options = {}) {
+        Object.defineProperty(this, "match", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: match
+        });
+        /// @internal
+        Object.defineProperty(this, "handler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /// @internal
+        Object.defineProperty(this, "undoable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.match = match;
+        this.handler = typeof handler == 'string'
+            ? stringHandler(handler)
+            : handler;
+        this.undoable = options.undoable !== false;
+        this.inCode = options.inCode || false;
+    }
+}
+function stringHandler(string) {
+    return function (state, match, start, end) {
+        let insert = string;
+        if (match[1]) {
+            let offset = match[0].lastIndexOf(match[1]);
+            insert += match[0].slice(offset + match[1].length);
+            start += offset;
+            let cutOff = start - end;
+            if (cutOff > 0) {
+                insert = match[0].slice(offset - cutOff, offset) + insert;
+                start = end;
+            }
+        }
+        return state.tr.insertText(insert, start, end);
+    };
+}
+const MAX_MATCH = 500;
+/// Create an input rules plugin. When enabled, it will cause text
+/// input that matches any of the given rules to trigger the rule's
+/// action.
+export class InputRulesPlugin extends Plugin {
+    constructor(rules) {
+        super({
+            state: {
+                init() {
+                    return null;
+                },
+                apply(tr, prev) {
+                    let stored = tr.getMeta(this);
+                    if (stored)
+                        return stored;
+                    return tr.selectionSet || tr.docChanged ? null : prev;
+                },
+            },
+            props: {
+                handleTextInput(view, from, to, text) {
+                    return run(view, from, to, text, rules, InputRulesPlugin);
+                },
+                handleDOMEvents: {
+                    compositionend: (view) => {
+                        setTimeout(() => {
+                            let { $cursor } = view.state.selection;
+                            if ($cursor) {
+                                run(view, $cursor.pos, $cursor.pos, '', rules, plugin);
+                            }
+                        });
+                    },
+                },
+            },
+            isInputRules: true,
+        });
+    }
+}
+function run(view, from, to, text, rules, plugin) {
+    if (view.composing)
+        return false;
+    let state = view.state, $from = state.doc.resolve(from);
+    let textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, '\ufffc') + text;
+    for (let i = 0; i < rules.length; i++) {
+        let rule = rules[i];
+        if ($from.parent.type.spec.code) {
+            if (!rule.inCode)
+                continue;
+        }
+        else if (rule.inCode === 'only') {
+            continue;
+        }
+        let match = rule.match.exec(textBefore);
+        let tr = match &&
+            rule.handler(state, match, from - (match[0].length - text.length), to);
+        if (!tr)
+            continue;
+        if (rule.undoable)
+            tr.setMeta(plugin, { transform: tr, from, to, text });
+        view.dispatch(tr);
+        return true;
+    }
+    return false;
+}
+/// This is a command that will undo an input rule, if applying such a
+/// rule was the last thing that the user did.
+export const undoInputRule = (state, dispatch) => {
+    let plugins = state.plugins;
+    for (let i = 0; i < plugins.length; i++) {
+        let plugin = plugins[i], undoable;
+        if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+            if (dispatch) {
+                let tr = state.tr, toUndo = undoable.transform;
+                for (let j = toUndo.steps.length - 1; j >= 0; j--) {
+                    tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+                }
+                if (undoable.text) {
+                    let marks = tr.doc.resolve(undoable.from).marks();
+                    tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+                }
+                else {
+                    tr.delete(undoable.from, undoable.to);
+                }
+                dispatch(tr);
+            }
+            return true;
+        }
+    }
+    return false;
+};

package/esm/editor/src/types.d.ts

@@ -0,0 +1,29 @@
+import type { ParseOptions } from 'prosemirror-model';
+import type { Extension } from './Extension.js';
+import type { Mark } from './Mark.js';
+import type { Node } from './Node.js';
+export type AnyExtension = (Extension | Node | Mark) & {
+    requires: Set<AnyExtension | string>;
+};
+export type Extensions = AnyExtension[];
+export type Content = JSONContent | JSONContent[] | null;
+export interface EditorOptions {
+    element: Element;
+    content: Content;
+    parseOptions: ParseOptions;
+    extensions: Extensions;
+    topNode?: string;
+}
+export type JSONContent = {
+    type?: string;
+    attrs?: Record<string, any>;
+    content?: JSONContent[];
+    marks?: {
+        type: string;
+        attrs?: Record<string, any>;
+        [key: string]: any;
+    }[];
+    text?: string;
+    [key: string]: any;
+};
+//# sourceMappingURL=types.d.ts.map

package/esm/editor/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/editor/src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,MAAM,YAAY,GAAG,CAAC,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG;IACrD,QAAQ,EAAE,GAAG,CAAC,YAAY,GAAG,MAAM,CAAC,CAAC;CACtC,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,YAAY,EAAE,CAAC;AAExC,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,WAAW,EAAE,GAAG,IAAI,CAAC;AAEzD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,EAAE,CAAC;IACJ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC"}

package/esm/editor/src/types.js

@@ -0,0 +1 @@
+export {};

package/esm/editor/src/utilities/createNodeFromContent.d.ts

@@ -0,0 +1,12 @@
+import { Fragment, Node as ProseMirrorNode, type ParseOptions, Schema } from 'prosemirror-model';
+import type { Content } from '../types.js';
+export type CreateNodeFromContentOptions = {
+    slice?: boolean;
+    parseOptions?: ParseOptions;
+    errorOnInvalidContent?: boolean;
+};
+export declare function elementFromString(value: string): HTMLElement;
+export declare function createNodeFromHTML(content: string, schema: Schema, options?: CreateNodeFromContentOptions): ProseMirrorNode | Fragment;
+export declare function createNodeFromObject(content: Content | ProseMirrorNode | Fragment, schema: Schema, options?: CreateNodeFromContentOptions): ProseMirrorNode | Fragment;
+export declare function createNodeFromContent(content: string | Content | ProseMirrorNode | Fragment, schema: Schema, options?: CreateNodeFromContentOptions): ProseMirrorNode | Fragment;
+//# sourceMappingURL=createNodeFromContent.d.ts.map

package/esm/editor/src/utilities/createNodeFromContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNodeFromContent.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/utilities/createNodeFromContent.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EACR,IAAI,IAAI,eAAe,EACvB,KAAK,YAAY,EACjB,MAAM,EACP,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,4BAA4B,GAAG;IACzC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAqBF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAQ5D;AAGD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,GAAG,QAAQ,CAiE5B;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,GAAG,eAAe,GAAG,QAAQ,EAC7C,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,GAAG,QAAQ,CAwC5B;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,eAAe,GAAG,QAAQ,EACtD,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,GAAG,QAAQ,CAiB5B"}

package/esm/editor/src/utilities/createNodeFromContent.js

@@ -0,0 +1,118 @@
+import { DOMParser, Fragment, Node as ProseMirrorNode, Schema, } from 'prosemirror-model';
+const removeWhitespaces = (node) => {
+    const children = node.childNodes;
+    for (let i = children.length - 1; i >= 0; i -= 1) {
+        const child = children[i];
+        if (child.nodeType === 3 && child.nodeValue &&
+            /^(\n\s\s|\n)$/.test(child.nodeValue)) {
+            node.removeChild(child);
+        }
+        else if (child.nodeType === 1) {
+            removeWhitespaces(child);
+        }
+    }
+    return node;
+};
+export function elementFromString(value) {
+    // add a wrapper to preserve leading and trailing whitespace
+    const wrappedValue = `<body>${value}</body>`;
+    const html = new globalThis.DOMParser().parseFromString(wrappedValue, 'text/html').body;
+    return removeWhitespaces(html);
+}
+// TODO: refactor to converters?
+export function createNodeFromHTML(content, schema, options) {
+    options = {
+        slice: true,
+        parseOptions: {},
+        ...options,
+    };
+    // Check for invalid content
+    if (options.errorOnInvalidContent) {
+        let hasInvalidContent = false;
+        let invalidContent = '';
+        // A copy of the current schema with a catch-all node at the end
+        const contentCheckSchema = new Schema({
+            topNode: schema.spec.topNode,
+            marks: schema.spec.marks,
+            // Prosemirror's schemas are executed such that: the last to execute, matches last
+            // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
+            nodes: schema.spec.nodes.append({
+                __unknown__catch__all__node: {
+                    content: 'inline*',
+                    group: 'block',
+                    parseDOM: [
+                        {
+                            tag: '*',
+                            getAttrs: (e) => {
+                                // If this is ever called, we know that the content has something that we don't know how to handle in the schema
+                                hasInvalidContent = true;
+                                // Try to stringify the element for a more helpful error message
+                                invalidContent = typeof e === 'string' ? e : e.outerHTML;
+                                return null;
+                            },
+                        },
+                    ],
+                },
+            }),
+        });
+        if (options.slice) {
+            DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
+        }
+        else {
+            DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
+        }
+        if (options.errorOnInvalidContent && hasInvalidContent) {
+            throw new Error('Invalid HTML content', {
+                cause: new Error(`Invalid element found: ${invalidContent}`),
+            });
+        }
+    }
+    const parser = DOMParser.fromSchema(schema);
+    if (options.slice) {
+        return parser.parseSlice(elementFromString(content), options.parseOptions)
+            .content;
+    }
+    return parser.parse(elementFromString(content), options.parseOptions);
+}
+export function createNodeFromObject(content, schema, options) {
+    options = {
+        slice: true,
+        parseOptions: {},
+        ...options,
+    };
+    try {
+        // if the JSON Content is an array of nodes, create a fragment for each node
+        if (Array.isArray(content) && content.length > 0) {
+            return Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
+        }
+        const node = schema.nodeFromJSON(content);
+        if (options.errorOnInvalidContent) {
+            node.check();
+        }
+        return node;
+    }
+    catch (error) {
+        if (options.errorOnInvalidContent) {
+            throw new Error('Invalid JSON content', {
+                cause: error,
+            });
+        }
+        console.warn('Invalid content.', 'Passed value:', content, 'Error:', error);
+        // TODO: refactor using EMPTY_DOC prop?
+        return createNodeFromHTML('', schema, options);
+    }
+}
+export function createNodeFromContent(content, schema, options) {
+    if (content instanceof ProseMirrorNode || content instanceof Fragment) {
+        return content;
+    }
+    const isJSONContent = typeof content === 'object' && content !== null;
+    const isTextContent = typeof content === 'string';
+    if (isJSONContent) {
+        createNodeFromObject(content, schema, options);
+    }
+    if (isTextContent) {
+        return createNodeFromHTML(content, schema, options);
+    }
+    return createNodeFromHTML('', schema, options);
+}

package/esm/editor/src/utilities/getHtmlAttributes.d.ts

@@ -0,0 +1,4 @@
+export declare function getHtmlAttributes(extension: any, node: any): {};
+export declare function setHtmlAttributes(extension: any, element: any): {};
+export declare function addAttributesToSchema(spec: any, extension: any): void;
+//# sourceMappingURL=getHtmlAttributes.d.ts.map

package/esm/editor/src/utilities/getHtmlAttributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHtmlAttributes.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/utilities/getHtmlAttributes.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,SAAS,KAAA,EAAE,IAAI,KAAA,MAkBhD;AAED,wBAAgB,iBAAiB,CAAC,SAAS,KAAA,EAAE,OAAO,KAAA,MAcnD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,KAAA,EAAE,SAAS,KAAA,QAcpD"}

package/esm/editor/src/utilities/getHtmlAttributes.js

@@ -0,0 +1,47 @@
+export function getHtmlAttributes(extension, node) {
+    const attrs = {};
+    if (extension.attributes) {
+        for (const [key, value] of Object.entries(extension.attributes)) {
+            if ('undefined' !== typeof node.attrs[key]) {
+                attrs[key] = node.attrs[key];
+            }
+            else {
+                if (value.toDom) {
+                    attrs[key] = value.toDom(node);
+                }
+                else {
+                    attrs[key] = value.default;
+                }
+            }
+        }
+    }
+    return attrs;
+}
+export function setHtmlAttributes(extension, element) {
+    const attrs = {};
+    if (extension.attributes) {
+        for (const [key, value] of Object.entries(extension.attributes)) {
+            if (value.fromDom) {
+                attrs[key] = value.fromDom(element);
+            }
+            else {
+                attrs[key] = value.default;
+            }
+        }
+    }
+    return attrs;
+}
+export function addAttributesToSchema(spec, extension) {
+    const attrs = {};
+    if (extension.attributes) {
+        if (!spec.attrs) {
+            spec.attrs = {};
+        }
+        for (const [key, value] of Object.entries(extension.attributes)) {
+            spec.attrs[key] = value;
+            if (!value.toDom) {
+                value.toDom = (node) => node.attrs[key];
+            }
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import { Schema } from 'prosemirror-model';
+import { type Converter, Extension } from '../../editor/src/mod.js';
+export declare class ExtensionOdt extends Extension {
+    name: string;
+    getConverters(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,EAAiB,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,KAAK,SAAS,EAAmB,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAMrF,qBAAa,YAAa,SAAQ,SAAS;IACzC,IAAI,SAAS;IAEb,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;CAsBzD"}

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

@@ -0,0 +1,32 @@
+import { Extension } from '../../editor/src/mod.js';
+import { parse_content, parse_styles, unzip } from '@kerebron/odt-wasm';
+import { OdtParser } from './OdtParser.js';
+export class ExtensionOdt extends Extension {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'odt'
+        });
+    }
+    getConverters(schema) {
+        return {
+            'application/vnd.oasis.opendocument.text': {
+                fromDoc(document) {
+                    throw new Error('Not implemented');
+                },
+                toDoc(content) {
+                    const files = unzip(content);
+                    const stylesTree = parse_styles(files.get('styles.xml'));
+                    const contentTree = parse_content(files.get('content.xml'));
+                    // console.log(JSON.stringify(stylesTree, null, 2).split('\n').slice(0, 20).join('\n'));
+                    // console.log(JSON.stringify(contentTree, null, 2).split('\n').slice(0, 20).join('\n'));
+                    const parser = new OdtParser(schema);
+                    return parser.parse({ ...files, contentTree, stylesTree });
+                },
+            },
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Attrs, Node, Schema } from 'prosemirror-model';
+interface OdtElement {
+}
+export interface ParseSpec {
+    node?: string;
+    children?: (node: OdtElement) => OdtElement[];
+    text?: (node: OdtElement) => string;
+    block?: string | ((node: OdtElement) => string);
+    mark?: string;
+    attrs?: Attrs | null;
+    getAttrs?: (token: OdtElement, style: Style) => Attrs | null;
+    ignore?: boolean;
+}
+interface Style {
+    '@name': string;
+}
+export declare class OdtParser {
+    private readonly schema;
+    constructor(schema: Schema);
+    parse(files: any): Node | null;
+}
+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,EACL,KAAK,EAGL,IAAI,EAEJ,MAAM,EACP,MAAM,mBAAmB,CAAC;AAE3B,UAAU,UAAU;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,UAAU,EAAE,CAAC;IAE9C,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CAAC;IAEpC,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CAAC,CAAC;IAEhD,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAErB,QAAQ,CAAC,EAAE,CACT,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,KAAK,KACT,KAAK,GAAG,IAAI,CAAC;IAElB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAaD,UAAU,KAAK;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AA4UD,qBAAa,SAAS;IACR,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAI3C,KAAK,CAAC,KAAK,EAAE,GAAG;CAkBjB"}