@richscripts/richtexteditor 2.5.4 → 2.6.1

package/richtexteditor/rte-headless.js

@@ -0,0 +1,360 @@
+/*
+ * RichTextEditor — Headless API  (rte-headless.js)
+ * ------------------------------------------------------------------
+ * Optional, un-obfuscated companion to rte.js. It lets you run the editor with
+ * NO built-in toolbar/chrome and drive everything from your own UI — the same
+ * "bring your own interface" model as headless frameworks, but on top of the
+ * full RichTextEditor engine (commands, plugins, collaboration, AI, etc.).
+ *
+ * What you get:
+ *   - a chrome-less editing surface (toolbar / sub-toolbar / status bar hidden)
+ *   - run(command, value)         -> dispatch any RTE command
+ *   - isActive(name) / state()    -> query active formatting for your buttons
+ *   - can(command)                -> queryCommandEnabled (undo/redo/...)
+ *   - on("update" | "change" | "selectionchange" | "focus" | "blur", cb)
+ *   - getHTML / setHTML / getText / setText / getMarkdown / setMarkdown / getJSON
+ *
+ * Example:
+ *   var hl = RTEHeadless("#editor", { value: "<p>Hello</p>" });
+ *   hl.on("update", function (s) {
+ *     boldBtn.classList.toggle("is-active", s.bold);
+ *   });
+ *   boldBtn.addEventListener("mousedown", function (e) {
+ *     e.preventDefault();          // keep the editor selection
+ *     hl.run("bold");
+ *   });
+ *
+ * Loads after rte-config.js + rte.js (+ optional plugins). Ships un-obfuscated
+ * on purpose, like rte-config.js — you are meant to read and extend it.
+ */
+(function (global) {
+    "use strict";
+
+    // logical state name -> how to query it on the editor document.
+    // "state" uses queryCommandState; "block" matches queryCommandValue("formatBlock").
+    var STATE_MAP = {
+        bold: { kind: "state", q: "bold" },
+        italic: { kind: "state", q: "italic" },
+        underline: { kind: "state", q: "underline" },
+        strike: { kind: "state", q: "strikethrough" },
+        strikethrough: { kind: "state", q: "strikethrough" },
+        subscript: { kind: "state", q: "subscript" },
+        superscript: { kind: "state", q: "superscript" },
+        ul: { kind: "state", q: "insertunorderedlist" },
+        unorderedlist: { kind: "state", q: "insertunorderedlist" },
+        ol: { kind: "state", q: "insertorderedlist" },
+        orderedlist: { kind: "state", q: "insertorderedlist" },
+        justifyleft: { kind: "state", q: "justifyleft" },
+        justifycenter: { kind: "state", q: "justifycenter" },
+        justifyright: { kind: "state", q: "justifyright" },
+        justifyfull: { kind: "state", q: "justifyfull" },
+        h1: { kind: "block", q: "h1" },
+        h2: { kind: "block", q: "h2" },
+        h3: { kind: "block", q: "h3" },
+        h4: { kind: "block", q: "h4" },
+        h5: { kind: "block", q: "h5" },
+        h6: { kind: "block", q: "h6" },
+        p: { kind: "block", q: "p" },
+        paragraph: { kind: "block", q: "p" },
+        blockquote: { kind: "block", q: "blockquote" },
+        pre: { kind: "block", q: "pre" }
+    };
+
+    // keys included in the snapshot returned by state() when no list is given.
+    var DEFAULT_STATE_KEYS = [
+        "bold", "italic", "underline", "strike", "ul", "ol",
+        "justifyleft", "justifycenter", "justifyright",
+        "blockquote", "h1", "h2", "h3", "p"
+    ];
+
+    function resolveTarget(target) {
+        if (typeof target === "string") {
+            return (typeof document !== "undefined") ? document.querySelector(target) : null;
+        }
+        return target || null;
+    }
+
+    function HeadlessController(editor, options) {
+        this.editor = editor;            // escape hatch: the underlying RichTextEditor
+        this._opts = options || {};
+        this._handlers = {};             // event name -> [cb]
+        this._scheduled = false;
+        this._destroyed = false;
+        this._wire();
+    }
+
+    // The contentEditable document we query formatting state against.
+    HeadlessController.prototype._doc = function () {
+        try {
+            var ifr = this.editor && this.editor.iframe;
+            if (!ifr) {
+                return null;
+            }
+            return ifr.contentDocument || (ifr.contentWindow && ifr.contentWindow.document) || null;
+        } catch (e) {
+            return null;
+        }
+    };
+
+    HeadlessController.prototype._wire = function () {
+        var self = this;
+        // Coalesce bursts into a single "update". setTimeout (not rAF) on purpose:
+        // requestAnimationFrame is paused in background/hidden tabs, which would
+        // latch _scheduled and silently drop every later update (collab, tests,
+        // off-screen editors). A ~16ms timer fires in every context.
+        function emitUpdate() {
+            if (self._destroyed || self._scheduled) {
+                return;
+            }
+            self._scheduled = true;
+            setTimeout(function () {
+                self._scheduled = false;
+                if (!self._destroyed) {
+                    self._emit("update", self.state());
+                }
+            }, 16);
+        }
+        this._emitUpdate = emitUpdate;
+
+        ["selectionchange", "change", "focus", "blur"].forEach(function (evt) {
+            try {
+                self.editor.attachEvent(evt, function (a, b) {
+                    self._emit(evt, a, b);
+                    if (evt === "selectionchange" || evt === "change") {
+                        emitUpdate();
+                    }
+                });
+            } catch (e) { /* event surface differs by build; ignore */ }
+        });
+
+        // Robust fallback: bind native listeners on the editor document so the
+        // "update" (active-state) snapshot stays in sync with EVERY caret/selection
+        // move and keystroke, even if a given build doesn't route them through the
+        // editor's own event hook. Coalesced by emitUpdate's per-frame guard.
+        var doc = this._doc();
+        if (doc && doc.addEventListener) {
+            // Only drive the coalesced "update" snapshot here; the editor's own
+            // hook owns the "change" event, so we don't double-emit it.
+            this._docListeners = [
+                ["selectionchange", function () { emitUpdate(); }],
+                ["mouseup", function () { emitUpdate(); }],
+                ["keyup", function () { emitUpdate(); }],
+                ["input", function () { emitUpdate(); }]
+            ];
+            for (var i = 0; i < this._docListeners.length; i++) {
+                try { doc.addEventListener(this._docListeners[i][0], this._docListeners[i][1], true); } catch (e) {}
+            }
+            this._boundDoc = doc;
+        }
+    };
+
+    HeadlessController.prototype.on = function (name, cb) {
+        if (typeof cb === "function") {
+            (this._handlers[name] = this._handlers[name] || []).push(cb);
+        }
+        return this;
+    };
+
+    HeadlessController.prototype.off = function (name, cb) {
+        var list = this._handlers[name];
+        if (list) {
+            this._handlers[name] = cb ? list.filter(function (f) { return f !== cb; }) : [];
+        }
+        return this;
+    };
+
+    HeadlessController.prototype._emit = function (name) {
+        var list = this._handlers[name];
+        if (!list || !list.length) {
+            return;
+        }
+        var args = Array.prototype.slice.call(arguments, 1);
+        for (var i = 0; i < list.length; i++) {
+            try {
+                list[i].apply(this, args);
+            } catch (e) {
+                if (global.console) { global.console.error(e); }
+            }
+        }
+    };
+
+    // Dispatch any RichTextEditor command (same names the toolbar uses), chainable.
+    HeadlessController.prototype.run = function (command, value) {
+        try {
+            this.editor.execCommand(command, value);
+        } catch (e) {
+            if (global.console) { global.console.error(e); }
+        }
+        if (this._emitUpdate) { this._emitUpdate(); }
+        return this;
+    };
+    HeadlessController.prototype.cmd = HeadlessController.prototype.run;
+
+    HeadlessController.prototype.isActive = function (name) {
+        var spec = STATE_MAP[String(name || "").toLowerCase()];
+        var doc = this._doc();
+        if (!spec || !doc) {
+            return false;
+        }
+        try {
+            if (spec.kind === "state") {
+                return !!doc.queryCommandState(spec.q);
+            }
+            var v = String(doc.queryCommandValue("formatBlock") || "").toLowerCase().replace(/[<>]/g, "");
+            return v === spec.q;
+        } catch (e) {
+            return false;
+        }
+    };
+
+    HeadlessController.prototype.can = function (command) {
+        var doc = this._doc();
+        if (!doc) {
+            return false;
+        }
+        try {
+            return !!doc.queryCommandEnabled(command);
+        } catch (e) {
+            return false;
+        }
+    };
+
+    // Snapshot of active formatting for binding a custom toolbar.
+    HeadlessController.prototype.state = function (keys) {
+        keys = keys || DEFAULT_STATE_KEYS;
+        var out = {};
+        for (var i = 0; i < keys.length; i++) {
+            out[keys[i]] = this.isActive(keys[i]);
+        }
+        out.canUndo = this.can("undo");
+        out.canRedo = this.can("redo");
+        return out;
+    };
+
+    // ---- content I/O (thin pass-throughs to the public editor API) ----
+    HeadlessController.prototype.getHTML = function () {
+        return this.editor.getHTMLCode ? this.editor.getHTMLCode() : "";
+    };
+    HeadlessController.prototype.setHTML = function (html) {
+        if (this.editor.setHTMLCode) { this.editor.setHTMLCode(html == null ? "" : html); }
+        if (this._emitUpdate) { this._emitUpdate(); }
+        return this;
+    };
+    HeadlessController.prototype.getText = function () {
+        return this.editor.getText ? this.editor.getText() : "";
+    };
+    HeadlessController.prototype.setText = function (text) {
+        if (this.editor.setText) { this.editor.setText(text == null ? "" : text); }
+        if (this._emitUpdate) { this._emitUpdate(); }
+        return this;
+    };
+    HeadlessController.prototype.getMarkdown = function () {
+        return this.editor.toMarkdown ? this.editor.toMarkdown() : "";
+    };
+    HeadlessController.prototype.setMarkdown = function (markdown) {
+        if (this.editor.fromMarkdown) { this.editor.fromMarkdown(markdown == null ? "" : markdown); }
+        if (this._emitUpdate) { this._emitUpdate(); }
+        return this;
+    };
+    HeadlessController.prototype.getJSON = function () {
+        return this.editor.getJSON ? this.editor.getJSON() : null;   // requires the structured-content bridge
+    };
+    HeadlessController.prototype.getStatistics = function () {
+        return this.editor.getStatistics ? this.editor.getStatistics() : null;
+    };
+    HeadlessController.prototype.isEmpty = function () {
+        return String(this.getText() || "").replace(/\s+/g, "").length === 0;
+    };
+
+    HeadlessController.prototype.focus = function () {
+        try { this.editor.focus(); } catch (e) { /* ignore */ }
+        return this;
+    };
+
+    HeadlessController.prototype.destroy = function () {
+        this._destroyed = true;
+        this._handlers = {};
+        if (this._boundDoc && this._docListeners) {
+            for (var i = 0; i < this._docListeners.length; i++) {
+                try { this._boundDoc.removeEventListener(this._docListeners[i][0], this._docListeners[i][1], true); } catch (e) {}
+            }
+        }
+        this._docListeners = null;
+        this._boundDoc = null;
+        try { if (this.editor.prepareDestroy) { this.editor.prepareDestroy(); } } catch (e) { /* ignore */ }
+        return this;
+    };
+
+    var _cssInjected = false;
+    function injectHeadlessCss() {
+        if (_cssInjected || typeof document === "undefined") {
+            return;
+        }
+        _cssInjected = true;
+        var css =
+            ".rte-headless rte-toolbar,.rte-headless rte-subtoolbar,.rte-headless rte-bottom{display:none !important;}" +
+            ".rte-headless{border:0 !important;background:transparent !important;}";
+        var style = document.createElement("style");
+        style.setAttribute("data-rte-headless", "");
+        style.appendChild(document.createTextNode(css));
+        (document.head || document.documentElement).appendChild(style);
+    }
+
+    // Factory: build a chrome-less editor and return a HeadlessController.
+    function createHeadless(target, options) {
+        options = options || {};
+        if (typeof global.RichTextEditor !== "function") {
+            throw new Error("rte-headless: RichTextEditor (rte.js) must be loaded before rte-headless.js.");
+        }
+        var el = resolveTarget(target);
+        if (!el) {
+            throw new Error("rte-headless: target element not found.");
+        }
+
+        // Start from the standard config so plugins/commands still work, then
+        // strip the chrome. A single-space toolbar definition parses to ZERO
+        // items (an empty string would fall back to the full toolbar).
+        var cfg = (typeof global.RTE_CreateConfig === "function") ? global.RTE_CreateConfig() : {};
+        if (options.config) {
+            for (var k in options.config) {
+                if (Object.prototype.hasOwnProperty.call(options.config, k)) {
+                    cfg[k] = options.config[k];
+                }
+            }
+        }
+        cfg.toolbar = "headless";
+        cfg.toolbar_headless = " ";
+        cfg.toolbarMobile = "headless";
+        if (options.showStatistics !== true) {
+            cfg.showStatistics = false;
+        }
+
+        injectHeadlessCss();
+        var editor = new global.RichTextEditor(el, cfg);
+        if (editor.container && editor.container.classList) {
+            editor.container.classList.add("rte-headless");
+        }
+        if (options.value != null && editor.setHTMLCode) {
+            editor.setHTMLCode(options.value);
+        }
+        return new HeadlessController(editor, options);
+    }
+
+    // ---- exports ----
+    if (typeof global !== "undefined") {
+        global.RTEHeadless = createHeadless;
+        if (typeof global.RichTextEditor === "function") {
+            global.RichTextEditor.headless = createHeadless;
+        }
+    }
+    if (typeof module !== "undefined" && module.exports) {
+        module.exports = {
+            RTEHeadless: createHeadless,
+            _internals: {
+                STATE_MAP: STATE_MAP,
+                DEFAULT_STATE_KEYS: DEFAULT_STATE_KEYS,
+                HeadlessController: HeadlessController
+            }
+        };
+    }
+})(typeof window !== "undefined" ? window : this);

package/richtexteditor/rte-watchdog.js

@@ -0,0 +1,303 @@
+/*
+ * RichTextEditor — Watchdog  (rte-watchdog.js)
+ * ------------------------------------------------------------------
+ * 2026-08-30. Optional, un-obfuscated companion to rte.js: keeps an editor alive
+ * across an unexpected error, and — more importantly — keeps the author's text.
+ *
+ * Why this exists. CKEditor 5 ships `Watchdog`; nothing here did. The gap is not
+ * a feature-list checkbox, it is the worst five seconds a writer can have: an
+ * uncaught exception leaves the editing surface half-dead — keystrokes land but
+ * commands throw, or the iframe stops accepting input — and the page looks fine,
+ * so nobody reloads until an hour of writing is already gone.
+ *
+ * What it does:
+ *   - snapshots the content on an interval and after every change, so there is
+ *     always a recent known-good document to restore;
+ *   - notices an uncaught error or rejection that came from the editor's own
+ *     code, and re-checks the editing surface before believing it;
+ *   - destroys and recreates the instance, then puts the snapshot back;
+ *   - refuses to do that forever. Restarting into the same crash is a loop that
+ *     eats the document a little more each pass, so after `crashNumberLimit`
+ *     crashes without a quiet period in between it stops, reports
+ *     "crashedPermanently", and holds the last snapshot for the host page to
+ *     save somewhere it trusts.
+ *
+ * What it deliberately does NOT do: guess. An error thrown by unrelated page code
+ * is none of its business — restarting the editor because an analytics script
+ * threw would destroy the selection, the undo stack and any in-progress dialog
+ * for no reason. Only errors whose stack names an editor script, or a genuinely
+ * unresponsive editing surface, count as a crash. `getDiagnostics()` reports the
+ * errors it saw and ignored, so a real crash that was filtered out is findable
+ * rather than invisible.
+ *
+ *   var wd = new RichTextEditorWatchdog();
+ *   wd.on("restart", function (info) { console.log("recovered", info.crashes); });
+ *   wd.on("crashedPermanently", function (info) { saveDraft(info.data); });
+ *   wd.create(document.getElementById("host"), RTE_CreateConfig());
+ *   wd.editor            // the live instance — re-read it after a restart
+ *   wd.getData()         // last known-good HTML, valid even while crashed
+ *
+ * Loads after rte-config.js + rte.js. Un-obfuscated on purpose: recovery policy
+ * is something an integrator should be able to read and change.
+ */
+(function (global) {
+    "use strict";
+
+    var STATE_INITIALIZING = "initializing";
+    var STATE_READY = "ready";
+    var STATE_CRASHED = "crashed";
+    var STATE_PERMANENT = "crashedPermanently";
+    var STATE_DESTROYED = "destroyed";
+
+    function RichTextEditorWatchdog(options) {
+        if (!(this instanceof RichTextEditorWatchdog)) return new RichTextEditorWatchdog(options);
+        options = options || {};
+
+        this.state = STATE_INITIALIZING;
+        this.editor = null;
+        this.crashes = [];
+
+        this._host = null;
+        this._config = null;
+        this._data = "";
+        this._listeners = {};
+        this._ignoredErrors = [];
+        this._timer = null;
+        this._destroyed = false;
+
+        // How many crashes without a quiet stretch before giving up. CKEditor's
+        // default is 3 and the reasoning holds: one crash is an accident, three
+        // in a row is a bug that restarting will not fix.
+        this._crashNumberLimit = typeof options.crashNumberLimit === "number" ? options.crashNumberLimit : 3;
+        // A crash this long after the previous one starts the count again.
+        this._minimumNonErrorTimePeriod = typeof options.minimumNonErrorTimePeriod === "number"
+            ? options.minimumNonErrorTimePeriod : 5000;
+        this._saveInterval = typeof options.saveInterval === "number" ? options.saveInterval : 5000;
+
+        // Swap these to supervise something other than a plain `new RichTextEditor`
+        // (a framework wrapper, a headless instance, a preconfigured factory).
+        this._creator = typeof options.creator === "function"
+            ? options.creator
+            : function (host, config) { return new global.RichTextEditor(host, config); };
+        this._destructor = typeof options.destructor === "function"
+            ? options.destructor
+            : function (editor) { if (editor && typeof editor.destroy === "function") editor.destroy(); };
+
+        // Which scripts count as "ours". An error is only a crash if its stack
+        // names one of them — see the comment at the top of the file.
+        this._ownScriptPattern = options.ownScriptPattern instanceof RegExp
+            ? options.ownScriptPattern
+            : /(^|[\/\\])(rte|rte-headless|rte-watchdog|all_plugins)([.\-][\w.]*)?\.js|RTE_Plugin_|RichTextEditor/;
+
+        var self = this;
+        this._onError = function (event) { self._handleError(event && event.error, event && event.message, event); };
+        this._onRejection = function (event) {
+            var reason = event && event.reason;
+            self._handleError(reason instanceof Error ? reason : null, String(reason && reason.message || reason || ""), event);
+        };
+        global.addEventListener("error", this._onError);
+        global.addEventListener("unhandledrejection", this._onRejection);
+    }
+
+    var proto = RichTextEditorWatchdog.prototype;
+
+    // ------------------------------------------------------------------ events
+
+    proto.on = function (name, callback) {
+        if (typeof callback !== "function") return this;
+        (this._listeners[name] = this._listeners[name] || []).push(callback);
+        return this;
+    };
+
+    proto.off = function (name, callback) {
+        var list = this._listeners[name];
+        if (!list) return this;
+        for (var i = list.length - 1; i >= 0; i--) if (list[i] === callback) list.splice(i, 1);
+        return this;
+    };
+
+    proto._emit = function (name, payload) {
+        var list = (this._listeners[name] || []).slice();
+        for (var i = 0; i < list.length; i++) {
+            // A throwing listener must not take down the recovery it was told about.
+            try { list[i].call(this, payload); } catch (e) {}
+        }
+    };
+
+    // ------------------------------------------------------------- lifecycle
+
+    proto.create = function (host, config) {
+        if (this._destroyed) throw new Error("This watchdog has been destroyed.");
+        this._host = host || this._host;
+        this._config = config || this._config;
+        return this._start();
+    };
+
+    proto._start = function () {
+        var self = this;
+        this.editor = this._creator(this._host, this._config);
+        this.state = STATE_READY;
+
+        // Snapshot on change AND on a timer. Change alone misses the case that
+        // matters most — a crash mid-edit that stops change events firing — and
+        // the timer alone can be up to `saveInterval` stale.
+        try {
+            this.editor.attachEvent("change", function () { self._snapshot(); });
+        } catch (e) {}
+        this._snapshot();
+        if (this._saveInterval > 0) {
+            this._timer = global.setInterval(function () { self._snapshot(); }, this._saveInterval);
+        }
+
+        this._emit("ready", { editor: this.editor });
+        return this.editor;
+    };
+
+    proto.destroy = function () {
+        if (this._destroyed) return;
+        this._destroyed = true;
+        this.state = STATE_DESTROYED;
+        if (this._timer) { global.clearInterval(this._timer); this._timer = null; }
+        global.removeEventListener("error", this._onError);
+        global.removeEventListener("unhandledrejection", this._onRejection);
+        try { this._destructor(this.editor); } catch (e) {}
+        this.editor = null;
+        this._emit("destroy", {});
+    };
+
+    // ------------------------------------------------------------------- data
+
+    proto.getData = function () { return this._data; };
+
+    proto._snapshot = function () {
+        if (!this.editor) return;
+        try {
+            var html = this.editor.getHTMLCode();
+            // A crashing editor can start returning "" or null. Overwriting a good
+            // snapshot with that is how a recovery feature loses the document it
+            // exists to protect, so empty never replaces non-empty.
+            if (typeof html === "string" && (html || !this._data)) this._data = html;
+        } catch (e) {}
+    };
+
+    proto.getDiagnostics = function () {
+        return {
+            state: this.state,
+            crashes: this.crashes.slice(),
+            ignoredErrors: this._ignoredErrors.slice(),
+            dataLength: this._data.length
+        };
+    };
+
+    // ------------------------------------------------------------------ crash
+
+    // Is the editing surface still usable? An error is only half the evidence:
+    // plenty of exceptions are thrown by a feature and leave editing perfectly
+    // fine, and restarting for those costs the author their selection and undo
+    // history for nothing.
+    proto.isEditorResponsive = function () {
+        var editor = this.editor;
+        if (!editor) return false;
+        try {
+            var editable = editor.getEditable();
+            if (!editable || !editable.ownerDocument) return false;
+            // The iframe was removed, or its document was replaced under us.
+            if (!editable.ownerDocument.defaultView) return false;
+            if (!editable.ownerDocument.body || !editable.ownerDocument.body.contains(editable)) {
+                if (editable !== editable.ownerDocument.body) return false;
+            }
+            // Still attached to the page the host element lives in?
+            var frame = editable.ownerDocument.defaultView.frameElement;
+            if (frame && !frame.ownerDocument.documentElement.contains(frame)) return false;
+            if (typeof editor.getHTMLCode !== "function") return false;
+            editor.getHTMLCode();
+            return true;
+        }
+        catch (e) { return false; }
+    };
+
+    proto._isOwnError = function (error, message) {
+        var stack = (error && error.stack) || "";
+        var where = stack + " " + (message || "") + " " + ((error && error.fileName) || "");
+        return this._ownScriptPattern.test(where);
+    };
+
+    proto._handleError = function (error, message, event) {
+        if (this._destroyed || this.state === STATE_PERMANENT) return;
+
+        var mine = this._isOwnError(error, message);
+        // An error from elsewhere still gets a health check — a crash can surface
+        // as a foreign stack (a framework's error boundary, a rethrow) — but it
+        // only counts if the editing surface is genuinely broken.
+        var responsive = this.isEditorResponsive();
+        if (!mine && responsive) {
+            this._ignoredErrors.push({ message: String(message || (error && error.message) || ""), at: Date.now() });
+            if (this._ignoredErrors.length > 50) this._ignoredErrors.shift();
+            return;
+        }
+        if (mine && responsive) {
+            // Ours, but the editor still works: record it, do not restart.
+            this._ignoredErrors.push({
+                message: String(message || (error && error.message) || ""),
+                at: Date.now(), own: true, restarted: false
+            });
+            if (this._ignoredErrors.length > 50) this._ignoredErrors.shift();
+            this._emit("error", { error: error, message: message, restarting: false, event: event });
+            return;
+        }
+
+        this._crash(error, message, event);
+    };
+
+    proto._crash = function (error, message, event) {
+        var now = Date.now();
+        var last = this.crashes.length ? this.crashes[this.crashes.length - 1].at : 0;
+        // A crash after a long quiet stretch is a new incident, not a loop.
+        if (last && (now - last) > this._minimumNonErrorTimePeriod) this.crashes = [];
+
+        this.crashes.push({ at: now, message: String(message || (error && error.message) || "") });
+        this.state = STATE_CRASHED;
+        this._emit("error", { error: error, message: message, restarting: true, event: event });
+
+        if (this.crashes.length > this._crashNumberLimit) {
+            this.state = STATE_PERMANENT;
+            if (this._timer) { global.clearInterval(this._timer); this._timer = null; }
+            this._emit("crashedPermanently", { data: this._data, crashes: this.crashes.slice() });
+            return;
+        }
+
+        this.restart();
+    };
+
+    proto.restart = function () {
+        if (this._destroyed) return null;
+        var data = this._data;
+
+        if (this._timer) { global.clearInterval(this._timer); this._timer = null; }
+        try { this._destructor(this.editor); } catch (e) {}
+        this.editor = null;
+
+        // The old instance leaves its chrome in the host element; a fresh editor
+        // built on top of that would stack two toolbars.
+        try { if (this._host) this._host.innerHTML = ""; } catch (e) {}
+
+        try {
+            this._start();
+        }
+        catch (e) {
+            this.state = STATE_PERMANENT;
+            this._emit("crashedPermanently", { data: data, crashes: this.crashes.slice(), error: e });
+            return null;
+        }
+
+        if (data) {
+            try { this.editor.setHTMLCode(data); this._data = data; } catch (e) {}
+        }
+        this._emit("restart", { editor: this.editor, crashes: this.crashes.length, data: data });
+        return this.editor;
+    };
+
+    global.RichTextEditorWatchdog = RichTextEditorWatchdog;
+    if (global.RichTextEditor) global.RichTextEditor.Watchdog = RichTextEditorWatchdog;
+    if (typeof module !== "undefined" && module.exports) module.exports = RichTextEditorWatchdog;
+})(typeof window !== "undefined" ? window : this);