diff options
Diffstat (limited to 'srcs/wordpress/wp-includes/js/tinymce/themes')
4 files changed, 19468 insertions, 0 deletions
diff --git a/srcs/wordpress/wp-includes/js/tinymce/themes/inlite/theme.js b/srcs/wordpress/wp-includes/js/tinymce/themes/inlite/theme.js new file mode 100644 index 0000000..b801afb --- /dev/null +++ b/srcs/wordpress/wp-includes/js/tinymce/themes/inlite/theme.js @@ -0,0 +1,9830 @@ +(function () { +var inlite = (function (domGlobals) { + 'use strict'; + + var global = tinymce.util.Tools.resolve('tinymce.ThemeManager'); + + var global$1 = tinymce.util.Tools.resolve('tinymce.Env'); + + var global$2 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils'); + + var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay'); + + var flatten = function (arr) { + return arr.reduce(function (results, item) { + return Array.isArray(item) ? results.concat(flatten(item)) : results.concat(item); + }, []); + }; + var DeepFlatten = { flatten: flatten }; + + var result = function (id, rect) { + return { + id: id, + rect: rect + }; + }; + var match = function (editor, matchers) { + for (var i = 0; i < matchers.length; i++) { + var f = matchers[i]; + var result_1 = f(editor); + if (result_1) { + return result_1; + } + } + return null; + }; + var Matcher = { + match: match, + result: result + }; + + var fromClientRect = function (clientRect) { + return { + x: clientRect.left, + y: clientRect.top, + w: clientRect.width, + h: clientRect.height + }; + }; + var toClientRect = function (geomRect) { + return { + left: geomRect.x, + top: geomRect.y, + width: geomRect.w, + height: geomRect.h, + right: geomRect.x + geomRect.w, + bottom: geomRect.y + geomRect.h + }; + }; + var Convert = { + fromClientRect: fromClientRect, + toClientRect: toClientRect + }; + + var toAbsolute = function (rect) { + var vp = global$2.DOM.getViewPort(); + return { + x: rect.x + vp.x, + y: rect.y + vp.y, + w: rect.w, + h: rect.h + }; + }; + var measureElement = function (elm) { + var clientRect = elm.getBoundingClientRect(); + return toAbsolute({ + x: clientRect.left, + y: clientRect.top, + w: Math.max(elm.clientWidth, elm.offsetWidth), + h: Math.max(elm.clientHeight, elm.offsetHeight) + }); + }; + var getElementRect = function (editor, elm) { + return measureElement(elm); + }; + var getPageAreaRect = function (editor) { + return measureElement(editor.getElement().ownerDocument.body); + }; + var getContentAreaRect = function (editor) { + return measureElement(editor.getContentAreaContainer() || editor.getBody()); + }; + var getSelectionRect = function (editor) { + var clientRect = editor.selection.getBoundingClientRect(); + return clientRect ? toAbsolute(Convert.fromClientRect(clientRect)) : null; + }; + var Measure = { + getElementRect: getElementRect, + getPageAreaRect: getPageAreaRect, + getContentAreaRect: getContentAreaRect, + getSelectionRect: getSelectionRect + }; + + var element = function (element, predicateIds) { + return function (editor) { + for (var i = 0; i < predicateIds.length; i++) { + if (predicateIds[i].predicate(element)) { + var result = Matcher.result(predicateIds[i].id, Measure.getElementRect(editor, element)); + return result; + } + } + return null; + }; + }; + var parent = function (elements, predicateIds) { + return function (editor) { + for (var i = 0; i < elements.length; i++) { + for (var x = 0; x < predicateIds.length; x++) { + if (predicateIds[x].predicate(elements[i])) { + return Matcher.result(predicateIds[x].id, Measure.getElementRect(editor, elements[i])); + } + } + } + return null; + }; + }; + var ElementMatcher = { + element: element, + parent: parent + }; + + var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools'); + + var create = function (id, predicate) { + return { + id: id, + predicate: predicate + }; + }; + var fromContextToolbars = function (toolbars) { + return global$4.map(toolbars, function (toolbar) { + return create(toolbar.id, toolbar.predicate); + }); + }; + var PredicateId = { + create: create, + fromContextToolbars: fromContextToolbars + }; + + var textSelection = function (id) { + return function (editor) { + if (!editor.selection.isCollapsed()) { + var result = Matcher.result(id, Measure.getSelectionRect(editor)); + return result; + } + return null; + }; + }; + var emptyTextBlock = function (elements, id) { + return function (editor) { + var i; + var textBlockElementsMap = editor.schema.getTextBlockElements(); + for (i = 0; i < elements.length; i++) { + if (elements[i].nodeName === 'TABLE') { + return null; + } + } + for (i = 0; i < elements.length; i++) { + if (elements[i].nodeName in textBlockElementsMap) { + if (editor.dom.isEmpty(elements[i])) { + return Matcher.result(id, Measure.getSelectionRect(editor)); + } + return null; + } + } + return null; + }; + }; + var SelectionMatcher = { + textSelection: textSelection, + emptyTextBlock: emptyTextBlock + }; + + var fireSkinLoaded = function (editor) { + editor.fire('SkinLoaded'); + }; + var fireBeforeRenderUI = function (editor) { + return editor.fire('BeforeRenderUI'); + }; + var Events = { + fireSkinLoaded: fireSkinLoaded, + fireBeforeRenderUI: fireBeforeRenderUI + }; + + var global$5 = tinymce.util.Tools.resolve('tinymce.EditorManager'); + + var isType = function (type) { + return function (value) { + return typeof value === type; + }; + }; + var isArray = function (value) { + return Array.isArray(value); + }; + var isNull = function (value) { + return value === null; + }; + var isObject = function (predicate) { + return function (value) { + return !isNull(value) && !isArray(value) && predicate(value); + }; + }; + var isString = function (value) { + return isType('string')(value); + }; + var isNumber = function (value) { + return isType('number')(value); + }; + var isFunction = function (value) { + return isType('function')(value); + }; + var isBoolean = function (value) { + return isType('boolean')(value); + }; + var Type = { + isString: isString, + isNumber: isNumber, + isBoolean: isBoolean, + isFunction: isFunction, + isObject: isObject(isType('object')), + isNull: isNull, + isArray: isArray + }; + + var validDefaultOrDie = function (value, predicate) { + if (predicate(value)) { + return true; + } + throw new Error('Default value doesn\'t match requested type.'); + }; + var getByTypeOr = function (predicate) { + return function (editor, name, defaultValue) { + var settings = editor.settings; + validDefaultOrDie(defaultValue, predicate); + return name in settings && predicate(settings[name]) ? settings[name] : defaultValue; + }; + }; + var splitNoEmpty = function (str, delim) { + return str.split(delim).filter(function (item) { + return item.length > 0; + }); + }; + var itemsToArray = function (value, defaultValue) { + var stringToItemsArray = function (value) { + return typeof value === 'string' ? splitNoEmpty(value, /[ ,]/) : value; + }; + var boolToItemsArray = function (value, defaultValue) { + return value === false ? [] : defaultValue; + }; + if (Type.isArray(value)) { + return value; + } else if (Type.isString(value)) { + return stringToItemsArray(value); + } else if (Type.isBoolean(value)) { + return boolToItemsArray(value, defaultValue); + } + return defaultValue; + }; + var getToolbarItemsOr = function (predicate) { + return function (editor, name, defaultValue) { + var value = name in editor.settings ? editor.settings[name] : defaultValue; + validDefaultOrDie(defaultValue, predicate); + return itemsToArray(value, defaultValue); + }; + }; + var EditorSettings = { + getStringOr: getByTypeOr(Type.isString), + getBoolOr: getByTypeOr(Type.isBoolean), + getNumberOr: getByTypeOr(Type.isNumber), + getHandlerOr: getByTypeOr(Type.isFunction), + getToolbarItemsOr: getToolbarItemsOr(Type.isArray) + }; + + var global$6 = tinymce.util.Tools.resolve('tinymce.geom.Rect'); + + var result$1 = function (rect, position) { + return { + rect: rect, + position: position + }; + }; + var moveTo = function (rect, toRect) { + return { + x: toRect.x, + y: toRect.y, + w: rect.w, + h: rect.h + }; + }; + var calcByPositions = function (testPositions1, testPositions2, targetRect, contentAreaRect, panelRect) { + var relPos, relRect, outputPanelRect; + var paddedContentRect = { + x: contentAreaRect.x, + y: contentAreaRect.y, + w: contentAreaRect.w + (contentAreaRect.w < panelRect.w + targetRect.w ? panelRect.w : 0), + h: contentAreaRect.h + (contentAreaRect.h < panelRect.h + targetRect.h ? panelRect.h : 0) + }; + relPos = global$6.findBestRelativePosition(panelRect, targetRect, paddedContentRect, testPositions1); + targetRect = global$6.clamp(targetRect, paddedContentRect); + if (relPos) { + relRect = global$6.relativePosition(panelRect, targetRect, relPos); + outputPanelRect = moveTo(panelRect, relRect); + return result$1(outputPanelRect, relPos); + } + targetRect = global$6.intersect(paddedContentRect, targetRect); + if (targetRect) { + relPos = global$6.findBestRelativePosition(panelRect, targetRect, paddedContentRect, testPositions2); + if (relPos) { + relRect = global$6.relativePosition(panelRect, targetRect, relPos); + outputPanelRect = moveTo(panelRect, relRect); + return result$1(outputPanelRect, relPos); + } + outputPanelRect = moveTo(panelRect, targetRect); + return result$1(outputPanelRect, relPos); + } + return null; + }; + var calcInsert = function (targetRect, contentAreaRect, panelRect) { + return calcByPositions([ + 'cr-cl', + 'cl-cr' + ], [ + 'bc-tc', + 'bl-tl', + 'br-tr' + ], targetRect, contentAreaRect, panelRect); + }; + var calc = function (targetRect, contentAreaRect, panelRect) { + return calcByPositions([ + 'tc-bc', + 'bc-tc', + 'tl-bl', + 'bl-tl', + 'tr-br', + 'br-tr', + 'cr-cl', + 'cl-cr' + ], [ + 'bc-tc', + 'bl-tl', + 'br-tr', + 'cr-cl' + ], targetRect, contentAreaRect, panelRect); + }; + var userConstrain = function (handler, targetRect, contentAreaRect, panelRect) { + var userConstrainedPanelRect; + if (typeof handler === 'function') { + userConstrainedPanelRect = handler({ + elementRect: Convert.toClientRect(targetRect), + contentAreaRect: Convert.toClientRect(contentAreaRect), + panelRect: Convert.toClientRect(panelRect) + }); + return Convert.fromClientRect(userConstrainedPanelRect); + } + return panelRect; + }; + var defaultHandler = function (rects) { + return rects.panelRect; + }; + var Layout = { + calcInsert: calcInsert, + calc: calc, + userConstrain: userConstrain, + defaultHandler: defaultHandler + }; + + var toAbsoluteUrl = function (editor, url) { + return editor.documentBaseURI.toAbsolute(url); + }; + var urlFromName = function (name) { + var prefix = global$5.baseURL + '/skins/'; + return name ? prefix + name : prefix + 'lightgray'; + }; + var getTextSelectionToolbarItems = function (editor) { + return EditorSettings.getToolbarItemsOr(editor, 'selection_toolbar', [ + 'bold', + 'italic', + '|', + 'quicklink', + 'h2', + 'h3', + 'blockquote' + ]); + }; + var getInsertToolbarItems = function (editor) { + return EditorSettings.getToolbarItemsOr(editor, 'insert_toolbar', [ + 'quickimage', + 'quicktable' + ]); + }; + var getPositionHandler = function (editor) { + return EditorSettings.getHandlerOr(editor, 'inline_toolbar_position_handler', Layout.defaultHandler); + }; + var getSkinUrl = function (editor) { + var settings = editor.settings; + return settings.skin_url ? toAbsoluteUrl(editor, settings.skin_url) : urlFromName(settings.skin); + }; + var isSkinDisabled = function (editor) { + return editor.settings.skin === false; + }; + var Settings = { + getTextSelectionToolbarItems: getTextSelectionToolbarItems, + getInsertToolbarItems: getInsertToolbarItems, + getPositionHandler: getPositionHandler, + getSkinUrl: getSkinUrl, + isSkinDisabled: isSkinDisabled + }; + + var fireSkinLoaded$1 = function (editor, callback) { + var done = function () { + editor._skinLoaded = true; + Events.fireSkinLoaded(editor); + callback(); + }; + if (editor.initialized) { + done(); + } else { + editor.on('init', done); + } + }; + var load = function (editor, callback) { + var skinUrl = Settings.getSkinUrl(editor); + var done = function () { + fireSkinLoaded$1(editor, callback); + }; + if (Settings.isSkinDisabled(editor)) { + done(); + } else { + global$2.DOM.styleSheetLoader.load(skinUrl + '/skin.min.css', done); + editor.contentCSS.push(skinUrl + '/content.inline.min.css'); + } + }; + var SkinLoader = { load: load }; + + var getSelectionElements = function (editor) { + var node = editor.selection.getNode(); + var elms = editor.dom.getParents(node, '*'); + return elms; + }; + var createToolbar = function (editor, selector, id, items) { + var selectorPredicate = function (elm) { + return editor.dom.is(elm, selector); + }; + return { + predicate: selectorPredicate, + id: id, + items: items + }; + }; + var getToolbars = function (editor) { + var contextToolbars = editor.contextToolbars; + return DeepFlatten.flatten([ + contextToolbars ? contextToolbars : [], + createToolbar(editor, 'img', 'image', 'alignleft aligncenter alignright') + ]); + }; + var findMatchResult = function (editor, toolbars) { + var result, elements, contextToolbarsPredicateIds; + elements = getSelectionElements(editor); + contextToolbarsPredicateIds = PredicateId.fromContextToolbars(toolbars); + result = Matcher.match(editor, [ + ElementMatcher.element(elements[0], contextToolbarsPredicateIds), + SelectionMatcher.textSelection('text'), + SelectionMatcher.emptyTextBlock(elements, 'insert'), + ElementMatcher.parent(elements, contextToolbarsPredicateIds) + ]); + return result && result.rect ? result : null; + }; + var editorHasFocus = function (editor) { + return domGlobals.document.activeElement === editor.getBody(); + }; + var togglePanel = function (editor, panel) { + var toggle = function () { + var toolbars = getToolbars(editor); + var result = findMatchResult(editor, toolbars); + if (result) { + panel.show(editor, result.id, result.rect, toolbars); + } else { + panel.hide(); + } + }; + return function () { + if (!editor.removed && editorHasFocus(editor)) { + toggle(); + } + }; + }; + var repositionPanel = function (editor, panel) { + return function () { + var toolbars = getToolbars(editor); + var result = findMatchResult(editor, toolbars); + if (result) { + panel.reposition(editor, result.id, result.rect); + } + }; + }; + var ignoreWhenFormIsVisible = function (editor, panel, f) { + return function () { + if (!editor.removed && !panel.inForm()) { + f(); + } + }; + }; + var bindContextualToolbarsEvents = function (editor, panel) { + var throttledTogglePanel = global$3.throttle(togglePanel(editor, panel), 0); + var throttledTogglePanelWhenNotInForm = global$3.throttle(ignoreWhenFormIsVisible(editor, panel, togglePanel(editor, panel)), 0); + var reposition = repositionPanel(editor, panel); + editor.on('blur hide ObjectResizeStart', panel.hide); + editor.on('click', throttledTogglePanel); + editor.on('nodeChange mouseup', throttledTogglePanelWhenNotInForm); + editor.on('ResizeEditor keyup', throttledTogglePanel); + editor.on('ResizeWindow', reposition); + global$2.DOM.bind(global$1.container, 'scroll', reposition); + editor.on('remove', function () { + global$2.DOM.unbind(global$1.container, 'scroll', reposition); + panel.remove(); + }); + editor.shortcuts.add('Alt+F10,F10', '', panel.focus); + }; + var overrideLinkShortcut = function (editor, panel) { + editor.shortcuts.remove('meta+k'); + editor.shortcuts.add('meta+k', '', function () { + var toolbars = getToolbars(editor); + var result = Matcher.match(editor, [SelectionMatcher.textSelection('quicklink')]); + if (result) { + panel.show(editor, result.id, result.rect, toolbars); + } + }); + }; + var renderInlineUI = function (editor, panel) { + SkinLoader.load(editor, function () { + bindContextualToolbarsEvents(editor, panel); + overrideLinkShortcut(editor, panel); + }); + return {}; + }; + var fail = function (message) { + throw new Error(message); + }; + var renderUI = function (editor, panel) { + return editor.inline ? renderInlineUI(editor, panel) : fail('inlite theme only supports inline mode.'); + }; + var Render = { renderUI: renderUI }; + + var noop = function () { + }; + var constant = function (value) { + return function () { + return value; + }; + }; + var never = constant(false); + var always = constant(true); + + var never$1 = never; + var always$1 = always; + var none = function () { + return NONE; + }; + var NONE = function () { + var eq = function (o) { + return o.isNone(); + }; + var call = function (thunk) { + return thunk(); + }; + var id = function (n) { + return n; + }; + var noop = function () { + }; + var nul = function () { + return null; + }; + var undef = function () { + return undefined; + }; + var me = { + fold: function (n, s) { + return n(); + }, + is: never$1, + isSome: never$1, + isNone: always$1, + getOr: id, + getOrThunk: call, + getOrDie: function (msg) { + throw new Error(msg || 'error: getOrDie called on none.'); + }, + getOrNull: nul, + getOrUndefined: undef, + or: id, + orThunk: call, + map: none, + ap: none, + each: noop, + bind: none, + flatten: none, + exists: never$1, + forall: always$1, + filter: none, + equals: eq, + equals_: eq, + toArray: function () { + return []; + }, + toString: constant('none()') + }; + if (Object.freeze) { + Object.freeze(me); + } + return me; + }(); + var some = function (a) { + var constant_a = function () { + return a; + }; + var self = function () { + return me; + }; + var map = function (f) { + return some(f(a)); + }; + var bind = function (f) { + return f(a); + }; + var me = { + fold: function (n, s) { + return s(a); + }, + is: function (v) { + return a === v; + }, + isSome: always$1, + isNone: never$1, + getOr: constant_a, + getOrThunk: constant_a, + getOrDie: constant_a, + getOrNull: constant_a, + getOrUndefined: constant_a, + or: self, + orThunk: self, + map: map, + ap: function (optfab) { + return optfab.fold(none, function (fab) { + return some(fab(a)); + }); + }, + each: function (f) { + f(a); + }, + bind: bind, + flatten: constant_a, + exists: bind, + forall: bind, + filter: function (f) { + return f(a) ? me : NONE; + }, + equals: function (o) { + return o.is(a); + }, + equals_: function (o, elementEq) { + return o.fold(never$1, function (b) { + return elementEq(a, b); + }); + }, + toArray: function () { + return [a]; + }, + toString: function () { + return 'some(' + a + ')'; + } + }; + return me; + }; + var from = function (value) { + return value === null || value === undefined ? NONE : some(value); + }; + var Option = { + some: some, + none: none, + from: from + }; + + var typeOf = function (x) { + if (x === null) { + return 'null'; + } + var t = typeof x; + if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) { + return 'array'; + } + if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) { + return 'string'; + } + return t; + }; + var isType$1 = function (type) { + return function (value) { + return typeOf(value) === type; + }; + }; + var isArray$1 = isType$1('array'); + var isFunction$1 = isType$1('function'); + var isNumber$1 = isType$1('number'); + + var slice = Array.prototype.slice; + var rawIndexOf = function () { + var pIndexOf = Array.prototype.indexOf; + var fastIndex = function (xs, x) { + return pIndexOf.call(xs, x); + }; + var slowIndex = function (xs, x) { + return slowIndexOf(xs, x); + }; + return pIndexOf === undefined ? slowIndex : fastIndex; + }(); + var indexOf = function (xs, x) { + var r = rawIndexOf(xs, x); + return r === -1 ? Option.none() : Option.some(r); + }; + var exists = function (xs, pred) { + return findIndex(xs, pred).isSome(); + }; + var map = function (xs, f) { + var len = xs.length; + var r = new Array(len); + for (var i = 0; i < len; i++) { + var x = xs[i]; + r[i] = f(x, i, xs); + } + return r; + }; + var each = function (xs, f) { + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + f(x, i, xs); + } + }; + var filter = function (xs, pred) { + var r = []; + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + if (pred(x, i, xs)) { + r.push(x); + } + } + return r; + }; + var foldl = function (xs, f, acc) { + each(xs, function (x) { + acc = f(acc, x); + }); + return acc; + }; + var find = function (xs, pred) { + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + if (pred(x, i, xs)) { + return Option.some(x); + } + } + return Option.none(); + }; + var findIndex = function (xs, pred) { + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + if (pred(x, i, xs)) { + return Option.some(i); + } + } + return Option.none(); + }; + var slowIndexOf = function (xs, x) { + for (var i = 0, len = xs.length; i < len; ++i) { + if (xs[i] === x) { + return i; + } + } + return -1; + }; + var push = Array.prototype.push; + var flatten$1 = function (xs) { + var r = []; + for (var i = 0, len = xs.length; i < len; ++i) { + if (!isArray$1(xs[i])) { + throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs); + } + push.apply(r, xs[i]); + } + return r; + }; + var from$1 = isFunction$1(Array.from) ? Array.from : function (x) { + return slice.call(x); + }; + + var count = 0; + var funcs = { + id: function () { + return 'mceu_' + count++; + }, + create: function (name, attrs, children) { + var elm = domGlobals.document.createElement(name); + global$2.DOM.setAttribs(elm, attrs); + if (typeof children === 'string') { + elm.innerHTML = children; + } else { + global$4.each(children, function (child) { + if (child.nodeType) { + elm.appendChild(child); + } + }); + } + return elm; + }, + createFragment: function (html) { + return global$2.DOM.createFragment(html); + }, + getWindowSize: function () { + return global$2.DOM.getViewPort(); + }, + getSize: function (elm) { + var width, height; + if (elm.getBoundingClientRect) { + var rect = elm.getBoundingClientRect(); + width = Math.max(rect.width || rect.right - rect.left, elm.offsetWidth); + height = Math.max(rect.height || rect.bottom - rect.bottom, elm.offsetHeight); + } else { + width = elm.offsetWidth; + height = elm.offsetHeight; + } + return { + width: width, + height: height + }; + }, + getPos: function (elm, root) { + return global$2.DOM.getPos(elm, root || funcs.getContainer()); + }, + getContainer: function () { + return global$1.container ? global$1.container : domGlobals.document.body; + }, + getViewPort: function (win) { + return global$2.DOM.getViewPort(win); + }, + get: function (id) { + return domGlobals.document.getElementById(id); + }, + addClass: function (elm, cls) { + return global$2.DOM.addClass(elm, cls); + }, + removeClass: function (elm, cls) { + return global$2.DOM.removeClass(elm, cls); + }, + hasClass: function (elm, cls) { + return global$2.DOM.hasClass(elm, cls); + }, + toggleClass: function (elm, cls, state) { + return global$2.DOM.toggleClass(elm, cls, state); + }, + css: function (elm, name, value) { + return global$2.DOM.setStyle(elm, name, value); + }, + getRuntimeStyle: function (elm, name) { + return global$2.DOM.getStyle(elm, name, true); + }, + on: function (target, name, callback, scope) { + return global$2.DOM.bind(target, name, callback, scope); + }, + off: function (target, name, callback) { + return global$2.DOM.unbind(target, name, callback); + }, + fire: function (target, name, args) { + return global$2.DOM.fire(target, name, args); + }, + innerHtml: function (elm, html) { + global$2.DOM.setHTML(elm, html); + } + }; + + var global$7 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery'); + + var global$8 = tinymce.util.Tools.resolve('tinymce.util.Class'); + + var global$9 = tinymce.util.Tools.resolve('tinymce.util.EventDispatcher'); + + var BoxUtils = { + parseBox: function (value) { + var len; + var radix = 10; + if (!value) { + return; + } + if (typeof value === 'number') { + value = value || 0; + return { + top: value, + left: value, + bottom: value, + right: value + }; + } + value = value.split(' '); + len = value.length; + if (len === 1) { + value[1] = value[2] = value[3] = value[0]; + } else if (len === 2) { + value[2] = value[0]; + value[3] = value[1]; + } else if (len === 3) { + value[3] = value[1]; + } + return { + top: parseInt(value[0], radix) || 0, + right: parseInt(value[1], radix) || 0, + bottom: parseInt(value[2], radix) || 0, + left: parseInt(value[3], radix) || 0 + }; + }, + measureBox: function (elm, prefix) { + function getStyle(name) { + var defaultView = elm.ownerDocument.defaultView; + if (defaultView) { + var computedStyle = defaultView.getComputedStyle(elm, null); + if (computedStyle) { + name = name.replace(/[A-Z]/g, function (a) { + return '-' + a; + }); + return computedStyle.getPropertyValue(name); + } else { + return null; + } + } + return elm.currentStyle[name]; + } + function getSide(name) { + var val = parseFloat(getStyle(name)); + return isNaN(val) ? 0 : val; + } + return { + top: getSide(prefix + 'TopWidth'), + right: getSide(prefix + 'RightWidth'), + bottom: getSide(prefix + 'BottomWidth'), + left: getSide(prefix + 'LeftWidth') + }; + } + }; + + function noop$1() { + } + function ClassList(onchange) { + this.cls = []; + this.cls._map = {}; + this.onchange = onchange || noop$1; + this.prefix = ''; + } + global$4.extend(ClassList.prototype, { + add: function (cls) { + if (cls && !this.contains(cls)) { + this.cls._map[cls] = true; + this.cls.push(cls); + this._change(); + } + return this; + }, + remove: function (cls) { + if (this.contains(cls)) { + var i = void 0; + for (i = 0; i < this.cls.length; i++) { + if (this.cls[i] === cls) { + break; + } + } + this.cls.splice(i, 1); + delete this.cls._map[cls]; + this._change(); + } + return this; + }, + toggle: function (cls, state) { + var curState = this.contains(cls); + if (curState !== state) { + if (curState) { + this.remove(cls); + } else { + this.add(cls); + } + this._change(); + } + return this; + }, + contains: function (cls) { + return !!this.cls._map[cls]; + }, + _change: function () { + delete this.clsValue; + this.onchange.call(this); + } + }); + ClassList.prototype.toString = function () { + var value; + if (this.clsValue) { + return this.clsValue; + } + value = ''; + for (var i = 0; i < this.cls.length; i++) { + if (i > 0) { + value += ' '; + } + value += this.prefix + this.cls[i]; + } + return value; + }; + + function unique(array) { + var uniqueItems = []; + var i = array.length, item; + while (i--) { + item = array[i]; + if (!item.__checked) { + uniqueItems.push(item); + item.__checked = 1; + } + } + i = uniqueItems.length; + while (i--) { + delete uniqueItems[i].__checked; + } + return uniqueItems; + } + var expression = /^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i; + var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g; + var whiteSpace = /^\s*|\s*$/g; + var Collection; + var Selector = global$8.extend({ + init: function (selector) { + var match = this.match; + function compileNameFilter(name) { + if (name) { + name = name.toLowerCase(); + return function (item) { + return name === '*' || item.type === name; + }; + } + } + function compileIdFilter(id) { + if (id) { + return function (item) { + return item._name === id; + }; + } + } + function compileClassesFilter(classes) { + if (classes) { + classes = classes.split('.'); + return function (item) { + var i = classes.length; + while (i--) { + if (!item.classes.contains(classes[i])) { + return false; + } + } + return true; + }; + } |