tui-calendar-rails 1.12.13.1

data/vendor/assets/javascripts/tui-code-snippet/tui-code-snippet.js

@@ -0,0 +1,4358 @@
+/*!
+ * tui-code-snippet.js
+ * @version 1.5.2
+ * @author NHN. FE Development Lab <dl_javascript@nhn.com>
+ * @license MIT
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["util"] = factory();
+	else
+		root["tui"] = root["tui"] || {}, root["tui"]["util"] = factory();
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "dist";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	/**
+	 * @fileoverview
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 * @namespace tui.util
+	 * @example
+	 * // node, commonjs
+	 * var util = require('tui-code-snippet');
+	 * @example
+	 * // distribution file, script
+	 * <script src='path-to/tui-code-snippt.js'></script>
+	 * <script>
+	 * var util = tui.util;
+	 * <script>
+	 */
+	var util = {};
+	var object = __webpack_require__(1);
+	var extend = object.extend;
+
+	extend(util, object);
+	extend(util, __webpack_require__(3));
+	extend(util, __webpack_require__(2));
+	extend(util, __webpack_require__(4));
+	extend(util, __webpack_require__(5));
+	extend(util, __webpack_require__(6));
+	extend(util, __webpack_require__(7));
+	extend(util, __webpack_require__(8));
+	extend(util, __webpack_require__(9));
+
+	util.browser = __webpack_require__(10);
+	util.popup = __webpack_require__(11);
+	util.formatDate = __webpack_require__(12);
+	util.defineClass = __webpack_require__(13);
+	util.defineModule = __webpack_require__(14);
+	util.defineNamespace = __webpack_require__(15);
+	util.CustomEvents = __webpack_require__(16);
+	util.Enum = __webpack_require__(17);
+	util.ExMap = __webpack_require__(18);
+	util.HashMap = __webpack_require__(20);
+	util.Map = __webpack_require__(19);
+
+	module.exports = util;
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module has some functions for handling a plain object, json.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var type = __webpack_require__(2);
+	var array = __webpack_require__(3);
+
+	/**
+	 * The last id of stamp
+	 * @type {number}
+	 * @private
+	 */
+	var lastId = 0;
+
+	/**
+	 * Extend the target object from other objects.
+	 * @param {object} target - Object that will be extended
+	 * @param {...object} objects - Objects as sources
+	 * @returns {object} Extended object
+	 * @memberof tui.util
+	 */
+	function extend(target, objects) { // eslint-disable-line no-unused-vars
+	    var hasOwnProp = Object.prototype.hasOwnProperty;
+	    var source, prop, i, len;
+
+	    for (i = 1, len = arguments.length; i < len; i += 1) {
+	        source = arguments[i];
+	        for (prop in source) {
+	            if (hasOwnProp.call(source, prop)) {
+	                target[prop] = source[prop];
+	            }
+	        }
+	    }
+
+	    return target;
+	}
+
+	/**
+	 * Assign a unique id to an object
+	 * @param {object} obj - Object that will be assigned id.
+	 * @returns {number} Stamped id
+	 * @memberof tui.util
+	 */
+	function stamp(obj) {
+	    if (!obj.__fe_id) {
+	        lastId += 1;
+	        obj.__fe_id = lastId; // eslint-disable-line camelcase
+	    }
+
+	    return obj.__fe_id;
+	}
+
+	/**
+	 * Verify whether an object has a stamped id or not.
+	 * @param {object} obj - adjusted object
+	 * @returns {boolean}
+	 * @memberof tui.util
+	 */
+	function hasStamp(obj) {
+	    return type.isExisty(pick(obj, '__fe_id'));
+	}
+
+	/**
+	 * Reset the last id of stamp
+	 * @private
+	 */
+	function resetLastId() {
+	    lastId = 0;
+	}
+
+	/**
+	 * Return a key-list(array) of a given object
+	 * @param {object} obj - Object from which a key-list will be extracted
+	 * @returns {Array} A key-list(array)
+	 * @memberof tui.util
+	 */
+	function keys(obj) {
+	    var keyArray = [];
+	    var key;
+
+	    for (key in obj) {
+	        if (obj.hasOwnProperty(key)) {
+	            keyArray.push(key);
+	        }
+	    }
+
+	    return keyArray;
+	}
+
+	/**
+	 * Return the equality for multiple objects(jsonObjects).<br>
+	 *  See {@link http://stackoverflow.com/questions/1068834/object-comparison-in-javascript}
+	 * @param {...object} object - Multiple objects for comparing.
+	 * @returns {boolean} Equality
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var jsonObj1 = {name:'milk', price: 1000};
+	 * var jsonObj2 = {name:'milk', price: 1000};
+	 * var jsonObj3 = {name:'milk', price: 1000};
+	 * util.compareJSON(jsonObj1, jsonObj2, jsonObj3);   // true
+	 *
+	 * var jsonObj4 = {name:'milk', price: 1000};
+	 * var jsonObj5 = {name:'beer', price: 3000};
+	 * util.compareJSON(jsonObj4, jsonObj5); // false
+	 */
+	function compareJSON(object) {
+	    var argsLen = arguments.length;
+	    var i = 1;
+
+	    if (argsLen < 1) {
+	        return true;
+	    }
+
+	    for (; i < argsLen; i += 1) {
+	        if (!isSameObject(object, arguments[i])) {
+	            return false;
+	        }
+	    }
+
+	    return true;
+	}
+
+	/**
+	 * @param {*} x - object to compare
+	 * @param {*} y - object to compare
+	 * @returns {boolean} - whether object x and y is same or not
+	 * @private
+	 */
+	function isSameObject(x, y) { // eslint-disable-line complexity
+	    var leftChain = [];
+	    var rightChain = [];
+	    var p;
+
+	    // remember that NaN === NaN returns false
+	    // and isNaN(undefined) returns true
+	    if (isNaN(x) &&
+	        isNaN(y) &&
+	        type.isNumber(x) &&
+	        type.isNumber(y)) {
+	        return true;
+	    }
+
+	    // Compare primitives and functions.
+	    // Check if both arguments link to the same object.
+	    // Especially useful on step when comparing prototypes
+	    if (x === y) {
+	        return true;
+	    }
+
+	    // Works in case when functions are created in constructor.
+	    // Comparing dates is a common scenario. Another built-ins?
+	    // We can even handle functions passed across iframes
+	    if ((type.isFunction(x) && type.isFunction(y)) ||
+	        (x instanceof Date && y instanceof Date) ||
+	        (x instanceof RegExp && y instanceof RegExp) ||
+	        (x instanceof String && y instanceof String) ||
+	        (x instanceof Number && y instanceof Number)) {
+	        return x.toString() === y.toString();
+	    }
+
+	    // At last checking prototypes as good a we can
+	    if (!(x instanceof Object && y instanceof Object)) {
+	        return false;
+	    }
+
+	    if (x.isPrototypeOf(y) ||
+	        y.isPrototypeOf(x) ||
+	        x.constructor !== y.constructor ||
+	        x.prototype !== y.prototype) {
+	        return false;
+	    }
+
+	    // check for infinitive linking loops
+	    if (array.inArray(x, leftChain) > -1 ||
+	        array.inArray(y, rightChain) > -1) {
+	        return false;
+	    }
+
+	    // Quick checking of one object beeing a subset of another.
+	    for (p in y) {
+	        if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+	            return false;
+	        } else if (typeof y[p] !== typeof x[p]) {
+	            return false;
+	        }
+	    }
+
+	    // This for loop executes comparing with hasOwnProperty() and typeof for each property in 'x' object,
+	    // and verifying equality for x[property] and y[property].
+	    for (p in x) {
+	        if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+	            return false;
+	        } else if (typeof y[p] !== typeof x[p]) {
+	            return false;
+	        }
+
+	        if (typeof (x[p]) === 'object' || typeof (x[p]) === 'function') {
+	            leftChain.push(x);
+	            rightChain.push(y);
+
+	            if (!isSameObject(x[p], y[p])) {
+	                return false;
+	            }
+
+	            leftChain.pop();
+	            rightChain.pop();
+	        } else if (x[p] !== y[p]) {
+	            return false;
+	        }
+	    }
+
+	    return true;
+	}
+	/* eslint-enable complexity */
+
+	/**
+	 * Retrieve a nested item from the given object/array
+	 * @param {object|Array} obj - Object for retrieving
+	 * @param {...string|number} paths - Paths of property
+	 * @returns {*} Value
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var obj = {
+	 *     'key1': 1,
+	 *     'nested' : {
+	 *         'key1': 11,
+	 *         'nested': {
+	 *             'key1': 21
+	 *         }
+	 *     }
+	 * };
+	 * util.pick(obj, 'nested', 'nested', 'key1'); // 21
+	 * util.pick(obj, 'nested', 'nested', 'key2'); // undefined
+	 *
+	 * var arr = ['a', 'b', 'c'];
+	 * util.pick(arr, 1); // 'b'
+	 */
+	function pick(obj, paths) { // eslint-disable-line no-unused-vars
+	    var args = arguments;
+	    var target = args[0];
+	    var i = 1;
+	    var length = args.length;
+
+	    for (; i < length; i += 1) {
+	        if (type.isUndefined(target) ||
+	            type.isNull(target)) {
+	            return;
+	        }
+
+	        target = target[args[i]];
+	    }
+
+	    return target; // eslint-disable-line consistent-return
+	}
+
+	module.exports = {
+	    extend: extend,
+	    stamp: stamp,
+	    hasStamp: hasStamp,
+	    resetLastId: resetLastId,
+	    keys: Object.prototype.keys || keys,
+	    compareJSON: compareJSON,
+	    pick: pick
+	};
+
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports) {
+
+	/**
+	 * @fileoverview This module provides some functions to check the type of variable
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var toString = Object.prototype.toString;
+
+	/**
+	 * Check whether the given variable is existing or not.<br>
+	 *  If the given variable is not null and not undefined, returns true.
+	 * @param {*} param - Target for checking
+	 * @returns {boolean} Is existy?
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * util.isExisty(''); //true
+	 * util.isExisty(0); //true
+	 * util.isExisty([]); //true
+	 * util.isExisty({}); //true
+	 * util.isExisty(null); //false
+	 * util.isExisty(undefined); //false
+	*/
+	function isExisty(param) {
+	    return !isUndefined(param) && !isNull(param);
+	}
+
+	/**
+	 * Check whether the given variable is undefined or not.<br>
+	 *  If the given variable is undefined, returns true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is undefined?
+	 * @memberof tui.util
+	 */
+	function isUndefined(obj) {
+	    return obj === undefined; // eslint-disable-line no-undefined
+	}
+
+	/**
+	 * Check whether the given variable is null or not.<br>
+	 *  If the given variable(arguments[0]) is null, returns true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is null?
+	 * @memberof tui.util
+	 */
+	function isNull(obj) {
+	    return obj === null;
+	}
+
+	/**
+	 * Check whether the given variable is truthy or not.<br>
+	 *  If the given variable is not null or not undefined or not false, returns true.<br>
+	 *  (It regards 0 as true)
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is truthy?
+	 * @memberof tui.util
+	 */
+	function isTruthy(obj) {
+	    return isExisty(obj) && obj !== false;
+	}
+
+	/**
+	 * Check whether the given variable is falsy or not.<br>
+	 *  If the given variable is null or undefined or false, returns true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is falsy?
+	 * @memberof tui.util
+	 */
+	function isFalsy(obj) {
+	    return !isTruthy(obj);
+	}
+
+	/**
+	 * Check whether the given variable is an arguments object or not.<br>
+	 *  If the given variable is an arguments object, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is arguments?
+	 * @memberof tui.util
+	 */
+	function isArguments(obj) {
+	    var result = isExisty(obj) &&
+	        ((toString.call(obj) === '[object Arguments]') || !!obj.callee);
+
+	    return result;
+	}
+
+	/**
+	 * Check whether the given variable is an instance of Array or not.<br>
+	 *  If the given variable is an instance of Array, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is array instance?
+	 * @memberof tui.util
+	 */
+	function isArray(obj) {
+	    return obj instanceof Array;
+	}
+
+	/**
+	 * Check whether the given variable is an object or not.<br>
+	 *  If the given variable is an object, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is object?
+	 * @memberof tui.util
+	 */
+	function isObject(obj) {
+	    return obj === Object(obj);
+	}
+
+	/**
+	 * Check whether the given variable is a function or not.<br>
+	 *  If the given variable is a function, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is function?
+	 * @memberof tui.util
+	 */
+	function isFunction(obj) {
+	    return obj instanceof Function;
+	}
+
+	/**
+	 * Check whether the given variable is a number or not.<br>
+	 *  If the given variable is a number, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is number?
+	 * @memberof tui.util
+	 */
+	function isNumber(obj) {
+	    return typeof obj === 'number' || obj instanceof Number;
+	}
+
+	/**
+	 * Check whether the given variable is a string or not.<br>
+	 *  If the given variable is a string, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is string?
+	 * @memberof tui.util
+	 */
+	function isString(obj) {
+	    return typeof obj === 'string' || obj instanceof String;
+	}
+
+	/**
+	 * Check whether the given variable is a boolean or not.<br>
+	 *  If the given variable is a boolean, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is boolean?
+	 * @memberof tui.util
+	 */
+	function isBoolean(obj) {
+	    return typeof obj === 'boolean' || obj instanceof Boolean;
+	}
+
+	/**
+	 * Check whether the given variable is an instance of Array or not.<br>
+	 *  If the given variable is an instance of Array, return true.<br>
+	 *  (It is used for multiple frame environments)
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is an instance of array?
+	 * @memberof tui.util
+	 */
+	function isArraySafe(obj) {
+	    return toString.call(obj) === '[object Array]';
+	}
+
+	/**
+	 * Check whether the given variable is a function or not.<br>
+	 *  If the given variable is a function, return true.<br>
+	 *  (It is used for multiple frame environments)
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is a function?
+	 * @memberof tui.util
+	 */
+	function isFunctionSafe(obj) {
+	    return toString.call(obj) === '[object Function]';
+	}
+
+	/**
+	 * Check whether the given variable is a number or not.<br>
+	 *  If the given variable is a number, return true.<br>
+	 *  (It is used for multiple frame environments)
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is a number?
+	 * @memberof tui.util
+	 */
+	function isNumberSafe(obj) {
+	    return toString.call(obj) === '[object Number]';
+	}
+
+	/**
+	 * Check whether the given variable is a string or not.<br>
+	 *  If the given variable is a string, return true.<br>
+	 *  (It is used for multiple frame environments)
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is a string?
+	 * @memberof tui.util
+	 */
+	function isStringSafe(obj) {
+	    return toString.call(obj) === '[object String]';
+	}
+
+	/**
+	 * Check whether the given variable is a boolean or not.<br>
+	 *  If the given variable is a boolean, return true.<br>
+	 *  (It is used for multiple frame environments)
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is a boolean?
+	 * @memberof tui.util
+	 */
+	function isBooleanSafe(obj) {
+	    return toString.call(obj) === '[object Boolean]';
+	}
+
+	/**
+	 * Check whether the given variable is a instance of HTMLNode or not.<br>
+	 *  If the given variables is a instance of HTMLNode, return true.
+	 * @param {*} html - Target for checking
+	 * @returns {boolean} Is HTMLNode ?
+	 * @memberof tui.util
+	 */
+	function isHTMLNode(html) {
+	    if (typeof HTMLElement === 'object') {
+	        return (html && (html instanceof HTMLElement || !!html.nodeType));
+	    }
+
+	    return !!(html && html.nodeType);
+	}
+
+	/**
+	 * Check whether the given variable is a HTML tag or not.<br>
+	 *  If the given variables is a HTML tag, return true.
+	 * @param {*} html - Target for checking
+	 * @returns {Boolean} Is HTML tag?
+	 * @memberof tui.util
+	 */
+	function isHTMLTag(html) {
+	    if (typeof HTMLElement === 'object') {
+	        return (html && (html instanceof HTMLElement));
+	    }
+
+	    return !!(html && html.nodeType && html.nodeType === 1);
+	}
+
+	/**
+	 * Check whether the given variable is empty(null, undefined, or empty array, empty object) or not.<br>
+	 *  If the given variables is empty, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is empty?
+	 * @memberof tui.util
+	 */
+	function isEmpty(obj) {
+	    if (!isExisty(obj) || _isEmptyString(obj)) {
+	        return true;
+	    }
+
+	    if (isArray(obj) || isArguments(obj)) {
+	        return obj.length === 0;
+	    }
+
+	    if (isObject(obj) && !isFunction(obj)) {
+	        return !_hasOwnProperty(obj);
+	    }
+
+	    return true;
+	}
+
+	/**
+	 * Check whether given argument is empty string
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} whether given argument is empty string
+	 * @memberof tui.util
+	 * @private
+	 */
+	function _isEmptyString(obj) {
+	    return isString(obj) && obj === '';
+	}
+
+	/**
+	 * Check whether given argument has own property
+	 * @param {Object} obj - Target for checking
+	 * @returns {boolean} - whether given argument has own property
+	 * @memberof tui.util
+	 * @private
+	 */
+	function _hasOwnProperty(obj) {
+	    var key;
+	    for (key in obj) {
+	        if (obj.hasOwnProperty(key)) {
+	            return true;
+	        }
+	    }
+
+	    return false;
+	}
+
+	/**
+	 * Check whether the given variable is not empty
+	 * (not null, not undefined, or not empty array, not empty object) or not.<br>
+	 *  If the given variables is not empty, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is not empty?
+	 * @memberof tui.util
+	 */
+	function isNotEmpty(obj) {
+	    return !isEmpty(obj);
+	}
+
+	/**
+	 * Check whether the given variable is an instance of Date or not.<br>
+	 *  If the given variables is an instance of Date, return true.
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is an instance of Date?
+	 * @memberof tui.util
+	 */
+	function isDate(obj) {
+	    return obj instanceof Date;
+	}
+
+	/**
+	 * Check whether the given variable is an instance of Date or not.<br>
+	 *  If the given variables is an instance of Date, return true.<br>
+	 *  (It is used for multiple frame environments)
+	 * @param {*} obj - Target for checking
+	 * @returns {boolean} Is an instance of Date?
+	 * @memberof tui.util
+	 */
+	function isDateSafe(obj) {
+	    return toString.call(obj) === '[object Date]';
+	}
+
+	module.exports = {
+	    isExisty: isExisty,
+	    isUndefined: isUndefined,
+	    isNull: isNull,
+	    isTruthy: isTruthy,
+	    isFalsy: isFalsy,
+	    isArguments: isArguments,
+	    isArray: isArray,
+	    isArraySafe: isArraySafe,
+	    isObject: isObject,
+	    isFunction: isFunction,
+	    isFunctionSafe: isFunctionSafe,
+	    isNumber: isNumber,
+	    isNumberSafe: isNumberSafe,
+	    isDate: isDate,
+	    isDateSafe: isDateSafe,
+	    isString: isString,
+	    isStringSafe: isStringSafe,
+	    isBoolean: isBoolean,
+	    isBooleanSafe: isBooleanSafe,
+	    isHTMLNode: isHTMLNode,
+	    isHTMLTag: isHTMLTag,
+	    isEmpty: isEmpty,
+	    isNotEmpty: isNotEmpty
+	};
+
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module has some functions for handling array.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var type = __webpack_require__(2);
+
+	var aps = Array.prototype.slice;
+	var util;
+
+	/**
+	 * Generate an integer Array containing an arithmetic progression.
+	 * @param {number} start - start index
+	 * @param {number} stop - stop index
+	 * @param {number} step - next visit index = current index + step
+	 * @returns {Array}
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * util.range(5); // [0, 1, 2, 3, 4]
+	 * util.range(1, 5); // [1,2,3,4]
+	 * util.range(2, 10, 2); // [2,4,6,8]
+	 * util.range(10, 2, -2); // [10,8,6,4]
+	 */
+	var range = function(start, stop, step) {
+	    var arr = [];
+	    var flag;
+
+	    if (type.isUndefined(stop)) {
+	        stop = start || 0;
+	        start = 0;
+	    }
+
+	    step = step || 1;
+	    flag = step < 0 ? -1 : 1;
+	    stop *= flag;
+
+	    for (; start * flag < stop; start += step) {
+	        arr.push(start);
+	    }
+
+	    return arr;
+	};
+
+	/* eslint-disable valid-jsdoc */
+	/**
+	 * Zip together multiple lists into a single array
+	 * @param {...Array}
+	 * @returns {Array}
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var result = util.zip([1, 2, 3], ['a', 'b','c'], [true, false, true]);
+	 * console.log(result[0]); // [1, 'a', true]
+	 * console.log(result[1]); // [2, 'b', false]
+	 * console.log(result[2]); // [3, 'c', true]
+	 */
+	var zip = function() {/* eslint-enable valid-jsdoc */
+	    var arr2d = aps.call(arguments);
+	    var result = [];
+
+	    collection.forEach(arr2d, function(arr) {
+	        collection.forEach(arr, function(value, index) {
+	            if (!result[index]) {
+	                result[index] = [];
+	            }
+	            result[index].push(value);
+	        });
+	    });
+
+	    return result;
+	};
+
+	/**
+	 * Returns the first index at which a given element can be found in the array
+	 * from start index(default 0), or -1 if it is not present.<br>
+	 * It compares searchElement to elements of the Array using strict equality
+	 * (the same method used by the ===, or triple-equals, operator).
+	 * @param {*} searchElement Element to locate in the array
+	 * @param {Array} array Array that will be traversed.
+	 * @param {number} startIndex Start index in array for searching (default 0)
+	 * @returns {number} the First index at which a given element, or -1 if it is not present
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var arr = ['one', 'two', 'three', 'four'];
+	 * var idx1 = util.inArray('one', arr, 3); // -1
+	 * var idx2 = util.inArray('one', arr); // 0
+	 */
+	var inArray = function(searchElement, array, startIndex) {
+	    var i;
+	    var length;
+	    startIndex = startIndex || 0;
+
+	    if (!type.isArray(array)) {
+	        return -1;
+	    }
+
+	    if (Array.prototype.indexOf) {
+	        return Array.prototype.indexOf.call(array, searchElement, startIndex);
+	    }
+
+	    length = array.length;
+	    for (i = startIndex; startIndex >= 0 && i < length; i += 1) {
+	        if (array[i] === searchElement) {
+	            return i;
+	        }
+	    }
+
+	    return -1;
+	};
+
+	util = {
+	    inArray: inArray,
+	    range: range,
+	    zip: zip
+	};
+
+	module.exports = util;
+
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module has some functions for handling object as collection.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var type = __webpack_require__(2);
+	var object = __webpack_require__(1);
+
+	/**
+	 * Execute the provided callback once for each element present
+	 * in the array(or Array-like object) in ascending order.<br>
+	 * If the callback function returns false, the loop will be stopped.<br>
+	 * Callback function(iteratee) is invoked with three arguments:
+	 *  - The value of the element
+	 *  - The index of the element
+	 *  - The array(or Array-like object) being traversed
+	 * @param {Array} arr The array(or Array-like object) that will be traversed
+	 * @param {function} iteratee Callback function
+	 * @param {Object} [context] Context(this) of callback function
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var sum = 0;
+	 *
+	 * util.forEachArray([1,2,3], function(value){
+	 *     sum += value;
+	 * });
+	 * alert(sum); // 6
+	 */
+	function forEachArray(arr, iteratee, context) {
+	    var index = 0;
+	    var len = arr.length;
+
+	    context = context || null;
+
+	    for (; index < len; index += 1) {
+	        if (iteratee.call(context, arr[index], index, arr) === false) {
+	            break;
+	        }
+	    }
+	}
+
+	/**
+	 * Execute the provided callback once for each property of object which actually exist.<br>
+	 * If the callback function returns false, the loop will be stopped.<br>
+	 * Callback function(iteratee) is invoked with three arguments:
+	 *  - The value of the property
+	 *  - The name of the property
+	 *  - The object being traversed
+	 * @param {Object} obj The object that will be traversed
+	 * @param {function} iteratee  Callback function
+	 * @param {Object} [context] Context(this) of callback function
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var sum = 0;
+	 *
+	 * util.forEachOwnProperties({a:1,b:2,c:3}, function(value){
+	 *     sum += value;
+	 * });
+	 * alert(sum); // 6
+	 **/
+	function forEachOwnProperties(obj, iteratee, context) {
+	    var key;
+
+	    context = context || null;
+
+	    for (key in obj) {
+	        if (obj.hasOwnProperty(key)) {
+	            if (iteratee.call(context, obj[key], key, obj) === false) {
+	                break;
+	            }
+	        }
+	    }
+	}
+
+	/**
+	 * Execute the provided callback once for each property of object(or element of array) which actually exist.<br>
+	 * If the object is Array-like object(ex-arguments object), It needs to transform to Array.(see 'ex2' of example).<br>
+	 * If the callback function returns false, the loop will be stopped.<br>
+	 * Callback function(iteratee) is invoked with three arguments:
+	 *  - The value of the property(or The value of the element)
+	 *  - The name of the property(or The index of the element)
+	 *  - The object being traversed
+	 * @param {Object} obj The object that will be traversed
+	 * @param {function} iteratee Callback function
+	 * @param {Object} [context] Context(this) of callback function
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var sum = 0;
+	 *
+	 * util.forEach([1,2,3], function(value){
+	 *     sum += value;
+	 * });
+	 * alert(sum); // 6
+	 *
+	 * // In case of Array-like object
+	 * var array = Array.prototype.slice.call(arrayLike); // change to array
+	 * util.forEach(array, function(value){
+	 *     sum += value;
+	 * });
+	 */
+	function forEach(obj, iteratee, context) {
+	    if (type.isArray(obj)) {
+	        forEachArray(obj, iteratee, context);
+	    } else {
+	        forEachOwnProperties(obj, iteratee, context);
+	    }
+	}
+
+	/**
+	 * Execute the provided callback function once for each element in an array, in order,
+	 * and constructs a new array from the results.<br>
+	 * If the object is Array-like object(ex-arguments object),
+	 * It needs to transform to Array.(see 'ex2' of forEach example)<br>
+	 * Callback function(iteratee) is invoked with three arguments:
+	 *  - The value of the property(or The value of the element)
+	 *  - The name of the property(or The index of the element)
+	 *  - The object being traversed
+	 * @param {Object} obj The object that will be traversed
+	 * @param {function} iteratee Callback function
+	 * @param {Object} [context] Context(this) of callback function
+	 * @returns {Array} A new array composed of returned values from callback function
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var result = util.map([0,1,2,3], function(value) {
+	 *     return value + 1;
+	 * });
+	 *
+	 * alert(result);  // 1,2,3,4
+	 */
+	function map(obj, iteratee, context) {
+	    var resultArray = [];
+
+	    context = context || null;
+
+	    forEach(obj, function() {
+	        resultArray.push(iteratee.apply(context, arguments));
+	    });
+
+	    return resultArray;
+	}
+
+	/**
+	 * Execute the callback function once for each element present in the array(or Array-like object or plain object).<br>
+	 * If the object is Array-like object(ex-arguments object),
+	 * It needs to transform to Array.(see 'ex2' of forEach example)<br>
+	 * Callback function(iteratee) is invoked with four arguments:
+	 *  - The previousValue
+	 *  - The currentValue
+	 *  - The index
+	 *  - The object being traversed
+	 * @param {Object} obj The object that will be traversed
+	 * @param {function} iteratee Callback function
+	 * @param {Object} [context] Context(this) of callback function
+	 * @returns {*} The result value
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var result = util.reduce([0,1,2,3], function(stored, value) {
+	 *     return stored + value;
+	 * });
+	 *
+	 * alert(result); // 6
+	 */
+	function reduce(obj, iteratee, context) {
+	    var index = 0;
+	    var keys, length, store;
+
+	    context = context || null;
+
+	    if (!type.isArray(obj)) {
+	        keys = object.keys(obj);
+	        length = keys.length;
+	        store = obj[keys[index += 1]];
+	    } else {
+	        length = obj.length;
+	        store = obj[index];
+	    }
+
+	    index += 1;
+	    for (; index < length; index += 1) {
+	        store = iteratee.call(context, store, obj[keys ? keys[index] : index]);
+	    }
+
+	    return store;
+	}
+
+	/**
+	 * Transform the Array-like object to Array.<br>
+	 * In low IE (below 8), Array.prototype.slice.call is not perfect. So, try-catch statement is used.
+	 * @param {*} arrayLike Array-like object
+	 * @returns {Array} Array
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var arrayLike = {
+	 *     0: 'one',
+	 *     1: 'two',
+	 *     2: 'three',
+	 *     3: 'four',
+	 *     length: 4
+	 * };
+	 * var result = util.toArray(arrayLike);
+	 *
+	 * alert(result instanceof Array); // true
+	 * alert(result); // one,two,three,four
+	 */
+	function toArray(arrayLike) {
+	    var arr;
+	    try {
+	        arr = Array.prototype.slice.call(arrayLike);
+	    } catch (e) {
+	        arr = [];
+	        forEachArray(arrayLike, function(value) {
+	            arr.push(value);
+	        });
+	    }
+
+	    return arr;
+	}
+
+	/**
+	 * Create a new array or plain object with all elements(or properties)
+	 * that pass the test implemented by the provided function.<br>
+	 * Callback function(iteratee) is invoked with three arguments:
+	 *  - The value of the property(or The value of the element)
+	 *  - The name of the property(or The index of the element)
+	 *  - The object being traversed
+	 * @param {Object} obj Object(plain object or Array) that will be traversed
+	 * @param {function} iteratee Callback function
+	 * @param {Object} [context] Context(this) of callback function
+	 * @returns {Object} plain object or Array
+	 * @memberof tui.util
+	 * @example
+	  * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var result1 = util.filter([0,1,2,3], function(value) {
+	 *     return (value % 2 === 0);
+	 * });
+	 * alert(result1); // [0, 2]
+	 *
+	 * var result2 = util.filter({a : 1, b: 2, c: 3}, function(value) {
+	 *     return (value % 2 !== 0);
+	 * });
+	 * alert(result2.a); // 1
+	 * alert(result2.b); // undefined
+	 * alert(result2.c); // 3
+	 */
+	function filter(obj, iteratee, context) {
+	    var result, add;
+
+	    context = context || null;
+
+	    if (!type.isObject(obj) || !type.isFunction(iteratee)) {
+	        throw new Error('wrong parameter');
+	    }
+
+	    if (type.isArray(obj)) {
+	        result = [];
+	        add = function(subResult, args) {
+	            subResult.push(args[0]);
+	        };
+	    } else {
+	        result = {};
+	        add = function(subResult, args) {
+	            subResult[args[1]] = args[0];
+	        };
+	    }
+
+	    forEach(obj, function() {
+	        if (iteratee.apply(context, arguments)) {
+	            add(result, arguments);
+	        }
+	    }, context);
+
+	    return result;
+	}
+
+	/**
+	 * fetching a property
+	 * @param {Array} arr target collection
+	 * @param {String|Number} property property name
+	 * @returns {Array}
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var objArr = [
+	 *     {'abc': 1, 'def': 2, 'ghi': 3},
+	 *     {'abc': 4, 'def': 5, 'ghi': 6},
+	 *     {'abc': 7, 'def': 8, 'ghi': 9}
+	 * ];
+	 * var arr2d = [
+	 *     [1, 2, 3],
+	 *     [4, 5, 6],
+	 *     [7, 8, 9]
+	 * ];
+	 * util.pluck(objArr, 'abc'); // [1, 4, 7]
+	 * util.pluck(arr2d, 2); // [3, 6, 9]
+	 */
+	function pluck(arr, property) {
+	    var result = map(arr, function(item) {
+	        return item[property];
+	    });
+
+	    return result;
+	}
+
+	module.exports = {
+	    forEachOwnProperties: forEachOwnProperties,
+	    forEachArray: forEachArray,
+	    forEach: forEach,
+	    toArray: toArray,
+	    map: map,
+	    reduce: reduce,
+	    filter: filter,
+	    pluck: pluck
+	};
+
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports) {
+
+	/**
+	 * @fileoverview This module provides a bind() function for context binding.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	/**
+	 * Create a new function that, when called, has its this keyword set to the provided value.
+	 * @param {function} fn A original function before binding
+	 * @param {*} obj context of function in arguments[0]
+	 * @returns {function()} A new bound function with context that is in arguments[1]
+	 * @memberof tui.util
+	 */
+	function bind(fn, obj) {
+	    var slice = Array.prototype.slice;
+	    var args;
+
+	    if (fn.bind) {
+	        return fn.bind.apply(fn, slice.call(arguments, 1));
+	    }
+
+	    /* istanbul ignore next */
+	    args = slice.call(arguments, 2);
+
+	    /* istanbul ignore next */
+	    return function() {
+	        /* istanbul ignore next */
+	        return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
+	    };
+	}
+
+	module.exports = {
+	    bind: bind
+	};
+
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports) {
+
+	/**
+	 * @fileoverview This module provides some simple function for inheritance.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	/**
+	 * Create a new object with the specified prototype object and properties.
+	 * @param {Object} obj This object will be a prototype of the newly-created object.
+	 * @returns {Object}
+	 * @memberof tui.util
+	 */
+	function createObject(obj) {
+	    function F() {} // eslint-disable-line require-jsdoc
+	    F.prototype = obj;
+
+	    return new F();
+	}
+
+	/**
+	 * Provide a simple inheritance in prototype-oriented.<br>
+	 * Caution :
+	 *  Don't overwrite the prototype of child constructor.
+	 *
+	 * @param {function} subType Child constructor
+	 * @param {function} superType Parent constructor
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * // Parent constructor
+	 * function Animal(leg) {
+	 *     this.leg = leg;
+	 * }
+	 * Animal.prototype.growl = function() {
+	 *     // ...
+	 * };
+	 *
+	 * // Child constructor
+	 * function Person(name) {
+	 *     this.name = name;
+	 * }
+	 *
+	 * // Inheritance
+	 * util.inherit(Person, Animal);
+	 *
+	 * // After this inheritance, please use only the extending of property.
+	 * // Do not overwrite prototype.
+	 * Person.prototype.walk = function(direction) {
+	 *     // ...
+	 * };
+	 */
+	function inherit(subType, superType) {
+	    var prototype = createObject(superType.prototype);
+	    prototype.constructor = subType;
+	    subType.prototype = prototype;
+	}
+
+	module.exports = {
+	    createObject: createObject,
+	    inherit: inherit
+	};
+
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module has some functions for handling the string.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var object = __webpack_require__(1);
+	/**
+	 * Transform the given HTML Entity string into plain string
+	 * @param {String} htmlEntity - HTML Entity type string
+	 * @returns {String} Plain string
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 *  var htmlEntityString = "A &#39;quote&#39; is &lt;b&gt;bold&lt;/b&gt;"
+	 *  var result = util.decodeHTMLEntity(htmlEntityString); //"A 'quote' is <b>bold</b>"
+	 */
+	function decodeHTMLEntity(htmlEntity) {
+	    var entities = {
+	        '&quot;': '"',
+	        '&amp;': '&',
+	        '&lt;': '<',
+	        '&gt;': '>',
+	        '&#39;': '\'',
+	        '&nbsp;': ' '
+	    };
+
+	    return htmlEntity.replace(/&amp;|&lt;|&gt;|&quot;|&#39;|&nbsp;/g, function(m0) {
+	        return entities[m0] ? entities[m0] : m0;
+	    });
+	}
+
+	/**
+	 * Transform the given string into HTML Entity string
+	 * @param {String} html - String for encoding
+	 * @returns {String} HTML Entity
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 *  var htmlEntityString = "<script> alert('test');</script><a href='test'>";
+	 *  var result = util.encodeHTMLEntity(htmlEntityString);
+	 * //"&lt;script&gt; alert(&#39;test&#39;);&lt;/script&gt;&lt;a href=&#39;test&#39;&gt;"
+	 */
+	function encodeHTMLEntity(html) {
+	    var entities = {
+	        '"': 'quot',
+	        '&': 'amp',
+	        '<': 'lt',
+	        '>': 'gt',
+	        '\'': '#39'
+	    };
+
+	    return html.replace(/[<>&"']/g, function(m0) {
+	        return entities[m0] ? '&' + entities[m0] + ';' : m0;
+	    });
+	}
+
+	/**
+	 * Return whether the string capable to transform into plain string is in the given string or not.
+	 * @param {String} string - test string
+	 * @memberof tui.util
+	 * @returns {boolean}
+	 */
+	function hasEncodableString(string) {
+	    return (/[<>&"']/).test(string);
+	}
+
+	/**
+	 * Return duplicate charters
+	 * @param {string} operandStr1 The operand string
+	 * @param {string} operandStr2 The operand string
+	 * @private
+	 * @memberof tui.util
+	 * @returns {string}
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * util.getDuplicatedChar('fe dev', 'nhn entertainment'); // 'e'
+	 * util.getDuplicatedChar('fdsa', 'asdf'); // 'asdf'
+	 */
+	function getDuplicatedChar(operandStr1, operandStr2) {
+	    var i = 0;
+	    var len = operandStr1.length;
+	    var pool = {};
+	    var dupl, key;
+
+	    for (; i < len; i += 1) {
+	        key = operandStr1.charAt(i);
+	        pool[key] = 1;
+	    }
+
+	    for (i = 0, len = operandStr2.length; i < len; i += 1) {
+	        key = operandStr2.charAt(i);
+	        if (pool[key]) {
+	            pool[key] += 1;
+	        }
+	    }
+
+	    pool = collection.filter(pool, function(item) {
+	        return item > 1;
+	    });
+
+	    pool = object.keys(pool).sort();
+	    dupl = pool.join('');
+
+	    return dupl;
+	}
+
+	module.exports = {
+	    decodeHTMLEntity: decodeHTMLEntity,
+	    encodeHTMLEntity: encodeHTMLEntity,
+	    hasEncodableString: hasEncodableString,
+	    getDuplicatedChar: getDuplicatedChar
+	};
+
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports) {
+
+	/**
+	 * @fileoverview collections of some technic methods.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript.nhn.com>
+	 */
+
+	'use strict';
+
+	var tricks = {};
+	var aps = Array.prototype.slice;
+
+	/**
+	 * Creates a debounced function that delays invoking fn until after delay milliseconds has elapsed
+	 * since the last time the debouced function was invoked.
+	 * @param {function} fn The function to debounce.
+	 * @param {number} [delay=0] The number of milliseconds to delay
+	 * @memberof tui.util
+	 * @returns {function} debounced function.
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * function someMethodToInvokeDebounced() {}
+	 *
+	 * var debounced = util.debounce(someMethodToInvokeDebounced, 300);
+	 *
+	 * // invoke repeatedly
+	 * debounced();
+	 * debounced();
+	 * debounced();
+	 * debounced();
+	 * debounced();
+	 * debounced();    // last invoke of debounced()
+	 *
+	 * // invoke someMethodToInvokeDebounced() after 300 milliseconds.
+	 */
+	function debounce(fn, delay) {
+	    var timer, args;
+
+	    /* istanbul ignore next */
+	    delay = delay || 0;
+
+	    function debounced() { // eslint-disable-line require-jsdoc
+	        args = aps.call(arguments);
+
+	        window.clearTimeout(timer);
+	        timer = window.setTimeout(function() {
+	            fn.apply(null, args);
+	        }, delay);
+	    }
+
+	    return debounced;
+	}
+
+	/**
+	 * return timestamp
+	 * @memberof tui.util
+	 * @returns {number} The number of milliseconds from Jan. 1970 00:00:00 (GMT)
+	 */
+	function timestamp() {
+	    return Number(new Date());
+	}
+
+	/**
+	 * Creates a throttled function that only invokes fn at most once per every interval milliseconds.
+	 *
+	 * You can use this throttle short time repeatedly invoking functions. (e.g MouseMove, Resize ...)
+	 *
+	 * if you need reuse throttled method. you must remove slugs (e.g. flag variable) related with throttling.
+	 * @param {function} fn function to throttle
+	 * @param {number} [interval=0] the number of milliseconds to throttle invocations to.
+	 * @memberof tui.util
+	 * @returns {function} throttled function
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * function someMethodToInvokeThrottled() {}
+	 *
+	 * var throttled = util.throttle(someMethodToInvokeThrottled, 300);
+	 *
+	 * // invoke repeatedly
+	 * throttled();    // invoke (leading)
+	 * throttled();
+	 * throttled();    // invoke (near 300 milliseconds)
+	 * throttled();
+	 * throttled();
+	 * throttled();    // invoke (near 600 milliseconds)
+	 * // ...
+	 * // invoke (trailing)
+	 *
+	 * // if you need reuse throttled method. then invoke reset()
+	 * throttled.reset();
+	 */
+	function throttle(fn, interval) {
+	    var base;
+	    var isLeading = true;
+	    var tick = function(_args) {
+	        fn.apply(null, _args);
+	        base = null;
+	    };
+	    var debounced, stamp, args;
+
+	    /* istanbul ignore next */
+	    interval = interval || 0;
+
+	    debounced = tricks.debounce(tick, interval);
+
+	    function throttled() { // eslint-disable-line require-jsdoc
+	        args = aps.call(arguments);
+
+	        if (isLeading) {
+	            tick(args);
+	            isLeading = false;
+
+	            return;
+	        }
+
+	        stamp = tricks.timestamp();
+
+	        base = base || stamp;
+
+	        // pass array directly because `debounce()`, `tick()` are already use
+	        // `apply()` method to invoke developer's `fn` handler.
+	        //
+	        // also, this `debounced` line invoked every time for implements
+	        // `trailing` features.
+	        debounced(args);
+
+	        if ((stamp - base) >= interval) {
+	            tick(args);
+	        }
+	    }
+
+	    function reset() { // eslint-disable-line require-jsdoc
+	        isLeading = true;
+	        base = null;
+	    }
+
+	    throttled.reset = reset;
+
+	    return throttled;
+	}
+
+	tricks.timestamp = timestamp;
+	tricks.debounce = debounce;
+	tricks.throttle = throttle;
+
+	module.exports = tricks;
+
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module has some functions for handling object as collection.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+	'use strict';
+
+	var object = __webpack_require__(1);
+	var collection = __webpack_require__(4);
+	var type = __webpack_require__(2);
+	var ms7days = 7 * 24 * 60 * 60 * 1000;
+
+	/**
+	 * Check if the date has passed 7 days
+	 * @param {number} date - milliseconds
+	 * @returns {boolean}
+	 * @ignore
+	 */
+	function isExpired(date) {
+	    var now = new Date().getTime();
+
+	    return now - date > ms7days;
+	}
+
+	/**
+	 * Send hostname on DOMContentLoaded.
+	 * To prevent hostname set tui.usageStatistics to false.
+	 * @param {string} appName - application name
+	 * @param {string} trackingId - GA tracking ID
+	 * @ignore
+	 */
+	function sendHostname(appName, trackingId) {
+	    var url = 'https://www.google-analytics.com/collect';
+	    var hostname = location.hostname;
+	    var hitType = 'event';
+	    var eventCategory = 'use';
+	    var applicationKeyForStorage = 'TOAST UI ' + appName + ' for ' + hostname + ': Statistics';
+	    var date = window.localStorage.getItem(applicationKeyForStorage);
+
+	    // skip if the flag is defined and is set to false explicitly
+	    if (!type.isUndefined(window.tui) && window.tui.usageStatistics === false) {
+	        return;
+	    }
+
+	    // skip if not pass seven days old
+	    if (date && !isExpired(date)) {
+	        return;
+	    }
+
+	    window.localStorage.setItem(applicationKeyForStorage, new Date().getTime());
+
+	    setTimeout(function() {
+	        if (document.readyState === 'interactive' || document.readyState === 'complete') {
+	            imagePing(url, {
+	                v: 1,
+	                t: hitType,
+	                tid: trackingId,
+	                cid: hostname,
+	                dp: hostname,
+	                dh: appName,
+	                el: appName,
+	                ec: eventCategory
+	            });
+	        }
+	    }, 1000);
+	}
+
+	/**
+	 * Request image ping.
+	 * @param {String} url url for ping request
+	 * @param {Object} trackingInfo infos for make query string
+	 * @returns {HTMLElement}
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * util.imagePing('https://www.google-analytics.com/collect', {
+	 *     v: 1,
+	 *     t: 'event',
+	 *     tid: 'trackingid',
+	 *     cid: 'cid',
+	 *     dp: 'dp',
+	 *     dh: 'dh'
+	 * });
+	 */
+	function imagePing(url, trackingInfo) {
+	    var queryString = collection.map(object.keys(trackingInfo), function(key, index) {
+	        var startWith = index === 0 ? '' : '&';
+
+	        return startWith + key + '=' + trackingInfo[key];
+	    }).join('');
+	    var trackingElement = document.createElement('img');
+
+	    trackingElement.src = url + '?' + queryString;
+
+	    trackingElement.style.display = 'none';
+	    document.body.appendChild(trackingElement);
+	    document.body.removeChild(trackingElement);
+
+	    return trackingElement;
+	}
+
+	module.exports = {
+	    imagePing: imagePing,
+	    sendHostname: sendHostname
+	};
+
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports) {
+
+	/**
+	 * @fileoverview This module detects the kind of well-known browser and version.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	/**
+	 * This object has an information that indicate the kind of browser.<br>
+	 * The list below is a detectable browser list.
+	 *  - ie8 ~ ie11
+	 *  - chrome
+	 *  - firefox
+	 *  - safari
+	 *  - edge
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * util.browser.chrome === true; // chrome
+	 * util.browser.firefox === true; // firefox
+	 * util.browser.safari === true; // safari
+	 * util.browser.msie === true; // IE
+	 * util.browser.edge === true; // edge
+	 * util.browser.others === true; // other browser
+	 * util.browser.version; // browser version
+	 */
+	var browser = {
+	    chrome: false,
+	    firefox: false,
+	    safari: false,
+	    msie: false,
+	    edge: false,
+	    others: false,
+	    version: 0
+	};
+
+	if (window && window.navigator) {
+	    detectBrowser();
+	}
+
+	/**
+	 * Detect the browser.
+	 * @private
+	 */
+	function detectBrowser() {
+	    var nav = window.navigator;
+	    var appName = nav.appName.replace(/\s/g, '_');
+	    var userAgent = nav.userAgent;
+
+	    var rIE = /MSIE\s([0-9]+[.0-9]*)/;
+	    var rIE11 = /Trident.*rv:11\./;
+	    var rEdge = /Edge\/(\d+)\./;
+	    var versionRegex = {
+	        firefox: /Firefox\/(\d+)\./,
+	        chrome: /Chrome\/(\d+)\./,
+	        safari: /Version\/([\d.]+).*Safari\/(\d+)/
+	    };
+
+	    var key, tmp;
+
+	    var detector = {
+	        Microsoft_Internet_Explorer: function() { // eslint-disable-line camelcase
+	            var detectedVersion = userAgent.match(rIE);
+
+	            if (detectedVersion) { // ie8 ~ ie10
+	                browser.msie = true;
+	                browser.version = parseFloat(detectedVersion[1]);
+	            } else { // no version information
+	                browser.others = true;
+	            }
+	        },
+	        Netscape: function() { // eslint-disable-line complexity
+	            var detected = false;
+
+	            if (rIE11.exec(userAgent)) {
+	                browser.msie = true;
+	                browser.version = 11;
+	                detected = true;
+	            } else if (rEdge.exec(userAgent)) {
+	                browser.edge = true;
+	                browser.version = userAgent.match(rEdge)[1];
+	                detected = true;
+	            } else {
+	                for (key in versionRegex) {
+	                    if (versionRegex.hasOwnProperty(key)) {
+	                        tmp = userAgent.match(versionRegex[key]);
+	                        if (tmp && tmp.length > 1) { // eslint-disable-line max-depth
+	                            browser[key] = detected = true;
+	                            browser.version = parseFloat(tmp[1] || 0);
+	                            break;
+	                        }
+	                    }
+	                }
+	            }
+	            if (!detected) {
+	                browser.others = true;
+	            }
+	        }
+	    };
+
+	    var fn = detector[appName];
+
+	    if (fn) {
+	        detector[appName]();
+	    }
+	}
+
+	module.exports = browser;
+
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module has some methods for handling popup-window
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var type = __webpack_require__(2);
+	var func = __webpack_require__(5);
+	var browser = __webpack_require__(10);
+	var object = __webpack_require__(1);
+
+	var popupId = 0;
+
+	/**
+	 * Popup management class
+	 * @constructor
+	 * @memberof tui.util
+	 * @example
+	 * // node, commonjs
+	 * var popup = require('tui-code-snippet').popup;
+	 * @example
+	 * // distribution file, script
+	 * <script src='path-to/tui-code-snippt.js'></script>
+	 * <script>
+	 * var popup = tui.util.popup;
+	 * <script>
+	 */
+	function Popup() {
+	    /**
+	     * Caching the window-contexts of opened popups
+	     * @type {Object}
+	     */
+	    this.openedPopup = {};
+
+	    /**
+	     * In IE7, an error occurs when the closeWithParent property attaches to window object.<br>
+	     * So, It is for saving the value of closeWithParent instead of attaching to window object.
+	     * @type {Object}
+	     */
+	    this.closeWithParentPopup = {};
+
+	    /**
+	     * Post data bridge for IE11 popup
+	     * @type {string}
+	     */
+	    this.postBridgeUrl = '';
+	}
+
+	/**********
+	 * public methods
+	 **********/
+
+	/**
+	 * Returns a popup-list administered by current window.
+	 * @param {string} [key] The key of popup.
+	 * @returns {Object} popup window list object
+	 */
+	Popup.prototype.getPopupList = function(key) {
+	    var target;
+	    if (type.isExisty(key)) {
+	        target = this.openedPopup[key];
+	    } else {
+	        target = this.openedPopup;
+	    }
+
+	    return target;
+	};
+
+	/**
+	 * Open popup
+	 * Caution:
+	 *  In IE11, when transfer data to popup by POST, must set the postBridgeUrl.
+	 *
+	 * @param {string} url - popup url
+	 * @param {Object} options - popup options
+	 *     @param {string} [options.popupName] - Key of popup window.<br>
+	 *      If the key is set, when you try to open by this key, the popup of this key is focused.<br>
+	 *      Or else a new popup window having this key is opened.
+	 *
+	 *     @param {string} [options.popupOptionStr=""] - Option string of popup window<br>
+	 *      It is same with the third parameter of window.open() method.<br>
+	 *      See {@link http://www.w3schools.com/jsref/met_win_open.asp}
+	 *
+	 *     @param {boolean} [options.closeWithParent=true] - Is closed when parent window closed?
+	 *
+	 *     @param {boolean} [options.useReload=false] - This property indicates whether reload the popup or not.<br>
+	 *      If true, the popup will be reloaded when you try to re-open the popup that has been opened.<br>
+	 *      When transmit the POST-data, some browsers alert a message for confirming whether retransmit or not.
+	 *
+	 *     @param {string} [options.postBridgeUrl='']
+	 *      Use this url to avoid a certain bug occuring when transmitting POST data to the popup in IE11.<br>
+	 *      This specific buggy situation is known to happen because IE11 tries to open the requested url<br>
+	 *      not in a new popup window as intended, but in a new tab.<br>
+	 *      See {@link http://wiki.nhnent.com/pages/viewpage.action?pageId=240562844}
+	 *
+	 *     @param {string} [options.method=get]
+	 *     The method of transmission when the form-data is transmitted to popup-window.
+	 *
+	 *     @param {Object} [options.param=null]
+	 *     Using as parameters for transmission when the form-data is transmitted to popup-window.
+	 */
+	Popup.prototype.openPopup = function(url, options) { // eslint-disable-line complexity
+	    var popup, formElement, useIEPostBridge;
+
+	    options = object.extend({
+	        popupName: 'popup_' + popupId + '_' + Number(new Date()),
+	        popupOptionStr: '',
+	        useReload: true,
+	        closeWithParent: true,
+	        method: 'get',
+	        param: {}
+	    }, options || {});
+
+	    options.method = options.method.toUpperCase();
+
+	    this.postBridgeUrl = options.postBridgeUrl || this.postBridgeUrl;
+
+	    useIEPostBridge = options.method === 'POST' && options.param &&
+	            browser.msie && browser.version === 11;
+
+	    if (!type.isExisty(url)) {
+	        throw new Error('Popup#open() need popup url.');
+	    }
+
+	    popupId += 1;
+
+	    /*
+	     * In form-data transmission
+	     * 1. Create a form before opening a popup.
+	     * 2. Transmit the form-data.
+	     * 3. Remove the form after transmission.
+	     */
+	    if (options.param) {
+	        if (options.method === 'GET') {
+	            url = url + (/\?/.test(url) ? '&' : '?') + this._parameterize(options.param);
+	        } else if (options.method === 'POST') {
+	            if (!useIEPostBridge) {
+	                formElement = this.createForm(url, options.param, options.method, options.popupName);
+	                url = 'about:blank';
+	            }
+	        }
+	    }
+
+	    popup = this.openedPopup[options.popupName];
+
+	    if (!type.isExisty(popup)) {
+	        this.openedPopup[options.popupName] = popup = this._open(useIEPostBridge, options.param,
+	            url, options.popupName, options.popupOptionStr);
+	    } else if (popup.closed) {
+	        this.openedPopup[options.popupName] = popup = this._open(useIEPostBridge, options.param,
+	            url, options.popupName, options.popupOptionStr);
+	    } else {
+	        if (options.useReload) {
+	            popup.location.replace(url);
+	        }
+	        popup.focus();
+	    }
+
+	    this.closeWithParentPopup[options.popupName] = options.closeWithParent;
+
+	    if (!popup || popup.closed || type.isUndefined(popup.closed)) {
+	        alert('please enable popup windows for this website');
+	    }
+
+	    if (options.param && options.method === 'POST' && !useIEPostBridge) {
+	        if (popup) {
+	            formElement.submit();
+	        }
+	        if (formElement.parentNode) {
+	            formElement.parentNode.removeChild(formElement);
+	        }
+	    }
+
+	    window.onunload = func.bind(this.closeAllPopup, this);
+	};
+
+	/**
+	 * Close the popup
+	 * @param {boolean} [skipBeforeUnload] - If true, the 'window.onunload' will be null and skip unload event.
+	 * @param {Window} [popup] - Window-context of popup for closing. If omit this, current window-context will be closed.
+	 */
+	Popup.prototype.close = function(skipBeforeUnload, popup) {
+	    var target = popup || window;
+	    skipBeforeUnload = type.isExisty(skipBeforeUnload) ? skipBeforeUnload : false;
+
+	    if (skipBeforeUnload) {
+	        window.onunload = null;
+	    }
+
+	    if (!target.closed) {
+	        target.opener = window.location.href;
+	        target.close();
+	    }
+	};
+
+	/**
+	 * Close all the popups in current window.
+	 * @param {boolean} closeWithParent - If true, popups having the closeWithParentPopup property as true will be closed.
+	 */
+	Popup.prototype.closeAllPopup = function(closeWithParent) {
+	    var hasArg = type.isExisty(closeWithParent);
+
+	    collection.forEachOwnProperties(this.openedPopup, function(popup, key) {
+	        if ((hasArg && this.closeWithParentPopup[key]) || !hasArg) {
+	            this.close(false, popup);
+	        }
+	    }, this);
+	};
+
+	/**
+	 * Activate(or focus) the popup of the given name.
+	 * @param {string} popupName - Name of popup for activation
+	 */
+	Popup.prototype.focus = function(popupName) {
+	    this.getPopupList(popupName).focus();
+	};
+
+	/**
+	 * Return an object made of parsing the query string.
+	 * @returns {Object} An object having some information of the query string.
+	 * @private
+	 */
+	Popup.prototype.parseQuery = function() {
+	    var param = {};
+	    var search, pair;
+
+	    search = window.location.search.substr(1);
+	    collection.forEachArray(search.split('&'), function(part) {
+	        pair = part.split('=');
+	        param[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
+	    });
+
+	    return param;
+	};
+
+	/**
+	 * Create a hidden form from the given arguments and return this form.
+	 * @param {string} action - URL for form transmission
+	 * @param {Object} [data] - Data for form transmission
+	 * @param {string} [method] - Method of transmission
+	 * @param {string} [target] - Target of transmission
+	 * @param {HTMLElement} [container] - Container element of form.
+	 * @returns {HTMLElement} Form element
+	 */
+	Popup.prototype.createForm = function(action, data, method, target, container) {
+	    var form = document.createElement('form'),
+	        input;
+
+	    container = container || document.body;
+
+	    form.method = method || 'POST';
+	    form.action = action || '';
+	    form.target = target || '';
+	    form.style.display = 'none';
+
+	    collection.forEachOwnProperties(data, function(value, key) {
+	        input = document.createElement('input');
+	        input.name = key;
+	        input.type = 'hidden';
+	        input.value = value;
+	        form.appendChild(input);
+	    });
+
+	    container.appendChild(form);
+
+	    return form;
+	};
+
+	/**********
+	 * private methods
+	 **********/
+
+	/**
+	 * Return an query string made by parsing the given object
+	 * @param {Object} obj - An object that has information for query string
+	 * @returns {string} - Query string
+	 * @private
+	 */
+	Popup.prototype._parameterize = function(obj) {
+	    var query = [];
+
+	    collection.forEachOwnProperties(obj, function(value, key) {
+	        query.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
+	    });
+
+	    return query.join('&');
+	};
+
+	/**
+	 * Open popup
+	 * @param {boolean} useIEPostBridge - A switch option whether to use alternative
+	 *                                  of tossing POST data to the popup window in IE11
+	 * @param {Object} param - A data for tossing to popup
+	 * @param {string} url - Popup url
+	 * @param {string} popupName - Popup name
+	 * @param {string} optionStr - Setting for popup, ex) 'width=640,height=320,scrollbars=yes'
+	 * @returns {Window} Window context of popup
+	 * @private
+	 */
+	Popup.prototype._open = function(useIEPostBridge, param, url, popupName, optionStr) {
+	    var popup;
+
+	    if (useIEPostBridge) {
+	        popup = window.open(this.postBridgeUrl, popupName, optionStr);
+	        setTimeout(function() {
+	            popup.redirect(url, param);
+	        }, 100);
+	    } else {
+	        popup = window.open(url, popupName, optionStr);
+	    }
+
+	    return popup;
+	};
+
+	module.exports = new Popup();
+
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module has a function for date format.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var type = __webpack_require__(2);
+	var object = __webpack_require__(1);
+
+	var tokens = /[\\]*YYYY|[\\]*YY|[\\]*MMMM|[\\]*MMM|[\\]*MM|[\\]*M|[\\]*DD|[\\]*D|[\\]*HH|[\\]*H|[\\]*A/gi;
+	var MONTH_STR = [
+	    'Invalid month', 'January', 'February', 'March', 'April', 'May',
+	    'June', 'July', 'August', 'September', 'October', 'November', 'December'
+	];
+	var MONTH_DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+	var replaceMap = {
+	    M: function(date) {
+	        return Number(date.month);
+	    },
+	    MM: function(date) {
+	        var month = date.month;
+
+	        return (Number(month) < 10) ? '0' + month : month;
+	    },
+	    MMM: function(date) {
+	        return MONTH_STR[Number(date.month)].substr(0, 3);
+	    },
+	    MMMM: function(date) {
+	        return MONTH_STR[Number(date.month)];
+	    },
+	    D: function(date) {
+	        return Number(date.date);
+	    },
+	    d: function(date) {
+	        return replaceMap.D(date); // eslint-disable-line new-cap
+	    },
+	    DD: function(date) {
+	        var dayInMonth = date.date;
+
+	        return (Number(dayInMonth) < 10) ? '0' + dayInMonth : dayInMonth;
+	    },
+	    dd: function(date) {
+	        return replaceMap.DD(date); // eslint-disable-line new-cap
+	    },
+	    YY: function(date) {
+	        return Number(date.year) % 100;
+	    },
+	    yy: function(date) {
+	        return replaceMap.YY(date); // eslint-disable-line new-cap
+	    },
+	    YYYY: function(date) {
+	        var prefix = '20',
+	            year = date.year;
+	        if (year > 69 && year < 100) {
+	            prefix = '19';
+	        }
+
+	        return (Number(year) < 100) ? prefix + String(year) : year;
+	    },
+	    yyyy: function(date) {
+	        return replaceMap.YYYY(date); // eslint-disable-line new-cap
+	    },
+	    A: function(date) {
+	        return date.meridiem;
+	    },
+	    a: function(date) {
+	        return date.meridiem;
+	    },
+	    hh: function(date) {
+	        var hour = date.hour;
+
+	        return (Number(hour) < 10) ? '0' + hour : hour;
+	    },
+	    HH: function(date) {
+	        return replaceMap.hh(date);
+	    },
+	    h: function(date) {
+	        return String(Number(date.hour));
+	    },
+	    H: function(date) {
+	        return replaceMap.h(date);
+	    },
+	    m: function(date) {
+	        return String(Number(date.minute));
+	    },
+	    mm: function(date) {
+	        var minute = date.minute;
+
+	        return (Number(minute) < 10) ? '0' + minute : minute;
+	    }
+	};
+
+	/**
+	 * Check whether the given variables are valid date or not.
+	 * @param {number} year - Year
+	 * @param {number} month - Month
+	 * @param {number} date - Day in month.
+	 * @returns {boolean} Is valid?
+	 * @private
+	 */
+	function isValidDate(year, month, date) { // eslint-disable-line complexity
+	    var isValidYear, isValidMonth, isValid, lastDayInMonth;
+
+	    year = Number(year);
+	    month = Number(month);
+	    date = Number(date);
+
+	    isValidYear = (year > -1 && year < 100) || ((year > 1969) && (year < 2070));
+	    isValidMonth = (month > 0) && (month < 13);
+
+	    if (!isValidYear || !isValidMonth) {
+	        return false;
+	    }
+
+	    lastDayInMonth = MONTH_DAYS[month];
+	    if (month === 2 && year % 4 === 0) {
+	        if (year % 100 !== 0 || year % 400 === 0) {
+	            lastDayInMonth = 29;
+	        }
+	    }
+
+	    isValid = (date > 0) && (date <= lastDayInMonth);
+
+	    return isValid;
+	}
+
+	/**
+	 * Return a string that transformed from the given form and date.
+	 * @param {string} form - Date form
+	 * @param {Date|Object} date - Date object
+	 * @param {{meridiemSet: {AM: string, PM: string}}} option - Option
+	 * @returns {boolean|string} A transformed string or false.
+	 * @memberof tui.util
+	 * @example
+	 *  // key             | Shorthand
+	 *  // --------------- |-----------------------
+	 *  // years           | YY / YYYY / yy / yyyy
+	 *  // months(n)       | M / MM
+	 *  // months(str)     | MMM / MMMM
+	 *  // days            | D / DD / d / dd
+	 *  // hours           | H / HH / h / hh
+	 *  // minutes         | m / mm
+	 *  // meridiem(AM,PM) | A / a
+	 *
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var dateStr1 = util.formatDate('yyyy-MM-dd', {
+	 *     year: 2014,
+	 *     month: 12,
+	 *     date: 12
+	 * });
+	 * alert(dateStr1); // '2014-12-12'
+	 *
+	 * var dateStr2 = util.formatDate('MMM DD YYYY HH:mm', {
+	 *     year: 1999,
+	 *     month: 9,
+	 *     date: 9,
+	 *     hour: 0,
+	 *     minute: 2
+	 * });
+	 * alert(dateStr2); // 'Sep 09 1999 00:02'
+	 *
+	 * var dt = new Date(2010, 2, 13),
+	 *     dateStr3 = util.formatDate('yyyy년 M월 dd일', dt);
+	 * alert(dateStr3); // '2010년 3월 13일'
+	 *
+	 * var option4 = {
+	 *     meridiemSet: {
+	 *         AM: '오전',
+	 *         PM: '오후'
+	 *     }
+	 * };
+	 * var date4 = {year: 1999, month: 9, date: 9, hour: 13, minute: 2};
+	 * var dateStr4 = util.formatDate('yyyy-MM-dd A hh:mm', date4, option4));
+	 * alert(dateStr4); // '1999-09-09 오후 01:02'
+	 */
+	function formatDate(form, date, option) { // eslint-disable-line complexity
+	    var am = object.pick(option, 'meridiemSet', 'AM') || 'AM';
+	    var pm = object.pick(option, 'meridiemSet', 'PM') || 'PM';
+	    var meridiem, nDate, resultStr;
+
+	    if (type.isDate(date)) {
+	        nDate = {
+	            year: date.getFullYear(),
+	            month: date.getMonth() + 1,
+	            date: date.getDate(),
+	            hour: date.getHours(),
+	            minute: date.getMinutes()
+	        };
+	    } else {
+	        nDate = {
+	            year: date.year,
+	            month: date.month,
+	            date: date.date,
+	            hour: date.hour,
+	            minute: date.minute
+	        };
+	    }
+
+	    if (!isValidDate(nDate.year, nDate.month, nDate.date)) {
+	        return false;
+	    }
+
+	    nDate.meridiem = '';
+	    if (/([^\\]|^)[aA]\b/.test(form)) {
+	        meridiem = (nDate.hour > 11) ? pm : am;
+	        if (nDate.hour > 12) { // See the clock system: https://en.wikipedia.org/wiki/12-hour_clock
+	            nDate.hour %= 12;
+	        }
+	        if (nDate.hour === 0) {
+	            nDate.hour = 12;
+	        }
+	        nDate.meridiem = meridiem;
+	    }
+
+	    resultStr = form.replace(tokens, function(key) {
+	        if (key.indexOf('\\') > -1) { // escape character
+	            return key.replace(/\\/, '');
+	        }
+
+	        return replaceMap[key](nDate) || '';
+	    });
+
+	    return resultStr;
+	}
+
+	module.exports = formatDate;
+
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview
+	 *  This module provides a function to make a constructor
+	 * that can inherit from the other constructors like the CLASS easily.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var inherit = __webpack_require__(6).inherit;
+	var extend = __webpack_require__(1).extend;
+
+	/**
+	 * Help a constructor to be defined and to inherit from the other constructors
+	 * @param {*} [parent] Parent constructor
+	 * @param {Object} props Members of constructor
+	 *  @param {Function} props.init Initialization method
+	 *  @param {Object} [props.static] Static members of constructor
+	 * @returns {*} Constructor
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var Parent = util.defineClass({
+	 *     init: function() { // constuructor
+	 *         this.name = 'made by def';
+	 *     },
+	 *     method: function() {
+	 *         // ...
+	 *     },
+	 *     static: {
+	 *         staticMethod: function() {
+	 *              // ...
+	 *         }
+	 *     }
+	 * });
+	 *
+	 * var Child = util.defineClass(Parent, {
+	 *     childMethod: function() {}
+	 * });
+	 *
+	 * Parent.staticMethod();
+	 *
+	 * var parentInstance = new Parent();
+	 * console.log(parentInstance.name); //made by def
+	 * parentInstance.staticMethod(); // Error
+	 *
+	 * var childInstance = new Child();
+	 * childInstance.method();
+	 * childInstance.childMethod();
+	 */
+	function defineClass(parent, props) {
+	    var obj;
+
+	    if (!props) {
+	        props = parent;
+	        parent = null;
+	    }
+
+	    obj = props.init || function() {};
+
+	    if (parent) {
+	        inherit(obj, parent);
+	    }
+
+	    if (props.hasOwnProperty('static')) {
+	        extend(obj, props['static']);
+	        delete props['static'];
+	    }
+
+	    extend(obj.prototype, props);
+
+	    return obj;
+	}
+
+	module.exports = defineClass;
+
+
+/***/ }),
+/* 14 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview Define module
+	 * @author NHN.
+	 *         FE Development Lab <dl_javscript@nhn.com>
+	 * @dependency type.js, defineNamespace.js
+	 */
+
+	'use strict';
+
+	var defineNamespace = __webpack_require__(15);
+	var type = __webpack_require__(2);
+
+	var INITIALIZATION_METHOD_NAME = 'initialize';
+
+	/**
+	 * Define module
+	 * @param {string} namespace - Namespace of module
+	 * @param {Object} moduleDefinition - Object literal for module
+	 * @returns {Object} Defined module
+	 * @memberof tui.util
+	 * @example
+	  * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var myModule = util.defineModule('modules.myModule', {
+	 *     name: 'john',
+	 *     message: '',
+	 *     initialize: function() {
+	 *        this.message = 'hello world';
+	 *     },
+	 *     getMessage: function() {
+	 *         return this.name + ': ' + this.message
+	 *     }
+	 * });
+	 *
+	 * console.log(myModule.getMessage());  // 'john: hello world';
+	 */
+	function defineModule(namespace, moduleDefinition) {
+	    var base = moduleDefinition || {};
+
+	    if (type.isFunction(base[INITIALIZATION_METHOD_NAME])) {
+	        base[INITIALIZATION_METHOD_NAME]();
+	    }
+
+	    return defineNamespace(namespace, base);
+	}
+
+	module.exports = defineModule;
+
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview Define namespace
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 * @dependency object.js, collection.js
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var object = __webpack_require__(1);
+
+	/**
+	 * Define namespace
+	 * @param {string} namespace - Namespace (ex- 'foo.bar.baz')
+	 * @param {(object|function)} props - A set of modules or one module
+	 * @param {boolean} [isOverride] - Override the props to the namespace.<br>
+	 *                                  (It removes previous properties of this namespace)
+	 * @returns {(object|function)} Defined namespace
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var util = require('tui-code-snippet'); // node, commonjs
+	 * var util = tui.util; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var neComp = util.defineNamespace;
+	 * neComp.listMenu = defineClass({
+	 *     init: function() {
+	 *         // ...
+	 *     }
+	 * });
+	 */
+	function defineNamespace(namespace, props, isOverride) {
+	    var names, result, prevLast, last;
+
+	    names = namespace.split('.');
+	    names.unshift(window);
+
+	    result = collection.reduce(names, function(obj, name) {
+	        obj[name] = obj[name] || {};
+
+	        return obj[name];
+	    });
+
+	    if (isOverride) {
+	        last = names.pop();
+	        prevLast = object.pick.apply(null, names);
+	        result = prevLast[last] = props;
+	    } else {
+	        object.extend(result, props);
+	    }
+
+	    return result;
+	}
+
+	module.exports = defineNamespace;
+
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview
+	 *  This module provides some functions for custom events.<br>
+	 *  And it is implemented in the observer design pattern.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var type = __webpack_require__(2);
+	var object = __webpack_require__(1);
+
+	var R_EVENTNAME_SPLIT = /\s+/g;
+
+	/**
+	 * A unit of event handler item.
+	 * @ignore
+	 * @typedef {object} HandlerItem
+	 * @property {function} fn - event handler
+	 * @property {object} ctx - context of event handler
+	 */
+
+	/**
+	 * @class
+	 * @memberof tui.util
+	 * @example
+	 * // node, commonjs
+	 * var CustomEvents = require('tui-code-snippet').CustomEvents;
+	 * @example
+	 * // distribution file, script
+	 * <script src='path-to/tui-code-snippt.js'></script>
+	 * <script>
+	 * var CustomEvents = tui.util.CustomEvents;
+	 * </script>
+	 */
+	function CustomEvents() {
+	    /**
+	     * @type {HandlerItem[]}
+	     */
+	    this.events = null;
+
+	    /**
+	     * only for checking specific context event was binded
+	     * @type {object[]}
+	     */
+	    this.contexts = null;
+	}
+
+	/**
+	 * Mixin custom events feature to specific constructor
+	 * @param {function} func - constructor
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var CustomEvents = require('tui-code-snippet').CustomEvents; // node, commonjs
+	 * var CustomEvents = tui.util.CustomEvents; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var model;
+	 * function Model() {
+	 *     this.name = '';
+	 * }
+	 * CustomEvents.mixin(Model);
+	 *
+	 * model = new Model();
+	 * model.on('change', function() { this.name = 'model'; }, this);
+	 * model.fire('change');
+	 * alert(model.name); // 'model';
+	 */
+	CustomEvents.mixin = function(func) {
+	    object.extend(func.prototype, CustomEvents.prototype);
+	};
+
+	/**
+	 * Get HandlerItem object
+	 * @param {function} handler - handler function
+	 * @param {object} [context] - context for handler
+	 * @returns {HandlerItem} HandlerItem object
+	 * @private
+	 */
+	CustomEvents.prototype._getHandlerItem = function(handler, context) {
+	    var item = {handler: handler};
+
+	    if (context) {
+	        item.context = context;
+	    }
+
+	    return item;
+	};
+
+	/**
+	 * Get event object safely
+	 * @param {string} [eventName] - create sub event map if not exist.
+	 * @returns {(object|array)} event object. if you supplied `eventName`
+	 *  parameter then make new array and return it
+	 * @private
+	 */
+	CustomEvents.prototype._safeEvent = function(eventName) {
+	    var events = this.events;
+	    var byName;
+
+	    if (!events) {
+	        events = this.events = {};
+	    }
+
+	    if (eventName) {
+	        byName = events[eventName];
+
+	        if (!byName) {
+	            byName = [];
+	            events[eventName] = byName;
+	        }
+
+	        events = byName;
+	    }
+
+	    return events;
+	};
+
+	/**
+	 * Get context array safely
+	 * @returns {array} context array
+	 * @private
+	 */
+	CustomEvents.prototype._safeContext = function() {
+	    var context = this.contexts;
+
+	    if (!context) {
+	        context = this.contexts = [];
+	    }
+
+	    return context;
+	};
+
+	/**
+	 * Get index of context
+	 * @param {object} ctx - context that used for bind custom event
+	 * @returns {number} index of context
+	 * @private
+	 */
+	CustomEvents.prototype._indexOfContext = function(ctx) {
+	    var context = this._safeContext();
+	    var index = 0;
+
+	    while (context[index]) {
+	        if (ctx === context[index][0]) {
+	            return index;
+	        }
+
+	        index += 1;
+	    }
+
+	    return -1;
+	};
+
+	/**
+	 * Memorize supplied context for recognize supplied object is context or
+	 *  name: handler pair object when off()
+	 * @param {object} ctx - context object to memorize
+	 * @private
+	 */
+	CustomEvents.prototype._memorizeContext = function(ctx) {
+	    var context, index;
+
+	    if (!type.isExisty(ctx)) {
+	        return;
+	    }
+
+	    context = this._safeContext();
+	    index = this._indexOfContext(ctx);
+
+	    if (index > -1) {
+	        context[index][1] += 1;
+	    } else {
+	        context.push([ctx, 1]);
+	    }
+	};
+
+	/**
+	 * Forget supplied context object
+	 * @param {object} ctx - context object to forget
+	 * @private
+	 */
+	CustomEvents.prototype._forgetContext = function(ctx) {
+	    var context, contextIndex;
+
+	    if (!type.isExisty(ctx)) {
+	        return;
+	    }
+
+	    context = this._safeContext();
+	    contextIndex = this._indexOfContext(ctx);
+
+	    if (contextIndex > -1) {
+	        context[contextIndex][1] -= 1;
+
+	        if (context[contextIndex][1] <= 0) {
+	            context.splice(contextIndex, 1);
+	        }
+	    }
+	};
+
+	/**
+	 * Bind event handler
+	 * @param {(string|{name:string, handler:function})} eventName - custom
+	 *  event name or an object {eventName: handler}
+	 * @param {(function|object)} [handler] - handler function or context
+	 * @param {object} [context] - context for binding
+	 * @private
+	 */
+	CustomEvents.prototype._bindEvent = function(eventName, handler, context) {
+	    var events = this._safeEvent(eventName);
+	    this._memorizeContext(context);
+	    events.push(this._getHandlerItem(handler, context));
+	};
+
+	/**
+	 * Bind event handlers
+	 * @param {(string|{name:string, handler:function})} eventName - custom
+	 *  event name or an object {eventName: handler}
+	 * @param {(function|object)} [handler] - handler function or context
+	 * @param {object} [context] - context for binding
+	 * //-- #1. Get Module --//
+	 * var CustomEvents = require('tui-code-snippet').CustomEvents; // node, commonjs
+	 * var CustomEvents = tui.util.CustomEvents; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * // # 2.1 Basic Usage
+	 * CustomEvents.on('onload', handler);
+	 *
+	 * // # 2.2 With context
+	 * CustomEvents.on('onload', handler, myObj);
+	 *
+	 * // # 2.3 Bind by object that name, handler pairs
+	 * CustomEvents.on({
+	 *     'play': handler,
+	 *     'pause': handler2
+	 * });
+	 *
+	 * // # 2.4 Bind by object that name, handler pairs with context object
+	 * CustomEvents.on({
+	 *     'play': handler
+	 * }, myObj);
+	 */
+	CustomEvents.prototype.on = function(eventName, handler, context) {
+	    var self = this;
+
+	    if (type.isString(eventName)) {
+	        // [syntax 1, 2]
+	        eventName = eventName.split(R_EVENTNAME_SPLIT);
+	        collection.forEach(eventName, function(name) {
+	            self._bindEvent(name, handler, context);
+	        });
+	    } else if (type.isObject(eventName)) {
+	        // [syntax 3, 4]
+	        context = handler;
+	        collection.forEach(eventName, function(func, name) {
+	            self.on(name, func, context);
+	        });
+	    }
+	};
+
+	/**
+	 * Bind one-shot event handlers
+	 * @param {(string|{name:string,handler:function})} eventName - custom
+	 *  event name or an object {eventName: handler}
+	 * @param {function|object} [handler] - handler function or context
+	 * @param {object} [context] - context for binding
+	 */
+	CustomEvents.prototype.once = function(eventName, handler, context) {
+	    var self = this;
+
+	    if (type.isObject(eventName)) {
+	        context = handler;
+	        collection.forEach(eventName, function(func, name) {
+	            self.once(name, func, context);
+	        });
+
+	        return;
+	    }
+
+	    function onceHandler() { // eslint-disable-line require-jsdoc
+	        handler.apply(context, arguments);
+	        self.off(eventName, onceHandler, context);
+	    }
+
+	    this.on(eventName, onceHandler, context);
+	};
+
+	/**
+	 * Splice supplied array by callback result
+	 * @param {array} arr - array to splice
+	 * @param {function} predicate - function return boolean
+	 * @private
+	 */
+	CustomEvents.prototype._spliceMatches = function(arr, predicate) {
+	    var i = 0;
+	    var len;
+
+	    if (!type.isArray(arr)) {
+	        return;
+	    }
+
+	    for (len = arr.length; i < len; i += 1) {
+	        if (predicate(arr[i]) === true) {
+	            arr.splice(i, 1);
+	            len -= 1;
+	            i -= 1;
+	        }
+	    }
+	};
+
+	/**
+	 * Get matcher for unbind specific handler events
+	 * @param {function} handler - handler function
+	 * @returns {function} handler matcher
+	 * @private
+	 */
+	CustomEvents.prototype._matchHandler = function(handler) {
+	    var self = this;
+
+	    return function(item) {
+	        var needRemove = handler === item.handler;
+
+	        if (needRemove) {
+	            self._forgetContext(item.context);
+	        }
+
+	        return needRemove;
+	    };
+	};
+
+	/**
+	 * Get matcher for unbind specific context events
+	 * @param {object} context - context
+	 * @returns {function} object matcher
+	 * @private
+	 */
+	CustomEvents.prototype._matchContext = function(context) {
+	    var self = this;
+
+	    return function(item) {
+	        var needRemove = context === item.context;
+
+	        if (needRemove) {
+	            self._forgetContext(item.context);
+	        }
+
+	        return needRemove;
+	    };
+	};
+
+	/**
+	 * Get matcher for unbind specific hander, context pair events
+	 * @param {function} handler - handler function
+	 * @param {object} context - context
+	 * @returns {function} handler, context matcher
+	 * @private
+	 */
+	CustomEvents.prototype._matchHandlerAndContext = function(handler, context) {
+	    var self = this;
+
+	    return function(item) {
+	        var matchHandler = (handler === item.handler);
+	        var matchContext = (context === item.context);
+	        var needRemove = (matchHandler && matchContext);
+
+	        if (needRemove) {
+	            self._forgetContext(item.context);
+	        }
+
+	        return needRemove;
+	    };
+	};
+
+	/**
+	 * Unbind event by event name
+	 * @param {string} eventName - custom event name to unbind
+	 * @param {function} [handler] - handler function
+	 * @private
+	 */
+	CustomEvents.prototype._offByEventName = function(eventName, handler) {
+	    var self = this;
+	    var forEach = collection.forEachArray;
+	    var andByHandler = type.isFunction(handler);
+	    var matchHandler = self._matchHandler(handler);
+
+	    eventName = eventName.split(R_EVENTNAME_SPLIT);
+
+	    forEach(eventName, function(name) {
+	        var handlerItems = self._safeEvent(name);
+
+	        if (andByHandler) {
+	            self._spliceMatches(handlerItems, matchHandler);
+	        } else {
+	            forEach(handlerItems, function(item) {
+	                self._forgetContext(item.context);
+	            });
+
+	            self.events[name] = [];
+	        }
+	    });
+	};
+
+	/**
+	 * Unbind event by handler function
+	 * @param {function} handler - handler function
+	 * @private
+	 */
+	CustomEvents.prototype._offByHandler = function(handler) {
+	    var self = this;
+	    var matchHandler = this._matchHandler(handler);
+
+	    collection.forEach(this._safeEvent(), function(handlerItems) {
+	        self._spliceMatches(handlerItems, matchHandler);
+	    });
+	};
+
+	/**
+	 * Unbind event by object(name: handler pair object or context object)
+	 * @param {object} obj - context or {name: handler} pair object
+	 * @param {function} handler - handler function
+	 * @private
+	 */
+	CustomEvents.prototype._offByObject = function(obj, handler) {
+	    var self = this;
+	    var matchFunc;
+
+	    if (this._indexOfContext(obj) < 0) {
+	        collection.forEach(obj, function(func, name) {
+	            self.off(name, func);
+	        });
+	    } else if (type.isString(handler)) {
+	        matchFunc = this._matchContext(obj);
+
+	        self._spliceMatches(this._safeEvent(handler), matchFunc);
+	    } else if (type.isFunction(handler)) {
+	        matchFunc = this._matchHandlerAndContext(handler, obj);
+
+	        collection.forEach(this._safeEvent(), function(handlerItems) {
+	            self._spliceMatches(handlerItems, matchFunc);
+	        });
+	    } else {
+	        matchFunc = this._matchContext(obj);
+
+	        collection.forEach(this._safeEvent(), function(handlerItems) {
+	            self._spliceMatches(handlerItems, matchFunc);
+	        });
+	    }
+	};
+
+	/**
+	 * Unbind custom events
+	 * @param {(string|object|function)} eventName - event name or context or
+	 *  {name: handler} pair object or handler function
+	 * @param {(function)} handler - handler function
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var CustomEvents = require('tui-code-snippet').CustomEvents; // node, commonjs
+	 * var CustomEvents = tui.util.CustomEvents; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * // # 2.1 off by event name
+	 * CustomEvents.off('onload');
+	 *
+	 * // # 2.2 off by event name and handler
+	 * CustomEvents.off('play', handler);
+	 *
+	 * // # 2.3 off by handler
+	 * CustomEvents.off(handler);
+	 *
+	 * // # 2.4 off by context
+	 * CustomEvents.off(myObj);
+	 *
+	 * // # 2.5 off by context and handler
+	 * CustomEvents.off(myObj, handler);
+	 *
+	 * // # 2.6 off by context and event name
+	 * CustomEvents.off(myObj, 'onload');
+	 *
+	 * // # 2.7 off by an Object.<string, function> that is {eventName: handler}
+	 * CustomEvents.off({
+	 *   'play': handler,
+	 *   'pause': handler2
+	 * });
+	 *
+	 * // # 2.8 off the all events
+	 * CustomEvents.off();
+	 */
+	CustomEvents.prototype.off = function(eventName, handler) {
+	    if (type.isString(eventName)) {
+	        // [syntax 1, 2]
+	        this._offByEventName(eventName, handler);
+	    } else if (!arguments.length) {
+	        // [syntax 8]
+	        this.events = {};
+	        this.contexts = [];
+	    } else if (type.isFunction(eventName)) {
+	        // [syntax 3]
+	        this._offByHandler(eventName);
+	    } else if (type.isObject(eventName)) {
+	        // [syntax 4, 5, 6]
+	        this._offByObject(eventName, handler);
+	    }
+	};
+
+	/**
+	 * Fire custom event
+	 * @param {string} eventName - name of custom event
+	 */
+	CustomEvents.prototype.fire = function(eventName) {  // eslint-disable-line
+	    this.invoke.apply(this, arguments);
+	};
+
+	/**
+	 * Fire a event and returns the result of operation 'boolean AND' with all
+	 *  listener's results.
+	 *
+	 * So, It is different from {@link CustomEvents#fire}.
+	 *
+	 * In service code, use this as a before event in component level usually
+	 *  for notifying that the event is cancelable.
+	 * @param {string} eventName - Custom event name
+	 * @param {...*} data - Data for event
+	 * @returns {boolean} The result of operation 'boolean AND'
+	 * @example
+	 * var map = new Map();
+	 * map.on({
+	 *     'beforeZoom': function() {
+	 *         // It should cancel the 'zoom' event by some conditions.
+	 *         if (that.disabled && this.getState()) {
+	 *             return false;
+	 *         }
+	 *         return true;
+	 *     }
+	 * });
+	 *
+	 * if (this.invoke('beforeZoom')) {    // check the result of 'beforeZoom'
+	 *     // if true,
+	 *     // doSomething
+	 * }
+	 */
+	CustomEvents.prototype.invoke = function(eventName) {
+	    var events, args, index, item;
+
+	    if (!this.hasListener(eventName)) {
+	        return true;
+	    }
+
+	    events = this._safeEvent(eventName);
+	    args = Array.prototype.slice.call(arguments, 1);
+	    index = 0;
+
+	    while (events[index]) {
+	        item = events[index];
+
+	        if (item.handler.apply(item.context, args) === false) {
+	            return false;
+	        }
+
+	        index += 1;
+	    }
+
+	    return true;
+	};
+
+	/**
+	 * Return whether at least one of the handlers is registered in the given
+	 *  event name.
+	 * @param {string} eventName - Custom event name
+	 * @returns {boolean} Is there at least one handler in event name?
+	 */
+	CustomEvents.prototype.hasListener = function(eventName) {
+	    return this.getListenerLength(eventName) > 0;
+	};
+
+	/**
+	 * Return a count of events registered.
+	 * @param {string} eventName - Custom event name
+	 * @returns {number} number of event
+	 */
+	CustomEvents.prototype.getListenerLength = function(eventName) {
+	    var events = this._safeEvent(eventName);
+
+	    return events.length;
+	};
+
+	module.exports = CustomEvents;
+
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module provides a Enum Constructor.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 * @example
+	 * // node, commonjs
+	 * var Enum = require('tui-code-snippet').Enum;
+	 * @example
+	 * // distribution file, script
+	 * <script src='path-to/tui-code-snippt.js'></script>
+	 * <script>
+	 * var Enum = tui.util.Enum;
+	 * <script>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var type = __webpack_require__(2);
+
+	/**
+	 * Check whether the defineProperty() method is supported.
+	 * @type {boolean}
+	 * @ignore
+	 */
+	var isSupportDefinedProperty = (function() {
+	    try {
+	        Object.defineProperty({}, 'x', {});
+
+	        return true;
+	    } catch (e) {
+	        return false;
+	    }
+	})();
+
+	/**
+	 * A unique value of a constant.
+	 * @type {number}
+	 * @ignore
+	 */
+	var enumValue = 0;
+
+	/**
+	 * Make a constant-list that has unique values.<br>
+	 * In modern browsers (except IE8 and lower),<br>
+	 *  a value defined once can not be changed.
+	 *
+	 * @param {...string|string[]} itemList Constant-list (An array of string is available)
+	 * @class
+	 * @memberof tui.util
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var Enum = require('tui-code-snippet').Enum; // node, commonjs
+	 * var Enum = tui.util.Enum; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var MYENUM = new Enum('TYPE1', 'TYPE2');
+	 * var MYENUM2 = new Enum(['TYPE1', 'TYPE2']);
+	 *
+	 * //usage
+	 * if (value === MYENUM.TYPE1) {
+	 *      ....
+	 * }
+	 *
+	 * //add (If a duplicate name is inputted, will be disregarded.)
+	 * MYENUM.set('TYPE3', 'TYPE4');
+	 *
+	 * //get name of a constant by a value
+	 * MYENUM.getName(MYENUM.TYPE1); // 'TYPE1'
+	 *
+	 * // In modern browsers (except IE8 and lower), a value can not be changed in constants.
+	 * var originalValue = MYENUM.TYPE1;
+	 * MYENUM.TYPE1 = 1234; // maybe TypeError
+	 * MYENUM.TYPE1 === originalValue; // true
+	 **/
+	function Enum(itemList) {
+	    if (itemList) {
+	        this.set.apply(this, arguments);
+	    }
+	}
+
+	/**
+	 * Define a constants-list
+	 * @param {...string|string[]} itemList Constant-list (An array of string is available)
+	 */
+	Enum.prototype.set = function(itemList) {
+	    var self = this;
+
+	    if (!type.isArray(itemList)) {
+	        itemList = collection.toArray(arguments);
+	    }
+
+	    collection.forEach(itemList, function itemListIteratee(item) {
+	        self._addItem(item);
+	    });
+	};
+
+	/**
+	 * Return a key of the constant.
+	 * @param {number} value A value of the constant.
+	 * @returns {string|undefined} Key of the constant.
+	 */
+	Enum.prototype.getName = function(value) {
+	    var self = this;
+	    var foundedKey;
+
+	    collection.forEach(this, function(itemValue, key) { // eslint-disable-line consistent-return
+	        if (self._isEnumItem(key) && value === itemValue) {
+	            foundedKey = key;
+
+	            return false;
+	        }
+	    });
+
+	    return foundedKey;
+	};
+
+	/**
+	 * Create a constant.
+	 * @private
+	 * @param {string} name Constant name. (It will be a key of a constant)
+	 */
+	Enum.prototype._addItem = function(name) {
+	    var value;
+
+	    if (!this.hasOwnProperty(name)) {
+	        value = this._makeEnumValue();
+
+	        if (isSupportDefinedProperty) {
+	            Object.defineProperty(this, name, {
+	                enumerable: true,
+	                configurable: false,
+	                writable: false,
+	                value: value
+	            });
+	        } else {
+	            this[name] = value;
+	        }
+	    }
+	};
+
+	/**
+	 * Return a unique value for assigning to a constant.
+	 * @private
+	 * @returns {number} A unique value
+	 */
+	Enum.prototype._makeEnumValue = function() {
+	    var value;
+
+	    value = enumValue;
+	    enumValue += 1;
+
+	    return value;
+	};
+
+	/**
+	 * Return whether a constant from the given key is in instance or not.
+	 * @param {string} key - A constant key
+	 * @returns {boolean} Result
+	 * @private
+	 */
+	Enum.prototype._isEnumItem = function(key) {
+	    return type.isNumber(this[key]);
+	};
+
+	module.exports = Enum;
+
+
+/***/ }),
+/* 18 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview
+	 *  Implements the ExMap (Extended Map) object.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var Map = __webpack_require__(19);
+
+	// Caching tui.util for performance enhancing
+	var mapAPIsForRead = ['get', 'has', 'forEach', 'keys', 'values', 'entries'];
+	var mapAPIsForDelete = ['delete', 'clear'];
+
+	/**
+	 * The ExMap object is Extended Version of the tui.util.Map object.<br>
+	 * and added some useful feature to make it easy to manage the Map object.
+	 * @constructor
+	 * @param {Array} initData - Array of key-value pairs (2-element Arrays).
+	 *      Each key-value pair will be added to the new Map
+	 * @memberof tui.util
+	 * @example
+	 * // node, commonjs
+	 * var ExMap = require('tui-code-snippet').ExMap;
+	 * @example
+	 * // distribution file, script
+	 * <script src='path-to/tui-code-snippt.js'></script>
+	 * <script>
+	 * var ExMap = tui.util.ExMap;
+	 * <script>
+	 */
+	function ExMap(initData) {
+	    this._map = new Map(initData);
+	    this.size = this._map.size;
+	}
+
+	collection.forEachArray(mapAPIsForRead, function(name) {
+	    ExMap.prototype[name] = function() {
+	        return this._map[name].apply(this._map, arguments);
+	    };
+	});
+
+	collection.forEachArray(mapAPIsForDelete, function(name) {
+	    ExMap.prototype[name] = function() {
+	        var result = this._map[name].apply(this._map, arguments);
+	        this.size = this._map.size;
+
+	        return result;
+	    };
+	});
+
+	ExMap.prototype.set = function() {
+	    this._map.set.apply(this._map, arguments);
+	    this.size = this._map.size;
+
+	    return this;
+	};
+
+	/**
+	 * Sets all of the key-value pairs in the specified object to the Map object.
+	 * @param  {Object} object - Plain object that has a key-value pair
+	 */
+	ExMap.prototype.setObject = function(object) {
+	    collection.forEachOwnProperties(object, function(value, key) {
+	        this.set(key, value);
+	    }, this);
+	};
+
+	/**
+	 * Removes the elements associated with keys in the specified array.
+	 * @param  {Array} keys - Array that contains keys of the element to remove
+	 */
+	ExMap.prototype.deleteByKeys = function(keys) {
+	    collection.forEachArray(keys, function(key) {
+	        this['delete'](key);
+	    }, this);
+	};
+
+	/**
+	 * Sets all of the key-value pairs in the specified Map object to this Map object.
+	 * @param  {Map} map - Map object to be merged into this Map object
+	 */
+	ExMap.prototype.merge = function(map) {
+	    map.forEach(function(value, key) {
+	        this.set(key, value);
+	    }, this);
+	};
+
+	/**
+	 * Looks through each key-value pair in the map and returns the new ExMap object of
+	 * all key-value pairs that pass a truth test implemented by the provided function.
+	 * @param  {function} predicate - Function to test each key-value pair of the Map object.<br>
+	 *      Invoked with arguments (value, key). Return true to keep the element, false otherwise.
+	 * @returns {ExMap} A new ExMap object
+	 */
+	ExMap.prototype.filter = function(predicate) {
+	    var filtered = new ExMap();
+
+	    this.forEach(function(value, key) {
+	        if (predicate(value, key)) {
+	            filtered.set(key, value);
+	        }
+	    });
+
+	    return filtered;
+	};
+
+	module.exports = ExMap;
+
+
+/***/ }),
+/* 19 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	
+	/**
+	 * @fileoverview
+	 *  Implements the Map object.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var type = __webpack_require__(2);
+	var array = __webpack_require__(3);
+	var browser = __webpack_require__(10);
+	var func = __webpack_require__(5);
+
+	/**
+	 * Using undefined for a key can be ambiguous if there's deleted item in the array,<br>
+	 * which is also undefined when accessed by index.<br>
+	 * So use this unique object as an undefined key to distinguish it from deleted keys.
+	 * @private
+	 * @constant
+	 */
+	var _KEY_FOR_UNDEFINED = {};
+
+	/**
+	 * For using NaN as a key, use this unique object as a NaN key.<br>
+	 * This makes it easier and faster to compare an object with each keys in the array<br>
+	 * through no exceptional comapring for NaN.
+	 * @private
+	 * @constant
+	 */
+	var _KEY_FOR_NAN = {};
+
+	/**
+	 * Constructor of MapIterator<br>
+	 * Creates iterator object with new keyword.
+	 * @constructor
+	 * @param  {Array} keys - The array of keys in the map
+	 * @param  {function} valueGetter - Function that returns certain value,
+	 *      taking key and keyIndex as arguments.
+	 * @ignore
+	 */
+	function MapIterator(keys, valueGetter) {
+	    this._keys = keys;
+	    this._valueGetter = valueGetter;
+	    this._length = this._keys.length;
+	    this._index = -1;
+	    this._done = false;
+	}
+
+	/**
+	 * Implementation of Iterator protocol.
+	 * @returns {{done: boolean, value: *}} Object that contains done(boolean) and value.
+	 */
+	MapIterator.prototype.next = function() {
+	    var data = {};
+	    do {
+	        this._index += 1;
+	    } while (type.isUndefined(this._keys[this._index]) && this._index < this._length);
+
+	    if (this._index >= this._length) {
+	        data.done = true;
+	    } else {
+	        data.done = false;
+	        data.value = this._valueGetter(this._keys[this._index], this._index);
+	    }
+
+	    return data;
+	};
+
+	/**
+	 * The Map object implements the ES6 Map specification as closely as possible.<br>
+	 * For using objects and primitive values as keys, this object uses array internally.<br>
+	 * So if the key is not a string, get(), set(), has(), delete() will operates in O(n),<br>
+	 * and it can cause performance issues with a large dataset.
+	 *
+	 * Features listed below are not supported. (can't be implented without native support)
+	 * - Map object is iterable<br>
+	 * - Iterable object can be used as an argument of constructor
+	 *
+	 * If the browser supports full implementation of ES6 Map specification, native Map obejct
+	 * will be used internally.
+	 * @class
+	 * @param  {Array} initData - Array of key-value pairs (2-element Arrays).
+	 *      Each key-value pair will be added to the new Map
+	 * @memberof tui.util
+	 * @example
+	 * // node, commonjs
+	 * var Map = require('tui-code-snippet').Map;
+	 * @example
+	 * // distribution file, script
+	 * <script src='path-to/tui-code-snippt.js'></script>
+	 * <script>
+	 * var Map = tui.util.Map;
+	 * <script>
+	 */
+	function Map(initData) {
+	    this._valuesForString = {};
+	    this._valuesForIndex = {};
+	    this._keys = [];
+
+	    if (initData) {
+	        this._setInitData(initData);
+	    }
+
+	    this.size = 0;
+	}
+
+	/* eslint-disable no-extend-native */
+	/**
+	 * Add all elements in the initData to the Map object.
+	 * @private
+	 * @param  {Array} initData - Array of key-value pairs to add to the Map object
+	 */
+	Map.prototype._setInitData = function(initData) {
+	    if (!type.isArray(initData)) {
+	        throw new Error('Only Array is supported.');
+	    }
+	    collection.forEachArray(initData, function(pair) {
+	        this.set(pair[0], pair[1]);
+	    }, this);
+	};
+
+	/**
+	 * Returns true if the specified value is NaN.<br>
+	 * For unsing NaN as a key, use this method to test equality of NaN<br>
+	 * because === operator doesn't work for NaN.
+	 * @private
+	 * @param {*} value - Any object to be tested
+	 * @returns {boolean} True if value is NaN, false otherwise.
+	 */
+	Map.prototype._isNaN = function(value) {
+	    return typeof value === 'number' && value !== value; // eslint-disable-line no-self-compare
+	};
+
+	/**
+	 * Returns the index of the specified key.
+	 * @private
+	 * @param  {*} key - The key object to search for.
+	 * @returns {number} The index of the specified key
+	 */
+	Map.prototype._getKeyIndex = function(key) {
+	    var result = -1;
+	    var value;
+
+	    if (type.isString(key)) {
+	        value = this._valuesForString[key];
+	        if (value) {
+	            result = value.keyIndex;
+	        }
+	    } else {
+	        result = array.inArray(key, this._keys);
+	    }
+
+	    return result;
+	};
+
+	/**
+	 * Returns the original key of the specified key.
+	 * @private
+	 * @param  {*} key - key
+	 * @returns {*} Original key
+	 */
+	Map.prototype._getOriginKey = function(key) {
+	    var originKey = key;
+	    if (key === _KEY_FOR_UNDEFINED) {
+	        originKey = undefined; // eslint-disable-line no-undefined
+	    } else if (key === _KEY_FOR_NAN) {
+	        originKey = NaN;
+	    }
+
+	    return originKey;
+	};
+
+	/**
+	 * Returns the unique key of the specified key.
+	 * @private
+	 * @param  {*} key - key
+	 * @returns {*} Unique key
+	 */
+	Map.prototype._getUniqueKey = function(key) {
+	    var uniqueKey = key;
+	    if (type.isUndefined(key)) {
+	        uniqueKey = _KEY_FOR_UNDEFINED;
+	    } else if (this._isNaN(key)) {
+	        uniqueKey = _KEY_FOR_NAN;
+	    }
+
+	    return uniqueKey;
+	};
+
+	/**
+	 * Returns the value object of the specified key.
+	 * @private
+	 * @param  {*} key - The key of the value object to be returned
+	 * @param  {number} keyIndex - The index of the key
+	 * @returns {{keyIndex: number, origin: *}} Value object
+	 */
+	Map.prototype._getValueObject = function(key, keyIndex) { // eslint-disable-line consistent-return
+	    if (type.isString(key)) {
+	        return this._valuesForString[key];
+	    }
+
+	    if (type.isUndefined(keyIndex)) {
+	        keyIndex = this._getKeyIndex(key);
+	    }
+	    if (keyIndex >= 0) {
+	        return this._valuesForIndex[keyIndex];
+	    }
+	};
+
+	/**
+	 * Returns the original value of the specified key.
+	 * @private
+	 * @param  {*} key - The key of the value object to be returned
+	 * @param  {number} keyIndex - The index of the key
+	 * @returns {*} Original value
+	 */
+	Map.prototype._getOriginValue = function(key, keyIndex) {
+	    return this._getValueObject(key, keyIndex).origin;
+	};
+
+	/**
+	 * Returns key-value pair of the specified key.
+	 * @private
+	 * @param  {*} key - The key of the value object to be returned
+	 * @param  {number} keyIndex - The index of the key
+	 * @returns {Array} Key-value Pair
+	 */
+	Map.prototype._getKeyValuePair = function(key, keyIndex) {
+	    return [this._getOriginKey(key), this._getOriginValue(key, keyIndex)];
+	};
+
+	/**
+	 * Creates the wrapper object of original value that contains a key index
+	 * and returns it.
+	 * @private
+	 * @param  {type} origin - Original value
+	 * @param  {type} keyIndex - Index of the key
+	 * @returns {{keyIndex: number, origin: *}} Value object
+	 */
+	Map.prototype._createValueObject = function(origin, keyIndex) {
+	    return {
+	        keyIndex: keyIndex,
+	        origin: origin
+	    };
+	};
+
+	/**
+	 * Sets the value for the key in the Map object.
+	 * @param  {*} key - The key of the element to add to the Map object
+	 * @param  {*} value - The value of the element to add to the Map object
+	 * @returns {Map} The Map object
+	 */
+	Map.prototype.set = function(key, value) {
+	    var uniqueKey = this._getUniqueKey(key);
+	    var keyIndex = this._getKeyIndex(uniqueKey);
+	    var valueObject;
+
+	    if (keyIndex < 0) {
+	        keyIndex = this._keys.push(uniqueKey) - 1;
+	        this.size += 1;
+	    }
+	    valueObject = this._createValueObject(value, keyIndex);
+
+	    if (type.isString(key)) {
+	        this._valuesForString[key] = valueObject;
+	    } else {
+	        this._valuesForIndex[keyIndex] = valueObject;
+	    }
+
+	    return this;
+	};
+
+	/**
+	 * Returns the value associated to the key, or undefined if there is none.
+	 * @param  {*} key - The key of the element to return
+	 * @returns {*} Element associated with the specified key
+	 */
+	Map.prototype.get = function(key) {
+	    var uniqueKey = this._getUniqueKey(key);
+	    var value = this._getValueObject(uniqueKey);
+
+	    return value && value.origin;
+	};
+
+	/**
+	 * Returns a new Iterator object that contains the keys for each element
+	 * in the Map object in insertion order.
+	 * @returns {Iterator} A new Iterator object
+	 */
+	Map.prototype.keys = function() {
+	    return new MapIterator(this._keys, func.bind(this._getOriginKey, this));
+	};
+
+	/**
+	 * Returns a new Iterator object that contains the values for each element
+	 * in the Map object in insertion order.
+	 * @returns {Iterator} A new Iterator object
+	 */
+	Map.prototype.values = function() {
+	    return new MapIterator(this._keys, func.bind(this._getOriginValue, this));
+	};
+
+	/**
+	 * Returns a new Iterator object that contains the [key, value] pairs
+	 * for each element in the Map object in insertion order.
+	 * @returns {Iterator} A new Iterator object
+	 */
+	Map.prototype.entries = function() {
+	    return new MapIterator(this._keys, func.bind(this._getKeyValuePair, this));
+	};
+
+	/**
+	 * Returns a boolean asserting whether a value has been associated to the key
+	 * in the Map object or not.
+	 * @param  {*} key - The key of the element to test for presence
+	 * @returns {boolean} True if an element with the specified key exists;
+	 *          Otherwise false
+	 */
+	Map.prototype.has = function(key) {
+	    return !!this._getValueObject(key);
+	};
+
+	/**
+	 * Removes the specified element from a Map object.
+	 * @param {*} key - The key of the element to remove
+	 * @function delete
+	 * @memberof tui.util.Map.prototype
+	 */
+	// cannot use reserved keyword as a property name in IE8 and under.
+	Map.prototype['delete'] = function(key) {
+	    var keyIndex;
+
+	    if (type.isString(key)) {
+	        if (this._valuesForString[key]) {
+	            keyIndex = this._valuesForString[key].keyIndex;
+	            delete this._valuesForString[key];
+	        }
+	    } else {
+	        keyIndex = this._getKeyIndex(key);
+	        if (keyIndex >= 0) {
+	            delete this._valuesForIndex[keyIndex];
+	        }
+	    }
+
+	    if (keyIndex >= 0) {
+	        delete this._keys[keyIndex];
+	        this.size -= 1;
+	    }
+	};
+
+	/**
+	 * Executes a provided function once per each key/value pair in the Map object,
+	 * in insertion order.
+	 * @param  {function} callback - Function to execute for each element
+	 * @param  {thisArg} thisArg - Value to use as this when executing callback
+	 */
+	Map.prototype.forEach = function(callback, thisArg) {
+	    thisArg = thisArg || this;
+	    collection.forEachArray(this._keys, function(key) {
+	        if (!type.isUndefined(key)) {
+	            callback.call(thisArg, this._getValueObject(key).origin, key, this);
+	        }
+	    }, this);
+	};
+
+	/**
+	 * Removes all elements from a Map object.
+	 */
+	Map.prototype.clear = function() {
+	    Map.call(this);
+	};
+	/* eslint-enable no-extend-native */
+
+	// Use native Map object if exists.
+	// But only latest versions of Chrome and Firefox support full implementation.
+	(function() {
+	    if (window.Map && (
+	        (browser.firefox && browser.version >= 37) ||
+	            (browser.chrome && browser.version >= 42)
+	    )
+	    ) {
+	        Map = window.Map; // eslint-disable-line no-func-assign
+	    }
+	})();
+
+	module.exports = Map;
+
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	/**
+	 * @fileoverview This module provides the HashMap constructor.
+	 * @author NHN.
+	 *         FE Development Lab <dl_javascript@nhn.com>
+	 */
+
+	'use strict';
+
+	var collection = __webpack_require__(4);
+	var type = __webpack_require__(2);
+	/**
+	 * All the data in hashMap begin with _MAPDATAPREFIX;
+	 * @type {string}
+	 * @private
+	 */
+	var _MAPDATAPREFIX = 'å';
+
+	/**
+	 * HashMap can handle the key-value pairs.<br>
+	 * Caution:<br>
+	 *  HashMap instance has a length property but is not an instance of Array.
+	 * @param {Object} [obj] A initial data for creation.
+	 * @constructor
+	 * @memberof tui.util
+	 * @deprecated since version 1.3.0
+	 * @example
+	 * // node, commonjs
+	 * var HashMap = require('tui-code-snippet').HashMap;
+	 * var hm = new tui.util.HashMap({
+	  'mydata': {
+	    'hello': 'imfine'
+	  },
+	  'what': 'time'
+	});
+	 * @example
+	 * // distribution file, script
+	 * <script src='path-to/tui-code-snippt.js'></script>
+	 * <script>
+	 * var HashMap = tui.util.HashMap;
+	 * <script>
+	 * var hm = new tui.util.HashMap({
+	  'mydata': {
+	    'hello': 'imfine'
+	  },
+	  'what': 'time'
+	});
+	 */
+	function HashMap(obj) {
+	    /**
+	     * size
+	     * @type {number}
+	     */
+	    this.length = 0;
+
+	    if (obj) {
+	        this.setObject(obj);
+	    }
+	}
+
+	/**
+	 * Set a data from the given key with value or the given object.
+	 * @param {string|Object} key A string or object for key
+	 * @param {*} [value] A data
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.set('key', 'value');
+	 * hm.set({
+	 *     'key1': 'data1',
+	 *     'key2': 'data2'
+	 * });
+	 */
+	HashMap.prototype.set = function(key, value) {
+	    if (arguments.length === 2) {
+	        this.setKeyValue(key, value);
+	    } else {
+	        this.setObject(key);
+	    }
+	};
+
+	/**
+	 * Set a data from the given key with value.
+	 * @param {string} key A string for key
+	 * @param {*} value A data
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.setKeyValue('key', 'value');
+	 */
+	HashMap.prototype.setKeyValue = function(key, value) {
+	    if (!this.has(key)) {
+	        this.length += 1;
+	    }
+	    this[this.encodeKey(key)] = value;
+	};
+
+	/**
+	 * Set a data from the given object.
+	 * @param {Object} obj A object for data
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.setObject({
+	 *     'key1': 'data1',
+	 *     'key2': 'data2'
+	 * });
+	 */
+	HashMap.prototype.setObject = function(obj) {
+	    var self = this;
+
+	    collection.forEachOwnProperties(obj, function(value, key) {
+	        self.setKeyValue(key, value);
+	    });
+	};
+
+	/**
+	 * Merge with the given another hashMap.
+	 * @param {HashMap} hashMap Another hashMap instance
+	 */
+	HashMap.prototype.merge = function(hashMap) {
+	    var self = this;
+
+	    hashMap.each(function(value, key) {
+	        self.setKeyValue(key, value);
+	    });
+	};
+
+	/**
+	 * Encode the given key for hashMap.
+	 * @param {string} key A string for key
+	 * @returns {string} A encoded key
+	 * @private
+	 */
+	HashMap.prototype.encodeKey = function(key) {
+	    return _MAPDATAPREFIX + key;
+	};
+
+	/**
+	 * Decode the given key in hashMap.
+	 * @param {string} key A string for key
+	 * @returns {string} A decoded key
+	 * @private
+	 */
+	HashMap.prototype.decodeKey = function(key) {
+	    var decodedKey = key.split(_MAPDATAPREFIX);
+
+	    return decodedKey[decodedKey.length - 1];
+	};
+
+	/**
+	 * Return the value from the given key.
+	 * @param {string} key A string for key
+	 * @returns {*} The value from a key
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.set('key', 'value');
+	 * hm.get('key') // value
+	 */
+	HashMap.prototype.get = function(key) {
+	    return this[this.encodeKey(key)];
+	};
+
+	/**
+	 * Check the existence of a value from the key.
+	 * @param {string} key A string for key
+	 * @returns {boolean} Indicating whether a value exists or not.
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.set('key', 'value');
+	 * hm.has('key') // true
+	 */
+	HashMap.prototype.has = function(key) {
+	    return this.hasOwnProperty(this.encodeKey(key));
+	};
+
+	/**
+	 * Remove a data(key-value pairs) from the given key or the given key-list.
+	 * @param {...string|string[]} key A string for key
+	 * @returns {string|string[]} A removed data
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.set('key', 'value');
+	 * hm.set('key2', 'value');
+	 *
+	 * hm.remove('key');
+	 * hm.remove('key', 'key2');
+	 * hm.remove(['key', 'key2']);
+	 */
+	HashMap.prototype.remove = function(key) {
+	    if (arguments.length > 1) {
+	        key = collection.toArray(arguments);
+	    }
+
+	    return type.isArray(key) ? this.removeByKeyArray(key) : this.removeByKey(key);
+	};
+
+	/**
+	 * Remove data(key-value pair) from the given key.
+	 * @param {string} key A string for key
+	 * @returns {*|null} A removed data
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.set('key', 'value');
+	 * hm.removeByKey('key')
+	 */
+	HashMap.prototype.removeByKey = function(key) {
+	    var data = this.has(key) ? this.get(key) : null;
+
+	    if (data !== null) {
+	        delete this[this.encodeKey(key)];
+	        this.length -= 1;
+	    }
+
+	    return data;
+	};
+
+	/**
+	 * Remove a data(key-value pairs) from the given key-list.
+	 * @param {string[]} keyArray An array of keys
+	 * @returns {string[]} A removed data
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.set('key', 'value');
+	 * hm.set('key2', 'value');
+	 * hm.removeByKeyArray(['key', 'key2']);
+	 */
+	HashMap.prototype.removeByKeyArray = function(keyArray) {
+	    var data = [];
+	    var self = this;
+
+	    collection.forEach(keyArray, function(key) {
+	        data.push(self.removeByKey(key));
+	    });
+
+	    return data;
+	};
+
+	/**
+	 * Remove all the data
+	 */
+	HashMap.prototype.removeAll = function() {
+	    var self = this;
+
+	    this.each(function(value, key) {
+	        self.remove(key);
+	    });
+	};
+
+	/**
+	 * Execute the provided callback once for each all the data.
+	 * @param {Function} iteratee Callback function
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm = new HashMap();
+	 * hm.set('key', 'value');
+	 * hm.set('key2', 'value');
+	 *
+	 * hm.each(function(value, key) {
+	 *     //do something...
+	 * });
+	 */
+	HashMap.prototype.each = function(iteratee) {
+	    var self = this;
+	    var flag;
+
+	    collection.forEachOwnProperties(this, function(value, key) { // eslint-disable-line consistent-return
+	        if (key.charAt(0) === _MAPDATAPREFIX) {
+	            flag = iteratee(value, self.decodeKey(key));
+	        }
+
+	        if (flag === false) {
+	            return flag;
+	        }
+	    });
+	};
+
+	/**
+	 * Return the key-list stored.
+	 * @returns {Array} A key-list
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 *  var hm = new HashMap();
+	 *  hm.set('key', 'value');
+	 *  hm.set('key2', 'value');
+	 *  hm.keys();  //['key', 'key2');
+	 */
+	HashMap.prototype.keys = function() {
+	    var keys = [];
+	    var self = this;
+
+	    this.each(function(value, key) {
+	        keys.push(self.decodeKey(key));
+	    });
+
+	    return keys;
+	};
+
+	/**
+	 * Work similarly to Array.prototype.map().<br>
+	 * It executes the provided callback that checks conditions once for each element of hashMap,<br>
+	 *  and returns a new array having elements satisfying the conditions
+	 * @param {Function} condition A function that checks conditions
+	 * @returns {Array} A new array having elements satisfying the conditions
+	 * @example
+	 * //-- #1. Get Module --//
+	 * var HashMap = require('tui-code-snippet').HashMap; // node, commonjs
+	 * var HashMap = tui.util.HashMap; // distribution file
+	 *
+	 * //-- #2. Use property --//
+	 * var hm1 = new HashMap();
+	 * hm1.set('key', 'value');
+	 * hm1.set('key2', 'value');
+	 *
+	 * hm1.find(function(value, key) {
+	 *     return key === 'key2';
+	 * }); // ['value']
+	 *
+	 * var hm2 = new HashMap({
+	 *     'myobj1': {
+	 *         visible: true
+	 *     },
+	 *     'mybobj2': {
+	 *         visible: false
+	 *     }
+	 * });
+	 *
+	 * hm2.find(function(obj, key) {
+	 *     return obj.visible === true;
+	 * }); // [{visible: true}];
+	 */
+	HashMap.prototype.find = function(condition) {
+	    var founds = [];
+
+	    this.each(function(value, key) {
+	        if (condition(value, key)) {
+	            founds.push(value);
+	        }
+	    });
+
+	    return founds;
+	};
+
+	/**
+	 * Return a new Array having all values.
+	 * @returns {Array} A new array having all values
+	 */
+	HashMap.prototype.toArray = function() {
+	    var result = [];
+
+	    this.each(function(v) {
+	        result.push(v);
+	    });
+
+	    return result;
+	};
+
+	module.exports = HashMap;
+
+
+/***/ })
+/******/ ])
+});
+;