promethee 1.4.8 → 1.4.9

data/node_modules/summernote/src/icons/trash.svg

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="1024px" height="1024px" viewBox="0 0 1024 1024" enable-background="new 0 0 1024 1024" xml:space="preserve">
+<g>
+	<g>
+		<path fill="#040507" d="M684.868,95.723c-38.258,0-69.273-30.712-69.273-68.606H389.834c0,37.891-31.018,68.606-69.276,68.606
+			H15.731v69.894h978.333V95.723H684.868z M224.755,996.884h560.281L924.92,234.799H84.871L224.755,996.884z M688.173,355.88
+			c0-22.491,18.415-40.721,41.121-40.721c22.71,0,41.12,18.23,41.12,40.721l-60.545,515.828c0,22.491-18.415,40.719-41.118,40.719
+			c-22.707,0-41.116-18.229-41.116-40.719L688.173,355.88z M464.44,355.88c0-22.491,18.413-40.721,41.123-40.721
+			c22.708,0,41.115,18.23,41.115,40.721v515.828c0,22.491-18.407,40.719-41.115,40.719c-22.712,0-41.123-18.229-41.123-40.719
+			V355.88z M269.712,315.159c22.711,0,41.118,18.23,41.118,40.721l70.229,515.828c0,22.491-18.405,40.719-41.113,40.719
+			c-22.712,0-41.123-18.229-41.123-40.719L228.593,355.88C228.594,333.39,247.004,315.159,269.712,315.159z"/>
+	</g>
+</g>
+</svg>

data/node_modules/summernote/src/icons/underline.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid" width="1024" height="1024" viewBox="0 0 1024 1024">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: #000;
+        fill-rule: evenodd;
+      }
+    </style>
+  </defs>
+  <path d="M908.526,146.582 C888.706,156.816 875.010,171.009 867.419,189.175 C859.828,207.341 856.035,232.713 856.035,265.284 L856.035,549.047 C856.035,610.022 852.133,659.822 844.334,698.446 C836.531,737.077 818.089,774.240 788.998,809.946 C759.903,845.651 719.429,874.367 667.570,896.077 C615.711,917.783 558.158,928.648 494.914,928.648 C428.718,928.648 369.376,917.893 316.885,896.388 C264.394,874.886 224.231,847.742 196.405,814.955 C168.579,782.175 149.702,746.473 139.800,707.842 C129.892,669.218 124.938,623.384 124.938,570.343 L124.938,235.218 C124.938,195.125 117.984,167.780 104.071,153.158 C90.153,138.544 59.799,131.235 12.997,131.235 L12.997,61.702 L465.824,61.702 L465.824,131.235 L451.278,131.235 C408.686,131.235 381.077,138.965 368.428,154.410 C355.779,169.867 349.453,196.799 349.453,235.218 L349.453,570.343 C349.453,631.319 354.515,679.338 364.635,714.418 C374.750,749.498 396.886,779.359 431.039,803.995 C465.192,828.639 506.081,840.953 553.732,840.953 C605.591,840.953 649.958,827.796 686.861,801.487 C723.745,775.177 747.670,743.134 758.639,705.333 C769.599,667.544 775.085,614.819 775.085,547.168 L775.085,261.527 C775.085,174.671 732.709,131.235 647.962,131.235 L647.962,61.702 L965.447,61.702 L965.447,131.235 C947.312,131.235 928.341,136.351 908.526,146.582 ZM932.995,1046.691 L70.468,1046.691 L70.468,975.619 L932.995,975.619 L932.995,1046.691 Z" class="cls-1"/>
+</svg>

data/node_modules/summernote/src/icons/undo.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024">
+  <defs>
+    <style>
+      .cls-1 {
+        fill-rule: evenodd;
+      }
+    </style>
+  </defs>
+  <path id="Shape_29_copy_2" data-name="Shape 29 copy 2" class="cls-1" d="M-84.808,193.372V728.531H480.079L325.064,580.294s-21.019-241.2,341.56-241.2S1176.34,648.131,1176.34,648.131s-147.14-482.4-546.5-482.4c-364.362,0-567.515,165.824-567.515,165.824Z"/>
+</svg>

data/node_modules/summernote/src/icons/unorderedlist.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="1024px" height="1024px" viewBox="0 0 1024 1024" enable-background="new 0 0 1024 1024" xml:space="preserve">
+<path d="M1032.671,90.351H270.806v170.108h761.865V90.351L1032.671,90.351z M271.531,428.395v168.558h761.97V428.395H271.531z
+	 M270.806,933.649h761.865V765.3H270.806V933.649z M160.712,90.351H-9.5v170.108h170.212V90.351L160.712,90.351z M-8.982,596.951
+	h170.314V428.395H-8.982V596.951z M-9.397,933.649h170.212V765.3H-9.397V933.649L-9.397,933.649z"/>
+</svg>

data/node_modules/summernote/src/icons/video.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="1024px" height="1024px" viewBox="0 0 1024 1024" enable-background="new 0 0 1024 1024" xml:space="preserve">
+<path d="M-70.443,728.622l284.268-120.036V416.415L-70.443,296.266V728.622z M962.801,200.673H329.249
+	c-39.146,0-71.374,31.489-71.374,69.789v484.301c0,38.076,32.118,69.564,71.374,69.564h633.552
+	c39.256,0,71.263-31.488,71.263-69.564V270.351C1034.064,232.162,1001.946,200.673,962.801,200.673z"/>
+</svg>

data/node_modules/summernote/src/js/base/Context.js

@@ -0,0 +1,231 @@
+import $ from 'jquery';
+import func from './core/func';
+import lists from './core/lists';
+import dom from './core/dom';
+
+export default class Context {
+  /**
+   * @param {jQuery} $note
+   * @param {Object} options
+   */
+  constructor($note, options) {
+    this.ui = $.summernote.ui;
+    this.$note = $note;
+
+    this.memos = {};
+    this.modules = {};
+    this.layoutInfo = {};
+    this.options = options;
+
+    this.initialize();
+  }
+
+  /**
+   * create layout and initialize modules and other resources
+   */
+  initialize() {
+    this.layoutInfo = this.ui.createLayout(this.$note, this.options);
+    this._initialize();
+    this.$note.hide();
+    return this;
+  }
+
+  /**
+   * destroy modules and other resources and remove layout
+   */
+  destroy() {
+    this._destroy();
+    this.$note.removeData('summernote');
+    this.ui.removeLayout(this.$note, this.layoutInfo);
+  }
+
+  /**
+   * destory modules and other resources and initialize it again
+   */
+  reset() {
+    const disabled = this.isDisabled();
+    this.code(dom.emptyPara);
+    this._destroy();
+    this._initialize();
+
+    if (disabled) {
+      this.disable();
+    }
+  }
+
+  _initialize() {
+    // add optional buttons
+    const buttons = $.extend({}, this.options.buttons);
+    Object.keys(buttons).forEach((key) => {
+      this.memo('button.' + key, buttons[key]);
+    });
+
+    const modules = $.extend({}, this.options.modules, $.summernote.plugins || {});
+
+    // add and initialize modules
+    Object.keys(modules).forEach((key) => {
+      this.module(key, modules[key], true);
+    });
+
+    Object.keys(this.modules).forEach((key) => {
+      this.initializeModule(key);
+    });
+  }
+
+  _destroy() {
+    // destroy modules with reversed order
+    Object.keys(this.modules).reverse().forEach((key) => {
+      this.removeModule(key);
+    });
+
+    Object.keys(this.memos).forEach((key) => {
+      this.removeMemo(key);
+    });
+    // trigger custom onDestroy callback
+    this.triggerEvent('destroy', this);
+  }
+
+  code(html) {
+    const isActivated = this.invoke('codeview.isActivated');
+
+    if (html === undefined) {
+      this.invoke('codeview.sync');
+      return isActivated ? this.layoutInfo.codable.val() : this.layoutInfo.editable.html();
+    } else {
+      if (isActivated) {
+        this.layoutInfo.codable.val(html);
+      } else {
+        this.layoutInfo.editable.html(html);
+      }
+      this.$note.val(html);
+      this.triggerEvent('change', html);
+    }
+  }
+
+  isDisabled() {
+    return this.layoutInfo.editable.attr('contenteditable') === 'false';
+  }
+
+  enable() {
+    this.layoutInfo.editable.attr('contenteditable', true);
+    this.invoke('toolbar.activate', true);
+    this.triggerEvent('disable', false);
+  }
+
+  disable() {
+    // close codeview if codeview is opend
+    if (this.invoke('codeview.isActivated')) {
+      this.invoke('codeview.deactivate');
+    }
+    this.layoutInfo.editable.attr('contenteditable', false);
+    this.invoke('toolbar.deactivate', true);
+
+    this.triggerEvent('disable', true);
+  }
+
+  triggerEvent() {
+    const namespace = lists.head(arguments);
+    const args = lists.tail(lists.from(arguments));
+
+    const callback = this.options.callbacks[func.namespaceToCamel(namespace, 'on')];
+    if (callback) {
+      callback.apply(this.$note[0], args);
+    }
+    this.$note.trigger('summernote.' + namespace, args);
+  }
+
+  initializeModule(key) {
+    const module = this.modules[key];
+    module.shouldInitialize = module.shouldInitialize || func.ok;
+    if (!module.shouldInitialize()) {
+      return;
+    }
+
+    // initialize module
+    if (module.initialize) {
+      module.initialize();
+    }
+
+    // attach events
+    if (module.events) {
+      dom.attachEvents(this.$note, module.events);
+    }
+  }
+
+  module(key, ModuleClass, withoutIntialize) {
+    if (arguments.length === 1) {
+      return this.modules[key];
+    }
+
+    this.modules[key] = new ModuleClass(this);
+
+    if (!withoutIntialize) {
+      this.initializeModule(key);
+    }
+  }
+
+  removeModule(key) {
+    const module = this.modules[key];
+    if (module.shouldInitialize()) {
+      if (module.events) {
+        dom.detachEvents(this.$note, module.events);
+      }
+
+      if (module.destroy) {
+        module.destroy();
+      }
+    }
+
+    delete this.modules[key];
+  }
+
+  memo(key, obj) {
+    if (arguments.length === 1) {
+      return this.memos[key];
+    }
+    this.memos[key] = obj;
+  }
+
+  removeMemo(key) {
+    if (this.memos[key] && this.memos[key].destroy) {
+      this.memos[key].destroy();
+    }
+
+    delete this.memos[key];
+  }
+
+  /**
+   * Some buttons need to change their visual style immediately once they get pressed
+   */
+  createInvokeHandlerAndUpdateState(namespace, value) {
+    return (event) => {
+      this.createInvokeHandler(namespace, value)(event);
+      this.invoke('buttons.updateCurrentStyle');
+    };
+  }
+
+  createInvokeHandler(namespace, value) {
+    return (event) => {
+      event.preventDefault();
+      const $target = $(event.target);
+      this.invoke(namespace, value || $target.closest('[data-value]').data('value'), $target);
+    };
+  }
+
+  invoke() {
+    const namespace = lists.head(arguments);
+    const args = lists.tail(lists.from(arguments));
+
+    const splits = namespace.split('.');
+    const hasSeparator = splits.length > 1;
+    const moduleName = hasSeparator && lists.head(splits);
+    const methodName = hasSeparator ? lists.last(splits) : lists.head(splits);
+
+    const module = this.modules[moduleName || 'editor'];
+    if (!moduleName && this[methodName]) {
+      return this[methodName].apply(this, args);
+    } else if (module && module[methodName] && module.shouldInitialize()) {
+      return module[methodName].apply(module, args);
+    }
+  }
+}

data/node_modules/summernote/src/js/base/core/async.js

@@ -0,0 +1,47 @@
+import $ from 'jquery';
+
+/**
+ * @method readFileAsDataURL
+ *
+ * read contents of file as representing URL
+ *
+ * @param {File} file
+ * @return {Promise} - then: dataUrl
+ */
+export function readFileAsDataURL(file) {
+  return $.Deferred((deferred) => {
+    $.extend(new FileReader(), {
+      onload: (e) => {
+        const dataURL = e.target.result;
+        deferred.resolve(dataURL);
+      },
+      onerror: (err) => {
+        deferred.reject(err);
+      }
+    }).readAsDataURL(file);
+  }).promise();
+}
+
+/**
+ * @method createImage
+ *
+ * create `<image>` from url string
+ *
+ * @param {String} url
+ * @return {Promise} - then: $image
+ */
+export function createImage(url) {
+  return $.Deferred((deferred) => {
+    const $img = $('<img>');
+
+    $img.one('load', () => {
+      $img.off('error abort');
+      deferred.resolve($img);
+    }).one('error abort', () => {
+      $img.off('load').detach();
+      deferred.reject($img);
+    }).css({
+      display: 'none'
+    }).appendTo(document.body).attr('src', url);
+  }).promise();
+}

data/node_modules/summernote/src/js/base/core/dom.js

@@ -0,0 +1,1088 @@
+import $ from 'jquery';
+import func from './func';
+import lists from './lists';
+import env from './env';
+
+const NBSP_CHAR = String.fromCharCode(160);
+const ZERO_WIDTH_NBSP_CHAR = '\ufeff';
+
+/**
+ * @method isEditable
+ *
+ * returns whether node is `note-editable` or not.
+ *
+ * @param {Node} node
+ * @return {Boolean}
+ */
+function isEditable(node) {
+  return node && $(node).hasClass('note-editable');
+}
+
+/**
+ * @method isControlSizing
+ *
+ * returns whether node is `note-control-sizing` or not.
+ *
+ * @param {Node} node
+ * @return {Boolean}
+ */
+function isControlSizing(node) {
+  return node && $(node).hasClass('note-control-sizing');
+}
+
+/**
+ * @method makePredByNodeName
+ *
+ * returns predicate which judge whether nodeName is same
+ *
+ * @param {String} nodeName
+ * @return {Function}
+ */
+function makePredByNodeName(nodeName) {
+  nodeName = nodeName.toUpperCase();
+  return function(node) {
+    return node && node.nodeName.toUpperCase() === nodeName;
+  };
+}
+
+/**
+ * @method isText
+ *
+ *
+ *
+ * @param {Node} node
+ * @return {Boolean} true if node's type is text(3)
+ */
+function isText(node) {
+  return node && node.nodeType === 3;
+}
+
+/**
+ * @method isElement
+ *
+ *
+ *
+ * @param {Node} node
+ * @return {Boolean} true if node's type is element(1)
+ */
+function isElement(node) {
+  return node && node.nodeType === 1;
+}
+
+/**
+ * ex) br, col, embed, hr, img, input, ...
+ * @see http://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements
+ */
+function isVoid(node) {
+  return node && /^BR|^IMG|^HR|^IFRAME|^BUTTON|^INPUT/.test(node.nodeName.toUpperCase());
+}
+
+function isPara(node) {
+  if (isEditable(node)) {
+    return false;
+  }
+
+  // Chrome(v31.0), FF(v25.0.1) use DIV for paragraph
+  return node && /^DIV|^P|^LI|^H[1-7]/.test(node.nodeName.toUpperCase());
+}
+
+function isHeading(node) {
+  return node && /^H[1-7]/.test(node.nodeName.toUpperCase());
+}
+
+const isPre = makePredByNodeName('PRE');
+
+const isLi = makePredByNodeName('LI');
+
+function isPurePara(node) {
+  return isPara(node) && !isLi(node);
+}
+
+const isTable = makePredByNodeName('TABLE');
+
+const isData = makePredByNodeName('DATA');
+
+function isInline(node) {
+  return !isBodyContainer(node) &&
+         !isList(node) &&
+         !isHr(node) &&
+         !isPara(node) &&
+         !isTable(node) &&
+         !isBlockquote(node) &&
+         !isData(node);
+}
+
+function isList(node) {
+  return node && /^UL|^OL/.test(node.nodeName.toUpperCase());
+}
+
+const isHr = makePredByNodeName('HR');
+
+function isCell(node) {
+  return node && /^TD|^TH/.test(node.nodeName.toUpperCase());
+}
+
+const isBlockquote = makePredByNodeName('BLOCKQUOTE');
+
+function isBodyContainer(node) {
+  return isCell(node) || isBlockquote(node) || isEditable(node);
+}
+
+const isAnchor = makePredByNodeName('A');
+
+function isParaInline(node) {
+  return isInline(node) && !!ancestor(node, isPara);
+}
+
+function isBodyInline(node) {
+  return isInline(node) && !ancestor(node, isPara);
+}
+
+const isBody = makePredByNodeName('BODY');
+
+/**
+ * returns whether nodeB is closest sibling of nodeA
+ *
+ * @param {Node} nodeA
+ * @param {Node} nodeB
+ * @return {Boolean}
+ */
+function isClosestSibling(nodeA, nodeB) {
+  return nodeA.nextSibling === nodeB ||
+         nodeA.previousSibling === nodeB;
+}
+
+/**
+ * returns array of closest siblings with node
+ *
+ * @param {Node} node
+ * @param {function} [pred] - predicate function
+ * @return {Node[]}
+ */
+function withClosestSiblings(node, pred) {
+  pred = pred || func.ok;
+
+  const siblings = [];
+  if (node.previousSibling && pred(node.previousSibling)) {
+    siblings.push(node.previousSibling);
+  }
+  siblings.push(node);
+  if (node.nextSibling && pred(node.nextSibling)) {
+    siblings.push(node.nextSibling);
+  }
+  return siblings;
+}
+
+/**
+ * blank HTML for cursor position
+ * - [workaround] old IE only works with  
+ * - [workaround] IE11 and other browser works with bogus br
+ */
+const blankHTML = env.isMSIE && env.browserVersion < 11 ? '&nbsp;' : '<br>';
+
+/**
+ * @method nodeLength
+ *
+ * returns #text's text size or element's childNodes size
+ *
+ * @param {Node} node
+ */
+function nodeLength(node) {
+  if (isText(node)) {
+    return node.nodeValue.length;
+  }
+
+  if (node) {
+    return node.childNodes.length;
+  }
+
+  return 0;
+}
+
+/**
+ * returns whether node is empty or not.
+ *
+ * @param {Node} node
+ * @return {Boolean}
+ */
+function isEmpty(node) {
+  const len = nodeLength(node);
+
+  if (len === 0) {
+    return true;
+  } else if (!isText(node) && len === 1 && node.innerHTML === blankHTML) {
+    // ex) <p><br></p>, <span><br></span>
+    return true;
+  } else if (lists.all(node.childNodes, isText) && node.innerHTML === '') {
+    // ex) <p></p>, <span></span>
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * padding blankHTML if node is empty (for cursor position)
+ */
+function paddingBlankHTML(node) {
+  if (!isVoid(node) && !nodeLength(node)) {
+    node.innerHTML = blankHTML;
+  }
+}
+
+/**
+ * find nearest ancestor predicate hit
+ *
+ * @param {Node} node
+ * @param {Function} pred - predicate function
+ */
+function ancestor(node, pred) {
+  while (node) {
+    if (pred(node)) { return node; }
+    if (isEditable(node)) { break; }
+
+    node = node.parentNode;
+  }
+  return null;
+}
+
+/**
+ * find nearest ancestor only single child blood line and predicate hit
+ *
+ * @param {Node} node
+ * @param {Function} pred - predicate function
+ */
+function singleChildAncestor(node, pred) {
+  node = node.parentNode;
+
+  while (node) {
+    if (nodeLength(node) !== 1) { break; }
+    if (pred(node)) { return node; }
+    if (isEditable(node)) { break; }
+
+    node = node.parentNode;
+  }
+  return null;
+}
+
+/**
+ * returns new array of ancestor nodes (until predicate hit).
+ *
+ * @param {Node} node
+ * @param {Function} [optional] pred - predicate function
+ */
+function listAncestor(node, pred) {
+  pred = pred || func.fail;
+
+  const ancestors = [];
+  ancestor(node, function(el) {
+    if (!isEditable(el)) {
+      ancestors.push(el);
+    }
+
+    return pred(el);
+  });
+  return ancestors;
+}
+
+/**
+ * find farthest ancestor predicate hit
+ */
+function lastAncestor(node, pred) {
+  const ancestors = listAncestor(node);
+  return lists.last(ancestors.filter(pred));
+}
+
+/**
+ * returns common ancestor node between two nodes.
+ *
+ * @param {Node} nodeA
+ * @param {Node} nodeB
+ */
+function commonAncestor(nodeA, nodeB) {
+  const ancestors = listAncestor(nodeA);
+  for (let n = nodeB; n; n = n.parentNode) {
+    if ($.inArray(n, ancestors) > -1) { return n; }
+  }
+  return null; // difference document area
+}
+
+/**
+ * listing all previous siblings (until predicate hit).
+ *
+ * @param {Node} node
+ * @param {Function} [optional] pred - predicate function
+ */
+function listPrev(node, pred) {
+  pred = pred || func.fail;
+
+  const nodes = [];
+  while (node) {
+    if (pred(node)) { break; }
+    nodes.push(node);
+    node = node.previousSibling;
+  }
+  return nodes;
+}
+
+/**
+ * listing next siblings (until predicate hit).
+ *
+ * @param {Node} node
+ * @param {Function} [pred] - predicate function
+ */
+function listNext(node, pred) {
+  pred = pred || func.fail;
+
+  const nodes = [];
+  while (node) {
+    if (pred(node)) { break; }
+    nodes.push(node);
+    node = node.nextSibling;
+  }
+  return nodes;
+}
+
+/**
+ * listing descendant nodes
+ *
+ * @param {Node} node
+ * @param {Function} [pred] - predicate function
+ */
+function listDescendant(node, pred) {
+  const descendants = [];
+  pred = pred || func.ok;
+
+  // start DFS(depth first search) with node
+  (function fnWalk(current) {
+    if (node !== current && pred(current)) {
+      descendants.push(current);
+    }
+    for (let idx = 0, len = current.childNodes.length; idx < len; idx++) {
+      fnWalk(current.childNodes[idx]);
+    }
+  })(node);
+
+  return descendants;
+}
+
+/**
+ * wrap node with new tag.
+ *
+ * @param {Node} node
+ * @param {Node} tagName of wrapper
+ * @return {Node} - wrapper
+ */
+function wrap(node, wrapperName) {
+  const parent = node.parentNode;
+  const wrapper = $('<' + wrapperName + '>')[0];
+
+  parent.insertBefore(wrapper, node);
+  wrapper.appendChild(node);
+
+  return wrapper;
+}
+
+/**
+ * insert node after preceding
+ *
+ * @param {Node} node
+ * @param {Node} preceding - predicate function
+ */
+function insertAfter(node, preceding) {
+  const next = preceding.nextSibling;
+  let parent = preceding.parentNode;
+  if (next) {
+    parent.insertBefore(node, next);
+  } else {
+    parent.appendChild(node);
+  }
+  return node;
+}
+
+/**
+ * append elements.
+ *
+ * @param {Node} node
+ * @param {Collection} aChild
+ */
+function appendChildNodes(node, aChild) {
+  $.each(aChild, function(idx, child) {
+    node.appendChild(child);
+  });
+  return node;
+}
+
+/**
+ * returns whether boundaryPoint is left edge or not.
+ *
+ * @param {BoundaryPoint} point
+ * @return {Boolean}
+ */
+function isLeftEdgePoint(point) {
+  return point.offset === 0;
+}
+
+/**
+ * returns whether boundaryPoint is right edge or not.
+ *
+ * @param {BoundaryPoint} point
+ * @return {Boolean}
+ */
+function isRightEdgePoint(point) {
+  return point.offset === nodeLength(point.node);
+}
+
+/**
+ * returns whether boundaryPoint is edge or not.
+ *
+ * @param {BoundaryPoint} point
+ * @return {Boolean}
+ */
+function isEdgePoint(point) {
+  return isLeftEdgePoint(point) || isRightEdgePoint(point);
+}
+
+/**
+ * returns whether node is left edge of ancestor or not.
+ *
+ * @param {Node} node
+ * @param {Node} ancestor
+ * @return {Boolean}
+ */
+function isLeftEdgeOf(node, ancestor) {
+  while (node && node !== ancestor) {
+    if (position(node) !== 0) {
+      return false;
+    }
+    node = node.parentNode;
+  }
+
+  return true;
+}
+
+/**
+ * returns whether node is right edge of ancestor or not.
+ *
+ * @param {Node} node
+ * @param {Node} ancestor
+ * @return {Boolean}
+ */
+function isRightEdgeOf(node, ancestor) {
+  if (!ancestor) {
+    return false;
+  }
+  while (node && node !== ancestor) {
+    if (position(node) !== nodeLength(node.parentNode) - 1) {
+      return false;
+    }
+    node = node.parentNode;
+  }
+
+  return true;
+}
+
+/**
+ * returns whether point is left edge of ancestor or not.
+ * @param {BoundaryPoint} point
+ * @param {Node} ancestor
+ * @return {Boolean}
+ */
+function isLeftEdgePointOf(point, ancestor) {
+  return isLeftEdgePoint(point) && isLeftEdgeOf(point.node, ancestor);
+}
+
+/**
+ * returns whether point is right edge of ancestor or not.
+ * @param {BoundaryPoint} point
+ * @param {Node} ancestor
+ * @return {Boolean}
+ */
+function isRightEdgePointOf(point, ancestor) {
+  return isRightEdgePoint(point) && isRightEdgeOf(point.node, ancestor);
+}
+
+/**
+ * returns offset from parent.
+ *
+ * @param {Node} node
+ */
+function position(node) {
+  let offset = 0;
+  while ((node = node.previousSibling)) {
+    offset += 1;
+  }
+  return offset;
+}
+
+function hasChildren(node) {
+  return !!(node && node.childNodes && node.childNodes.length);
+}
+
+/**
+ * returns previous boundaryPoint
+ *
+ * @param {BoundaryPoint} point
+ * @param {Boolean} isSkipInnerOffset
+ * @return {BoundaryPoint}
+ */
+function prevPoint(point, isSkipInnerOffset) {
+  let node;
+  let offset;
+
+  if (point.offset === 0) {
+    if (isEditable(point.node)) {
+      return null;
+    }
+
+    node = point.node.parentNode;
+    offset = position(point.node);
+  } else if (hasChildren(point.node)) {
+    node = point.node.childNodes[point.offset - 1];
+    offset = nodeLength(node);
+  } else {
+    node = point.node;
+    offset = isSkipInnerOffset ? 0 : point.offset - 1;
+  }
+
+  return {
+    node: node,
+    offset: offset
+  };
+}
+
+/**
+ * returns next boundaryPoint
+ *
+ * @param {BoundaryPoint} point
+ * @param {Boolean} isSkipInnerOffset
+ * @return {BoundaryPoint}
+ */
+function nextPoint(point, isSkipInnerOffset) {
+  let node, offset;
+
+  if (nodeLength(point.node) === point.offset) {
+    if (isEditable(point.node)) {
+      return null;
+    }
+
+    node = point.node.parentNode;
+    offset = position(point.node) + 1;
+  } else if (hasChildren(point.node)) {
+    node = point.node.childNodes[point.offset];
+    offset = 0;
+  } else {
+    node = point.node;
+    offset = isSkipInnerOffset ? nodeLength(point.node) : point.offset + 1;
+  }
+
+  return {
+    node: node,
+    offset: offset
+  };
+}
+
+/**
+ * returns whether pointA and pointB is same or not.
+ *
+ * @param {BoundaryPoint} pointA
+ * @param {BoundaryPoint} pointB
+ * @return {Boolean}
+ */
+function isSamePoint(pointA, pointB) {
+  return pointA.node === pointB.node && pointA.offset === pointB.offset;
+}
+
+/**
+ * returns whether point is visible (can set cursor) or not.
+ *
+ * @param {BoundaryPoint} point
+ * @return {Boolean}
+ */
+function isVisiblePoint(point) {
+  if (isText(point.node) || !hasChildren(point.node) || isEmpty(point.node)) {
+    return true;
+  }
+
+  const leftNode = point.node.childNodes[point.offset - 1];
+  const rightNode = point.node.childNodes[point.offset];
+  if ((!leftNode || isVoid(leftNode)) && (!rightNode || isVoid(rightNode))) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * @method prevPointUtil
+ *
+ * @param {BoundaryPoint} point
+ * @param {Function} pred
+ * @return {BoundaryPoint}
+ */
+function prevPointUntil(point, pred) {
+  while (point) {
+    if (pred(point)) {
+      return point;
+    }
+
+    point = prevPoint(point);
+  }
+
+  return null;
+}
+
+/**
+ * @method nextPointUntil
+ *
+ * @param {BoundaryPoint} point
+ * @param {Function} pred
+ * @return {BoundaryPoint}
+ */
+function nextPointUntil(point, pred) {
+  while (point) {
+    if (pred(point)) {
+      return point;
+    }
+
+    point = nextPoint(point);
+  }
+
+  return null;
+}
+
+/**
+ * returns whether point has character or not.
+ *
+ * @param {Point} point
+ * @return {Boolean}
+ */
+function isCharPoint(point) {
+  if (!isText(point.node)) {
+    return false;
+  }
+
+  const ch = point.node.nodeValue.charAt(point.offset - 1);
+  return ch && (ch !== ' ' && ch !== NBSP_CHAR);
+}
+
+/**
+ * @method walkPoint
+ *
+ * @param {BoundaryPoint} startPoint
+ * @param {BoundaryPoint} endPoint
+ * @param {Function} handler
+ * @param {Boolean} isSkipInnerOffset
+ */
+function walkPoint(startPoint, endPoint, handler, isSkipInnerOffset) {
+  let point = startPoint;
+
+  while (point) {
+    handler(point);
+
+    if (isSamePoint(point, endPoint)) {
+      break;
+    }
+
+    const isSkipOffset = isSkipInnerOffset &&
+                       startPoint.node !== point.node &&
+                       endPoint.node !== point.node;
+    point = nextPoint(point, isSkipOffset);
+  }
+}
+
+/**
+ * @method makeOffsetPath
+ *
+ * return offsetPath(array of offset) from ancestor
+ *
+ * @param {Node} ancestor - ancestor node
+ * @param {Node} node
+ */
+function makeOffsetPath(ancestor, node) {
+  const ancestors = listAncestor(node, func.eq(ancestor));
+  return ancestors.map(position).reverse();
+}
+
+/**
+ * @method fromOffsetPath
+ *
+ * return element from offsetPath(array of offset)
+ *
+ * @param {Node} ancestor - ancestor node
+ * @param {array} offsets - offsetPath
+ */
+function fromOffsetPath(ancestor, offsets) {
+  let current = ancestor;
+  for (let i = 0, len = offsets.length; i < len; i++) {
+    if (current.childNodes.length <= offsets[i]) {
+      current = current.childNodes[current.childNodes.length - 1];
+    } else {
+      current = current.childNodes[offsets[i]];
+    }
+  }
+  return current;
+}
+
+/**
+ * @method splitNode
+ *
+ * split element or #text
+ *
+ * @param {BoundaryPoint} point
+ * @param {Object} [options]
+ * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
+ * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
+ * @return {Node} right node of boundaryPoint
+ */
+function splitNode(point, options) {
+  const isSkipPaddingBlankHTML = options && options.isSkipPaddingBlankHTML;
+  const isNotSplitEdgePoint = options && options.isNotSplitEdgePoint;
+
+  // edge case
+  if (isEdgePoint(point) && (isText(point.node) || isNotSplitEdgePoint)) {
+    if (isLeftEdgePoint(point)) {
+      return point.node;
+    } else if (isRightEdgePoint(point)) {
+      return point.node.nextSibling;
+    }
+  }
+
+  // split #text
+  if (isText(point.node)) {
+    return point.node.splitText(point.offset);
+  } else {
+    const childNode = point.node.childNodes[point.offset];
+    const clone = insertAfter(point.node.cloneNode(false), point.node);
+    appendChildNodes(clone, listNext(childNode));
+
+    if (!isSkipPaddingBlankHTML) {
+      paddingBlankHTML(point.node);
+      paddingBlankHTML(clone);
+    }
+
+    return clone;
+  }
+}
+
+/**
+ * @method splitTree
+ *
+ * split tree by point
+ *
+ * @param {Node} root - split root
+ * @param {BoundaryPoint} point
+ * @param {Object} [options]
+ * @param {Boolean} [options.isSkipPaddingBlankHTML] - default: false
+ * @param {Boolean} [options.isNotSplitEdgePoint] - default: false
+ * @return {Node} right node of boundaryPoint
+ */
+function splitTree(root, point, options) {
+  // ex) [#text, <span>, <p>]
+  const ancestors = listAncestor(point.node, func.eq(root));
+
+  if (!ancestors.length) {
+    return null;
+  } else if (ancestors.length === 1) {
+    return splitNode(point, options);
+  }
+
+  return ancestors.reduce(function(node, parent) {
+    if (node === point.node) {
+      node = splitNode(point, options);
+    }
+
+    return splitNode({
+      node: parent,
+      offset: node ? position(node) : nodeLength(parent)
+    }, options);
+  });
+}
+
+/**
+ * split point
+ *
+ * @param {Point} point
+ * @param {Boolean} isInline
+ * @return {Object}
+ */
+function splitPoint(point, isInline) {
+  // find splitRoot, container
+  //  - inline: splitRoot is a child of paragraph
+  //  - block: splitRoot is a child of bodyContainer
+  const pred = isInline ? isPara : isBodyContainer;
+  const ancestors = listAncestor(point.node, pred);
+  const topAncestor = lists.last(ancestors) || point.node;
+
+  let splitRoot, container;
+  if (pred(topAncestor)) {
+    splitRoot = ancestors[ancestors.length - 2];
+    container = topAncestor;
+  } else {
+    splitRoot = topAncestor;
+    container = splitRoot.parentNode;
+  }
+
+  // if splitRoot is exists, split with splitTree
+  let pivot = splitRoot && splitTree(splitRoot, point, {
+    isSkipPaddingBlankHTML: isInline,
+    isNotSplitEdgePoint: isInline
+  });
+
+  // if container is point.node, find pivot with point.offset
+  if (!pivot && container === point.node) {
+    pivot = point.node.childNodes[point.offset];
+  }
+
+  return {
+    rightNode: pivot,
+    container: container
+  };
+}
+
+function create(nodeName) {
+  return document.createElement(nodeName);
+}
+
+function createText(text) {
+  return document.createTextNode(text);
+}
+
+/**
+ * @method remove
+ *
+ * remove node, (isRemoveChild: remove child or not)
+ *
+ * @param {Node} node
+ * @param {Boolean} isRemoveChild
+ */
+function remove(node, isRemoveChild) {
+  if (!node || !node.parentNode) { return; }
+  if (node.removeNode) { return node.removeNode(isRemoveChild); }
+
+  const parent = node.parentNode;
+  if (!isRemoveChild) {
+    const nodes = [];
+    for (let i = 0, len = node.childNodes.length; i < len; i++) {
+      nodes.push(node.childNodes[i]);
+    }
+
+    for (let i = 0, len = nodes.length; i < len; i++) {
+      parent.insertBefore(nodes[i], node);
+    }
+  }
+
+  parent.removeChild(node);
+}
+
+/**
+ * @method removeWhile
+ *
+ * @param {Node} node
+ * @param {Function} pred
+ */
+function removeWhile(node, pred) {
+  while (node) {
+    if (isEditable(node) || !pred(node)) {
+      break;
+    }
+
+    const parent = node.parentNode;
+    remove(node);
+    node = parent;
+  }
+}
+
+/**
+ * @method replace
+ *
+ * replace node with provided nodeName
+ *
+ * @param {Node} node
+ * @param {String} nodeName
+ * @return {Node} - new node
+ */
+function replace(node, nodeName) {
+  if (node.nodeName.toUpperCase() === nodeName.toUpperCase()) {
+    return node;
+  }
+
+  const newNode = create(nodeName);
+
+  if (node.style.cssText) {
+    newNode.style.cssText = node.style.cssText;
+  }
+
+  appendChildNodes(newNode, lists.from(node.childNodes));
+  insertAfter(newNode, node);
+  remove(node);
+
+  return newNode;
+}
+
+const isTextarea = makePredByNodeName('TEXTAREA');
+
+/**
+ * @param {jQuery} $node
+ * @param {Boolean} [stripLinebreaks] - default: false
+ */
+function value($node, stripLinebreaks) {
+  const val = isTextarea($node[0]) ? $node.val() : $node.html();
+  if (stripLinebreaks) {
+    return val.replace(/[\n\r]/g, '');
+  }
+  return val;
+}
+
+/**
+ * @method html
+ *
+ * get the HTML contents of node
+ *
+ * @param {jQuery} $node
+ * @param {Boolean} [isNewlineOnBlock]
+ */
+function html($node, isNewlineOnBlock) {
+  let markup = value($node);
+
+  if (isNewlineOnBlock) {
+    const regexTag = /<(\/?)(\b(?!!)[^>\s]*)(.*?)(\s*\/?>)/g;
+    markup = markup.replace(regexTag, function(match, endSlash, name) {
+      name = name.toUpperCase();
+      const isEndOfInlineContainer = /^DIV|^TD|^TH|^P|^LI|^H[1-7]/.test(name) &&
+                                   !!endSlash;
+      const isBlockNode = /^BLOCKQUOTE|^TABLE|^TBODY|^TR|^HR|^UL|^OL/.test(name);
+
+      return match + ((isEndOfInlineContainer || isBlockNode) ? '\n' : '');
+    });
+    markup = $.trim(markup);
+  }
+
+  return markup;
+}
+
+function posFromPlaceholder(placeholder) {
+  const $placeholder = $(placeholder);
+  const pos = $placeholder.offset();
+  const height = $placeholder.outerHeight(true); // include margin
+
+  return {
+    left: pos.left,
+    top: pos.top + height
+  };
+}
+
+function attachEvents($node, events) {
+  Object.keys(events).forEach(function(key) {
+    $node.on(key, events[key]);
+  });
+}
+
+function detachEvents($node, events) {
+  Object.keys(events).forEach(function(key) {
+    $node.off(key, events[key]);
+  });
+}
+
+/**
+ * @method isCustomStyleTag
+ *
+ * assert if a node contains a "note-styletag" class,
+ * which implies that's a custom-made style tag node
+ *
+ * @param {Node} an HTML DOM node
+ */
+function isCustomStyleTag(node) {
+  return node && !isText(node) && lists.contains(node.classList, 'note-styletag');
+}
+
+export default {
+  /** @property {String} NBSP_CHAR */
+  NBSP_CHAR,
+  /** @property {String} ZERO_WIDTH_NBSP_CHAR */
+  ZERO_WIDTH_NBSP_CHAR,
+  /** @property {String} blank */
+  blank: blankHTML,
+  /** @property {String} emptyPara */
+  emptyPara: `<p>${blankHTML}</p>`,
+  makePredByNodeName,
+  isEditable,
+  isControlSizing,
+  isText,
+  isElement,
+  isVoid,
+  isPara,
+  isPurePara,
+  isHeading,
+  isInline,
+  isBlock: func.not(isInline),
+  isBodyInline,
+  isBody,
+  isParaInline,
+  isPre,
+  isList,
+  isTable,
+  isData,
+  isCell,
+  isBlockquote,
+  isBodyContainer,
+  isAnchor,
+  isDiv: makePredByNodeName('DIV'),
+  isLi,
+  isBR: makePredByNodeName('BR'),
+  isSpan: makePredByNodeName('SPAN'),
+  isB: makePredByNodeName('B'),
+  isU: makePredByNodeName('U'),
+  isS: makePredByNodeName('S'),
+  isI: makePredByNodeName('I'),
+  isImg: makePredByNodeName('IMG'),
+  isTextarea,
+  isEmpty,
+  isEmptyAnchor: func.and(isAnchor, isEmpty),
+  isClosestSibling,
+  withClosestSiblings,
+  nodeLength,
+  isLeftEdgePoint,
+  isRightEdgePoint,
+  isEdgePoint,
+  isLeftEdgeOf,
+  isRightEdgeOf,
+  isLeftEdgePointOf,
+  isRightEdgePointOf,
+  prevPoint,
+  nextPoint,
+  isSamePoint,
+  isVisiblePoint,
+  prevPointUntil,
+  nextPointUntil,
+  isCharPoint,
+  walkPoint,
+  ancestor,
+  singleChildAncestor,
+  listAncestor,
+  lastAncestor,
+  listNext,
+  listPrev,
+  listDescendant,
+  commonAncestor,
+  wrap,
+  insertAfter,
+  appendChildNodes,
+  position,
+  hasChildren,
+  makeOffsetPath,
+  fromOffsetPath,
+  splitTree,
+  splitPoint,
+  create,
+  createText,
+  remove,
+  removeWhile,
+  replace,
+  html,
+  value,
+  posFromPlaceholder,
+  attachEvents,
+  detachEvents,
+  isCustomStyleTag
+};