@richscripts/richtexteditor 2.4.0

package/richtexteditor/plugins/dictation.js

@@ -0,0 +1,268 @@
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+RTE_DefaultConfig.plugin_dictation = RTE_Plugin_Dictation;
+
+if (!RTE_DefaultConfig.svgCode_dictation) {
+    // Solid microphone glyph, stroke-matched to the default toolbar icon set.
+    RTE_DefaultConfig.svgCode_dictation = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="9" y="3" width="6" height="11" rx="3"/><path d="M5 11a7 7 0 0 0 14 0"/><path d="M12 18v3"/><path d="M8 21h8"/></svg>';
+}
+
+/**
+ * Dictation plugin — converts microphone input to text via the Web Speech
+ * API and inserts it into the editor. Toolbar toggle button; click to start,
+ * click again to stop. Interim results render live under the cursor so the
+ * user sees what the browser heard before committing.
+ *
+ * Browser support: Chrome, Edge, Opera, Safari (via webkitSpeechRecognition).
+ * Firefox does not ship a SpeechRecognition implementation — we detect and
+ * hide the toolbar button when unsupported.
+ *
+ * Config:
+ *   config.dictationLang           — BCP-47 language, default navigator.language
+ *   config.dictationContinuous     — default true; when false, one utterance then stops
+ *   config.dictationInterimResults — default true; show partial transcript live
+ *   config.dictationAutoPunctuation— default true; auto-capitalize sentences + add periods
+ */
+function RTE_Plugin_Dictation() {
+    var obj = this;
+    var config;
+    var editor;
+    var recognition = null;
+    var listening = false;
+    var button = null;
+    var interimNode = null;
+
+    obj.PluginName = "Dictation";
+
+    obj.InitConfig = function (argconfig) {
+        config = argconfig;
+        // Opt-in: require dictationEnabled===true (set via Tag Helper attribute
+        // `enable-dictation="true"` or by the host JS). The feature is opt-in
+        // because it requires microphone permission — we don't want a visible
+        // mic button on every editor that ships the plugin JS.
+        if (config.dictationEnabled !== true) return;
+        if (!isSupported()) return;
+
+        if (typeof config.dictationContinuous !== "boolean") config.dictationContinuous = true;
+        if (typeof config.dictationInterimResults !== "boolean") config.dictationInterimResults = true;
+        if (typeof config.dictationAutoPunctuation !== "boolean") config.dictationAutoPunctuation = true;
+        config.dictationLang = config.dictationLang || (typeof navigator !== "undefined" ? navigator.language : "en-US");
+
+        appendToolbarCommand("toolbar_default", "#{dictation}");
+        appendToolbarCommand("toolbar_full", "#{dictation}");
+    };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+        if (config.dictationEnabled !== true) return;
+        if (!isSupported()) return;
+
+        editor.dictation = {
+            start: start,
+            stop: stop,
+            toggle: toggle,
+            isListening: function () { return listening; },
+            isSupported: function () { return true; }
+        };
+
+        editor.toolbarFactoryMap["dictation"] = createButton;
+
+        editor.attachEvent("exec_command_dictation", function () { toggle(); });
+
+        // Stop recognition when the editor is torn down.
+        editor.attachEvent("destroy", function () { if (recognition) try { recognition.abort(); } catch (e) { } });
+    };
+
+    function isSupported() {
+        return typeof window !== "undefined"
+            && (typeof window.SpeechRecognition === "function"
+             || typeof window.webkitSpeechRecognition === "function");
+    }
+
+    function appendToolbarCommand(key, token) {
+        var current = config[key] || "";
+        if (current.indexOf(token) !== -1) return;
+        config[key] = current ? current + " " + token : token;
+    }
+
+    function createButton(cmd) {
+        button = editor.createToolbarButton(cmd, {
+            tooltip: "Dictate (click to start/stop)",
+            svgcode: config.svgCode_dictation
+        });
+        return button;
+    }
+
+    function buildRecognition() {
+        var Impl = window.SpeechRecognition || window.webkitSpeechRecognition;
+        var r = new Impl();
+        r.continuous = !!config.dictationContinuous;
+        r.interimResults = !!config.dictationInterimResults;
+        r.lang = config.dictationLang;
+
+        r.onresult = function (event) {
+            var finalTranscript = "";
+            var interimTranscript = "";
+            for (var i = event.resultIndex; i < event.results.length; i++) {
+                var result = event.results[i];
+                if (result.isFinal) finalTranscript += result[0].transcript;
+                else interimTranscript += result[0].transcript;
+            }
+            if (finalTranscript) {
+                insertFinal(finalTranscript);
+            }
+            if (interimTranscript) {
+                renderInterim(interimTranscript);
+            } else if (finalTranscript) {
+                clearInterim();
+            }
+        };
+
+        r.onend = function () {
+            // If we're supposed to be listening (not user-stopped) restart —
+            // some browsers stop after a silence window even in continuous mode.
+            if (listening) {
+                try { r.start(); return; } catch (e) { /* ignore: race with user-stop */ }
+            }
+            listening = false;
+            updateButton();
+            clearInterim();
+        };
+
+        r.onerror = function (event) {
+            listening = false;
+            updateButton();
+            clearInterim();
+            if (event && event.error === "not-allowed") {
+                notify("Microphone permission denied. Enable it in your browser site settings to dictate.");
+            } else if (event && event.error === "no-speech") {
+                // benign; user didn't speak — no toast
+            } else if (event && event.error) {
+                notify("Dictation error: " + event.error);
+            }
+        };
+
+        return r;
+    }
+
+    function start() {
+        if (!isSupported() || listening) return;
+        if (!recognition) recognition = buildRecognition();
+        try { recognition.start(); }
+        catch (e) {
+            // start() throws if already started; reset and retry.
+            try { recognition.abort(); } catch (e2) { }
+            recognition = buildRecognition();
+            try { recognition.start(); } catch (e3) { return; }
+        }
+        listening = true;
+        updateButton();
+    }
+
+    function stop() {
+        if (!recognition || !listening) return;
+        listening = false;   // set first so onend doesn't auto-restart
+        try { recognition.stop(); } catch (e) { /* ignore */ }
+        updateButton();
+        clearInterim();
+    }
+
+    function toggle() {
+        if (listening) stop();
+        else start();
+    }
+
+    function insertFinal(text) {
+        if (!text) return;
+        var normalized = normalize(text, true);
+        if (!normalized) return;
+        try {
+            if (editor.insertText) editor.insertText(normalized);
+            else if (editor.insertHTML) editor.insertHTML(escapeHtml(normalized));
+        } catch (e) { }
+    }
+
+    function renderInterim(text) {
+        if (!text || !config.dictationInterimResults) return;
+        var normalized = normalize(text, false);
+        if (!interimNode) {
+            var doc = editor.getDocument ? editor.getDocument() : document;
+            interimNode = doc.createElement("span");
+            interimNode.setAttribute("data-rte-dictation-interim", "true");
+            interimNode.style.cssText = "opacity:.55;color:#0f8b8d;font-style:italic;pointer-events:none;user-select:none;";
+            try {
+                var sel = editor.getSelection();
+                if (sel && sel.rangeCount > 0) {
+                    var range = sel.getRangeAt(0);
+                    range.collapse(true);
+                    range.insertNode(interimNode);
+                }
+            } catch (e) { }
+        }
+        if (interimNode) interimNode.textContent = " " + normalized;
+    }
+
+    function clearInterim() {
+        if (interimNode && interimNode.parentNode) {
+            interimNode.parentNode.removeChild(interimNode);
+        }
+        interimNode = null;
+    }
+
+    function updateButton() {
+        if (!button) return;
+        button.classList.toggle("rte-dictation-on", listening);
+        button.setAttribute("aria-pressed", listening ? "true" : "false");
+        button.setAttribute("title", listening ? "Dictating… (click to stop)" : "Dictate (click to start/stop)");
+        ensureStyles();
+    }
+
+    var stylesInjected = false;
+    function ensureStyles() {
+        if (stylesInjected) return;
+        stylesInjected = true;
+        var css = ".rte-dictation-on { position: relative; background: linear-gradient(180deg,#fee2e2,#fecaca); box-shadow: inset 0 0 0 1px #f87171; }"
+                + ".rte-dictation-on::after { content: ''; position: absolute; top: 4px; right: 4px; width: 6px; height: 6px; border-radius: 50%; background: #dc2626; box-shadow: 0 0 0 0 rgba(220,38,38,.6); animation: rte-dictation-pulse 1.4s infinite; }"
+                + "@@keyframes rte-dictation-pulse { 0%{box-shadow:0 0 0 0 rgba(220,38,38,.6);} 70%{box-shadow:0 0 0 6px rgba(220,38,38,0);} 100%{box-shadow:0 0 0 0 rgba(220,38,38,0);} }";
+        // Note: the "@@" above is a literal pass-through for Razor safety; at
+        // runtime we ship with a single @ via this replace:
+        css = css.replace(/@@keyframes/g, "@keyframes");
+        var style = document.createElement("style");
+        style.setAttribute("data-rte-dictation", "1");
+        style.appendChild(document.createTextNode(css));
+        document.head.appendChild(style);
+    }
+
+    function normalize(text, isFinal) {
+        if (!text) return "";
+        var t = text.replace(/\s+/g, " ");
+        if (!isFinal) return t.trim();
+        // Final chunks: collapse leading whitespace, apply light auto-punctuation.
+        t = t.replace(/^\s+/, "");
+        if (config.dictationAutoPunctuation) {
+            // Capitalize first letter.
+            if (t.length > 0 && /[a-z]/.test(t[0])) {
+                t = t[0].toUpperCase() + t.substring(1);
+            }
+            // Ensure trailing space so consecutive dictations don't glue words together.
+            if (!/[.!?,;:]$/.test(t)) t += ".";
+            t += " ";
+        } else {
+            if (!/\s$/.test(t)) t += " ";
+        }
+        return t;
+    }
+
+    function escapeHtml(s) {
+        return String(s).replace(/[&<>"']/g, function (c) {
+            return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
+        });
+    }
+
+    function notify(msg) {
+        try {
+            if (editor && editor.showAlert) { editor.showAlert(msg); return; }
+        } catch (e) { }
+        if (typeof window !== "undefined" && window.console) window.console.warn("[dictation]", msg);
+    }
+}

package/richtexteditor/plugins/documentimport.js

@@ -0,0 +1,369 @@
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+// 2026-06-09 Document import — the natural pair to Export-to-Word/Markdown/PDF.
+// Opens a local file and loads it into the editor. Library-free for the common
+// formats: Markdown (.md/.markdown via the core fromMarkdown engine), HTML
+// (.html/.htm), plain text (.txt), and Word's HTML-based format (.doc, which
+// Word saves as MSO-flavored HTML) — Word junk (mso-* styles, o:/w: tags,
+// conditional comments) is stripped the same way paste-from-Word is.
+//
+// Zipped .docx is NOT parseable library-free (it's a ZIP of XML); for it (or to
+// override any type) supply config.documentImportResolver(file) returning an
+// HTML string or Promise<string>, so a server/library can convert it.
+//
+// API:
+//   editor.openImportDialog(options?)        -> file picker, then import
+//   editor.importFile(file, options?)        -> import a File object (Promise)
+//   editor.htmlFromImportText(text, kind)     -> convert text to HTML (kind: md|html|txt|doc)
+// Command: exec_command "importdocument" opens the picker. Slash: "/import".
+// Config:
+//   config.documentImport = false                 // disable
+//   config.documentImportMode = "replace" | "insert"   // default "replace"
+//   config.documentImportAccept = ".md,.markdown,.html,.htm,.txt,.doc,.docx"
+//   config.documentImportResolver = function(file){ return htmlOrPromise; }
+RTE_DefaultConfig.plugin_documentimport = RTE_Plugin_DocumentImport;
+if (typeof RTE_DefaultConfig.documentImport === "undefined") RTE_DefaultConfig.documentImport = true;
+
+function RTE_Plugin_DocumentImport() {
+    var obj = this;
+    var config, editor;
+
+    obj.PluginName = "DocumentImport";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+        if (config.documentImport === false) return;
+
+        editor.htmlFromImportText = function (text, kind) { return toHtml(String(text == null ? "" : text), kind); };
+        editor.importFile = function (file, options) { return importFile(file, options || {}); };
+        editor.openImportDialog = function (options) { return openPicker(options || {}); };
+
+        editor.attachEvent("exec_command_importdocument", function (state) {
+            state.returnValue = true;
+            state.stopBubble = true;
+            openPicker({});
+        });
+
+        if (editor.slashCommands && typeof editor.slashCommands.register === "function") {
+            try {
+                editor.slashCommands.register({
+                    id: "import-document",
+                    title: "Import document",
+                    description: "Open a Markdown, HTML, text, or Word (.doc) file into the editor",
+                    keywords: ["import", "open", "file", "word", "markdown", "upload"],
+                    action: function () { openPicker({}); }
+                });
+            } catch (e) {}
+        }
+    };
+
+    function kindFromName(name) {
+        var n = String(name || "").toLowerCase();
+        if (/\.(md|markdown|mdown|mkd)$/.test(n)) return "md";
+        if (/\.html?$/.test(n)) return "html";
+        if (/\.doc$/.test(n)) return "doc";
+        if (/\.docx$/.test(n)) return "docx";
+        if (/\.txt$/.test(n)) return "txt";
+        return "txt";
+    }
+
+    function esc(s) {
+        return String(s == null ? "" : s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    }
+
+    // Strip Word/MSO debris from .doc HTML (same intent as paste-from-Word).
+    function cleanWordHtml(html) {
+        var h = String(html || "");
+        // body only, drop head/xml/style islands and conditional comments
+        var bodyMatch = /<body[^>]*>([\s\S]*?)<\/body>/i.exec(h);
+        if (bodyMatch) h = bodyMatch[1];
+        h = h.replace(/<!--\[if[\s\S]*?\[endif\]-->/gi, "");
+        h = h.replace(/<!--[\s\S]*?-->/g, "");
+        h = h.replace(/<\/?(o:p|o:|w:|xml|style|meta|link|title|head)[^>]*>/gi, "");
+        h = h.replace(/<\\?\?xml[^>]*>/gi, "");
+        // strip mso-* declarations + empty style/class/lang attrs
+        h = h.replace(/\sstyle="[^"]*"/gi, function (m) {
+            var cleaned = m.replace(/mso-[^;"]*;?/gi, "").replace(/style="\s*;*\s*"/i, "");
+            return /style="\s*"/.test(cleaned) || cleaned === ' style=""' ? "" : cleaned;
+        });
+        h = h.replace(/\sclass="Mso[^"]*"/gi, "");
+        h = h.replace(/\s(lang|xmlns(:\w+)?)="[^"]*"/gi, "");
+        return h;
+    }
+
+    function toHtml(text, kind) {
+        switch (kind) {
+            case "md":
+                if (editor && typeof editor.fromMarkdown === "function") return editor.fromMarkdown(text, { apply: false });
+                return "<p>" + esc(text).replace(/\n{2,}/g, "</p><p>").replace(/\n/g, "<br>") + "</p>";
+            case "html":
+                return text;
+            case "doc":
+                return cleanWordHtml(text);
+            case "txt":
+            default:
+                var paras = String(text).replace(/\r\n?/g, "\n").split(/\n{2,}/);
+                return paras.map(function (p) {
+                    return "<p>" + esc(p).replace(/\n/g, "<br>") + "</p>";
+                }).join("");
+        }
+    }
+
+    function applyHtml(html, mode) {
+        if (html == null) return false;
+        if (mode === "insert") {
+            if (typeof editor.insertHTML === "function") { editor.insertHTML(html); return true; }
+        }
+        if (typeof editor.setHTMLCode === "function") { editor.setHTMLCode(html); return true; }
+        return false;
+    }
+
+    function importFile(file, options) {
+        var mode = options.mode || config.documentImportMode || "replace";
+        return new Promise(function (resolve) {
+            if (!file) { resolve(false); return; }
+            var kind = kindFromName(file.name);
+
+            // BYOK resolver wins for any type (lets a host handle .docx etc.).
+            if (typeof config.documentImportResolver === "function") {
+                try {
+                    var r = config.documentImportResolver(file);
+                    Promise.resolve(r).then(function (html) {
+                        if (typeof html === "string") { resolve(applyHtml(html, mode)); }
+                        else { builtin(); }
+                    }, function () { builtin(); });
+                    return;
+                } catch (e) { builtin(); return; }
+            }
+            builtin();
+
+            function builtin() {
+                if (kind === "docx") {
+                    // Library-free .docx: unzip word/document.xml (native
+                    // DecompressionStream) + transform WordprocessingML -> HTML.
+                    if (!docxSupported()) {
+                        notify("This browser can't unpack .docx (no DecompressionStream). Save as .doc/.html/.md, or wire config.documentImportResolver.");
+                        resolve(false);
+                        return;
+                    }
+                    readDocx(file).then(function (html) {
+                        if (html != null) resolve(applyHtml(html, mode));
+                        else { notify("Could not read this .docx file."); resolve(false); }
+                    }, function () { notify("Could not read this .docx file."); resolve(false); });
+                    return;
+                }
+                if (typeof FileReader === "undefined") { resolve(false); return; }
+                var reader = new FileReader();
+                reader.onload = function () {
+                    var html = toHtml(reader.result, kind);
+                    resolve(applyHtml(html, mode));
+                };
+                reader.onerror = function () { resolve(false); };
+                reader.readAsText(file);
+            }
+        });
+    }
+
+    function openPicker(options) {
+        try {
+            var input = document.createElement("input");
+            input.type = "file";
+            input.accept = options.accept || config.documentImportAccept || ".md,.markdown,.html,.htm,.txt,.doc,.docx";
+            input.style.position = "fixed";
+            input.style.left = "-9999px";
+            input.addEventListener("change", function () {
+                var f = input.files && input.files[0];
+                if (f) importFile(f, options);
+                setTimeout(function () { try { document.body.removeChild(input); } catch (e) {} }, 0);
+            });
+            document.body.appendChild(input);
+            input.click();
+            return true;
+        } catch (e) {
+            if (window.console) console.error("documentimport: openPicker failed", e);
+            return false;
+        }
+    }
+
+    // ---- library-free .docx (ZIP of XML) ----
+    function docxSupported() {
+        return typeof DecompressionStream === "function" && typeof DOMParser === "function" &&
+            (typeof Response === "function" || typeof Blob === "function");
+    }
+
+    // Locate an entry via the ZIP central directory (reliable comp sizes/offsets).
+    function findZipEntry(bytes, wantName) {
+        var dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        // End Of Central Directory: signature 0x06054b50, scan from the end.
+        var eocd = -1;
+        for (var i = bytes.length - 22; i >= 0 && i >= bytes.length - 22 - 65536; i--) {
+            if (dv.getUint32(i, true) === 0x06054b50) { eocd = i; break; }
+        }
+        if (eocd < 0) return null;
+        var cdOffset = dv.getUint32(eocd + 16, true);
+        var cdCount = dv.getUint16(eocd + 10, true);
+        var p = cdOffset;
+        for (var n = 0; n < cdCount; n++) {
+            if (dv.getUint32(p, true) !== 0x02014b50) break;
+            var method = dv.getUint16(p + 10, true);
+            var compSize = dv.getUint32(p + 20, true);
+            var nameLen = dv.getUint16(p + 28, true);
+            var extraLen = dv.getUint16(p + 30, true);
+            var commentLen = dv.getUint16(p + 32, true);
+            var localOff = dv.getUint32(p + 42, true);
+            // Normalize separators: the ZIP spec mandates "/", but some Windows
+            // tools (.NET ZipFile on older runtimes) emit "\".
+            var name = utf8(bytes.subarray(p + 46, p + 46 + nameLen)).replace(/\\/g, "/");
+            if (name === wantName) {
+                var lh = new DataView(bytes.buffer, bytes.byteOffset + localOff, 30);
+                var lNameLen = lh.getUint16(26, true);
+                var lExtraLen = lh.getUint16(28, true);
+                var dataStart = localOff + 30 + lNameLen + lExtraLen;
+                return { method: method, data: bytes.subarray(dataStart, dataStart + compSize) };
+            }
+            p += 46 + nameLen + extraLen + commentLen;
+        }
+        return null;
+    }
+
+    function utf8(u8) {
+        try { return new TextDecoder("utf-8").decode(u8); } catch (e) {
+            var s = ""; for (var i = 0; i < u8.length; i++) s += String.fromCharCode(u8[i]); return s;
+        }
+    }
+
+    function inflateRaw(u8) {
+        // method 0 = stored, 8 = deflate (raw).
+        var ds = new DecompressionStream("deflate-raw");
+        var blob = new Blob([u8]);
+        return new Response(blob.stream().pipeThrough(ds)).arrayBuffer().then(function (ab) {
+            return new Uint8Array(ab);
+        });
+    }
+
+    function readDocx(file) {
+        var bufPromise = file.arrayBuffer ? file.arrayBuffer() : new Promise(function (res, rej) {
+            var r = new FileReader(); r.onload = function () { res(r.result); }; r.onerror = rej; r.readAsArrayBuffer(file);
+        });
+        return bufPromise.then(function (ab) {
+            var bytes = new Uint8Array(ab);
+            var entry = findZipEntry(bytes, "word/document.xml");
+            if (!entry) return null;
+            var xmlPromise = entry.method === 0 ? Promise.resolve(entry.data) : inflateRaw(entry.data);
+            return xmlPromise.then(function (xmlBytes) { return docxXmlToHtml(utf8(xmlBytes)); });
+        });
+    }
+
+    function docxXmlToHtml(xml) {
+        var doc = new DOMParser().parseFromString(xml, "application/xml");
+        var W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+        function els(parent, ln) { return parent.getElementsByTagNameNS(W, ln); }
+        function firstChildEl(parent, ln) {
+            for (var i = 0; i < parent.childNodes.length; i++) {
+                var c = parent.childNodes[i];
+                if (c.nodeType === 1 && c.localName === ln && c.namespaceURI === W) return c;
+            }
+            return null;
+        }
+        function runText(r) {
+            var t = "", kids = r.childNodes;
+            for (var i = 0; i < kids.length; i++) {
+                var c = kids[i];
+                if (c.nodeType !== 1) continue;
+                if (c.localName === "t") t += c.textContent || "";
+                else if (c.localName === "tab") t += "\t";
+                else if (c.localName === "br" || c.localName === "cr") t += "\n";
+            }
+            return t;
+        }
+        function runHtml(r) {
+            var txt = esc(runText(r));
+            if (!txt) return "";
+            txt = txt.replace(/\n/g, "<br>");
+            var rpr = firstChildEl(r, "rPr");
+            if (rpr) {
+                if (firstChildEl(rpr, "b")) txt = "<strong>" + txt + "</strong>";
+                if (firstChildEl(rpr, "i")) txt = "<em>" + txt + "</em>";
+                if (firstChildEl(rpr, "u")) txt = "<u>" + txt + "</u>";
+                if (firstChildEl(rpr, "strike")) txt = "<s>" + txt + "</s>";
+            }
+            return txt;
+        }
+        function paraInner(p) {
+            var h = "", kids = p.childNodes;
+            for (var i = 0; i < kids.length; i++) {
+                var c = kids[i];
+                if (c.nodeType === 1 && c.localName === "r" && c.namespaceURI === W) h += runHtml(c);
+                else if (c.nodeType === 1 && c.localName === "hyperlink") {
+                    for (var j = 0; j < c.childNodes.length; j++) if (c.childNodes[j].localName === "r") h += runHtml(c.childNodes[j]);
+                }
+            }
+            return h;
+        }
+        function paraStyle(p) {
+            var ppr = firstChildEl(p, "pPr"); if (!ppr) return {};
+            var info = {};
+            var ps = firstChildEl(ppr, "pStyle");
+            if (ps) { var v = ps.getAttributeNS(W, "val") || ps.getAttribute("w:val") || ""; var m = /heading(\d)/i.exec(v); if (m) info.heading = Math.min(6, parseInt(m[1], 10)); }
+            if (firstChildEl(ppr, "numPr")) info.list = true;
+            return info;
+        }
+        var body = els(doc, "body")[0];
+        if (!body) return "";
+        var out = [], inList = false;
+        function closeList() { if (inList) { out.push("</ul>"); inList = false; } }
+        for (var i = 0; i < body.childNodes.length; i++) {
+            var node = body.childNodes[i];
+            if (node.nodeType !== 1 || node.namespaceURI !== W) continue;
+            if (node.localName === "p") {
+                var st = paraStyle(node);
+                var inner = paraInner(node);
+                if (st.list) { if (!inList) { out.push("<ul>"); inList = true; } out.push("<li>" + (inner || "") + "</li>"); continue; }
+                closeList();
+                if (st.heading) out.push("<h" + st.heading + ">" + (inner || "") + "</h" + st.heading + ">");
+                else out.push("<p>" + (inner || "<br>") + "</p>");
+            } else if (node.localName === "tbl") {
+                closeList();
+                out.push(tableHtml(node));
+            }
+        }
+        closeList();
+        return out.join("\n");
+
+        function tableHtml(tbl) {
+            var rows = [], kids = tbl.childNodes;
+            for (var i = 0; i < kids.length; i++) {
+                var tr = kids[i];
+                if (tr.nodeType !== 1 || tr.localName !== "tr") continue;
+                var cells = [];
+                for (var j = 0; j < tr.childNodes.length; j++) {
+                    var tc = tr.childNodes[j];
+                    if (tc.nodeType !== 1 || tc.localName !== "tc") continue;
+                    var cellHtml = "";
+                    for (var k = 0; k < tc.childNodes.length; k++) {
+                        if (tc.childNodes[k].localName === "p") cellHtml += "<p>" + (paraInner(tc.childNodes[k]) || "<br>") + "</p>";
+                    }
+                    cells.push("<td>" + cellHtml + "</td>");
+                }
+                rows.push("<tr>" + cells.join("") + "</tr>");
+            }
+            return "<table>" + rows.join("") + "</table>";
+        }
+    }
+
+    function notify(msg) {
+        try {
+            if (editor && typeof editor.createDialog === "function") {
+                var d = editor.createDialog((editor.getLangText && editor.getLangText("importtitle")) || "Import document", "rte-dialog-import");
+                var w = d.ownerDocument.createElement("div");
+                w.style.cssText = "padding:16px;max-width:420px;font:13px -apple-system,Segoe UI,sans-serif;line-height:1.5";
+                w.textContent = msg;
+                d.appendChild(w);
+                return;
+            }
+        } catch (e) {}
+        if (window.console) console.warn("documentimport:", msg);
+    }
+}