ꦫꦣꦺꦤ꧀ꦄꦤ꧀ꦠꦱꦺꦤ

PATH: home / lab2454c / vaultchip.com / platform / core / base / public / libraries / tinymce / plugins / hanbiroclip / js

function each(obj, cb) {
                if (obj) Object.keys(obj)
                    .forEach(function(key) {
                        cb(obj[key], key)
                    })
            }

function has(obj, key) {
                return {}.hasOwnProperty.call(obj, key)
            }

function sanitizeHtml(html, options, _recursing) {
                var result = "";

function stringifyStyleAttributes(filteredAST) {
                    return filteredAST.nodes[0].nodes.reduce(function(extractedAttributes, attributeObject) {
                            extractedAttributes.push(attributeObject.prop + ":" + attributeObject.value);
                            return extractedAttributes
                        }, [])
                        .join(";")
                }

function filterDeclarations(selectedRule) {
                    return function(allowedDeclarationsList, attributeObject) {
                        if (selectedRule.hasOwnProperty(attributeObject.prop)) {
                            var matchesRegex = selectedRule[attributeObject.prop].some(function(regularExpression) {
                                return regularExpression.test(attributeObject.value)
                            });
                            if (matchesRegex) {
                                allowedDeclarationsList.push(attributeObject)
                            }
                        }
                        return allowedDeclarationsList
                    }
                }

function uniqSet(arr) {
                    var seen = new Set;
                    return arr.filter(function(el) {
                        if (!seen.has(el)) {
                            seen.add(el);
                            return true
                        }
                        return false
                    })
                }

function uniqSetWithForEach(arr) {
                    var ret = [];
                    new Set(arr)
                        .forEach(function(el) {
                            ret.push(el)
                        });
                    return ret
                }

function getLens(b64) {
                var len = b64.length;
                if (len % 4 > 0) {
                    throw new Error("Invalid string. Length must be a multiple of 4")
                }
                var validLen = b64.indexOf("=");
                if (validLen === -1) validLen = len;
                var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
                return [validLen, placeHoldersLen]
            }

function byteLength(b64) {
                var lens = getLens(b64);
                var validLen = lens[0];
                var placeHoldersLen = lens[1];
                return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen
            }

function _byteLength(b64, validLen, placeHoldersLen) {
                return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen
            }

function tripletToBase64(num) {
                return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63]
            }

function encodeChunk(uint8, start, end) {
                var tmp;
                var output = [];
                for (var i = start; i < end; i += 3) {
                    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
                    output.push(tripletToBase64(tmp))
                }
                return output.join("")
            }

function createBuffer(length) {
                    if (length > K_MAX_LENGTH) {
                        throw new RangeError('The value "' + length + '" is invalid for option "size"')
                    }
                    var buf = new Uint8Array(length);
                    buf.__proto__ = Buffer.prototype;
                    return buf
                }

function Buffer(arg, encodingOrOffset, length) {
                    if (typeof arg === "number") {
                        if (typeof encodingOrOffset === "string") {
                            throw new TypeError('The "string" argument must be of type string. Received type number')
                        }
                        return allocUnsafe(arg)
                    }
                    return from(arg, encodingOrOffset, length)
                }
                if (typeof Symbol !== "undefined" && Symbol.species != null && Buffer[Symbol.species] === Buffer) {
                    Object.defineProperty(Buffer, Symbol.species, {
                        value: null,
                        configurable: true,
                        enumerable: false,
                        writable: false
                    })
                }
                Buffer.poolSize = 8192;

function assertSize(size) {
                    if (typeof size !== "number") {
                        throw new TypeError('"size" argument must be of type number')
                    } else if (size < 0) {
                        throw new RangeError('The value "' + size + '" is invalid for option "size"')
                    }
                }

function alloc(size, fill, encoding) {
                    assertSize(size);
                    if (size <= 0) {
                        return createBuffer(size)
                    }
                    if (fill !== undefined) {
                        return typeof encoding === "string" ? createBuffer(size)
                            .fill(fill, encoding) : createBuffer(size)
                            .fill(fill)
                    }
                    return createBuffer(size)
                }
                Buffer.alloc = function(size, fill, encoding) {
                    return alloc(size, fill, encoding)
                };

function fromArrayLike(array) {
                    var length = array.length < 0 ? 0 : checked(array.length) | 0;
                    var buf = createBuffer(length);
                    for (var i = 0; i < length; i += 1) {
                        buf[i] = array[i] & 255
                    }
                    return buf
                }

function fromArrayBuffer(array, byteOffset, length) {
                    if (byteOffset < 0 || array.byteLength < byteOffset) {
                        throw new RangeError('"offset" is outside of buffer bounds')
                    }
                    if (array.byteLength < byteOffset + (length || 0)) {
                        throw new RangeError('"length" is outside of buffer bounds')
                    }
                    var buf;
                    if (byteOffset === undefined && length === undefined) {
                        buf = new Uint8Array(array)
                    } else if (length === undefined) {
                        buf = new Uint8Array(array, byteOffset)
                    } else {
                        buf = new Uint8Array(array, byteOffset, length)
                    }
                    buf.__proto__ = Buffer.prototype;
                    return buf
                }

function checked(length) {
                    if (length >= K_MAX_LENGTH) {
                        throw new RangeError("Attempt to allocate Buffer larger than maximum " + "size: 0x" + K_MAX_LENGTH.toString(16) + " bytes")
                    }
                    return length | 0
                }

function utf8Write(buf, string, offset, length) {
                    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
                }

function asciiWrite(buf, string, offset, length) {
                    return blitBuffer(asciiToBytes(string), buf, offset, length)
                }

function latin1Write(buf, string, offset, length) {
                    return asciiWrite(buf, string, offset, length)
                }

function base64Write(buf, string, offset, length) {
                    return blitBuffer(base64ToBytes(string), buf, offset, length)
                }

function base64Slice(buf, start, end) {
                    if (start === 0 && end === buf.length) {
                        return base64.fromByteArray(buf)
                    } else {
                        return base64.fromByteArray(buf.slice(start, end))
                    }
                }

function asciiSlice(buf, start, end) {
                    var ret = "";
                    end = Math.min(buf.length, end);
                    for (var i = start; i < end; ++i) {
                        ret += String.fromCharCode(buf[i] & 127)
                    }
                    return ret
                }

function latin1Slice(buf, start, end) {
                    var ret = "";
                    end = Math.min(buf.length, end);
                    for (var i = start; i < end; ++i) {
                        ret += String.fromCharCode(buf[i])
                    }
                    return ret
                }

function hexSlice(buf, start, end) {
                    var len = buf.length;
                    if (!start || start < 0) start = 0;
                    if (!end || end < 0 || end > len) end = len;
                    var out = "";
                    for (var i = start; i < end; ++i) {
                        out += toHex(buf[i])
                    }
                    return out
                }

function checkIEEE754(buf, value, offset, ext, max, min) {
                    if (offset + ext > buf.length) throw new RangeError("Index out of range");
                    if (offset < 0) throw new RangeError("Index out of range")
                }

function base64clean(str) {
                    str = str.split("=")[0];
                    str = str.trim()
                        .replace(INVALID_BASE64_RE, "");
                    if (str.length < 2) return "";
                    while (str.length % 4 !== 0) {
                        str = str + "="
                    }
                    return str
                }

function toHex(n) {
                    if (n < 16) return "0" + n.toString(16);
                    return n.toString(16)
                }

function asciiToBytes(str) {
                    var byteArray = [];
                    for (var i = 0; i < str.length; ++i) {
                        byteArray.push(str.charCodeAt(i) & 255)
                    }
                    return byteArray
                }

function utf16leToBytes(str, units) {
                    var c, hi, lo;
                    var byteArray = [];
                    for (var i = 0; i < str.length; ++i) {
                        if ((units -= 2) < 0) break;
                        c = str.charCodeAt(i);
                        hi = c >> 8;
                        lo = c % 256;
                        byteArray.push(lo);
                        byteArray.push(hi)
                    }
                    return byteArray
                }

function base64ToBytes(str) {
                    return base64.toByteArray(base64clean(str))
                }

function blitBuffer(src, dst, offset, length) {
                    for (var i = 0; i < length; ++i) {
                        if (i + offset >= dst.length || i >= src.length) break;
                        dst[i + offset] = src[i]
                    }
                    return i
                }

function isInstance(obj, type) {
                    return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name
                }

function renderDirective(elem) {
                return "<" + elem.data + ">"
            }

function renderText(elem, opts) {
                var data = elem.data || "";
                if (opts.decodeEntities && !(elem.parent && elem.parent.name in unencodedElements)) {
                    data = entities.encodeXML(data)
                }
                return data
            }

function renderCdata(elem) {
                return "<![CDATA[" + elem.children[0].data + "]]>"
            }

function getAttribCheck(attrib, value) {
                if (typeof value === "function") {
                    return function(elem) {
                        return elem.attribs && value(elem.attribs[attrib])
                    }
                } else {
                    return function(elem) {
                        return elem.attribs && elem.attribs[attrib] === value
                    }
                }
            }

function filter(test, element, recurse, limit) {
                if (!Array.isArray(element)) element = [element];
                if (typeof limit !== "number" || !isFinite(limit)) {
                    limit = Infinity
                }
                return find(test, element, recurse !== false, limit)
            }

function findOneChild(test, elems) {
                for (var i = 0, l = elems.length; i < l; i++) {
                    if (test(elems[i])) return elems[i]
                }
                return null
            }

function existsOne(test, elems) {
                for (var i = 0, l = elems.length; i < l; i++) {
                    if (isTag(elems[i]) && (test(elems[i]) || elems[i].children.length > 0 && existsOne(test, elems[i].children))) {
                        return true
                    }
                }
                return false
            }

function getInnerHTML(elem, opts) {
                return elem.children ? elem.children.map(function(elem) {
                        return getOuterHTML(elem, opts)
                    })
                    .join("") : ""
            }

function replacer(str) {
                    if (str.substr(-1) !== ";") str += ";";
                    return replace(str)
                }
                return function(str) {
                    return String(str)
                        .replace(re, replacer)
                }
            }();

function sorter(a, b) {
                return a < b ? 1 : -1
            }

function getReplacer(map) {
                return function replace(str) {
                    if (str.charAt(1) === "#") {
                        if (str.charAt(2) === "X" || str.charAt(2) === "x") {
                            return decodeCodePoint(parseInt(str.substr(3), 16))
                        }
                        return decodeCodePoint(parseInt(str.substr(2), 10))
                    }
                    return map[str.slice(1, -1)]
                }
            }
            module.exports = {
                XML: decodeXMLStrict,
                HTML: decodeHTML,
                HTMLStrict: decodeHTMLStrict
            }
        }, {
            "../maps/entities.json": 23,
            "../maps/legacy.json": 24,
            "../maps/xml.json": 25,
            "./decode_codepoint.js": 20
        }],
        20: [function(require, module, exports) {
            var decodeMap = require("../maps/decode.json");
            module.exports = decodeCodePoint;

function getInverseObj(obj) {
                return Object.keys(obj)
                    .sort()
                    .reduce(function(inverse, name) {
                        inverse[obj[name]] = "&" + name + ";";
                        return inverse
                    }, {})
            }

function singleCharReplacer(c) {
                return "&#x" + c.charCodeAt(0)
                    .toString(16)
                    .toUpperCase() + ";"
            }

function astralReplacer(c) {
                var high = c.charCodeAt(0);
                var low = c.charCodeAt(1);
                var codePoint = (high - 55296) * 1024 + low - 56320 + 65536;
                return "&#x" + codePoint.toString(16)
                    .toUpperCase() + ";"
            }

function getInverse(inverse, re) {
                function func(name) {
                    return inverse[name]
                }
                return function(data) {
                    return data.replace(re, func)
                        .replace(re_astralSymbols, astralReplacer)
                        .replace(re_nonASCII, singleCharReplacer)
                }
            }
            var re_xmlChars = getInverseReplacer(inverseXML);

function $getMaxListeners(that) {
                if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners;
                return that._maxListeners
            }
            EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
                return $getMaxListeners(this)
            };

function emitNone(handler, isFn, self) {
                if (isFn) handler.call(self);
                else {
                    var len = handler.length;
                    var listeners = arrayClone(handler, len);
                    for (var i = 0; i < len; ++i) listeners[i].call(self)
                }
            }

function emitOne(handler, isFn, self, arg1) {
                if (isFn) handler.call(self, arg1);
                else {
                    var len = handler.length;
                    var listeners = arrayClone(handler, len);
                    for (var i = 0; i < len; ++i) listeners[i].call(self, arg1)
                }
            }

function emitTwo(handler, isFn, self, arg1, arg2) {
                if (isFn) handler.call(self, arg1, arg2);
                else {
                    var len = handler.length;
                    var listeners = arrayClone(handler, len);
                    for (var i = 0; i < len; ++i) listeners[i].call(self, arg1, arg2)
                }
            }

function emitThree(handler, isFn, self, arg1, arg2, arg3) {
                if (isFn) handler.call(self, arg1, arg2, arg3);
                else {
                    var len = handler.length;
                    var listeners = arrayClone(handler, len);
                    for (var i = 0; i < len; ++i) listeners[i].call(self, arg1, arg2, arg3)
                }
            }

function spliceOne(list, index) {
                for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) list[i] = list[k];
                list.pop()
            }

function arrayClone(arr, n) {
                var copy = new Array(n);
                for (var i = 0; i < n; ++i) copy[i] = arr[i];
                return copy
            }

function unwrapListeners(arr) {
                var ret = new Array(arr.length);
                for (var i = 0; i < ret.length; ++i) {
                    ret[i] = arr[i].listener || arr[i]
                }
                return ret
            }

function objectCreatePolyfill(proto) {
                var F = function() {};
                F.prototype = proto;
                return new F
            }

function objectKeysPolyfill(obj) {
                var keys = [];
                for (var k in obj)
                    if (Object.prototype.hasOwnProperty.call(obj, k)) {
                        keys.push(k)
                    } return k
            }

function functionBindPolyfill(context) {
                var fn = this;
                return function() {
                    return fn.apply(context, arguments)
                }
            }
        }, {}],
        27: [function(require, module, exports) {
            module.exports = CollectingHandler;

function FeedHandler(callback, options) {
                this.init(callback, options)
            }
            require("inherits")(FeedHandler, DomHandler);
            FeedHandler.prototype.init = DomHandler;

function getElements(what, where) {
                return DomUtils.getElementsByTagName(what, where, true)
            }

function getOneElement(what, where) {
                return DomUtils.getElementsByTagName(what, where, true, 1)[0]
            }

function fetch(what, where, recurse) {
                return DomUtils.getText(DomUtils.getElementsByTagName(what, where, recurse, 1))
                    .trim()
            }

function Stream(options) {
                Parser.call(this, new Cbs(this), options)
            }
            require("inherits")(Stream, Parser);
            Stream.prototype.readable = true;

function whitespace(c) {
                return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r"
            }

function consumeSpecialNameChar(upper, NEXT_STATE) {
                var lower = upper.toLowerCase();
                return function(c) {
                    if (c === lower || c === upper) {
                        this._state = NEXT_STATE
                    } else {
                        this._state = IN_TAG_NAME;
                        this._index--
                    }
                }
            }

function addMapEntry(map, pair) {
                    map.set(pair[0], pair[1]);
                    return map
                }

function addSetEntry(set, value) {
                    set.add(value);
                    return set
                }

function arrayEach(array, iteratee) {
                    var index = -1,
                        length = array ? array.length : 0;
                    while (++index < length) {
                        if (iteratee(array[index], index, array) === false) {
                            break
                        }
                    }
                    return array
                }

function arrayPush(array, values) {
                    var index = -1,
                        length = values.length,
                        offset = array.length;
                    while (++index < length) {
                        array[offset + index] = values[index]
                    }
                    return array
                }

function arrayReduce(array, iteratee, accumulator, initAccum) {
                    var index = -1,
                        length = array ? array.length : 0;
                    if (initAccum && length) {
                        accumulator = array[++index]
                    }
                    while (++index < length) {
                        accumulator = iteratee(accumulator, array[index], index, array)
                    }
                    return accumulator
                }

function baseTimes(n, iteratee) {
                    var index = -1,
                        result = Array(n);
                    while (++index < n) {
                        result[index] = iteratee(index)
                    }
                    return result
                }

function getValue(object, key) {
                    return object == null ? undefined : object[key]
                }

function isHostObject(value) {
                    var result = false;
                    if (value != null && typeof value.toString != "function") {
                        try {
                            result = !!(value + "")
                        } catch (e) {}
                    }
                    return result
                }

function mapToArray(map) {
                    var index = -1,
                        result = Array(map.size);
                    map.forEach(function(value, key) {
                        result[++index] = [key, value]
                    });
                    return result
                }

function overArg(func, transform) {
                    return function(arg) {
                        return func(transform(arg))
                    }
                }

function Hash(entries) {
                    var index = -1,
                        length = entries ? entries.length : 0;
                    this.clear();
                    while (++index < length) {
                        var entry = entries[index];
                        this.set(entry[0], entry[1])
                    }
                }

function hashClear() {
                    this.__data__ = nativeCreate ? nativeCreate(null) : {}
                }

function hashDelete(key) {
                    return this.has(key) && delete this.__data__[key]
                }

function hashGet(key) {
                    var data = this.__data__;
                    if (nativeCreate) {
                        var result = data[key];
                        return result === HASH_UNDEFINED ? undefined : result
                    }
                    return hasOwnProperty.call(data, key) ? data[key] : undefined
                }

function hashHas(key) {
                    var data = this.__data__;
                    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key)
                }

function hashSet(key, value) {
                    var data = this.__data__;
                    data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
                    return this
                }
                Hash.prototype.clear = hashClear;
                Hash.prototype["delete"] = hashDelete;
                Hash.prototype.get = hashGet;
                Hash.prototype.has = hashHas;
                Hash.prototype.set = hashSet;

function ListCache(entries) {
                    var index = -1,
                        length = entries ? entries.length : 0;
                    this.clear();
                    while (++index < length) {
                        var entry = entries[index];
                        this.set(entry[0], entry[1])
                    }
                }

function listCacheClear() {
                    this.__data__ = []
                }

function listCacheDelete(key) {
                    var data = this.__data__,
                        index = assocIndexOf(data, key);
                    if (index < 0) {
                        return false
                    }
                    var lastIndex = data.length - 1;
                    if (index == lastIndex) {
                        data.pop()
                    } else {
                        splice.call(data, index, 1)
                    }
                    return true
                }

function listCacheGet(key) {
                    var data = this.__data__,
                        index = assocIndexOf(data, key);
                    return index < 0 ? undefined : data[index][1]
                }

function listCacheHas(key) {
                    return assocIndexOf(this.__data__, key) > -1
                }

function MapCache(entries) {
                    var index = -1,
                        length = entries ? entries.length : 0;
                    this.clear();
                    while (++index < length) {
                        var entry = entries[index];
                        this.set(entry[0], entry[1])
                    }
                }

function mapCacheClear() {
                    this.__data__ = {
                        hash: new Hash,
                        map: new(Map || ListCache),
                        string: new Hash
                    }
                }

function mapCacheDelete(key) {
                    return getMapData(this, key)["delete"](key)
                }

function mapCacheGet(key) {
                    return getMapData(this, key)
                        .get(key)
                }

function mapCacheHas(key) {
                    return getMapData(this, key)
                        .has(key)
                }

function mapCacheSet(key, value) {
                    getMapData(this, key)
                        .set(key, value);
                    return this
                }
                MapCache.prototype.clear = mapCacheClear;
                MapCache.prototype["delete"] = mapCacheDelete;
                MapCache.prototype.get = mapCacheGet;
                MapCache.prototype.has = mapCacheHas;
                MapCache.prototype.set = mapCacheSet;

function Stack(entries) {
                    this.__data__ = new ListCache(entries)
                }

function stackClear() {
                    this.__data__ = new ListCache
                }

function stackDelete(key) {
                    return this.__data__["delete"](key)
                }

function stackGet(key) {
                    return this.__data__.get(key)
                }

function stackHas(key) {
                    return this.__data__.has(key)
                }

function arrayLikeKeys(value, inherited) {
                    var result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : [];
                    var length = result.length,
                        skipIndexes = !!length;
                    for (var key in value) {
                        if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isIndex(key, length)))) {
                            result.push(key)
                        }
                    }
                    return result
                }

function assignValue(object, key, value) {
                    var objValue = object[key];
                    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined && !(key in object)) {
                        object[key] = value
                    }
                }

function assocIndexOf(array, key) {
                    var length = array.length;
                    while (length--) {
                        if (eq(array[length][0], key)) {
                            return length
                        }
                    }
                    return -1
                }

function baseAssign(object, source) {
                    return object && copyObject(source, keys(source), object)
                }

function baseCreate(proto) {
                    return isObject(proto) ? objectCreate(proto) : {}
                }

function baseGetAllKeys(object, keysFunc, symbolsFunc) {
                    var result = keysFunc(object);
                    return isArray(object) ? result : arrayPush(result, symbolsFunc(object))
                }

function baseGetTag(value) {
                    return objectToString.call(value)
                }

function baseIsNative(value) {
                    if (!isObject(value) || isMasked(value)) {
                        return false
                    }
                    var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
                    return pattern.test(toSource(value))
                }

function baseKeys(object) {
                    if (!isPrototype(object)) {
                        return nativeKeys(object)
                    }
                    var result = [];
                    for (var key in Object(object)) {
                        if (hasOwnProperty.call(object, key) && key != "constructor") {
                            result.push(key)
                        }
                    }
                    return result
                }

function cloneBuffer(buffer, isDeep) {
                    if (isDeep) {
                        return buffer.slice()
                    }
                    var result = new buffer.constructor(buffer.length);
                    buffer.copy(result);
                    return result
                }

function cloneArrayBuffer(arrayBuffer) {
                    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
                    new Uint8Array(result)
                        .set(new Uint8Array(arrayBuffer));
                    return result
                }

function cloneDataView(dataView, isDeep) {
                    var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
                    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength)
                }

function cloneMap(map, isDeep, cloneFunc) {
                    var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
                    return arrayReduce(array, addMapEntry, new map.constructor)
                }

function cloneRegExp(regexp) {
                    var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
                    result.lastIndex = regexp.lastIndex;
                    return result
                }

function cloneSet(set, isDeep, cloneFunc) {
                    var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
                    return arrayReduce(array, addSetEntry, new set.constructor)
                }

function cloneSymbol(symbol) {
                    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}
                }

function cloneTypedArray(typedArray, isDeep) {
                    var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
                    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length)
                }

function copyArray(source, array) {
                    var index = -1,
                        length = source.length;
                    array || (array = Array(length));
                    while (++index < length) {
                        array[index] = source[index]
                    }
                    return array
                }

function copySymbols(source, object) {
                    return copyObject(source, getSymbols(source), object)
                }

function getAllKeys(object) {
                    return baseGetAllKeys(object, keys, getSymbols)
                }

function getMapData(map, key) {
                    var data = map.__data__;
                    return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map
                }

function initCloneArray(array) {
                    var length = array.length,
                        result = array.constructor(length);
                    if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
                        result.index = array.index;
                        result.input = array.input
                    }
                    return result
                }

function initCloneObject(object) {
                    return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {}
                }

function initCloneByTag(object, tag, cloneFunc, isDeep) {
                    var Ctor = object.constructor;
                    switch (tag) {
                        case arrayBufferTag:
                            return cloneArrayBuffer(object);
                        case boolTag:
                        case dateTag:
                            return new Ctor(+object);
                        case dataViewTag:
                            return cloneDataView(object, isDeep);
                        case float32Tag:
                        case float64Tag:
                        case int8Tag:
                        case int16Tag:
                        case int32Tag:
                        case uint8Tag:
                        case uint8ClampedTag:
                        case uint16Tag:
                        case uint32Tag:
                            return cloneTypedArray(object, isDeep);
                        case mapTag:
                            return cloneMap(object, isDeep, cloneFunc);
                        case numberTag:
                        case stringTag:
                            return new Ctor(object);
                        case regexpTag:
                            return cloneRegExp(object);
                        case setTag:
                            return cloneSet(object, isDeep, cloneFunc);
                        case symbolTag:
                            return cloneSymbol(object)
                    }
                }

function isIndex(value, length) {
                    length = length == null ? MAX_SAFE_INTEGER : length;
                    return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length)
                }

function isKeyable(value) {
                    var type = typeof value;
                    return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null
                }

function isMasked(func) {
                    return !!maskSrcKey && maskSrcKey in func
                }

function isPrototype(value) {
                    var Ctor = value && value.constructor,
                        proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
                    return value === proto
                }

function toSource(func) {
                    if (func != null) {
                        try {
                            return funcToString.call(func)
                        } catch (e) {}
                        try {
                            return func + ""
                        } catch (e) {}
                    }
                    return ""
                }

function cloneDeep(value) {
                    return baseClone(value, true, true)
                }

function eq(value, other) {
                    return value === other || value !== value && other !== other
                }

function isArguments(value) {
                    return isArrayLikeObject(value) && hasOwnProperty.call(value, "callee") && (!propertyIsEnumerable.call(value, "callee") || objectToString.call(value) == argsTag)
                }
                var isArray = Array.isArray;

function isArrayLike(value) {
                    return value != null && isLength(value.length) && !isFunction(value)
                }

function isArrayLikeObject(value) {
                    return isObjectLike(value) && isArrayLike(value)
                }
                var isBuffer = nativeIsBuffer || stubFalse;

function isFunction(value) {
                    var tag = isObject(value) ? objectToString.call(value) : "";
                    return tag == funcTag || tag == genTag
                }

function isLength(value) {
                    return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER
                }

function isObject(value) {
                    var type = typeof value;
                    return !!value && (type == "object" || type == "function")
                }

function isObjectLike(value) {
                    return !!value && typeof value == "object"
                }

function keys(object) {
                    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object)
                }

function stubArray() {
                    return []
                }

function baseToString(value) {
                    if (typeof value == "string") {
                        return value
                    }
                    if (isSymbol(value)) {
                        return symbolToString ? symbolToString.call(value) : ""
                    }
                    var result = value + "";
                    return result == "0" && 1 / value == -INFINITY ? "-0" : result
                }

function isObjectLike(value) {
                    return !!value && typeof value == "object"
                }

function isSymbol(value) {
                    return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag
                }

function toString(value) {
                    return value == null ? "" : baseToString(value)
                }

function escapeRegExp(string) {
                    string = toString(string);
                    return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string
                }
                module.exports = escapeRegExp
            })
            .call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
        }, {}],
        39: [function(require, module, exports) {
            var objectTag = "[object Object]";

function isHostObject(value) {
                var result = false;
                if (value != null && typeof value.toString != "function") {
                    try {
                        result = !!(value + "")
                    } catch (e) {}
                }
                return result
            }

function overArg(func, transform) {
                return function(arg) {
                    return func(transform(arg))
                }
            }
            var funcProto = Function.prototype,
                objectProto = Object.prototype;
            var funcToString = funcProto.toString;
            var hasOwnProperty = objectProto.hasOwnProperty;
            var objectCtorString = funcToString.call(Object);
            var objectToString = objectProto.toString;
            var getPrototype = overArg(Object.getPrototypeOf, Object);

function isObjectLike(value) {
                return !!value && typeof value == "object"
            }

function isObjectLike(value) {
                return !!value && typeof value == "object"
            }

function apply(func, thisArg, args) {
                    switch (args.length) {
                        case 0:
                            return func.call(thisArg);
                        case 1:
                            return func.call(thisArg, args[0]);
                        case 2:
                            return func.call(thisArg, args[0], args[1]);
                        case 3:
                            return func.call(thisArg, args[0], args[1], args[2])
                    }
                    return func.apply(thisArg, args)
                }

function baseUnary(func) {
                    return function(value) {
                        return func(value)
                    }
                }

function getValue(object, key) {
                    return object == null ? undefined : object[key]
                }

function overArg(func, transform) {
                    return function(arg) {
                        return func(transform(arg))
                    }
                }

function Hash(entries) {
                    var index = -1,
                        length = entries == null ? 0 : entries.length;
                    this.clear();
                    while (++index < length) {
                        var entry = entries[index];
                        this.set(entry[0], entry[1])
                    }
                }

function hashClear() {
                    this.__data__ = nativeCreate ? nativeCreate(null) : {};
                    this.size = 0
                }

function hashDelete(key) {
                    var result = this.has(key) && delete this.__data__[key];
                    this.size -= result ? 1 : 0;
                    return result
                }

function hashHas(key) {
                    var data = this.__data__;
                    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key)
                }

function hashSet(key, value) {
                    var data = this.__data__;
                    this.size += this.has(key) ? 0 : 1;
                    data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
                    return this
                }
                Hash.prototype.clear = hashClear;
                Hash.prototype["delete"] = hashDelete;
                Hash.prototype.get = hashGet;
                Hash.prototype.has = hashHas;
                Hash.prototype.set = hashSet;

function ListCache(entries) {
                    var index = -1,
                        length = entries == null ? 0 : entries.length;
                    this.clear();
                    while (++index < length) {
                        var entry = entries[index];
                        this.set(entry[0], entry[1])
                    }
                }

function listCacheClear() {
                    this.__data__ = [];
                    this.size = 0
                }

function listCacheHas(key) {
                    return assocIndexOf(this.__data__, key) > -1
                }

function MapCache(entries) {
                    var index = -1,
                        length = entries == null ? 0 : entries.length;
                    this.clear();
                    while (++index < length) {
                        var entry = entries[index];
                        this.set(entry[0], entry[1])
                    }
                }

function mapCacheClear() {
                    this.size = 0;
                    this.__data__ = {
                        hash: new Hash,
                        map: new(Map || ListCache),
                        string: new Hash
                    }
                }

function mapCacheDelete(key) {
                    var result = getMapData(this, key)["delete"](key);
                    this.size -= result ? 1 : 0;
                    return result
                }

function mapCacheGet(key) {
                    return getMapData(this, key)
                        .get(key)
                }

function mapCacheHas(key) {
                    return getMapData(this, key)
                        .has(key)
                }

function mapCacheSet(key, value) {
                    var data = getMapData(this, key),
                        size = data.size;
                    data.set(key, value);
                    this.size += data.size == size ? 0 : 1;
                    return this
                }
                MapCache.prototype.clear = mapCacheClear;
                MapCache.prototype["delete"] = mapCacheDelete;
                MapCache.prototype.get = mapCacheGet;
                MapCache.prototype.has = mapCacheHas;
                MapCache.prototype.set = mapCacheSet;

function Stack(entries) {
                    var data = this.__data__ = new ListCache(entries);
                    this.size = data.size
                }

function stackClear() {
                    this.__data__ = new ListCache;
                    this.size = 0
                }

function stackDelete(key) {
                    var data = this.__data__,
                        result = data["delete"](key);
                    this.size = data.size;
                    return result
                }

function stackGet(key) {
                    return this.__data__.get(key)
                }

function stackHas(key) {
                    return this.__data__.has(key)
                }

function arrayLikeKeys(value, inherited) {
                    var isArr = isArray(value),
                        isArg = !isArr && isArguments(value),
                        isBuff = !isArr && !isArg && isBuffer(value),
                        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
                        skipIndexes = isArr || isArg || isBuff || isType,
                        result = skipIndexes ? baseTimes(value.length, String) : [],
                        length = result.length;
                    for (var key in value) {
                        if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
                            result.push(key)
                        }
                    }
                    return result
                }

function assignMergeValue(object, key, value) {
                    if (value !== undefined && !eq(object[key], value) || value === undefined && !(key in object)) {
                        baseAssignValue(object, key, value)
                    }
                }

function assignValue(object, key, value) {
                    var objValue = object[key];
                    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined && !(key in object)) {
                        baseAssignValue(object, key, value)
                    }
                }

function baseAssignValue(object, key, value) {
                    if (key == "__proto__" && defineProperty) {
                        defineProperty(object, key, {
                            configurable: true,
                            enumerable: true,
                            value: value,
                            writable: true
                        })
                    } else {
                        object[key] = value
                    }
                }
                var baseFor = createBaseFor();

function baseGetTag(value) {
                    if (value == null) {
                        return value === undefined ? undefinedTag : nullTag
                    }
                    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value)
                }

function baseIsArguments(value) {
                    return isObjectLike(value) && baseGetTag(value) == argsTag
                }

function baseIsNative(value) {
                    if (!isObject(value) || isMasked(value)) {
                        return false
                    }
                    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
                    return pattern.test(toSource(value))
                }

function baseIsTypedArray(value) {
                    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)]
                }

function baseKeysIn(object) {
                    if (!isObject(object)) {
                        return nativeKeysIn(object)
                    }
                    var isProto = isPrototype(object),
                        result = [];
                    for (var key in object) {
                        if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
                            result.push(key)
                        }
                    }
                    return result
                }

function baseMerge(object, source, srcIndex, customizer, stack) {
                    if (object === source) {
                        return
                    }
                    baseFor(source, function(srcValue, key) {
                        if (isObject(srcValue)) {
                            stack || (stack = new Stack);
                            baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack)
                        } else {
                            var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : undefined;
                            if (newValue === undefined) {
                                newValue = srcValue
                            }
                            assignMergeValue(object, key, newValue)
                        }
                    }, keysIn)
                }

function baseRest(func, start) {
                    return setToString(overRest(func, start, identity), func + "")
                }
                var baseSetToString = !defineProperty ? identity : function(func, string) {
                    return defineProperty(func, "toString", {
                        configurable: true,
                        enumerable: false,
                        value: constant(string),
                        writable: true
                    })
                };

function cloneBuffer(buffer, isDeep) {
                    if (isDeep) {
                        return buffer.slice()
                    }
                    var length = buffer.length,
                        result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
                    buffer.copy(result);
                    return result
                }

function createBaseFor(fromRight) {
                    return function(object, iteratee, keysFunc) {
                        var index = -1,
                            iterable = Object(object),
                            props = keysFunc(object),
                            length = props.length;
                        while (length--) {
                            var key = props[fromRight ? length : ++index];
                            if (iteratee(iterable[key], key, iterable) === false) {
                                break
                            }
                        }
                        return object
                    }
                }

function getMapData(map, key) {
                    var data = map.__data__;
                    return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map
                }

function getNative(object, key) {
                    var value = getValue(object, key);
                    return baseIsNative(value) ? value : undefined
                }

function initCloneObject(object) {
                    return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {}
                }

function isIndex(value, length) {
                    var type = typeof value;
                    length = length == null ? MAX_SAFE_INTEGER : length;
                    return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length)
                }

function isIterateeCall(value, index, object) {
                    if (!isObject(object)) {
                        return false
                    }
                    var type = typeof index;
                    if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
                        return eq(object[index], value)
                    }
                    return false
                }

function isMasked(func) {
                    return !!maskSrcKey && maskSrcKey in func
                }

function nativeKeysIn(object) {
                    var result = [];
                    if (object != null) {
                        for (var key in Object(object)) {
                            result.push(key)
                        }
                    }
                    return result
                }

function objectToString(value) {
                    return nativeObjectToString.call(value)
                }

function eq(value, other) {
                    return value === other || value !== value && other !== other
                }
                var isArguments = baseIsArguments(function() {
                    return arguments
                }()) ? baseIsArguments : function(value) {
                    return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee")
                };
                var isArray = Array.isArray;

function isArrayLike(value) {
                    return value != null && isLength(value.length) && !isFunction(value)
                }

function isArrayLikeObject(value) {
                    return isObjectLike(value) && isArrayLike(value)
                }
                var isBuffer = nativeIsBuffer || stubFalse;

function isFunction(value) {
                    if (!isObject(value)) {
                        return false
                    }
                    var tag = baseGetTag(value);
                    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag
                }

function isLength(value) {
                    return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER
                }

function isObject(value) {
                    var type = typeof value;
                    return value != null && (type == "object" || type == "function")
                }

function isObjectLike(value) {
                    return value != null && typeof value == "object"
                }

function toPlainObject(value) {
                    return copyObject(value, keysIn(value))
                }

function keysIn(object) {
                    return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object)
                }
                var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
                    baseMerge(object, source, srcIndex, customizer)
                });

function constant(value) {
                    return function() {
                        return value
                    }
                }

function identity(value) {
                    return value
                }

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _inheritsLoose(subClass, superClass) {
                subClass.prototype = Object.create(superClass.prototype);
                subClass.prototype.constructor = subClass;
                subClass.__proto__ = superClass
            }
            var AtRule = function(_Container) {
                _inheritsLoose(AtRule, _Container);

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _inheritsLoose(subClass, superClass) {
                subClass.prototype = Object.create(superClass.prototype);
                subClass.prototype.constructor = subClass;
                subClass.__proto__ = superClass
            }
            var Comment = function(_Node) {
                _inheritsLoose(Comment, _Node);

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _defineProperties(target, props) {
                for (var i = 0; i < props.length; i++) {
                    var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true;
                    if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor)
                }
            }

function cleanSource(nodes) {
                return nodes.map(function(i) {
                    if (i.nodes) i.nodes = cleanSource(i.nodes);
                    delete i.source;
                    return i
                })
            }
            var Container = function(_Node) {
                _inheritsLoose(Container, _Node);

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _assertThisInitialized(self) {
                if (self === void 0) {
                    throw new ReferenceError("this hasn't been initialised - super() hasn't been called")
                }
                return self
            }

function _wrapNativeSuper(Class) {
                var _cache = typeof Map === "function" ? new Map : undefined;
                _wrapNativeSuper = function _wrapNativeSuper(Class) {
                    if (Class === null || !_isNativeFunction(Class)) return Class;
                    if (typeof Class !== "function") {
                        throw new TypeError("Super expression must either be null or a function")
                    }
                    if (typeof _cache !== "undefined") {
                        if (_cache.has(Class)) return _cache.get(Class);
                        _cache.set(Class, Wrapper)
                    }

function Wrapper() {
                        return _construct(Class, arguments, _getPrototypeOf(this)
                            .constructor)
                    }
                    Wrapper.prototype = Object.create(Class.prototype, {
                        constructor: {
                            value: Wrapper,
                            enumerable: false,
                            writable: true,
                            configurable: true
                        }
                    });
                    return _setPrototypeOf(Wrapper, Class)
                };
                return _wrapNativeSuper(Class)
            }

function _isNativeFunction(fn) {
                return Function.toString.call(fn)
                    .indexOf("[native code]") !== -1
            }

function _setPrototypeOf(o, p) {
                _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
                    o.__proto__ = p;
                    return o
                };
                return _setPrototypeOf(o, p)
            }

function _getPrototypeOf(o) {
                _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
                    return o.__proto__ || Object.getPrototypeOf(o)
                };
                return _getPrototypeOf(o)
            }
            var CssSyntaxError = function(_Error) {
                _inheritsLoose(CssSyntaxError, _Error);

function mark(text) {
                        if (color && _chalk.default.red) {
                            return _chalk.default.red.bold(text)
                        }
                        return text
                    }

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _inheritsLoose(subClass, superClass) {
                subClass.prototype = Object.create(superClass.prototype);
                subClass.prototype.constructor = subClass;
                subClass.__proto__ = superClass
            }
            var Declaration = function(_Node) {
                _inheritsLoose(Declaration, _Node);

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _interopRequireDefault(obj) {
                    return obj && obj.__esModule ? obj : {
                        default: obj
                    }
                }

function _defineProperties(target, props) {
                    for (var i = 0; i < props.length; i++) {
                        var descriptor = props[i];
                        descriptor.enumerable = descriptor.enumerable || false;
                        descriptor.configurable = true;
                        if ("value" in descriptor) descriptor.writable = true;
                        Object.defineProperty(target, descriptor.key, descriptor)
                    }
                }

function _interopRequireDefault(obj) {
                    return obj && obj.__esModule ? obj : {
                        default: obj
                    }
                }

function _interopRequireDefault(obj) {
                    return obj && obj.__esModule ? obj : {
                        default: obj
                    }
                }

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _interopRequireDefault(obj) {
                    return obj && obj.__esModule ? obj : {
                        default: obj
                    }
                }

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _inheritsLoose(subClass, superClass) {
                subClass.prototype = Object.create(superClass.prototype);
                subClass.prototype.constructor = subClass;
                subClass.__proto__ = superClass
            }
            var Root = function(_Container) {
                _inheritsLoose(Root, _Container);

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function _inheritsLoose(subClass, superClass) {
                subClass.prototype = Object.create(superClass.prototype);
                subClass.prototype.constructor = subClass;
                subClass.__proto__ = superClass
            }
            var Rule = function(_Container) {
                _inheritsLoose(Rule, _Container);

function _interopRequireDefault(obj) {
                return obj && obj.__esModule ? obj : {
                    default: obj
                }
            }

function tokenizer(input, options) {
                if (options === void 0) {
                    options = {}
                }
                var css = input.css.valueOf();
                var ignore = options.ignoreErrors;
                var code, next, quote, lines, last, content, escape;
                var nextLine, nextOffset, escaped, escapePos, prev, n, currentToken;
                var length = css.length;
                var offset = -1;
                var line = 1;
                var pos = 0;
                var buffer = [];
                var returned = [];

function position() {
                    return pos
                }

function unclosed(what) {
                    throw input.error("Unclosed " + what, line, pos - offset)
                }

function endOfFile() {
                    return returned.length === 0 && pos >= length
                }

function defaultSetTimout() {
                throw new Error("setTimeout has not been defined")
            }

function defaultClearTimeout() {
                throw new Error("clearTimeout has not been defined")
            }(function() {
                try {
                    if (typeof setTimeout === "function") {
                        cachedSetTimeout = setTimeout
                    } else {
                        cachedSetTimeout = defaultSetTimout
                    }
                } catch (e) {
                    cachedSetTimeout = defaultSetTimout
                }
                try {
                    if (typeof clearTimeout === "function") {
                        cachedClearTimeout = clearTimeout
                    } else {
                        cachedClearTimeout = defaultClearTimeout
                    }
                } catch (e) {
                    cachedClearTimeout = defaultClearTimeout
                }
            })();

function runTimeout(fun) {
                if (cachedSetTimeout === setTimeout) {
                    return setTimeout(fun, 0)
                }
                if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
                    cachedSetTimeout = setTimeout;
                    return setTimeout(fun, 0)
                }
                try {
                    return cachedSetTimeout(fun, 0)
                } catch (e) {
                    try {
                        return cachedSetTimeout.call(null, fun, 0)
                    } catch (e) {
                        return cachedSetTimeout.call(this, fun, 0)
                    }
                }
            }

function cleanUpNextTick() {
                if (!draining || !currentQueue) {
                    return
                }
                draining = false;
                if (currentQueue.length) {
                    queue = currentQueue.concat(queue)
                } else {
                    queueIndex = -1
                }
                if (queue.length) {
                    drainQueue()
                }
            }

function error(type) {
                        throw new RangeError(errors[type])
                    }

function map(array, fn) {
                        var length = array.length;
                        var result = [];
                        while (length--) {
                            result[length] = fn(array[length])
                        }
                        return result
                    }

function mapDomain(string, fn) {
                        var parts = string.split("@");
                        var result = "";
                        if (parts.length > 1) {
                            result = parts[0] + "@";
                            string = parts[1]
                        }
                        string = string.replace(regexSeparators, ".");
                        var labels = string.split(".");
                        var encoded = map(labels, fn)
                            .join(".");
                        return result + encoded
                    }

function basicToDigit(codePoint) {
                        if (codePoint - 48 < 10) {
                            return codePoint - 22
                        }
                        if (codePoint - 65 < 26) {
                            return codePoint - 65
                        }
                        if (codePoint - 97 < 26) {
                            return codePoint - 97
                        }
                        return base
                    }

function digitToBasic(digit, flag) {
                        return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5)
                    }

function adapt(delta, numPoints, firstTime) {
                        var k = 0;
                        delta = firstTime ? floor(delta / damp) : delta >> 1;
                        delta += floor(delta / numPoints);
                        for (; delta > baseMinusTMin * tMax >> 1; k += base) {
                            delta = floor(delta / baseMinusTMin)
                        }
                        return floor(k + (baseMinusTMin + 1) * delta / (delta + skew))
                    }

function toUnicode(input) {
                        return mapDomain(input, function(string) {
                            return regexPunycode.test(string) ? decode(string.slice(4)
                                .toLowerCase()) : string
                        })
                    }

function toASCII(input) {
                        return mapDomain(input, function(string) {
                            return regexNonASCII.test(string) ? "xn--" + encode(string) : string
                        })
                    }
                    punycode = {
                        version: "1.4.1",
                        ucs2: {
                            decode: ucs2decode,
                            encode: ucs2encode
                        },
                        decode: decode,
                        encode: encode,
                        toASCII: toASCII,
                        toUnicode: toUnicode
                    };
                    if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
                        define("punycode", function() {
                            return punycode
                        })
                    } else if (freeExports && freeModule) {
                        if (module.exports == freeExports) {
                            freeModule.exports = punycode
                        } else {
                            for (key in punycode) {
                                punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key])
                            }
                        }
                    } else {
                        root.punycode = punycode
                    }
                })(this)
            })
            .call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
        }, {}],
        70: [function(require, module, exports) {
            "use strict";

function copyProps(src, dst) {
                for (var key in src) {
                    dst[key] = src[key]
                }
            }
            if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
                module.exports = buffer
            } else {
                copyProps(buffer, exports);
                exports.Buffer = SafeBuffer
            }

function toVLQSigned(aValue) {
                return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0
            }

function generatedPositionAfter(mappingA, mappingB) {
                var lineA = mappingA.generatedLine;
                var lineB = mappingB.generatedLine;
                var columnA = mappingA.generatedColumn;
                var columnB = mappingB.generatedColumn;
                return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0
            }

function randomIntInRange(low, high) {
                return Math.round(low + Math.random() * (high - low))
            }

function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
                this.children = [];
                this.sourceContents = {};
                this.line = aLine == null ? null : aLine;
                this.column = aColumn == null ? null : aColumn;
                this.source = aSource == null ? null : aSource;
                this.name = aName == null ? null : aName;
                this[isSourceNode] = true;
                if (aChunks != null) this.add(aChunks)
            }
            SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
                var node = new SourceNode;
                var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
                var remainingLinesIndex = 0;
                var shiftNextLine = function() {
                    var lineContents = getNextLine();
                    var newLine = getNextLine() || "";
                    return lineContents + newLine;

function urlParse(aUrl) {
                var match = aUrl.match(urlRegexp);
                if (!match) {
                    return null
                }
                return {
                    scheme: match[1],
                    auth: match[2],
                    host: match[3],
                    port: match[4],
                    path: match[5]
                }
            }
            exports.urlParse = urlParse;

function identity(s) {
                return s
            }

function toSetString(aStr) {
                if (isProtoString(aStr)) {
                    return "$" + aStr
                }
                return aStr
            }
            exports.toSetString = supportsNullProto ? identity : toSetString;

function fromSetString(aStr) {
                if (isProtoString(aStr)) {
                    return aStr.slice(1)
                }
                return aStr
            }
            exports.fromSetString = supportsNullProto ? identity : fromSetString;

function strcmp(aStr1, aStr2) {
                if (aStr1 === aStr2) {
                    return 0
                }
                if (aStr1 === null) {
                    return 1
                }
                if (aStr2 === null) {
                    return -1
                }
                if (aStr1 > aStr2) {
                    return 1
                }
                return -1
            }

function parseSourceMapInput(str) {
                return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""))
            }
            exports.parseSourceMapInput = parseSourceMapInput;

function normalizeEncoding(enc) {
                var nenc = _normalizeEncoding(enc);
                if (typeof nenc !== "string" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
                return nenc || enc
            }
            exports.StringDecoder = StringDecoder;

function utf8CheckByte(byte) {
                if (byte <= 127) return 0;
                else if (byte >> 5 === 6) return 2;
                else if (byte >> 4 === 14) return 3;
                else if (byte >> 3 === 30) return 4;
                return byte >> 6 === 2 ? -1 : -2
            }

function utf8FillLast(buf) {
                var p = this.lastTotal - this.lastNeed;
                var r = utf8CheckExtraBytes(this, buf, p);
                if (r !== undefined) return r;
                if (this.lastNeed <= buf.length) {
                    buf.copy(this.lastChar, p, 0, this.lastNeed);
                    return this.lastChar.toString(this.encoding, 0, this.lastTotal)
                }
                buf.copy(this.lastChar, p, 0, buf.length);
                this.lastNeed -= buf.length
            }

function utf8Text(buf, i) {
                var total = utf8CheckIncomplete(this, buf, i);
                if (!this.lastNeed) return buf.toString("utf8", i);
                this.lastTotal = total;
                var end = buf.length - (total - this.lastNeed);
                buf.copy(this.lastChar, 0, end);
                return buf.toString("utf8", i, end)
            }

function utf8End(buf) {
                var r = buf && buf.length ? this.write(buf) : "";
                if (this.lastNeed) return r + "�";
                return r
            }

function utf16End(buf) {
                var r = buf && buf.length ? this.write(buf) : "";
                if (this.lastNeed) {
                    var end = this.lastTotal - this.lastNeed;
                    return r + this.lastChar.toString("utf16le", 0, end)
                }
                return r
            }

function base64End(buf) {
                var r = buf && buf.length ? this.write(buf) : "";
                if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
                return r
            }

function simpleWrite(buf) {
                return buf.toString(this.encoding)
            }

function urlResolve(source, relative) {
                return urlParse(source, false, true)
                    .resolve(relative)
            }
            Url.prototype.resolve = function(relative) {
                return this.resolveObject(urlParse(relative, false, true))
                    .format()
            };

[-] sanitize-html.js [edit]
[+] ..