yks-element 1.5.2 → 1.5.4

package/lib/27846e85433e54a3ec0ab34d62233dc5.js

@@ -0,0 +1,186 @@
+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/split"], function(require, exports, 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/lib/2f25a4dc442bc9aebc58cae30c50c3e2.js

@@ -0,0 +1,192 @@
+ace.define("ace/ext/whitespace",["require","exports","module","ace/lib/lang"], function(require, exports, module){"use strict";
+var lang = require("../lib/lang");
+exports.$detectIndentation = function (lines, fallback) {
+    var stats = [];
+    var changes = [];
+    var tabIndents = 0;
+    var prevSpaces = 0;
+    var max = Math.min(lines.length, 1000);
+    for (var i = 0; i < max; i++) {
+        var line = lines[i];
+        if (!/^\s*[^*+\-\s]/.test(line))
+            continue;
+        if (line[0] == "\t") {
+            tabIndents++;
+            prevSpaces = -Number.MAX_VALUE;
+        }
+        else {
+            var spaces = line.match(/^ */)[0].length;
+            if (spaces && line[spaces] != "\t") {
+                var diff = spaces - prevSpaces;
+                if (diff > 0 && !(prevSpaces % diff) && !(spaces % diff))
+                    changes[diff] = (changes[diff] || 0) + 1;
+                stats[spaces] = (stats[spaces] || 0) + 1;
+            }
+            prevSpaces = spaces;
+        }
+        while (i < max && line[line.length - 1] == "\\")
+            line = lines[i++];
+    }
+    function getScore(indent) {
+        var score = 0;
+        for (var i = indent; i < stats.length; i += indent)
+            score += stats[i] || 0;
+        return score;
+    }
+    var changesTotal = changes.reduce(function (a, b) { return a + b; }, 0);
+    var first = { score: 0, length: 0 };
+    var spaceIndents = 0;
+    for (var i = 1; i < 12; i++) {
+        var score = getScore(i);
+        if (i == 1) {
+            spaceIndents = score;
+            score = stats[1] ? 0.9 : 0.8;
+            if (!stats.length)
+                score = 0;
+        }
+        else
+            score /= spaceIndents;
+        if (changes[i])
+            score += changes[i] / changesTotal;
+        if (score > first.score)
+            first = { score: score, length: i };
+    }
+    if (first.score && first.score > 1.4)
+        var tabLength = first.length;
+    if (tabIndents > spaceIndents + 1) {
+        if (tabLength == 1 || spaceIndents < tabIndents / 4 || first.score < 1.8)
+            tabLength = undefined;
+        return { ch: "\t", length: tabLength };
+    }
+    if (spaceIndents > tabIndents + 1)
+        return { ch: " ", length: tabLength };
+};
+exports.detectIndentation = function (session) {
+    var lines = session.getLines(0, 1000);
+    var indent = exports.$detectIndentation(lines) || {};
+    if (indent.ch)
+        session.setUseSoftTabs(indent.ch == " ");
+    if (indent.length)
+        session.setTabSize(indent.length);
+    return indent;
+};
+exports.trimTrailingSpace = function (session, options) {
+    var doc = session.getDocument();
+    var lines = doc.getAllLines();
+    var min = options && options.trimEmpty ? -1 : 0;
+    var cursors = [], ci = -1;
+    if (options && options.keepCursorPosition) {
+        if (session.selection.rangeCount) {
+            session.selection.rangeList.ranges.forEach(function (x, i, ranges) {
+                var next = ranges[i + 1];
+                if (next && next.cursor.row == x.cursor.row)
+                    return;
+                cursors.push(x.cursor);
+            });
+        }
+        else {
+            cursors.push(session.selection.getCursor());
+        }
+        ci = 0;
+    }
+    var cursorRow = cursors[ci] && cursors[ci].row;
+    for (var i = 0, l = lines.length; i < l; i++) {
+        var line = lines[i];
+        var index = line.search(/\s+$/);
+        if (i == cursorRow) {
+            if (index < cursors[ci].column && index > min)
+                index = cursors[ci].column;
+            ci++;
+            cursorRow = cursors[ci] ? cursors[ci].row : -1;
+        }
+        if (index > min)
+            doc.removeInLine(i, index, line.length);
+    }
+};
+exports.convertIndentation = function (session, ch, len) {
+    var oldCh = session.getTabString()[0];
+    var oldLen = session.getTabSize();
+    if (!len)
+        len = oldLen;
+    if (!ch)
+        ch = oldCh;
+    var tab = ch == "\t" ? ch : lang.stringRepeat(ch, len);
+    var doc = session.doc;
+    var lines = doc.getAllLines();
+    var cache = {};
+    var spaceCache = {};
+    for (var i = 0, l = lines.length; i < l; i++) {
+        var line = lines[i];
+        var match = line.match(/^\s*/)[0];
+        if (match) {
+            var w = session.$getStringScreenWidth(match)[0];
+            var tabCount = Math.floor(w / oldLen);
+            var reminder = w % oldLen;
+            var toInsert = cache[tabCount] || (cache[tabCount] = lang.stringRepeat(tab, tabCount));
+            toInsert += spaceCache[reminder] || (spaceCache[reminder] = lang.stringRepeat(" ", reminder));
+            if (toInsert != match) {
+                doc.removeInLine(i, 0, match.length);
+                doc.insertInLine({ row: i, column: 0 }, toInsert);
+            }
+        }
+    }
+    session.setTabSize(len);
+    session.setUseSoftTabs(ch == " ");
+};
+exports.$parseStringArg = function (text) {
+    var indent = {};
+    if (/t/.test(text))
+        indent.ch = "\t";
+    else if (/s/.test(text))
+        indent.ch = " ";
+    var m = text.match(/\d+/);
+    if (m)
+        indent.length = parseInt(m[0], 10);
+    return indent;
+};
+exports.$parseArg = function (arg) {
+    if (!arg)
+        return {};
+    if (typeof arg == "string")
+        return exports.$parseStringArg(arg);
+    if (typeof arg.text == "string")
+        return exports.$parseStringArg(arg.text);
+    return arg;
+};
+exports.commands = [{
+        name: "detectIndentation",
+        description: "Detect indentation from content",
+        exec: function (editor) {
+            exports.detectIndentation(editor.session);
+        }
+    }, {
+        name: "trimTrailingSpace",
+        description: "Trim trailing whitespace",
+        exec: function (editor, args) {
+            exports.trimTrailingSpace(editor.session, args);
+        }
+    }, {
+        name: "convertIndentation",
+        description: "Convert indentation to ...",
+        exec: function (editor, arg) {
+            var indent = exports.$parseArg(arg);
+            exports.convertIndentation(editor.session, indent.ch, indent.length);
+        }
+    }, {
+        name: "setIndentation",
+        description: "Set indentation",
+        exec: function (editor, arg) {
+            var indent = exports.$parseArg(arg);
+            indent.length && editor.session.setTabSize(indent.length);
+            indent.ch && editor.session.setUseSoftTabs(indent.ch == " ");
+        }
+    }];
+
+});                (function() {
+                    ace.require(["ace/ext/whitespace"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/lib/2f55cddc8eb85b63ee5b4ce0e5488230.js

@@ -0,0 +1,67 @@
+ace.define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"], function(require, exports, 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/lib/2fe2904fc024afaf81732563cb83e547.js

@@ -0,0 +1,116 @@
+ace.define("ace/ext/hardwrap",["require","exports","module","ace/range","ace/editor","ace/config"], function(require, exports, module){"use strict";
+var Range = require("../range").Range;
+function hardWrap(editor, options) {
+    var max = options.column || editor.getOption("printMarginColumn");
+    var allowMerge = options.allowMerge != false;
+    var row = Math.min(options.startRow, options.endRow);
+    var endRow = Math.max(options.startRow, options.endRow);
+    var session = editor.session;
+    while (row <= endRow) {
+        var line = session.getLine(row);
+        if (line.length > max) {
+            var space = findSpace(line, max, 5);
+            if (space) {
+                var indentation = /^\s*/.exec(line)[0];
+                session.replace(new Range(row, space.start, row, space.end), "\n" + indentation);
+            }
+            endRow++;
+        }
+        else if (allowMerge && /\S/.test(line) && row != endRow) {
+            var nextLine = session.getLine(row + 1);
+            if (nextLine && /\S/.test(nextLine)) {
+                var trimmedLine = line.replace(/\s+$/, "");
+                var trimmedNextLine = nextLine.replace(/^\s+/, "");
+                var mergedLine = trimmedLine + " " + trimmedNextLine;
+                var space = findSpace(mergedLine, max, 5);
+                if (space && space.start > trimmedLine.length || mergedLine.length < max) {
+                    var replaceRange = new Range(row, trimmedLine.length, row + 1, nextLine.length - trimmedNextLine.length);
+                    session.replace(replaceRange, " ");
+                    row--;
+                    endRow--;
+                }
+                else if (trimmedLine.length < line.length) {
+                    session.remove(new Range(row, trimmedLine.length, row, line.length));
+                }
+            }
+        }
+        row++;
+    }
+    function findSpace(line, max, min) {
+        if (line.length < max)
+            return;
+        var before = line.slice(0, max);
+        var after = line.slice(max);
+        var spaceAfter = /^(?:(\s+)|(\S+)(\s+))/.exec(after);
+        var spaceBefore = /(?:(\s+)|(\s+)(\S+))$/.exec(before);
+        var start = 0;
+        var end = 0;
+        if (spaceBefore && !spaceBefore[2]) {
+            start = max - spaceBefore[1].length;
+            end = max;
+        }
+        if (spaceAfter && !spaceAfter[2]) {
+            if (!start)
+                start = max;
+            end = max + spaceAfter[1].length;
+        }
+        if (start) {
+            return {
+                start: start,
+                end: end
+            };
+        }
+        if (spaceBefore && spaceBefore[2] && spaceBefore.index > min) {
+            return {
+                start: spaceBefore.index,
+                end: spaceBefore.index + spaceBefore[2].length
+            };
+        }
+        if (spaceAfter && spaceAfter[2]) {
+            start = max + spaceAfter[2].length;
+            return {
+                start: start,
+                end: start + spaceAfter[3].length
+            };
+        }
+    }
+}
+function wrapAfterInput(e) {
+    if (e.command.name == "insertstring" && /\S/.test(e.args)) {
+        var editor = e.editor;
+        var cursor = editor.selection.cursor;
+        if (cursor.column <= editor.renderer.$printMarginColumn)
+            return;
+        var lastDelta = editor.session.$undoManager.$lastDelta;
+        hardWrap(editor, {
+            startRow: cursor.row, endRow: cursor.row,
+            allowMerge: false
+        });
+        if (lastDelta != editor.session.$undoManager.$lastDelta)
+            editor.session.markUndoGroup();
+    }
+}
+var Editor = require("../editor").Editor;
+require("../config").defineOptions(Editor.prototype, "editor", {
+    hardWrap: {
+        set: function (val) {
+            if (val) {
+                this.commands.on("afterExec", wrapAfterInput);
+            }
+            else {
+                this.commands.off("afterExec", wrapAfterInput);
+            }
+        },
+        value: false
+    }
+});
+exports.hardWrap = hardWrap;
+
+});                (function() {
+                    ace.require(["ace/ext/hardwrap"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+