c0ckp1t 1.0.0

package/js_ext/ace-editor/ext-simple_tokenizer.js

@@ -0,0 +1,137 @@
+ace.define("ace/mode/json_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module){"use strict";
+var oop = require("../lib/oop");
+var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
+var JsonHighlightRules = function () {
+    this.$rules = {
+        "start": [
+            {
+                token: "variable", // single line
+                regex: '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]\\s*(?=:)'
+            }, {
+                token: "string", // single line
+                regex: '"',
+                next: "string"
+            }, {
+                token: "constant.numeric", // hex
+                regex: "0[xX][0-9a-fA-F]+\\b"
+            }, {
+                token: "constant.numeric", // float
+                regex: "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
+            }, {
+                token: "constant.language.boolean",
+                regex: "(?:true|false)\\b"
+            }, {
+                token: "text", // single quoted strings are not allowed
+                regex: "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
+            }, {
+                token: "comment", // comments are not allowed, but who cares?
+                regex: "\\/\\/.*$"
+            }, {
+                token: "comment.start", // comments are not allowed, but who cares?
+                regex: "\\/\\*",
+                next: "comment"
+            }, {
+                token: "paren.lparen",
+                regex: "[[({]"
+            }, {
+                token: "paren.rparen",
+                regex: "[\\])}]"
+            }, {
+                token: "punctuation.operator",
+                regex: /[,]/
+            }, {
+                token: "text",
+                regex: "\\s+"
+            }
+        ],
+        "string": [
+            {
+                token: "constant.language.escape",
+                regex: /\\(?:x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|["\\\/bfnrt])/
+            }, {
+                token: "string",
+                regex: '"|$',
+                next: "start"
+            }, {
+                defaultToken: "string"
+            }
+        ],
+        "comment": [
+            {
+                token: "comment.end", // comments are not allowed, but who cares?
+                regex: "\\*\\/",
+                next: "start"
+            }, {
+                defaultToken: "comment"
+            }
+        ]
+    };
+};
+oop.inherits(JsonHighlightRules, TextHighlightRules);
+exports.JsonHighlightRules = JsonHighlightRules;
+
+});
+
+ace.define("ace/ext/simple_tokenizer",["require","exports","module","ace/ext/simple_tokenizer","ace/mode/json_highlight_rules","ace/tokenizer","ace/layer/text_util"], function(require, exports, module){/**
+ * ## Simple tokenizer extension
+ *
+ * Provides standalone tokenization functionality that can parse code content using Ace's highlight rules without
+ * requiring a full editor instance. This is useful for generating syntax-highlighted tokens for external rendering,
+ * static code generation, or testing tokenization rules. The tokenizer processes text line by line and returns
+ * structured token data with CSS class names compatible with Ace themes.
+ *
+ * **Usage:**
+ * ```javascript
+ * const { tokenize } = require("ace/ext/simple_tokenizer");
+ * const { JsonHighlightRules } = require("ace/mode/json_highlight_rules");
+ *
+ * const content = '{"name": "value"}';
+ * const tokens = tokenize(content, new JsonHighlightRules());
+ * // Returns: [[{className: "ace_paren ace_lparen", value: "{"}, ...]]
+ * ```
+ *
+ * @module
+ */
+"use strict";
+var Tokenizer = require("../tokenizer").Tokenizer;
+var isTextToken = require("../layer/text_util").isTextToken;
+var SimpleTokenizer = /** @class */ (function () {
+    function SimpleTokenizer(content, tokenizer) {
+        this._lines = content.split(/\r\n|\r|\n/);
+        this._states = [];
+        this._tokenizer = tokenizer;
+    }
+    SimpleTokenizer.prototype.getTokens = function (row) {
+        var line = this._lines[row];
+        var previousState = this._states[row - 1];
+        var data = this._tokenizer.getLineTokens(line, previousState);
+        this._states[row] = data.state;
+        return data.tokens;
+    };
+    SimpleTokenizer.prototype.getLength = function () {
+        return this._lines.length;
+    };
+    return SimpleTokenizer;
+}());
+function tokenize(content, highlightRules) {
+    var tokenizer = new SimpleTokenizer(content, new Tokenizer(highlightRules.getRules()));
+    var result = [];
+    for (var lineIndex = 0; lineIndex < tokenizer.getLength(); lineIndex++) {
+        var lineTokens = tokenizer.getTokens(lineIndex);
+        result.push(lineTokens.map(function (token) { return ({
+            className: isTextToken(token.type) ? undefined : "ace_" + token.type.replace(/\./g, " ace_"),
+            value: token.value
+        }); }));
+    }
+    return result;
+}
+exports.tokenize = tokenize;
+
+});                (function() {
+                    ace.require(["ace/ext/simple_tokenizer"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/js_ext/ace-editor/ext-spellcheck.js

@@ -0,0 +1,79 @@
+ace.define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"], function(require, exports, module){/**
+ * ## Browser spellcheck integration extension for native spelling correction
+ *
+ * Provides seamless integration with browser's native spellcheck functionality through context menu interactions.
+ * Enables right-click spelling suggestions on misspelled words while preserving editor functionality and text input
+ * handling. The extension bridges browser spellcheck capabilities with the editor's text manipulation system.
+ *
+ * **Enable:** `editor.setOption("spellcheck", true)` (enabled by default)
+ * or configure it during editor initialization in the options object.
+ *
+ * @module
+ */
+"use strict";
+var event = require("../lib/event");
+exports.contextMenuHandler = function (e) {
+    var host = e.target;
+    var text = host.textInput.getElement();
+    if (!host.selection.isEmpty())
+        return;
+    var c = host.getCursorPosition();
+    var r = host.session.getWordRange(c.row, c.column);
+    var w = host.session.getTextRange(r);
+    host.session.tokenRe.lastIndex = 0;
+    if (!host.session.tokenRe.test(w))
+        return;
+    var PLACEHOLDER = "\x01\x01";
+    var value = w + " " + PLACEHOLDER;
+    text.value = value;
+    text.setSelectionRange(w.length, w.length + 1);
+    text.setSelectionRange(0, 0);
+    text.setSelectionRange(0, w.length);
+    var afterKeydown = false;
+    event.addListener(text, "keydown", function onKeydown() {
+        event.removeListener(text, "keydown", onKeydown);
+        afterKeydown = true;
+    });
+    host.textInput.setInputHandler(function (newVal) {
+        if (newVal == value)
+            return '';
+        if (newVal.lastIndexOf(value, 0) === 0)
+            return newVal.slice(value.length);
+        if (newVal.substr(text.selectionEnd) == value)
+            return newVal.slice(0, -value.length);
+        if (newVal.slice(-2) == PLACEHOLDER) {
+            var val = newVal.slice(0, -2);
+            if (val.slice(-1) == " ") {
+                if (afterKeydown)
+                    return val.substring(0, text.selectionEnd);
+                val = val.slice(0, -1);
+                host.session.replace(r, val);
+                return "";
+            }
+        }
+        return newVal;
+    });
+};
+var Editor = require("../editor").Editor;
+require("../config").defineOptions(Editor.prototype, "editor", {
+    spellcheck: {
+        set: function (val) {
+            var text = this.textInput.getElement();
+            text.spellcheck = !!val;
+            if (!val)
+                this.removeListener("nativecontextmenu", exports.contextMenuHandler);
+            else
+                this.on("nativecontextmenu", exports.contextMenuHandler);
+        },
+        value: true
+    }
+});
+
+});                (function() {
+                    ace.require(["ace/ext/spellcheck"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/js_ext/ace-editor/ext-split.js

@@ -0,0 +1,203 @@
+ace.define("ace/split",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/editor","ace/virtual_renderer","ace/edit_session"], function(require, exports, module){"use strict";
+var oop = require("./lib/oop");
+var lang = require("./lib/lang");
+var EventEmitter = require("./lib/event_emitter").EventEmitter;
+var Editor = require("./editor").Editor;
+var Renderer = require("./virtual_renderer").VirtualRenderer;
+var EditSession = require("./edit_session").EditSession;
+var Split;
+Split = function (container, theme, splits) {
+    this.BELOW = 1;
+    this.BESIDE = 0;
+    this.$container = container;
+    this.$theme = theme;
+    this.$splits = 0;
+    this.$editorCSS = "";
+    this.$editors = [];
+    this.$orientation = this.BESIDE;
+    this.setSplits(splits || 1);
+    this.$cEditor = this.$editors[0];
+    this.on("focus", function (editor) {
+        this.$cEditor = editor;
+    }.bind(this));
+};
+(function () {
+    oop.implement(this, EventEmitter);
+    this.$createEditor = function () {
+        var el = document.createElement("div");
+        el.className = this.$editorCSS;
+        el.style.cssText = "position: absolute; top:0px; bottom:0px";
+        this.$container.appendChild(el);
+        var editor = new Editor(new Renderer(el, this.$theme));
+        editor.on("focus", function () {
+            this._emit("focus", editor);
+        }.bind(this));
+        this.$editors.push(editor);
+        editor.setFontSize(this.$fontSize);
+        return editor;
+    };
+    this.setSplits = function (splits) {
+        var editor;
+        if (splits < 1) {
+            throw "The number of splits have to be > 0!";
+        }
+        if (splits == this.$splits) {
+            return;
+        }
+        else if (splits > this.$splits) {
+            while (this.$splits < this.$editors.length && this.$splits < splits) {
+                editor = this.$editors[this.$splits];
+                this.$container.appendChild(editor.container);
+                editor.setFontSize(this.$fontSize);
+                this.$splits++;
+            }
+            while (this.$splits < splits) {
+                this.$createEditor();
+                this.$splits++;
+            }
+        }
+        else {
+            while (this.$splits > splits) {
+                editor = this.$editors[this.$splits - 1];
+                this.$container.removeChild(editor.container);
+                this.$splits--;
+            }
+        }
+        this.resize();
+    };
+    this.getSplits = function () {
+        return this.$splits;
+    };
+    this.getEditor = function (idx) {
+        return this.$editors[idx];
+    };
+    this.getCurrentEditor = function () {
+        return this.$cEditor;
+    };
+    this.focus = function () {
+        this.$cEditor.focus();
+    };
+    this.blur = function () {
+        this.$cEditor.blur();
+    };
+    this.setTheme = function (theme) {
+        this.$editors.forEach(function (editor) {
+            editor.setTheme(theme);
+        });
+    };
+    this.setKeyboardHandler = function (keybinding) {
+        this.$editors.forEach(function (editor) {
+            editor.setKeyboardHandler(keybinding);
+        });
+    };
+    this.forEach = function (callback, scope) {
+        this.$editors.forEach(callback, scope);
+    };
+    this.$fontSize = "";
+    this.setFontSize = function (size) {
+        this.$fontSize = size;
+        this.forEach(function (editor) {
+            editor.setFontSize(size);
+        });
+    };
+    this.$cloneSession = function (session) {
+        var s = new EditSession(session.getDocument(), session.getMode());
+        var undoManager = session.getUndoManager();
+        s.setUndoManager(undoManager);
+        s.setTabSize(session.getTabSize());
+        s.setUseSoftTabs(session.getUseSoftTabs());
+        s.setOverwrite(session.getOverwrite());
+        s.setBreakpoints(session.getBreakpoints());
+        s.setUseWrapMode(session.getUseWrapMode());
+        s.setUseWorker(session.getUseWorker());
+        s.setWrapLimitRange(session.$wrapLimitRange.min, session.$wrapLimitRange.max);
+        s.$foldData = session.$cloneFoldData();
+        return s;
+    };
+    this.setSession = function (session, idx) {
+        var editor;
+        if (idx == null) {
+            editor = this.$cEditor;
+        }
+        else {
+            editor = this.$editors[idx];
+        }
+        var isUsed = this.$editors.some(function (editor) {
+            return editor.session === session;
+        });
+        if (isUsed) {
+            session = this.$cloneSession(session);
+        }
+        editor.setSession(session);
+        return session;
+    };
+    this.getOrientation = function () {
+        return this.$orientation;
+    };
+    this.setOrientation = function (orientation) {
+        if (this.$orientation == orientation) {
+            return;
+        }
+        this.$orientation = orientation;
+        this.resize();
+    };
+    this.resize = function () {
+        var width = this.$container.clientWidth;
+        var height = this.$container.clientHeight;
+        var editor;
+        if (this.$orientation == this.BESIDE) {
+            var editorWidth = width / this.$splits;
+            for (var i = 0; i < this.$splits; i++) {
+                editor = this.$editors[i];
+                editor.container.style.width = editorWidth + "px";
+                editor.container.style.top = "0px";
+                editor.container.style.left = i * editorWidth + "px";
+                editor.container.style.height = height + "px";
+                editor.resize();
+            }
+        }
+        else {
+            var editorHeight = height / this.$splits;
+            for (var i = 0; i < this.$splits; i++) {
+                editor = this.$editors[i];
+                editor.container.style.width = width + "px";
+                editor.container.style.top = i * editorHeight + "px";
+                editor.container.style.left = "0px";
+                editor.container.style.height = editorHeight + "px";
+                editor.resize();
+            }
+        }
+    };
+}).call(Split.prototype);
+exports.Split = Split;
+
+});
+
+ace.define("ace/ext/split",["require","exports","module","ace/ext/split","ace/split"], function(require, exports, module){/**
+ * ## Split editor container extension for multiple editor instances
+ *
+ * Provides functionality to create and manage multiple editor instances within a single container,
+ * arranged either horizontally (beside) or vertically (below). Enables synchronized editing sessions
+ * with shared configurations while maintaining independent cursor positions and selections.
+ *
+ * **Usage:**
+ * ```javascript
+ * var Split = require("ace/ext/split").Split;
+ * var split = new Split(container, theme, numberOfSplits);
+ * split.setOrientation(split.BESIDE); // or split.BELOW
+ * ```
+ *
+ * @experimental
+ * @module
+ */
+"use strict";
+module.exports = require("../split");
+
+});                (function() {
+                    ace.require(["ace/ext/split"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/js_ext/ace-editor/ext-static_highlight.js

@@ -0,0 +1,194 @@
+ace.define("ace/ext/static-css",["require","exports","module"], function(require, exports, module){module.exports = ".ace_static_highlight {\n    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'Source Code Pro', 'source-code-pro', 'Droid Sans Mono', monospace;\n    font-size: 12px;\n    white-space: pre-wrap\n}\n\n.ace_static_highlight .ace_gutter {\n    width: 2em;\n    text-align: right;\n    padding: 0 3px 0 0;\n    margin-right: 3px;\n    contain: none;\n}\n\n.ace_static_highlight.ace_show_gutter .ace_line {\n    padding-left: 2.6em;\n}\n\n.ace_static_highlight .ace_line { position: relative; }\n\n.ace_static_highlight .ace_gutter-cell {\n    -moz-user-select: -moz-none;\n    -khtml-user-select: none;\n    -webkit-user-select: none;\n    user-select: none;\n    top: 0;\n    bottom: 0;\n    left: 0;\n    position: absolute;\n}\n\n\n.ace_static_highlight .ace_gutter-cell:before {\n    content: counter(ace_line, decimal);\n    counter-increment: ace_line;\n}\n.ace_static_highlight {\n    counter-reset: ace_line;\n}\n";
+
+});
+
+ace.define("ace/ext/static_highlight",["require","exports","module","ace/edit_session","ace/layer/text","ace/ext/static-css","ace/config","ace/lib/dom","ace/lib/lang"], function(require, exports, module){/**
+ * ## Static syntax highlighting extension for code-to-HTML conversion
+ *
+ * Transforms code snippets into syntax-highlighted HTML with CSS styling without requiring a live editor instance.
+ * Uses a simplified DOM implementation to generate standalone HTML output suitable for static content generation,
+ * documentation, code export, and embedding highlighted code in web pages. Supports automatic language detection
+ * from CSS classes and custom modes/themes.
+ *
+ * @module
+ */
+"use strict";
+var EditSession = require("../edit_session").EditSession;
+var TextLayer = require("../layer/text").Text;
+var baseStyles = require("./static-css");
+var config = require("../config");
+var dom = require("../lib/dom");
+var escapeHTML = require("../lib/lang").escapeHTML;
+var Element = /** @class */ (function () {
+    function Element(type) { this.className;
+        this.type = type;
+        this.style = {};
+        this.textContent = "";
+    }
+    Element.prototype.cloneNode = function () {
+        return this;
+    };
+    Element.prototype.appendChild = function (child) {
+        this.textContent += child.toString();
+    };
+    Element.prototype.toString = function () {
+        var stringBuilder = [];
+        if (this.type != "fragment") {
+            stringBuilder.push("<", this.type);
+            if (this.className)
+                stringBuilder.push(" class='", this.className, "'");
+            var styleStr = [];
+            for (var key in this.style) {
+                styleStr.push(key, ":", this.style[key]);
+            }
+            if (styleStr.length)
+                stringBuilder.push(" style='", styleStr.join(""), "'");
+            stringBuilder.push(">");
+        }
+        if (this.textContent) {
+            stringBuilder.push(this.textContent);
+        }
+        if (this.type != "fragment") {
+            stringBuilder.push("</", this.type, ">");
+        }
+        return stringBuilder.join("");
+    };
+    return Element;
+}());
+var simpleDom = {
+    createTextNode: function (/** @type {string} */ textContent, /** @type {any} */ element) {
+        return escapeHTML(textContent);
+    },
+    createElement: function (/** @type {string} */ type) {
+        return new Element(type);
+    },
+    createFragment: function () {
+        return new Element("fragment");
+    }
+};
+var SimpleTextLayer = function () {
+    this.config = {};
+    this.dom = simpleDom;
+};
+SimpleTextLayer.prototype = TextLayer.prototype;
+var highlight = function (el, opts, callback) {
+    var m = el.className.match(/lang-(\w+)/);
+    var mode = opts.mode || m && ("ace/mode/" + m[1]);
+    if (!mode)
+        return false;
+    var theme = opts.theme || "ace/theme/textmate";
+    var data = "";
+    var nodes = [];
+    if (el.firstElementChild) {
+        var textLen = 0;
+        for (var i = 0; i < el.childNodes.length; i++) {
+            var ch = el.childNodes[i];
+            if (ch.nodeType == 3) {
+                textLen += ch.data.length;
+                data += ch.data;
+            }
+            else {
+                nodes.push(textLen, ch);
+            }
+        }
+    }
+    else {
+        data = el.textContent;
+        if (opts.trim)
+            data = data.trim();
+    }
+    highlight.render(data, mode, theme, opts.firstLineNumber, !opts.showGutter, function (highlighted) {
+        dom.importCssString(highlighted.css, "ace_highlight", true);
+        el.innerHTML = highlighted.html;
+        var container = el.firstChild.firstChild;
+        for (var i = 0; i < nodes.length; i += 2) {
+            var pos = highlighted.session.doc.indexToPosition(nodes[i]);
+            var node = nodes[i + 1];
+            var lineEl = container.children[pos.row];
+            lineEl && lineEl.appendChild(node);
+        }
+        callback && callback();
+    });
+};
+highlight.render = function (input, mode, theme, lineStart, disableGutter, callback) {
+    var waiting = 1;
+    var modeCache = EditSession.prototype.$modes;
+    if (typeof theme == "string") {
+        waiting++;
+        config.loadModule(['theme', theme], function (m) {
+            theme = m;
+            --waiting || done();
+        });
+    }
+    var modeOptions;
+    if (mode && typeof mode === "object" && !mode.getTokenizer) {
+        modeOptions = mode;
+        mode = modeOptions.path;
+    }
+    if (typeof mode == "string") {
+        waiting++;
+        config.loadModule(['mode', mode], function (m) {
+            if (!modeCache[ /**@type{string}*/(mode)] || modeOptions)
+                modeCache[ /**@type{string}*/(mode)] = new m.Mode(modeOptions);
+            mode = modeCache[ /**@type{string}*/(mode)];
+            --waiting || done();
+        });
+    }
+    function done() {
+        var result = highlight.renderSync(input, mode, /**@type{Theme}*/ (theme), lineStart, disableGutter);
+        return callback ? callback(result) : result;
+    }
+    return --waiting || done();
+};
+highlight.renderSync = function (input, mode, theme, lineStart, disableGutter) {
+    lineStart = parseInt(lineStart || 1, 10);
+    var session = new EditSession("");
+    session.setUseWorker(false);
+    session.setMode(mode);
+    var textLayer = new SimpleTextLayer();
+    textLayer.setSession(session);
+    Object.keys(textLayer.$tabStrings).forEach(function (k) {
+        if (typeof textLayer.$tabStrings[k] == "string") {
+            var el = simpleDom.createFragment();
+            el.textContent = textLayer.$tabStrings[k];
+            textLayer.$tabStrings[k] = el;
+        }
+    });
+    session.setValue(input);
+    var length = session.getLength();
+    var outerEl = simpleDom.createElement("div");
+    outerEl.className = theme.cssClass;
+    var innerEl = simpleDom.createElement("div");
+    innerEl.className = "ace_static_highlight" + (disableGutter ? "" : " ace_show_gutter");
+    innerEl.style["counter-reset"] = "ace_line " + (lineStart - 1);
+    for (var ix = 0; ix < length; ix++) {
+        var lineEl = simpleDom.createElement("div");
+        lineEl.className = "ace_line";
+        if (!disableGutter) {
+            var gutterEl = simpleDom.createElement("span");
+            gutterEl.className = "ace_gutter ace_gutter-cell";
+            gutterEl.textContent = "";
+            lineEl.appendChild(gutterEl);
+        }
+        textLayer.$renderLine(lineEl, ix, false);
+        lineEl.textContent += "\n";
+        innerEl.appendChild(lineEl);
+    }
+    outerEl.appendChild(innerEl);
+    return {
+        css: baseStyles + theme.cssText,
+        html: outerEl.toString(),
+        session: session
+    };
+};
+module.exports = highlight;
+module.exports.highlight = highlight;
+
+});                (function() {
+                    ace.require(["ace/ext/static_highlight"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/js_ext/ace-editor/ext-statusbar.js

@@ -0,0 +1,63 @@
+ace.define("ace/ext/statusbar",["require","exports","module","ace/ext/statusbar","ace/lib/dom","ace/lib/lang"], function(require, exports, module){/**
+ * ## Status bar extension for displaying editor state information
+ *
+ * Provides a lightweight status indicator that displays real-time information about the editor state including
+ * cursor position, selection details, recording status, and keyboard binding information. The status bar
+ * automatically updates on editor events and renders as an inline element that can be embedded in any parent container.
+ *
+ * **Usage:**
+ * ```javascript
+ * var StatusBar = require("ace/ext/statusbar").StatusBar;
+ * var statusBar = new StatusBar(editor, parentElement);
+ * ```
+ *
+ * @module
+ */
+"use strict";
+var dom = require("../lib/dom");
+var lang = require("../lib/lang");
+var StatusBar = /** @class */ (function () {
+    function StatusBar(editor, parentNode) {
+        this.element = dom.createElement("div");
+        this.element.className = "ace_status-indicator";
+        this.element.style.cssText = "display: inline-block;";
+        parentNode.appendChild(this.element);
+        var statusUpdate = lang.delayedCall(function () {
+            this.updateStatus(editor);
+        }.bind(this)).schedule.bind(null, 100);
+        editor.on("changeStatus", statusUpdate);
+        editor.on("changeSelection", statusUpdate);
+        editor.on("keyboardActivity", statusUpdate);
+    }
+    StatusBar.prototype.updateStatus = function (editor) {
+        var status = [];
+        function add(str, separator) {
+            str && status.push(str, separator || "|");
+        }
+        add(editor.keyBinding.getStatusText(editor));
+        if (editor.commands.recording)
+            add("REC");
+        var sel = editor.selection;
+        var c = sel.lead;
+        if (!sel.isEmpty()) {
+            var r = editor.getSelectionRange();
+            add("(" + (r.end.row - r.start.row) + ":" + (r.end.column - r.start.column) + ")", " ");
+        }
+        add(c.row + ":" + c.column, " ");
+        if (sel.rangeCount)
+            add("[" + sel.rangeCount + "]", " ");
+        status.pop();
+        this.element.textContent = status.join("");
+    };
+    return StatusBar;
+}());
+exports.StatusBar = StatusBar;
+
+});                (function() {
+                    ace.require(["ace/ext/statusbar"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+