文档迁移

_src/api.js

+/**
+ * 该文件定义了API文档所使用到的本地函数的说明
+ * @file
+ * @module Native
+ */
+
+/**
+ * 辅助接口说明
+ * @module Native
+ * @unfile
+ */
+
+/**
+ * 原生String对象， 字符串
+ * @class String
+ */
+
+/**
+ * 原生Function对象， 函数
+ * @class Function
+ */
+
+/**
+ * 原生Object对象， 普通对象
+ * @remind 如果某一方法的参数类型为Object时， 表示该参数应该接受一个key-value集合
+ * @class Object
+ */
+
+/**
+ * 原生Boolean对象， 布尔值
+ * @class Boolean
+ */
+
+/**
+ * 原生Number对象， 数值
+ * @class Number
+ */
+
+/**
+ * 原生NULL对象， 空
+ * @class NULL
+ */
+
+/**
+ * 原生Array对象， 数组
+ * @class Array
+ */
+
+/**
+ * 浏览器Node， dom节点
+ * @class Node
+ */
+
+/**
+ * 浏览器Element， dom元素
+ * @class Element
+ */
+
+/**
+ * UEditor模拟dom节点对象
+ * @class uNode
+ */
\ No newline at end of file

_src/core/EventBase.js

 /**
+ * UE采用的事件基类
  * @file
- * @name UE.EventBase
- * @short EventBase
- * @import editor.js,core/utils.js
- * @desc UE采用的事件基类，继承此类的对应类将获取addListener,removeListener,fireEvent方法。
+ * @module UE
+ * @class EventBase
+ * @since 1.2.6.1
+ */
+
+/**
+ * UEditor公用空间，UEditor所有的功能都挂载在该空间下
+ * @unfile
+ * @module UE
+ */
+
+/**
+ * UE采用的事件基类，继承此类的对应类将获取addListener,removeListener,fireEvent方法。
  * 在UE中，Editor以及所有ui实例都继承了该类，故可以在对应的ui对象以及editor对象上使用上述方法。
+ * @unfile
+ * @module UE
+ * @class EventBase
+ */
+
+/**
+ * 通过此构造器，子类可以继承EventBase获取事件监听的方法
+ * @constructor
+ * @example
+ * ```javascript
+ * UE.EventBase.call(editor);
+ * ```
  */
 var EventBase = UE.EventBase = function () {};
 
 EventBase.prototype = {
+
     /**
      * 注册事件监听器
-     * @name addListener
-     * @grammar editor.addListener(types,fn)  //types为事件名称，多个可用空格分隔
+     * @method addListener
+     * @param { String } types 监听的事件名称，同时监听多个事件使用空格分隔
+     * @param { Function } fn 监听的事件被触发时，会执行该回调函数
+     * @waining 事件被触发时，监听的函数假如返回的值恒等于true，回调函数的队列中后面的函数将不执行
      * @example
+     * ```javascript
      * editor.addListener('selectionchange',function(){
      *      console.log("选区已经变化！");
      * })
@@ -25,6 +51,8 @@ EventBase.prototype = {
      *         }
      *         console.log(this.getContent) // this是注册的事件的编辑器实例
      * })
+     * ```
+     * @see UE.EventBase:fireEvent(String)
      */
     addListener:function (types, listener) {
         types = utils.trim(types).split(' ');
@@ -32,13 +60,17 @@ EventBase.prototype = {
             getListener(this, ti, true).push(listener);
         }
     },
+
     /**
      * 移除事件监听器
-     * @name removeListener
-     * @grammar editor.removeListener(types,fn)  //types为事件名称，多个可用空格分隔
+     * @method removeListener
+     * @param { String } types 移除的事件名称，同时移除多个事件使用空格分隔
+     * @param { Function } fn 移除监听事件的函数引用
      * @example
+     * ```javascript
      * //changeCallback为方法体
      * editor.removeListener("selectionchange",changeCallback);
+     * ```
      */
     removeListener:function (types, listener) {
         types = utils.trim(types).split(' ');
@@ -46,12 +78,38 @@ EventBase.prototype = {
             utils.removeItem(getListener(this, ti) || [], listener);
         }
     },
+
     /**
      * 触发事件
-     * @name fireEvent
-     * @grammar editor.fireEvent(types)  //types为事件名称，多个可用空格分隔
+     * @method fireEvent
+     * @param { String } types 触发的事件名称，同时触发多个事件使用空格分隔
+     * @remind 该方法会触发addListener
+     * @return { * } 返回触发事件的队列中，最后执行的回调函数的返回值
      * @example
+     * ```javascript
      * editor.fireEvent("selectionchange");
+     * ```
+     */
+
+    /**
+     * 触发事件
+     * @method fireEvent
+     * @param { String } types 触发的事件名称，同时触发多个事件使用空格分隔
+     * @param { *... } options 可选参数，可以传入一个或多个参数，会传给事件触发的回调函数
+     * @return { * } 返回触发事件的队列中，最后执行的回调函数的返回值
+     * @example
+     * ```javascript
+     *
+     * editor.addListener( "selectionchange", function ( type, arg1, arg2 ) {
+     *
+     *     console.log( arg1 + " " + arg2 );
+     *
+     * } );
+     *
+     * //触发selectionchange事件， 会执行上面的事件监听器
+     * //output: Hello World
+     * editor.fireEvent("selectionchange", "Hello", "World");
+     * ```
      */
     fireEvent:function () {
         var types = arguments[0];
@@ -81,12 +139,15 @@ EventBase.prototype = {
 };
 /**
  * 获得对象所拥有监听类型的所有监听器
+ * @unfile
+ * @module UE
+ * @since 1.2.6.1
+ * @method getListener
  * @public
- * @function
- * @param {Object} obj  查询监听器的对象
- * @param {String} type 事件类型
- * @param {Boolean} force  为true且当前所有type类型的侦听器不存在时，创建一个空监听器数组
- * @returns {Array} 监听器数组
+ * @param { Object } obj  查询监听器的对象
+ * @param { String } type 事件类型
+ * @param { Boolean } force  为true且当前所有type类型的侦听器不存在时，创建一个空监听器数组
+ * @return { Array } 监听器数组
  */
 function getListener(obj, type, force) {
     var allListeners;

_src/core/Selection.js

-///import editor.js
-///import core/browser.js
-///import core/dom/dom.js
-///import core/dom/dtd.js
-///import core/dom/domUtils.js
-///import core/dom/Range.js
 /**
- * @class baidu.editor.dom.Selection    Selection类
+ * 选集
+ * @file
+ * @module UE.dom
+ * @class Selection
+ * @since 1.2.6.1
+ */
+
+/**
+ * 选区集合
+ * @unfile
+ * @module UE.dom
+ * @class Selection
  */
 (function () {
 
@@ -73,7 +78,7 @@
         return  {container:child, offset:position > 0 ? -distance : child.nodeValue.length + distance}
     }
 
-    /**
+    /*
      * 将ieRange转换为Range对象
      * @param {Range}   ieRange    ieRange对象
      * @param {Range}   range      Range对象
@@ -93,7 +98,7 @@
         return range;
     }
 
-    /**
+    /*
      * 获得ieRange
      * @param {Selection} sel    Selection对象
      * @return {ieRange}    得到ieRange
@@ -135,17 +140,21 @@
     };
 
     Selection.prototype = {
+
         rangeInBody : function(rng,txtRange){
             var node = browser.ie9below || txtRange ? rng.item ? rng.item() : rng.parentElement() : rng.startContainer;
 
             return node === this.document.body || domUtils.inDoc(node,this.document);
         },
+
         /**
          * 获取原生seleciton对象
-         * @public
-         * @function
-         * @name    baidu.editor.dom.Selection.getNative
-         * @return {Selection}    获得selection对象
+         * @method getNative
+         * @return { Object } 获得selection对象
+         * @example
+         * ```javascript
+         * editor.selection.getNative();
+         * ```
          */
         getNative:function () {
             var doc = this.document;
@@ -155,12 +164,15 @@
                 return null;
             }
         },
+
         /**
          * 获得ieRange
-         * @public
-         * @function
-         * @name    baidu.editor.dom.Selection.getIERange
-         * @return {ieRange}    返回ie原生的Range
+         * @method getIERange
+         * @return { Object } 返回ie原生的Range
+         * @example
+         * ```javascript
+         * editor.selection.getIERange();
+         * ```
          */
         getIERange:function () {
             var ieRange = _getIERange( this );
@@ -174,9 +186,7 @@
 
         /**
          * 缓存当前选区的range和选区的开始节点
-         * @public
-         * @function
-         * @name    baidu.editor.dom.Selection.cache
+         * @method cache
          */
         cache:function () {
             this.clear();
@@ -185,6 +195,15 @@
             this._cachedStartElementPath = this.getStartElementPath();
         },
 
+        /**
+         * 获取选区开始位置的父节点到body
+         * @method getStartElementPath
+         * @return { Array } 返回父节点集合
+         * @example
+         * ```javascript
+         * editor.selection.getStartElementPath();
+         * ```
+         */
         getStartElementPath:function () {
             if ( this._cachedStartElementPath ) {
                 return this._cachedStartElementPath;
@@ -195,17 +214,18 @@
             }
             return [];
         },
+
         /**
          * 清空缓存
-         * @public
-         * @function
-         * @name    baidu.editor.dom.Selection.clear
+         * @method clear
          */
         clear:function () {
             this._cachedStartElementPath = this._cachedRange = this._cachedStartElement = null;
         },
+
         /**
          * 编辑器是否得到了选区
+         * @method isFocus
          */
         isFocus:function () {
             try {
@@ -221,12 +241,15 @@
             }
 
         },
+
         /**
          * 获取选区对应的Range
-         * @public
-         * @function
-         * @name    baidu.editor.dom.Selection.getRange
-         * @returns {baidu.editor.dom.Range}    得到Range对象
+         * @method getRange
+         * @return { Object } 得到Range对象
+         * @example
+         * ```javascript
+         * editor.selection.getRange();
+         * ```
          */
         getRange:function () {
             var me = this;
@@ -285,10 +308,12 @@
 
         /**
          * 获取开始元素，用于状态反射
-         * @public
-         * @function
-         * @name    baidu.editor.dom.Selection.getStart
-         * @return {Element}     获得开始元素
+         * @method getStart
+         * @return { Element } 获得开始元素
+         * @example
+         * ```javascript
+         * editor.selection.getStart();
+         * ```
          */
         getStart:function () {
             if ( this._cachedStartElement ) {
@@ -330,12 +355,15 @@
             }
             return start;
         },
+
         /**
          * 得到选区中的文本
-         * @public
-         * @function
-         * @name    baidu.editor.dom.Selection.getText
-         * @return  {String}    选区中包含的文本
+         * @method getText
+         * @return { String } 选区中包含的文本
+         * @example
+         * ```javascript
+         * editor.selection.getText();
+         * ```
          */
         getText:function () {
             var nativeSel, nativeRange;
@@ -345,6 +373,15 @@
             }
             return '';
         },
+
+        /**
+         * 清除选区
+         * @method clearRange
+         * @example
+         * ```javascript
+         * editor.selection.clearRange();
+         * ```
+         */
         clearRange : function(){
             this.getNative()[browser.ie9below ? 'empty' : 'removeAllRanges']();
         }

_src/core/ajax.js

 /**
  * @file
- * @name UE.ajax
- * @short Ajax
- * @desc UEditor内置的ajax请求模块
- * @import core/utils.js
- * @user: taoqili
- * @date: 11-8-18
- * @time: 下午3:18
+ * @module UE.ajax
+ * @since 1.2.6.1
+ */
+
+/**
+ * 提供对ajax请求的支持
+ * @module UE.ajax
  */
 UE.ajax = function() {
-    /**
-     * 创建一个ajaxRequest对象
-     */
+
+    //创建一个ajaxRequest对象
     var fnStr = 'XMLHttpRequest()';
     try {
         new ActiveXObject("Msxml2.XMLHTTP");
@@ -26,7 +25,7 @@ UE.ajax = function() {
     var creatAjaxRequest = new Function('return new ' + fnStr);
 
 
-    /**
+    /*
      * 将json参数转化成适合ajax提交的参数列表
      * @param json
      */
@@ -46,30 +45,63 @@ UE.ajax = function() {
 
 
     return {
-		/**
-         * @name request
-         * @desc 发出ajax请求，ajaxOpt中默认包含method，timeout，async，data，onsuccess以及onerror等六个，支持自定义添加参数
-         * @grammar UE.ajax.request(url,ajaxOpt);
+        /**
+         * 根据给定的参数项，向指定的url发起一个ajax请求。 ajax请求完成后，会根据请求结果调用相应回调： 如果请求
+         * 成功， 则调用onsuccess回调， 失败则调用 onerror 回调
+         * @method request
+         * @param { URLString } url ajax请求的url地址
+         * @param { Object } ajaxOptions ajax请求选项的键值对，支持的选项如下：
          * @example
-         * UE.ajax.request('http://www.xxxx.com/test.php',{
-         *     //可省略，默认POST
-         *     method:'POST',
-         *     //可以自定义参数
-         *     content:'这里是提交的内容',
-         *     //也可以直接传json，但是只能命名为data，否则当做一般字符串处理
-         *     data:{
-         *         name:'UEditor',
-         *         age:'1'
-         *     }
-         *     onsuccess:function(xhr){
-         *         console.log(xhr.responseText);
+         * ```javascript
+         * //向sayhello.php发起一个异步的Ajax GET请求, 请求超时时间为10s， 请求完成后执行相应的回调。
+         * UE.ajax.requeset( 'sayhello.php', {
+         *
+         *     //请求方法。可选值： 'GET', 'POST'，默认值是'POST'
+         *     method: 'GET',
+         *
+         *     //超时时间。 默认为5000， 单位是ms
+         *     timeout: 10000,
+         *
+         *     //是否是异步请求。 true为异步请求， false为同步请求
+         *     async: true,
+         *
+         *     //请求携带的数据。如果请求为GET请求， data会经过stringify后附加到请求url之后。
+         *     data: {
+         *         name: 'ueditor'
+         *     },
+         *
+         *     //请求成功后的回调， 该回调接受当前的XMLHttpRequest对象作为参数。
+         *     onsuccess: function ( xhr ) {
+         *         console.log( xhr.responseText );
          *     },
-         *     onerror:function(xhr){
-         *         console.log(xhr.responseText);
+         *
+         *     //请求失败或者超时后的回调。
+         *     onerror: function ( xhr ) {
+         *          alert( 'Ajax请求失败' );
          *     }
-         * })
-		 * @param ajaxOptions
-		 */
+         *
+         * } );
+         * ```
+         */
+
+        /**
+         * 根据给定的参数项发起一个ajax请求， 参数项里必须包含一个url地址。 ajax请求完成后，会根据请求结果调用相应回调： 如果请求
+         * 成功， 则调用onsuccess回调， 失败则调用 onerror 回调。
+         * @method request
+         * @warning 如果在参数项里未提供一个key为“url”的地址值，则该请求将直接退出。
+         * @param { Object } ajaxOptions ajax请求选项的键值对，支持的选项如下：
+         * @example
+         * ```javascript
+         *
+         * //向sayhello.php发起一个异步的Ajax POST请求, 请求超时时间为5s， 请求完成后不执行任何回调。
+         * UE.ajax.requeset( 'sayhello.php', {
+         *
+         *     //请求的地址， 该项是必须的。
+         *     url: 'sayhello.php'
+         *
+         * } );
+         * ```
+         */
 		request:function(url, ajaxOptions) {
             var ajaxRequest = creatAjaxRequest(),
                 //是否超时

_src/core/browser.js

 /**
+ * 浏览器判断模块
  * @file
- * @name UE.browser
- * @short Browser
- * @desc UEditor中采用的浏览器判断模块
+ * @module UE.browser
+ * @since 1.2.6.1
+ */
+
+/**
+ * 提供浏览器检测的模块
+ * @unfile
+ * @module UE.browser
  */
 var browser = UE.browser = function(){
     var agent = navigator.userAgent.toLowerCase(),
         opera = window.opera,
         browser = {
         /**
-         * 检测浏览器是否为IE
-         * @name ie
-         * @grammar UE.browser.ie  => true|false
+         * @property {boolean} ie 检测当前浏览器是否为IE
+         * @example
+         * ```javascript
+         * if ( UE.browser.ie ) {
+         *     console.log( '当前浏览器是IE' );
+         * }
+         * ```
          */
         ie		: !!window.ActiveXObject,
 
         /**
-         * 检测浏览器是否为Opera
-         * @name opera
-         * @grammar UE.browser.opera  => true|false
+         * @property {boolean} opera 检测当前浏览器是否为Opera
+         * @example
+         * ```javascript
+         * if ( UE.browser.opera ) {
+         *     console.log( '当前浏览器是Opera' );
+         * }
+         * ```
          */
         opera	: ( !!opera && opera.version ),
 
         /**
-         * 检测浏览器是否为webkit内核
-         * @name webkit
-         * @grammar UE.browser.webkit  => true|false
+         * @property {boolean} webkit 检测当前浏览器是否是webkit内核的浏览器
+         * @example
+         * ```javascript
+         * if ( UE.browser.webkit ) {
+         *     console.log( '当前浏览器是webkit内核浏览器' );
+         * }
+         * ```
          */
         webkit	: ( agent.indexOf( ' applewebkit/' ) > -1 ),
 
         /**
-         * 检测浏览器是否为mac系统下的浏览器
-         * @name mac
-         * @grammar UE.browser.mac  => true|false
+         * @property {boolean} mac 检测当前浏览器是否是运行在mac平台下
+         * @example
+         * ```javascript
+         * if ( UE.browser.mac ) {
+         *     console.log( '当前浏览器运行在mac平台下' );
+         * }
+         * ```
          */
         mac	: ( agent.indexOf( 'macintosh' ) > -1 ),
 
         /**
-         * 检测浏览器是否处于怪异模式
-         * @name quirks
-         * @grammar UE.browser.quirks  => true|false
+         * @property {boolean} quirks 检测当前浏览器是否处于“怪异模式”下
+         * @example
+         * ```javascript
+         * if ( UE.browser.quirks ) {
+         *     console.log( '当前浏览器运行处于“怪异模式”' );
+         * }
+         * ```
          */
         quirks : ( document.compatMode == 'BackCompat' )
     };
+
     /**
-     * 检测浏览器是否处为gecko内核
-     * @name gecko
-     * @grammar UE.browser.gecko  => true|false
-     */
+    * @property {boolean} gecko 检测当前浏览器内核是否是gecko内核
+    * @example
+    * ```javascript
+    * if ( UE.browser.gecko ) {
+    *     console.log( '当前浏览器内核是gecko内核' );
+    * }
+    * ```
+    */
     browser.gecko =( navigator.product == 'Gecko' && !browser.webkit && !browser.opera );
 
     var version = 0;
@@ -56,37 +87,63 @@ var browser = UE.browser = function(){
     if ( browser.ie ){
         version = parseFloat( agent.match( /msie (\d+)/ )[1] );
         /**
-         * 检测浏览器是否为 IE9 模式
-         * @name ie9Compat
-         * @grammar UE.browser.ie9Compat  => true|false
+         * @property { boolean } ie9Compat 检测浏览器模式是否为 IE9 兼容模式
+         * @warning 如果浏览器不是IE， 则该值为undefined
+         * @example
+         * ```javascript
+         * if ( UE.browser.ie9Compat ) {
+         *     console.log( '当前浏览器运行在IE9兼容模式下' );
+         * }
+         * ```
          */
         browser.ie9Compat = document.documentMode == 9;
+
         /**
-         * 检测浏览器是否为 IE8 浏览器
-         * @name ie8
-         * @grammar     UE.browser.ie8  => true|false
+         * @property { boolean } ie8 检测浏览器是否是IE8浏览器
+         * @warning 如果浏览器不是IE， 则该值为undefined
+         * @example
+         * ```javascript
+         * if ( UE.browser.ie8 ) {
+         *     console.log( '当前浏览器是IE8浏览器' );
+         * }
+         * ```
          */
         browser.ie8 = !!document.documentMode;
 
         /**
-         * 检测浏览器是否为 IE8 模式
-         * @name ie8Compat
-         * @grammar     UE.browser.ie8Compat  => true|false
+         * @property { boolean } ie8Compat 检测浏览器模式是否为 IE8 兼容模式
+         * @warning 如果浏览器不是IE， 则该值为undefined
+         * @example
+         * ```javascript
+         * if ( UE.browser.ie8Compat ) {
+         *     console.log( '当前浏览器运行在IE8兼容模式下' );
+         * }
+         * ```
          */
         browser.ie8Compat = document.documentMode == 8;
 
         /**
-         * 检测浏览器是否运行在 兼容IE7模式
-         * @name ie7Compat
-         * @grammar     UE.browser.ie7Compat  => true|false
+         * @property { boolean } ie7Compat 检测浏览器模式是否为 IE7 兼容模式
+         * @warning 如果浏览器不是IE， 则该值为undefined
+         * @example
+         * ```javascript
+         * if ( UE.browser.ie7Compat ) {
+         *     console.log( '当前浏览器运行在IE7兼容模式下' );
+         * }
+         * ```
          */
         browser.ie7Compat = ( ( version == 7 && !document.documentMode )
                 || document.documentMode == 7 );
 
         /**
-         * 检测浏览器是否IE6模式或怪异模式
-         * @name ie6Compat
-         * @grammar     UE.browser.ie6Compat  => true|false
+         * @property { boolean } ie6Compat 检测浏览器模式是否为 IE6 模式 或者怪异模式
+         * @warning 如果浏览器不是IE， 则该值为undefined
+         * @example
+         * ```javascript
+         * if ( UE.browser.ie6Compat ) {
+         *     console.log( '当前浏览器运行在IE6模式或者怪异模式下' );
+         * }
+         * ```
          */
         browser.ie6Compat = ( version < 7 || browser.quirks );
 
@@ -105,18 +162,30 @@ var browser = UE.browser = function(){
             version = geckoRelease[0] * 10000 + ( geckoRelease[1] || 0 ) * 100 + ( geckoRelease[2] || 0 ) * 1;
         }
     }
+
     /**
-     * 检测浏览器是否为chrome
-     * @name chrome
-     * @grammar     UE.browser.chrome  => true|false
+     * @property { Number } chrome 检测当前浏览器是否为Chrome, 如果是，则返回Chrome的大版本号
+     * @warning 如果浏览器不是chrome， 则该值为undefined
+     * @example
+     * ```javascript
+     * if ( UE.browser.chrome ) {
+     *     console.log( '当前浏览器是Chrome' );
+     * }
+     * ```
      */
     if (/chrome\/(\d+\.\d)/i.test(agent)) {
         browser.chrome = + RegExp['\x241'];
     }
+
     /**
-     * 检测浏览器是否为safari
-     * @name safari
-     * @grammar     UE.browser.safari  => true|false
+     * @property { Number } safari 检测当前浏览器是否为Safari, 如果是，则返回Safari的大版本号
+     * @warning 如果浏览器不是safari， 则该值为undefined
+     * @example
+     * ```javascript
+     * if ( UE.browser.safari ) {
+     *     console.log( '当前浏览器是Safari' );
+     * }
+     * ```
      */
     if(/(\d+\.\d)?(?:\.\d)?\s+safari\/?(\d+\.\d+)?/i.test(agent) && !/chrome/i.test(agent)){
     	browser.safari = + (RegExp['\x241'] || RegExp['\x242']);
@@ -132,27 +201,28 @@ var browser = UE.browser = function(){
         version = parseFloat( agent.match( / applewebkit\/(\d+)/ )[1] );
 
     /**
-     * 浏览器版本判断
-     * IE系列返回值为5,6,7,8,9,10等
-     * gecko系列会返回10900，158900等.
-     * webkit系列会返回其build号 (如 522等).
-     * @name version
-     * @grammar     UE.browser.version  => number
+     * @property { Number } version 检测当前浏览器版本号
+     * @remind
+     * <ul>
+     *     <li>IE系列返回值为5,6,7,8,9,10等</li>
+     *     <li>gecko系列会返回10900，158900等</li>
+     *     <li>webkit系列会返回其build号 (如 522等)</li>
+     * </ul>
      * @example
-     * if ( UE.browser.ie && UE.browser.version == 6 ){
-     *     alert( "Ouch!居然是万恶的IE6!" );
-     * }
+     * ```javascript
+     * console.log( '当前浏览器版本号是： ' + UE.browser.version );
+     * ```
      */
     browser.version = version;
 
     /**
-     * 是否是兼容模式的浏览器
-     * @name isCompatible
-     * @grammar  UE.browser.isCompatible  => true|false
+     * @property { boolean } isCompatible 检测当前浏览器是否能够与UEditor良好兼容
      * @example
-     * if ( UE.browser.isCompatible ){
-     *     alert( "你的浏览器相当不错哦！" );
+     * ```javascript
+     * if ( UE.browser.isCompatible ) {
+     *     console.log( '浏览器与UEditor能够良好兼容' );
      * }
+     * ```
      */
     browser.isCompatible =
         !browser.mobile && (

_src/core/dtd.js

 ///import editor.js
 ///import core/dom/dom.js
 ///import core/utils.js
-/**
+/*
  * dtd html语义化的体现类
  * @constructor
  * @namespace dtd

_src/core/filternode.js

 /**
+ * UE过滤节点的静态方法
  * @file
- * @name UE.filterNode
- * @short filterNode
- * @desc 根据给定的规则过滤节点
- * @import editor.js,core/utils.js
- * @anthor zhanyi
+ */
+
+/**
+ * UEditor公用空间，UEditor所有的功能都挂载在该空间下
+ * @module UE
+ */
+
+
+/**
+ * 根据传入节点和过滤规则过滤相应节点
+ * @module UE
+ * @since 1.2.6.1
+ * @method filterNode
+ * @param { Object } root 指定root节点
+ * @param { Object } rules 过滤规则json对象
+ * @example
+ * ```javascript
+ * UE.filterNode(root,editor.options.filterRules);
+ * ```
  */
 var filterNode = UE.filterNode = function () {
     function filterNode(node,rules){

_src/core/filterword.js

 /**
+ * UE过滤word的静态方法
  * @file
- * @name UE.filterWord
- * @short filterWord
- * @desc 用来过滤word粘贴过来的字符串
- * @import editor.js,core/utils.js
- * @anthor zhanyi
+ */
+
+/**
+ * UEditor公用空间，UEditor所有的功能都挂载在该空间下
+ * @module UE
+ */
+
+
+/**
+ * 根据传入html字符串过滤word
+ * @module UE
+ * @since 1.2.6.1
+ * @method filterWord
+ * @param { String } html html字符串
+ * @return { String } 已过滤后的结果字符串
+ * @example
+ * ```javascript
+ * UE.filterWord(html);
+ * ```
  */
 var filterWord = UE.filterWord = function () {
 

_src/core/plugin.js

-/**
+/*
  * Created with JetBrains PhpStorm.
  * User: campaign
  * Date: 10/8/13

_src/plugins/autoheight.js

@@ -2,7 +2,7 @@
 ///commands 当输入内容超过编辑器高度时，编辑器自动增高
 ///commandsName  AutoHeight,autoHeightEnabled
 ///commandsTitle  自动增高
-/**
+/*
  * @description 自动伸展
  * @author zhanyi
  */