c0ckp1t 1.0.0

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

@@ -0,0 +1,400 @@
+ace.define("ace/ext/textarea",["require","exports","module","ace/ext/textarea","ace/lib/event","ace/lib/useragent","ace/ace"], function(require, exports, module){/**
+ * ## Textarea transformation extension
+ *
+ * Transforms HTML textarea elements into fully-featured Ace editor instances while maintaining form compatibility
+ * and providing an interactive settings panel. Handles automatic resizing, form submission integration, and
+ * preserves the original textarea's styling properties. Includes a visual settings interface for configuring
+ * editor options like themes, modes, keybindings, and display preferences through an overlay panel.
+ *
+ * **Usage:**
+ * ```javascript
+ * var ace = require("ace/ext/textarea");
+ * var editor = ace.transformTextarea(textareaElement, {
+ *   mode: "javascript",
+ *   theme: "monokai",
+ *   wrap: true
+ * });
+ * ```
+ *
+ * @module
+ */
+"use strict";
+var event = require("../lib/event");
+var UA = require("../lib/useragent");
+var ace = require("../ace");
+module.exports = exports = ace;
+var getCSSProperty = function (element, container, property) {
+    var ret = element.style[property];
+    if (!ret) {
+        if (window.getComputedStyle) {
+            ret = window.getComputedStyle(element, '').getPropertyValue(property);
+        }
+        else {
+            ret = element.currentStyle[property];
+        }
+    }
+    if (!ret || ret == 'auto' || ret == 'intrinsic') {
+        ret = container.style[property];
+    }
+    return ret;
+};
+function applyStyles(elm, styles) {
+    for (var style in styles) {
+        elm.style[style] = styles[style];
+    }
+}
+function setupContainer(element, getValue) {
+    if (element.type != 'textarea') {
+        throw new Error("Textarea required!");
+    }
+    var parentNode = element.parentNode;
+    var container = document.createElement('div');
+    var resizeEvent = function () {
+        var style = 'position:relative;';
+        [
+            'margin-top', 'margin-left', 'margin-right', 'margin-bottom'
+        ].forEach(function (item) {
+            style += item + ':' +
+                getCSSProperty(element, container, item) + ';';
+        });
+        var width = getCSSProperty(element, container, 'width') || (element.clientWidth + "px");
+        var height = getCSSProperty(element, container, 'height') || (element.clientHeight + "px");
+        style += 'height:' + height + ';width:' + width + ';';
+        style += 'display:inline-block;';
+        container.style.cssText = style;
+    };
+    event.addListener(window, 'resize', resizeEvent);
+    resizeEvent();
+    parentNode.insertBefore(container, element.nextSibling);
+    while (parentNode !== document) {
+        if (parentNode.tagName.toUpperCase() === 'FORM') {
+            var oldSumit = parentNode.onsubmit;
+            parentNode.onsubmit = function (evt) {
+                element.value = getValue();
+                if (oldSumit) {
+                    oldSumit.call(this, evt);
+                }
+            };
+            break;
+        }
+        parentNode = parentNode.parentNode;
+    }
+    return container;
+}
+exports.transformTextarea = function (element, options) {
+    var isFocused = element.autofocus || document.activeElement == element;
+    var session;
+    var container = setupContainer(element, function () {
+        return session.getValue();
+    });
+    element.style.display = 'none';
+    container.style.background = 'white';
+    var editorDiv = document.createElement("div");
+    applyStyles(editorDiv, {
+        top: "0px",
+        left: "0px",
+        right: "0px",
+        bottom: "0px",
+        border: "1px solid gray",
+        position: "absolute"
+    });
+    container.appendChild(editorDiv);
+    var settingOpener = document.createElement("div");
+    applyStyles(settingOpener, {
+        position: "absolute",
+        right: "0px",
+        bottom: "0px",
+        cursor: "nw-resize",
+        border: "solid 9px",
+        borderColor: "lightblue gray gray #ceade6",
+        zIndex: 101
+    });
+    var settingDiv = document.createElement("div");
+    var settingDivStyles = {
+        top: "0px",
+        left: "20%",
+        right: "0px",
+        bottom: "0px",
+        position: "absolute",
+        padding: "5px",
+        zIndex: 100,
+        color: "white",
+        display: "none",
+        overflow: "auto",
+        fontSize: "14px",
+        boxShadow: "-5px 2px 3px gray"
+    };
+    if (!UA.isOldIE) {
+        settingDivStyles.backgroundColor = "rgba(0, 0, 0, 0.6)";
+    }
+    else {
+        settingDivStyles.backgroundColor = "#333";
+    }
+    applyStyles(settingDiv, settingDivStyles);
+    container.appendChild(settingDiv);
+    options = options || exports.defaultOptions;
+    var editor = ace.edit(editorDiv);
+    session = editor.getSession();
+    session.setValue(element.value || element.innerHTML);
+    if (isFocused)
+        editor.focus();
+    container.appendChild(settingOpener);
+    setupApi(editor, editorDiv, settingDiv, ace, options);
+    setupSettingPanel(settingDiv, settingOpener, editor);
+    var state = "";
+    event.addListener(settingOpener, "mousemove", function (e) {
+        var rect = this.getBoundingClientRect();
+        var x = e.clientX - rect.left, y = e.clientY - rect.top;
+        if (x + y < (rect.width + rect.height) / 2) {
+            this.style.cursor = "pointer";
+            state = "toggle";
+        }
+        else {
+            state = "resize";
+            this.style.cursor = "nw-resize";
+        }
+    });
+    event.addListener(settingOpener, "mousedown", function (e) {
+        e.preventDefault();
+        if (state == "toggle") {
+            editor.setDisplaySettings();
+            return;
+        }
+        container.style.zIndex = "100000";
+        var rect = container.getBoundingClientRect();
+        var startX = rect.width + rect.left - e.clientX;
+        var startY = rect.height + rect.top - e.clientY;
+        event.capture(settingOpener, function (e) {
+            container.style.width = e.clientX - rect.left + startX + "px";
+            container.style.height = e.clientY - rect.top + startY + "px";
+            editor.resize();
+        }, function () { });
+    });
+    return editor;
+};
+function setupApi(editor, editorDiv, settingDiv, ace, options) {
+    function toBool(value) {
+        return value === "true" || value == true;
+    }
+    editor.setDisplaySettings = function (display) {
+        if (display == null)
+            display = settingDiv.style.display == "none";
+        if (display) {
+            settingDiv.style.display = "block";
+            settingDiv.hideButton.focus();
+            editor.on("focus", function onFocus() {
+                editor.removeListener("focus", onFocus);
+                settingDiv.style.display = "none";
+            });
+        }
+        else {
+            editor.focus();
+        }
+    };
+    editor.$setOption = editor.setOption;
+    editor.$getOption = editor.getOption;
+    editor.setOption = function (key, value) {
+        switch (key) {
+            case "mode":
+                editor.$setOption("mode", "ace/mode/" + value);
+                break;
+            case "theme":
+                editor.$setOption("theme", "ace/theme/" + value);
+                break;
+            case "keybindings":
+                switch (value) {
+                    case "vim":
+                        editor.setKeyboardHandler("ace/keyboard/vim");
+                        break;
+                    case "emacs":
+                        editor.setKeyboardHandler("ace/keyboard/emacs");
+                        break;
+                    default:
+                        editor.setKeyboardHandler(null);
+                }
+                break;
+            case "wrap":
+            case "fontSize":
+                editor.$setOption(key, value);
+                break;
+            default:
+                editor.$setOption(key, toBool(value));
+        }
+    };
+    editor.getOption = function (key) {
+        switch (key) {
+            case "mode":
+                return editor.$getOption("mode").substr("ace/mode/".length);
+                break;
+            case "theme":
+                return editor.$getOption("theme").substr("ace/theme/".length);
+                break;
+            case "keybindings":
+                var value = editor.getKeyboardHandler();
+                switch (value && value.$id) {
+                    case "ace/keyboard/vim":
+                        return "vim";
+                    case "ace/keyboard/emacs":
+                        return "emacs";
+                    default:
+                        return "ace";
+                }
+                break;
+            default:
+                return editor.$getOption(key);
+        }
+    };
+    editor.setOptions(options);
+    return editor;
+}
+function setupSettingPanel(settingDiv, settingOpener, editor) {
+    var BOOL = null;
+    var desc = {
+        mode: "Mode:",
+        wrap: "Soft Wrap:",
+        theme: "Theme:",
+        fontSize: "Font Size:",
+        showGutter: "Display Gutter:",
+        keybindings: "Keyboard",
+        showPrintMargin: "Show Print Margin:",
+        useSoftTabs: "Use Soft Tabs:",
+        showInvisibles: "Show Invisibles"
+    };
+    var optionValues = {
+        mode: {
+            text: "Plain",
+            javascript: "JavaScript",
+            xml: "XML",
+            html: "HTML",
+            css: "CSS",
+            scss: "SCSS",
+            python: "Python",
+            php: "PHP",
+            java: "Java",
+            ruby: "Ruby",
+            c_cpp: "C/C++",
+            coffee: "CoffeeScript",
+            json: "json",
+            perl: "Perl",
+            clojure: "Clojure",
+            ocaml: "OCaml",
+            csharp: "C#",
+            haxe: "haXe",
+            svg: "SVG",
+            textile: "Textile",
+            groovy: "Groovy",
+            liquid: "Liquid",
+            Scala: "Scala"
+        },
+        theme: {
+            clouds: "Clouds",
+            clouds_midnight: "Clouds Midnight",
+            cobalt: "Cobalt",
+            crimson_editor: "Crimson Editor",
+            dawn: "Dawn",
+            gob: "Green on Black",
+            eclipse: "Eclipse",
+            idle_fingers: "Idle Fingers",
+            kr_theme: "Kr Theme",
+            merbivore: "Merbivore",
+            merbivore_soft: "Merbivore Soft",
+            mono_industrial: "Mono Industrial",
+            monokai: "Monokai",
+            pastel_on_dark: "Pastel On Dark",
+            solarized_dark: "Solarized Dark",
+            solarized_light: "Solarized Light",
+            textmate: "Textmate",
+            twilight: "Twilight",
+            vibrant_ink: "Vibrant Ink"
+        },
+        showGutter: BOOL,
+        fontSize: {
+            "10px": "10px",
+            "11px": "11px",
+            "12px": "12px",
+            "14px": "14px",
+            "16px": "16px"
+        },
+        wrap: {
+            off: "Off",
+            40: "40",
+            80: "80",
+            free: "Free"
+        },
+        keybindings: {
+            ace: "ace",
+            vim: "vim",
+            emacs: "emacs"
+        },
+        showPrintMargin: BOOL,
+        useSoftTabs: BOOL,
+        showInvisibles: BOOL
+    };
+    var table = [];
+    table.push("<table><tr><th>Setting</th><th>Value</th></tr>");
+    function renderOption(builder, option, obj, cValue) {
+        if (!obj) {
+            builder.push("<input type='checkbox' title='", option, "' ", cValue + "" == "true" ? "checked='true'" : "", "'></input>");
+            return;
+        }
+        builder.push("<select title='" + option + "'>");
+        for (var value in obj) {
+            builder.push("<option value='" + value + "' ");
+            if (cValue == value) {
+                builder.push(" selected ");
+            }
+            builder.push(">", obj[value], "</option>");
+        }
+        builder.push("</select>");
+    }
+    for (var option in exports.defaultOptions) {
+        table.push("<tr><td>", desc[option], "</td>");
+        table.push("<td>");
+        renderOption(table, option, optionValues[option], editor.getOption(option));
+        table.push("</td></tr>");
+    }
+    table.push("</table>");
+    settingDiv.innerHTML = table.join("");
+    var onChange = function (e) {
+        var select = e.currentTarget;
+        editor.setOption(select.title, select.value);
+    };
+    var onClick = function (e) {
+        var cb = e.currentTarget;
+        editor.setOption(cb.title, cb.checked);
+    };
+    var selects = settingDiv.getElementsByTagName("select");
+    for (var i = 0; i < selects.length; i++)
+        selects[i].onchange = onChange;
+    var cbs = settingDiv.getElementsByTagName("input");
+    for (var i = 0; i < cbs.length; i++)
+        cbs[i].onclick = onClick;
+    var button = document.createElement("input");
+    button.type = "button";
+    button.value = "Hide";
+    event.addListener(button, "click", function () {
+        editor.setDisplaySettings(false);
+    });
+    settingDiv.appendChild(button);
+    settingDiv.hideButton = button;
+}
+exports.defaultOptions = {
+    mode: "javascript",
+    theme: "textmate",
+    wrap: "off",
+    fontSize: "12px",
+    showGutter: "false",
+    keybindings: "ace",
+    showPrintMargin: "false",
+    useSoftTabs: "true",
+    showInvisibles: "false"
+};
+
+});                (function() {
+                    ace.require(["ace/ext/textarea"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

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

@@ -0,0 +1,80 @@
+ace.define("ace/ext/themelist",["require","exports","module"], function(require, exports, module){/**
+ * ## Theme enumeration utility
+ *
+ * Provides theme management for the Ace Editor by generating and organizing available themes into
+ * categorized collections. Automatically maps theme data into structured objects containing theme metadata including
+ * display captions, theme paths, brightness classification (dark/light), and normalized names. Exports both an
+ * indexed theme collection and a complete themes array for easy integration with theme selection components
+ * and configuration systems.
+ *
+ * @author <a href="mailto:matthewkastor@gmail.com">
+ *  Matthew Christopher Kastor-Inare III </a><br />
+ * @module
+ */
+"use strict";
+var themeData = [
+    ["Chrome"],
+    ["Clouds"],
+    ["Crimson Editor"],
+    ["Dawn"],
+    ["Dreamweaver"],
+    ["Eclipse"],
+    ["GitHub Light Default"],
+    ["GitHub (Legacy)", "github", "light"],
+    ["IPlastic"],
+    ["Solarized Light"],
+    ["TextMate"],
+    ["Tomorrow"],
+    ["XCode"],
+    ["Kuroir"],
+    ["KatzenMilch"],
+    ["SQL Server", "sqlserver", "light"],
+    ["CloudEditor", "cloud_editor", "light"],
+    ["Ambiance", "ambiance", "dark"],
+    ["Chaos", "chaos", "dark"],
+    ["Clouds Midnight", "clouds_midnight", "dark"],
+    ["Dracula", "", "dark"],
+    ["Cobalt", "cobalt", "dark"],
+    ["Gruvbox", "gruvbox", "dark"],
+    ["Green on Black", "gob", "dark"],
+    ["idle Fingers", "idle_fingers", "dark"],
+    ["krTheme", "kr_theme", "dark"],
+    ["Merbivore", "merbivore", "dark"],
+    ["Merbivore Soft", "merbivore_soft", "dark"],
+    ["Mono Industrial", "mono_industrial", "dark"],
+    ["Monokai", "monokai", "dark"],
+    ["Nord Dark", "nord_dark", "dark"],
+    ["One Dark", "one_dark", "dark"],
+    ["Pastel on dark", "pastel_on_dark", "dark"],
+    ["Solarized Dark", "solarized_dark", "dark"],
+    ["Terminal", "terminal", "dark"],
+    ["Tomorrow Night", "tomorrow_night", "dark"],
+    ["Tomorrow Night Blue", "tomorrow_night_blue", "dark"],
+    ["Tomorrow Night Bright", "tomorrow_night_bright", "dark"],
+    ["Tomorrow Night 80s", "tomorrow_night_eighties", "dark"],
+    ["Twilight", "twilight", "dark"],
+    ["Vibrant Ink", "vibrant_ink", "dark"],
+    ["GitHub Dark", "github_dark", "dark"],
+    ["CloudEditor Dark", "cloud_editor_dark", "dark"]
+];
+exports.themesByName = {};
+exports.themes = themeData.map(function (data) {
+    var name = data[1] || data[0].replace(/ /g, "_").toLowerCase();
+    var theme = {
+        caption: data[0],
+        theme: "ace/theme/" + name,
+        isDark: data[2] == "dark",
+        name: name
+    };
+    exports.themesByName[name] = theme;
+    return theme;
+});
+
+});                (function() {
+                    ace.require(["ace/ext/themelist"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

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

@@ -0,0 +1,201 @@
+ace.define("ace/ext/whitespace",["require","exports","module","ace/lib/lang"], function(require, exports, module){/**
+ * ## Whitespace management and indentation utilities extension
+ *
+ * Provides whitespace handling capabilities including automatic indentation detection, trailing whitespace trimming,
+ * and indentation format conversion. Analyzes code patterns to determine optimal tab settings and offers commands for
+ * maintaining consistent code formatting across different indentation styles (spaces vs. tabs) and sizes.
+ *
+ * @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;
+                        }
+                    });
+                })();
+