feat: WWJCloud 企业级全栈框架 v0.3.5 完整更新

🚀 核心更新：
- ✅ 完善 NestJS 企业级架构设计
- ✅ 优化配置中心和基础设施层
- ✅ 增强第三方服务集成能力
- ✅ 完善多租户架构支持
- 🎯 对标 Java Spring Boot 和 PHP ThinkPHP

📦 新增文件：
- wwjcloud-nest 完整框架结构
- Docker 容器化配置
- 管理后台界面
- 数据库迁移脚本

🔑 Key: ebb38b43ec39f355f071294fd1cf9c42

admin/public/ueditor/third-party/clipboard/clipboard.js

@@ -0,0 +1,753 @@
+/*!
+ * clipboard.js v1.5.15
+ * https://zenorocha.github.io/clipboard.js
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Clipboard = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+    /**
+     * A polyfill for Element.matches()
+     */
+    if (Element && !Element.prototype.matches) {
+        var proto = Element.prototype;
+
+        proto.matches = proto.matchesSelector ||
+            proto.mozMatchesSelector ||
+            proto.msMatchesSelector ||
+            proto.oMatchesSelector ||
+            proto.webkitMatchesSelector;
+    }
+
+    /**
+     * Finds the closest parent that matches a selector.
+     *
+     * @param {Element} element
+     * @param {String} selector
+     * @return {Function}
+     */
+    function closest (element, selector) {
+        while (element && element !== document) {
+            if (element.matches(selector)) return element;
+            element = element.parentNode;
+        }
+    }
+
+    module.exports = closest;
+
+},{}],2:[function(require,module,exports){
+    var closest = require('./closest');
+
+    /**
+     * Delegates event to a selector.
+     *
+     * @param {Element} element
+     * @param {String} selector
+     * @param {String} type
+     * @param {Function} callback
+     * @param {Boolean} useCapture
+     * @return {Object}
+     */
+    function delegate(element, selector, type, callback, useCapture) {
+        var listenerFn = listener.apply(this, arguments);
+
+        element.addEventListener(type, listenerFn, useCapture);
+
+        return {
+            destroy: function() {
+                element.removeEventListener(type, listenerFn, useCapture);
+            }
+        }
+    }
+
+    /**
+     * Finds closest match and invokes callback.
+     *
+     * @param {Element} element
+     * @param {String} selector
+     * @param {String} type
+     * @param {Function} callback
+     * @return {Function}
+     */
+    function listener(element, selector, type, callback) {
+        return function(e) {
+            e.delegateTarget = closest(e.target, selector);
+
+            if (e.delegateTarget) {
+                callback.call(element, e);
+            }
+        }
+    }
+
+    module.exports = delegate;
+
+},{"./closest":1}],3:[function(require,module,exports){
+    /**
+     * Check if argument is a HTML element.
+     *
+     * @param {Object} value
+     * @return {Boolean}
+     */
+    exports.node = function(value) {
+        return value !== undefined
+            && value instanceof HTMLElement
+            && value.nodeType === 1;
+    };
+
+    /**
+     * Check if argument is a list of HTML elements.
+     *
+     * @param {Object} value
+     * @return {Boolean}
+     */
+    exports.nodeList = function(value) {
+        var type = Object.prototype.toString.call(value);
+
+        return value !== undefined
+            && (type === '[object NodeList]' || type === '[object HTMLCollection]')
+            && ('length' in value)
+            && (value.length === 0 || exports.node(value[0]));
+    };
+
+    /**
+     * Check if argument is a string.
+     *
+     * @param {Object} value
+     * @return {Boolean}
+     */
+    exports.string = function(value) {
+        return typeof value === 'string'
+            || value instanceof String;
+    };
+
+    /**
+     * Check if argument is a function.
+     *
+     * @param {Object} value
+     * @return {Boolean}
+     */
+    exports.fn = function(value) {
+        var type = Object.prototype.toString.call(value);
+
+        return type === '[object Function]';
+    };
+
+},{}],4:[function(require,module,exports){
+    var is = require('./is');
+    var delegate = require('delegate');
+
+    /**
+     * Validates all params and calls the right
+     * listener function based on its target type.
+     *
+     * @param {String|HTMLElement|HTMLCollection|NodeList} target
+     * @param {String} type
+     * @param {Function} callback
+     * @return {Object}
+     */
+    function listen(target, type, callback) {
+        if (!target && !type && !callback) {
+            throw new Error('Missing required arguments');
+        }
+
+        if (!is.string(type)) {
+            throw new TypeError('Second argument must be a String');
+        }
+
+        if (!is.fn(callback)) {
+            throw new TypeError('Third argument must be a Function');
+        }
+
+        if (is.node(target)) {
+            return listenNode(target, type, callback);
+        }
+        else if (is.nodeList(target)) {
+            return listenNodeList(target, type, callback);
+        }
+        else if (is.string(target)) {
+            return listenSelector(target, type, callback);
+        }
+        else {
+            throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
+        }
+    }
+
+    /**
+     * Adds an event listener to a HTML element
+     * and returns a remove listener function.
+     *
+     * @param {HTMLElement} node
+     * @param {String} type
+     * @param {Function} callback
+     * @return {Object}
+     */
+    function listenNode(node, type, callback) {
+        node.addEventListener(type, callback);
+
+        return {
+            destroy: function() {
+                node.removeEventListener(type, callback);
+            }
+        }
+    }
+
+    /**
+     * Add an event listener to a list of HTML elements
+     * and returns a remove listener function.
+     *
+     * @param {NodeList|HTMLCollection} nodeList
+     * @param {String} type
+     * @param {Function} callback
+     * @return {Object}
+     */
+    function listenNodeList(nodeList, type, callback) {
+        Array.prototype.forEach.call(nodeList, function(node) {
+            node.addEventListener(type, callback);
+        });
+
+        return {
+            destroy: function() {
+                Array.prototype.forEach.call(nodeList, function(node) {
+                    node.removeEventListener(type, callback);
+                });
+            }
+        }
+    }
+
+    /**
+     * Add an event listener to a selector
+     * and returns a remove listener function.
+     *
+     * @param {String} selector
+     * @param {String} type
+     * @param {Function} callback
+     * @return {Object}
+     */
+    function listenSelector(selector, type, callback) {
+        return delegate(document.body, selector, type, callback);
+    }
+
+    module.exports = listen;
+
+},{"./is":3,"delegate":2}],5:[function(require,module,exports){
+    function select(element) {
+        var selectedText;
+
+        if (element.nodeName === 'SELECT') {
+            element.focus();
+
+            selectedText = element.value;
+        }
+        else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
+            element.focus();
+            element.setSelectionRange(0, element.value.length);
+
+            selectedText = element.value;
+        }
+        else {
+            if (element.hasAttribute('contenteditable')) {
+                element.focus();
+            }
+
+            var selection = window.getSelection();
+            var range = document.createRange();
+
+            range.selectNodeContents(element);
+            selection.removeAllRanges();
+            selection.addRange(range);
+
+            selectedText = selection.toString();
+        }
+
+        return selectedText;
+    }
+
+    module.exports = select;
+
+},{}],6:[function(require,module,exports){
+    function E () {
+        // Keep this empty so it's easier to inherit from
+        // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+    }
+
+    E.prototype = {
+        on: function (name, callback, ctx) {
+            var e = this.e || (this.e = {});
+
+            (e[name] || (e[name] = [])).push({
+                fn: callback,
+                ctx: ctx
+            });
+
+            return this;
+        },
+
+        once: function (name, callback, ctx) {
+            var self = this;
+            function listener () {
+                self.off(name, listener);
+                callback.apply(ctx, arguments);
+            };
+
+            listener._ = callback
+            return this.on(name, listener, ctx);
+        },
+
+        emit: function (name) {
+            var data = [].slice.call(arguments, 1);
+            var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+            var i = 0;
+            var len = evtArr.length;
+
+            for (i; i < len; i++) {
+                evtArr[i].fn.apply(evtArr[i].ctx, data);
+            }
+
+            return this;
+        },
+
+        off: function (name, callback) {
+            var e = this.e || (this.e = {});
+            var evts = e[name];
+            var liveEvents = [];
+
+            if (evts && callback) {
+                for (var i = 0, len = evts.length; i < len; i++) {
+                    if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+                        liveEvents.push(evts[i]);
+                }
+            }
+
+            // Remove event from queue to prevent memory leak
+            // Suggested by https://github.com/lazd
+            // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+
+            (liveEvents.length)
+                ? e[name] = liveEvents
+                : delete e[name];
+
+            return this;
+        }
+    };
+
+    module.exports = E;
+
+},{}],7:[function(require,module,exports){
+    (function (global, factory) {
+        if (typeof define === "function" && define.amd) {
+            define(['module', 'select'], factory);
+        } else if (typeof exports !== "undefined") {
+            factory(module, require('select'));
+        } else {
+            var mod = {
+                exports: {}
+            };
+            factory(mod, global.select);
+            global.clipboardAction = mod.exports;
+        }
+    })(this, function (module, _select) {
+        'use strict';
+
+        var _select2 = _interopRequireDefault(_select);
+
+        function _interopRequireDefault(obj) {
+            return obj && obj.__esModule ? obj : {
+                default: obj
+            };
+        }
+
+        var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+            return typeof obj;
+        } : function (obj) {
+            return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+        };
+
+        function _classCallCheck(instance, Constructor) {
+            if (!(instance instanceof Constructor)) {
+                throw new TypeError("Cannot call a class as a function");
+            }
+        }
+
+        var _createClass = function () {
+            function defineProperties(target, props) {
+                for (var i = 0; i < props.length; i++) {
+                    var descriptor = props[i];
+                    descriptor.enumerable = descriptor.enumerable || false;
+                    descriptor.configurable = true;
+                    if ("value" in descriptor) descriptor.writable = true;
+                    Object.defineProperty(target, descriptor.key, descriptor);
+                }
+            }
+
+            return function (Constructor, protoProps, staticProps) {
+                if (protoProps) defineProperties(Constructor.prototype, protoProps);
+                if (staticProps) defineProperties(Constructor, staticProps);
+                return Constructor;
+            };
+        }();
+
+        var ClipboardAction = function () {
+            /**
+             * @param {Object} options
+             */
+            function ClipboardAction(options) {
+                _classCallCheck(this, ClipboardAction);
+
+                this.resolveOptions(options);
+                this.initSelection();
+            }
+
+            /**
+             * Defines base properties passed from constructor.
+             * @param {Object} options
+             */
+
+
+            _createClass(ClipboardAction, [{
+                key: 'resolveOptions',
+                value: function resolveOptions() {
+                    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+                    this.action = options.action;
+                    this.emitter = options.emitter;
+                    this.target = options.target;
+                    this.text = options.text;
+                    this.trigger = options.trigger;
+
+                    this.selectedText = '';
+                }
+            }, {
+                key: 'initSelection',
+                value: function initSelection() {
+                    if (this.text) {
+                        this.selectFake();
+                    } else if (this.target) {
+                        this.selectTarget();
+                    }
+                }
+            }, {
+                key: 'selectFake',
+                value: function selectFake() {
+                    var _this = this;
+
+                    var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
+
+                    this.removeFake();
+
+                    this.fakeHandlerCallback = function () {
+                        return _this.removeFake();
+                    };
+                    this.fakeHandler = document.body.addEventListener('click', this.fakeHandlerCallback) || true;
+
+                    this.fakeElem = document.createElement('textarea');
+                    // Prevent zooming on iOS
+                    this.fakeElem.style.fontSize = '12pt';
+                    // Reset box model
+                    this.fakeElem.style.border = '0';
+                    this.fakeElem.style.padding = '0';
+                    this.fakeElem.style.margin = '0';
+                    // Move element out of screen horizontally
+                    this.fakeElem.style.position = 'absolute';
+                    this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px';
+                    // Move element to the same position vertically
+                    var yPosition = window.pageYOffset || document.documentElement.scrollTop;
+                    this.fakeElem.addEventListener('focus', window.scrollTo(0, yPosition));
+                    this.fakeElem.style.top = yPosition + 'px';
+
+                    this.fakeElem.setAttribute('readonly', '');
+                    this.fakeElem.value = this.text;
+
+                    document.body.appendChild(this.fakeElem);
+
+                    this.selectedText = (0, _select2.default)(this.fakeElem);
+                    this.copyText();
+                }
+            }, {
+                key: 'removeFake',
+                value: function removeFake() {
+                    if (this.fakeHandler) {
+                        document.body.removeEventListener('click', this.fakeHandlerCallback);
+                        this.fakeHandler = null;
+                        this.fakeHandlerCallback = null;
+                    }
+
+                    if (this.fakeElem) {
+                        document.body.removeChild(this.fakeElem);
+                        this.fakeElem = null;
+                    }
+                }
+            }, {
+                key: 'selectTarget',
+                value: function selectTarget() {
+                    this.selectedText = (0, _select2.default)(this.target);
+                    this.copyText();
+                }
+            }, {
+                key: 'copyText',
+                value: function copyText() {
+                    var succeeded = void 0;
+
+                    try {
+                        succeeded = document.execCommand(this.action);
+                    } catch (err) {
+                        succeeded = false;
+                    }
+
+                    this.handleResult(succeeded);
+                }
+            }, {
+                key: 'handleResult',
+                value: function handleResult(succeeded) {
+                    this.emitter.emit(succeeded ? 'success' : 'error', {
+                        action: this.action,
+                        text: this.selectedText,
+                        trigger: this.trigger,
+                        clearSelection: this.clearSelection.bind(this)
+                    });
+                }
+            }, {
+                key: 'clearSelection',
+                value: function clearSelection() {
+                    if (this.target) {
+                        this.target.blur();
+                    }
+
+                    window.getSelection().removeAllRanges();
+                }
+            }, {
+                key: 'destroy',
+                value: function destroy() {
+                    this.removeFake();
+                }
+            }, {
+                key: 'action',
+                set: function set() {
+                    var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';
+
+                    this._action = action;
+
+                    if (this._action !== 'copy' && this._action !== 'cut') {
+                        throw new Error('Invalid "action" value, use either "copy" or "cut"');
+                    }
+                },
+                get: function get() {
+                    return this._action;
+                }
+            }, {
+                key: 'target',
+                set: function set(target) {
+                    if (target !== undefined) {
+                        if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
+                            if (this.action === 'copy' && target.hasAttribute('disabled')) {
+                                throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
+                            }
+
+                            if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
+                                throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
+                            }
+
+                            this._target = target;
+                        } else {
+                            throw new Error('Invalid "target" value, use a valid Element');
+                        }
+                    }
+                },
+                get: function get() {
+                    return this._target;
+                }
+            }]);
+
+            return ClipboardAction;
+        }();
+
+        module.exports = ClipboardAction;
+    });
+
+},{"select":5}],8:[function(require,module,exports){
+    (function (global, factory) {
+        if (typeof define === "function" && define.amd) {
+            define(['module', './clipboard-action', 'tiny-emitter', 'good-listener'], factory);
+        } else if (typeof exports !== "undefined") {
+            factory(module, require('./clipboard-action'), require('tiny-emitter'), require('good-listener'));
+        } else {
+            var mod = {
+                exports: {}
+            };
+            factory(mod, global.clipboardAction, global.tinyEmitter, global.goodListener);
+            global.clipboard = mod.exports;
+        }
+    })(this, function (module, _clipboardAction, _tinyEmitter, _goodListener) {
+        'use strict';
+
+        var _clipboardAction2 = _interopRequireDefault(_clipboardAction);
+
+        var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
+
+        var _goodListener2 = _interopRequireDefault(_goodListener);
+
+        function _interopRequireDefault(obj) {
+            return obj && obj.__esModule ? obj : {
+                default: obj
+            };
+        }
+
+        function _classCallCheck(instance, Constructor) {
+            if (!(instance instanceof Constructor)) {
+                throw new TypeError("Cannot call a class as a function");
+            }
+        }
+
+        var _createClass = function () {
+            function defineProperties(target, props) {
+                for (var i = 0; i < props.length; i++) {
+                    var descriptor = props[i];
+                    descriptor.enumerable = descriptor.enumerable || false;
+                    descriptor.configurable = true;
+                    if ("value" in descriptor) descriptor.writable = true;
+                    Object.defineProperty(target, descriptor.key, descriptor);
+                }
+            }
+
+            return function (Constructor, protoProps, staticProps) {
+                if (protoProps) defineProperties(Constructor.prototype, protoProps);
+                if (staticProps) defineProperties(Constructor, staticProps);
+                return Constructor;
+            };
+        }();
+
+        function _possibleConstructorReturn(self, call) {
+            if (!self) {
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            }
+
+            return call && (typeof call === "object" || typeof call === "function") ? call : self;
+        }
+
+        function _inherits(subClass, superClass) {
+            if (typeof superClass !== "function" && superClass !== null) {
+                throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+            }
+
+            subClass.prototype = Object.create(superClass && superClass.prototype, {
+                constructor: {
+                    value: subClass,
+                    enumerable: false,
+                    writable: true,
+                    configurable: true
+                }
+            });
+            if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+        }
+
+        var Clipboard = function (_Emitter) {
+            _inherits(Clipboard, _Emitter);
+
+            /**
+             * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+             * @param {Object} options
+             */
+            function Clipboard(trigger, options) {
+                _classCallCheck(this, Clipboard);
+
+                var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));
+
+                _this.resolveOptions(options);
+                _this.listenClick(trigger);
+                return _this;
+            }
+
+            /**
+             * Defines if attributes would be resolved using internal setter functions
+             * or custom functions that were passed in the constructor.
+             * @param {Object} options
+             */
+
+
+            _createClass(Clipboard, [{
+                key: 'resolveOptions',
+                value: function resolveOptions() {
+                    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+                    this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
+                    this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
+                    this.text = typeof options.text === 'function' ? options.text : this.defaultText;
+                }
+            }, {
+                key: 'listenClick',
+                value: function listenClick(trigger) {
+                    var _this2 = this;
+
+                    this.listener = (0, _goodListener2.default)(trigger, 'click', function (e) {
+                        return _this2.onClick(e);
+                    });
+                }
+            }, {
+                key: 'onClick',
+                value: function onClick(e) {
+                    var trigger = e.delegateTarget || e.currentTarget;
+
+                    if (this.clipboardAction) {
+                        this.clipboardAction = null;
+                    }
+
+                    this.clipboardAction = new _clipboardAction2.default({
+                        action: this.action(trigger),
+                        target: this.target(trigger),
+                        text: this.text(trigger),
+                        trigger: trigger,
+                        emitter: this
+                    });
+                }
+            }, {
+                key: 'defaultAction',
+                value: function defaultAction(trigger) {
+                    return getAttributeValue('action', trigger);
+                }
+            }, {
+                key: 'defaultTarget',
+                value: function defaultTarget(trigger) {
+                    var selector = getAttributeValue('target', trigger);
+
+                    if (selector) {
+                        return document.querySelector(selector);
+                    }
+                }
+            }, {
+                key: 'defaultText',
+                value: function defaultText(trigger) {
+                    return getAttributeValue('text', trigger);
+                }
+            }, {
+                key: 'destroy',
+                value: function destroy() {
+                    this.listener.destroy();
+
+                    if (this.clipboardAction) {
+                        this.clipboardAction.destroy();
+                        this.clipboardAction = null;
+                    }
+                }
+            }]);
+
+            return Clipboard;
+        }(_tinyEmitter2.default);
+
+        /**
+         * Helper function to retrieve attribute value.
+         * @param {String} suffix
+         * @param {Element} element
+         */
+        function getAttributeValue(suffix, element) {
+            var attribute = 'data-clipboard-' + suffix;
+
+            if (!element.hasAttribute(attribute)) {
+                return;
+            }
+
+            return element.getAttribute(attribute);
+        }
+
+        module.exports = Clipboard;
+    });
+
+},{"./clipboard-action":7,"good-listener":4,"tiny-emitter":6}]},{},[8])(8)
+});

admin/public/ueditor/third-party/codemirror/codemirror.css

@@ -0,0 +1,106 @@
+.CodeMirror {
+    line-height: 1.5;
+    font-family: monospace;
+}
+
+.CodeMirror-scroll {
+    overflow: auto;
+    height: 300px;
+    /* This is needed to prevent an IE[67] bug where the scrolled content
+       is visible outside of the scrolling box. */
+    position: relative;
+}
+
+.CodeMirror-gutter {
+    position: absolute; left: 0; top: 0;
+    z-index: 10;
+    background-color: #f7f7f7;
+    border-right: 1px solid #eee;
+    min-width: 2em;
+    height: 100%;
+}
+.CodeMirror-gutter-text {
+    color: #aaa;
+    text-align: right;
+    padding: .4em .2em .4em .4em;
+    white-space: pre !important;
+}
+.CodeMirror-lines {
+    padding: .4em;
+}
+
+.CodeMirror pre {
+    -moz-border-radius: 0;
+    -webkit-border-radius: 0;
+    -o-border-radius: 0;
+    border-radius: 0;
+    border-width: 0; margin: 0; padding: 0; background: transparent;
+    font-family: inherit;
+    font-size: inherit;
+    padding: 0; margin: 0;
+    white-space: pre;
+    word-wrap: normal;
+}
+
+.CodeMirror-wrap pre {
+    word-wrap: break-word;
+    white-space: pre-wrap;
+    line-height: 1.4;
+}
+.CodeMirror-wrap .CodeMirror-scroll {
+    overflow-x: hidden;
+}
+
+.CodeMirror textarea {
+    outline: none !important;
+}
+
+.CodeMirror pre.CodeMirror-cursor {
+    z-index: 10;
+    position: absolute;
+    visibility: hidden;
+    border-left: 1px solid black;
+    margin-top: -2px;
+}
+.CodeMirror-focused pre.CodeMirror-cursor {
+    visibility: visible;
+}
+
+span.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused span.CodeMirror-selected { background: #d2dcf8; }
+
+.CodeMirror-searching {background: #ffa;}
+
+/* Default theme */
+
+.cm-s-default span.cm-keyword {color: #708;}
+.cm-s-default span.cm-atom {color: #219;}
+.cm-s-default span.cm-number {color: #164;}
+.cm-s-default span.cm-def {color: #00f;}
+.cm-s-default span.cm-variable {color: black;}
+.cm-s-default span.cm-variable-2 {color: #05a;}
+.cm-s-default span.cm-variable-3 {color: #085;}
+.cm-s-default span.cm-property {color: black;}
+.cm-s-default span.cm-operator {color: black;}
+.cm-s-default span.cm-comment {color: #a50;}
+.cm-s-default span.cm-string {color: #a11;}
+.cm-s-default span.cm-string-2 {color: #f50;}
+.cm-s-default span.cm-meta {color: #555;}
+.cm-s-default span.cm-error {color: #f00;}
+.cm-s-default span.cm-qualifier {color: #555;}
+.cm-s-default span.cm-builtin {color: #30a;}
+.cm-s-default span.cm-bracket {color: #cc7;}
+.cm-s-default span.cm-tag {color: #170;}
+.cm-s-default span.cm-attribute {color: #00c;}
+.cm-s-default span.cm-header {color: #a0a;}
+.cm-s-default span.cm-quote {color: #090;}
+.cm-s-default span.cm-hr {color: #999;}
+.cm-s-default span.cm-link {color: #00c;}
+
+span.cm-header, span.cm-strong {font-weight: bold;}
+span.cm-em {font-style: italic;}
+span.cm-emstrong {font-style: italic; font-weight: bold;}
+span.cm-link {text-decoration: underline;}
+
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}

admin/public/ueditor/third-party/webuploader/webuploader.css

@@ -0,0 +1,88 @@
+:root {
+    --webuploader-color-primary: var(--color-primary, #00B7EE);
+    --webuploader-color-content-bg: var(--color-content-bg, #FFFFFF);
+}
+
+.webuploader-container {
+    position: relative
+}
+
+.webuploader-element-invisible {
+    position: absolute !important;
+    clip: rect(1px 1px 1px 1px);
+    clip: rect(1px, 1px, 1px, 1px)
+}
+
+.webuploader-pick {
+    position: relative;
+    display: block;
+    cursor: pointer;
+    padding: 0;
+    color: #666;
+    text-align: center;
+    border-radius: 2px;
+    overflow: hidden;
+}
+
+.webuploader-pick-hover {
+}
+
+.webuploader-pick-disable {
+    opacity: .6;
+    pointer-events: none
+}
+
+.webuploader-list {
+    display: block;
+    margin: 0;
+    padding: 0;
+    position: static;
+    border: 1px solid #EEE;
+    border-radius: 0.2rem;
+    padding: 0.2rem;
+    background-color: var(--webuploader-color-content-bg);
+}
+
+.webuploader-list:empty {
+    display: none;
+}
+
+.webuploader-list > li {
+    list-style: none;
+    display: block;
+    border: 1px solid #EEE;
+    padding: 0px;
+    margin-bottom: 0.1rem;
+    background: var(--webuploader-color-content-bg);
+    border-radius: 0.2rem;
+}
+
+.webuploader-list > li .progress-box {
+    background-color: #EEE;
+    margin: 2px;
+    border-radius: 4px;
+}
+
+.webuploader-list > li .progress-box .progress-bar {
+    height: 3px;
+    background-color: var(--webuploader-color-primary);
+    border-radius: 4px;
+}
+
+.webuploader-list > li .progress-info {
+    font-size: 12px;
+    line-height: 20px;
+    width: 100%;
+    word-wrap: normal;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    overflow: hidden;
+    color: #999
+}
+
+.webuploader-list > li .progress-info .status {
+    display: inline;
+    line-height: 20px
+}
+
+