@daoyi/nmtl-ui 2.0.1-beta.47 → 2.0.1-beta.49

package/lib/utils/vendor-3ec75cc9.js

@@ -1,1289 +0,0 @@
-var domToImage = {exports: {}};
-
-(function (module) {
-	(function (global) {
-
-	    var util = newUtil();
-	    var inliner = newInliner();
-	    var fontFaces = newFontFaces();
-	    var images = newImages();
-
-	    // Default impl options
-	    var defaultOptions = {
-	        // Default is to fail on error, no placeholder
-	        imagePlaceholder: undefined,
-	        // Default cache bust is false, it will use the cache
-	        cacheBust: false
-	    };
-
-	    var domtoimage = {
-	        toSvg: toSvg,
-	        toPng: toPng,
-	        toJpeg: toJpeg,
-	        toBlob: toBlob,
-	        toPixelData: toPixelData,
-	        impl: {
-	            fontFaces: fontFaces,
-	            images: images,
-	            util: util,
-	            inliner: inliner,
-	            options: {}
-	        }
-	    };
-
-	    module.exports = domtoimage;
-
-
-	    /**
-	     * @param {Node} node - The DOM Node object to render
-	     * @param {Object} options - Rendering options
-	     * @param {Function} options.filter - Should return true if passed node should be included in the output
-	     *          (excluding node means excluding it's children as well). Not called on the root node.
-	     * @param {String} options.bgcolor - color for the background, any valid CSS color value.
-	     * @param {Number} options.width - width to be applied to node before rendering.
-	     * @param {Number} options.height - height to be applied to node before rendering.
-	     * @param {Object} options.style - an object whose properties to be copied to node's style before rendering.
-	     * @param {Number} options.quality - a Number between 0 and 1 indicating image quality (applicable to JPEG only),
-	                defaults to 1.0.
-	     * @param {String} options.imagePlaceholder - dataURL to use as a placeholder for failed images, default behaviour is to fail fast on images we can't fetch
-	     * @param {Boolean} options.cacheBust - set to true to cache bust by appending the time to the request url
-	     * @return {Promise} - A promise that is fulfilled with a SVG image data URL
-	     * */
-	    function toSvg(node, options) {
-	        options = options || {};
-	        copyOptions(options);
-	        return Promise.resolve(node)
-	            .then(function (node) {
-	                return cloneNode(node, options.filter, true);
-	            })
-	            .then(embedFonts)
-	            .then(inlineImages)
-	            .then(applyOptions)
-	            .then(function (clone) {
-	                return makeSvgDataUri(clone,
-	                    options.width || util.width(node),
-	                    options.height || util.height(node)
-	                );
-	            });
-
-	        function applyOptions(clone) {
-	            if (options.bgcolor) clone.style.backgroundColor = options.bgcolor;
-
-	            if (options.width) clone.style.width = options.width + 'px';
-	            if (options.height) clone.style.height = options.height + 'px';
-
-	            if (options.style)
-	                Object.keys(options.style).forEach(function (property) {
-	                    clone.style[property] = options.style[property];
-	                });
-
-	            return clone;
-	        }
-	    }
-
-	    /**
-	     * @param {Node} node - The DOM Node object to render
-	     * @param {Object} options - Rendering options, @see {@link toSvg}
-	     * @return {Promise} - A promise that is fulfilled with a Uint8Array containing RGBA pixel data.
-	     * */
-	    function toPixelData(node, options) {
-	        return draw(node, options || {})
-	            .then(function (canvas) {
-	                return canvas.getContext('2d').getImageData(
-	                    0,
-	                    0,
-	                    util.width(node),
-	                    util.height(node)
-	                ).data;
-	            });
-	    }
-
-	    /**
-	     * @param {Node} node - The DOM Node object to render
-	     * @param {Object} options - Rendering options, @see {@link toSvg}
-	     * @return {Promise} - A promise that is fulfilled with a PNG image data URL
-	     * */
-	    function toPng(node, options) {
-	        return draw(node, options || {})
-	            .then(function (canvas) {
-	                return canvas.toDataURL();
-	            });
-	    }
-
-	    /**
-	     * @param {Node} node - The DOM Node object to render
-	     * @param {Object} options - Rendering options, @see {@link toSvg}
-	     * @return {Promise} - A promise that is fulfilled with a JPEG image data URL
-	     * */
-	    function toJpeg(node, options) {
-	        options = options || {};
-	        return draw(node, options)
-	            .then(function (canvas) {
-	                return canvas.toDataURL('image/jpeg', options.quality || 1.0);
-	            });
-	    }
-
-	    /**
-	     * @param {Node} node - The DOM Node object to render
-	     * @param {Object} options - Rendering options, @see {@link toSvg}
-	     * @return {Promise} - A promise that is fulfilled with a PNG image blob
-	     * */
-	    function toBlob(node, options) {
-	        return draw(node, options || {})
-	            .then(util.canvasToBlob);
-	    }
-
-	    function copyOptions(options) {
-	        // Copy options to impl options for use in impl
-	        if(typeof(options.imagePlaceholder) === 'undefined') {
-	            domtoimage.impl.options.imagePlaceholder = defaultOptions.imagePlaceholder;
-	        } else {
-	            domtoimage.impl.options.imagePlaceholder = options.imagePlaceholder;
-	        }
-
-	        if(typeof(options.cacheBust) === 'undefined') {
-	            domtoimage.impl.options.cacheBust = defaultOptions.cacheBust;
-	        } else {
-	            domtoimage.impl.options.cacheBust = options.cacheBust;
-	        }
-	    }
-
-	    function draw(domNode, options) {
-	        return toSvg(domNode, options)
-	            .then(util.makeImage)
-	            .then(util.delay(100))
-	            .then(function (image) {
-	                var canvas = newCanvas(domNode);
-	                canvas.getContext('2d').drawImage(image, 0, 0);
-	                return canvas;
-	            });
-
-	        function newCanvas(domNode) {
-	            var canvas = document.createElement('canvas');
-	            canvas.width = options.width || util.width(domNode);
-	            canvas.height = options.height || util.height(domNode);
-
-	            if (options.bgcolor) {
-	                var ctx = canvas.getContext('2d');
-	                ctx.fillStyle = options.bgcolor;
-	                ctx.fillRect(0, 0, canvas.width, canvas.height);
-	            }
-
-	            return canvas;
-	        }
-	    }
-
-	    function cloneNode(node, filter, root) {
-	        if (!root && filter && !filter(node)) return Promise.resolve();
-
-	        return Promise.resolve(node)
-	            .then(makeNodeCopy)
-	            .then(function (clone) {
-	                return cloneChildren(node, clone, filter);
-	            })
-	            .then(function (clone) {
-	                return processClone(node, clone);
-	            });
-
-	        function makeNodeCopy(node) {
-	            if (node instanceof HTMLCanvasElement) return util.makeImage(node.toDataURL());
-	            return node.cloneNode(false);
-	        }
-
-	        function cloneChildren(original, clone, filter) {
-	            var children = original.childNodes;
-	            if (children.length === 0) return Promise.resolve(clone);
-
-	            return cloneChildrenInOrder(clone, util.asArray(children), filter)
-	                .then(function () {
-	                    return clone;
-	                });
-
-	            function cloneChildrenInOrder(parent, children, filter) {
-	                var done = Promise.resolve();
-	                children.forEach(function (child) {
-	                    done = done
-	                        .then(function () {
-	                            return cloneNode(child, filter);
-	                        })
-	                        .then(function (childClone) {
-	                            if (childClone) parent.appendChild(childClone);
-	                        });
-	                });
-	                return done;
-	            }
-	        }
-
-	        function processClone(original, clone) {
-	            if (!(clone instanceof Element)) return clone;
-
-	            return Promise.resolve()
-	                .then(cloneStyle)
-	                .then(clonePseudoElements)
-	                .then(copyUserInput)
-	                .then(fixSvg)
-	                .then(function () {
-	                    return clone;
-	                });
-
-	            function cloneStyle() {
-	                copyStyle(window.getComputedStyle(original), clone.style);
-
-	                function copyStyle(source, target) {
-	                    if (source.cssText) target.cssText = source.cssText;
-	                    else copyProperties(source, target);
-
-	                    function copyProperties(source, target) {
-	                        util.asArray(source).forEach(function (name) {
-	                            target.setProperty(
-	                                name,
-	                                source.getPropertyValue(name),
-	                                source.getPropertyPriority(name)
-	                            );
-	                        });
-	                    }
-	                }
-	            }
-
-	            function clonePseudoElements() {
-	                [':before', ':after'].forEach(function (element) {
-	                    clonePseudoElement(element);
-	                });
-
-	                function clonePseudoElement(element) {
-	                    var style = window.getComputedStyle(original, element);
-	                    var content = style.getPropertyValue('content');
-
-	                    if (content === '' || content === 'none') return;
-
-	                    var className = util.uid();
-	                    clone.className = clone.className + ' ' + className;
-	                    var styleElement = document.createElement('style');
-	                    styleElement.appendChild(formatPseudoElementStyle(className, element, style));
-	                    clone.appendChild(styleElement);
-
-	                    function formatPseudoElementStyle(className, element, style) {
-	                        var selector = '.' + className + ':' + element;
-	                        var cssText = style.cssText ? formatCssText(style) : formatCssProperties(style);
-	                        return document.createTextNode(selector + '{' + cssText + '}');
-
-	                        function formatCssText(style) {
-	                            var content = style.getPropertyValue('content');
-	                            return style.cssText + ' content: ' + content + ';';
-	                        }
-
-	                        function formatCssProperties(style) {
-
-	                            return util.asArray(style)
-	                                .map(formatProperty)
-	                                .join('; ') + ';';
-
-	                            function formatProperty(name) {
-	                                return name + ': ' +
-	                                    style.getPropertyValue(name) +
-	                                    (style.getPropertyPriority(name) ? ' !important' : '');
-	                            }
-	                        }
-	                    }
-	                }
-	            }
-
-	            function copyUserInput() {
-	                if (original instanceof HTMLTextAreaElement) clone.innerHTML = original.value;
-	                if (original instanceof HTMLInputElement) clone.setAttribute("value", original.value);
-	            }
-
-	            function fixSvg() {
-	                if (!(clone instanceof SVGElement)) return;
-	                clone.setAttribute('xmlns', 'http://www.w3.org/2000/svg');
-
-	                if (!(clone instanceof SVGRectElement)) return;
-	                ['width', 'height'].forEach(function (attribute) {
-	                    var value = clone.getAttribute(attribute);
-	                    if (!value) return;
-
-	                    clone.style.setProperty(attribute, value);
-	                });
-	            }
-	        }
-	    }
-
-	    function embedFonts(node) {
-	        return fontFaces.resolveAll()
-	            .then(function (cssText) {
-	                var styleNode = document.createElement('style');
-	                node.appendChild(styleNode);
-	                styleNode.appendChild(document.createTextNode(cssText));
-	                return node;
-	            });
-	    }
-
-	    function inlineImages(node) {
-	        return images.inlineAll(node)
-	            .then(function () {
-	                return node;
-	            });
-	    }
-
-	    function makeSvgDataUri(node, width, height) {
-	        return Promise.resolve(node)
-	            .then(function (node) {
-	                node.setAttribute('xmlns', 'http://www.w3.org/1999/xhtml');
-	                return new XMLSerializer().serializeToString(node);
-	            })
-	            .then(util.escapeXhtml)
-	            .then(function (xhtml) {
-	                return '<foreignObject x="0" y="0" width="100%" height="100%">' + xhtml + '</foreignObject>';
-	            })
-	            .then(function (foreignObject) {
-	                return '<svg xmlns="http://www.w3.org/2000/svg" width="' + width + '" height="' + height + '">' +
-	                    foreignObject + '</svg>';
-	            })
-	            .then(function (svg) {
-	                return 'data:image/svg+xml;charset=utf-8,' + svg;
-	            });
-	    }
-
-	    function newUtil() {
-	        return {
-	            escape: escape,
-	            parseExtension: parseExtension,
-	            mimeType: mimeType,
-	            dataAsUrl: dataAsUrl,
-	            isDataUrl: isDataUrl,
-	            canvasToBlob: canvasToBlob,
-	            resolveUrl: resolveUrl,
-	            getAndEncode: getAndEncode,
-	            uid: uid(),
-	            delay: delay,
-	            asArray: asArray,
-	            escapeXhtml: escapeXhtml,
-	            makeImage: makeImage,
-	            width: width,
-	            height: height
-	        };
-
-	        function mimes() {
-	            /*
-	             * Only WOFF and EOT mime types for fonts are 'real'
-	             * see http://www.iana.org/assignments/media-types/media-types.xhtml
-	             */
-	            var WOFF = 'application/font-woff';
-	            var JPEG = 'image/jpeg';
-
-	            return {
-	                'woff': WOFF,
-	                'woff2': WOFF,
-	                'ttf': 'application/font-truetype',
-	                'eot': 'application/vnd.ms-fontobject',
-	                'png': 'image/png',
-	                'jpg': JPEG,
-	                'jpeg': JPEG,
-	                'gif': 'image/gif',
-	                'tiff': 'image/tiff',
-	                'svg': 'image/svg+xml'
-	            };
-	        }
-
-	        function parseExtension(url) {
-	            var match = /\.([^\.\/]*?)$/g.exec(url);
-	            if (match) return match[1];
-	            else return '';
-	        }
-
-	        function mimeType(url) {
-	            var extension = parseExtension(url).toLowerCase();
-	            return mimes()[extension] || '';
-	        }
-
-	        function isDataUrl(url) {
-	            return url.search(/^(data:)/) !== -1;
-	        }
-
-	        function toBlob(canvas) {
-	            return new Promise(function (resolve) {
-	                var binaryString = window.atob(canvas.toDataURL().split(',')[1]);
-	                var length = binaryString.length;
-	                var binaryArray = new Uint8Array(length);
-
-	                for (var i = 0; i < length; i++)
-	                    binaryArray[i] = binaryString.charCodeAt(i);
-
-	                resolve(new Blob([binaryArray], {
-	                    type: 'image/png'
-	                }));
-	            });
-	        }
-
-	        function canvasToBlob(canvas) {
-	            if (canvas.toBlob)
-	                return new Promise(function (resolve) {
-	                    canvas.toBlob(resolve);
-	                });
-
-	            return toBlob(canvas);
-	        }
-
-	        function resolveUrl(url, baseUrl) {
-	            var doc = document.implementation.createHTMLDocument();
-	            var base = doc.createElement('base');
-	            doc.head.appendChild(base);
-	            var a = doc.createElement('a');
-	            doc.body.appendChild(a);
-	            base.href = baseUrl;
-	            a.href = url;
-	            return a.href;
-	        }
-
-	        function uid() {
-	            var index = 0;
-
-	            return function () {
-	                return 'u' + fourRandomChars() + index++;
-
-	                function fourRandomChars() {
-	                    /* see http://stackoverflow.com/a/6248722/2519373 */
-	                    return ('0000' + (Math.random() * Math.pow(36, 4) << 0).toString(36)).slice(-4);
-	                }
-	            };
-	        }
-
-	        function makeImage(uri) {
-	            return new Promise(function (resolve, reject) {
-	                var image = new Image();
-	                image.onload = function () {
-	                    resolve(image);
-	                };
-	                image.onerror = reject;
-	                image.src = uri;
-	            });
-	        }
-
-	        function getAndEncode(url) {
-	            var TIMEOUT = 30000;
-	            if(domtoimage.impl.options.cacheBust) {
-	                // Cache bypass so we dont have CORS issues with cached images
-	                // Source: https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest#Bypassing_the_cache
-	                url += ((/\?/).test(url) ? "&" : "?") + (new Date()).getTime();
-	            }
-
-	            return new Promise(function (resolve) {
-	                var request = new XMLHttpRequest();
-
-	                request.onreadystatechange = done;
-	                request.ontimeout = timeout;
-	                request.responseType = 'blob';
-	                request.timeout = TIMEOUT;
-	                request.open('GET', url, true);
-	                request.send();
-
-	                var placeholder;
-	                if(domtoimage.impl.options.imagePlaceholder) {
-	                    var split = domtoimage.impl.options.imagePlaceholder.split(/,/);
-	                    if(split && split[1]) {
-	                        placeholder = split[1];
-	                    }
-	                }
-
-	                function done() {
-	                    if (request.readyState !== 4) return;
-
-	                    if (request.status !== 200) {
-	                        if(placeholder) {
-	                            resolve(placeholder);
-	                        } else {
-	                            fail('cannot fetch resource: ' + url + ', status: ' + request.status);
-	                        }
-
-	                        return;
-	                    }
-
-	                    var encoder = new FileReader();
-	                    encoder.onloadend = function () {
-	                        var content = encoder.result.split(/,/)[1];
-	                        resolve(content);
-	                    };
-	                    encoder.readAsDataURL(request.response);
-	                }
-
-	                function timeout() {
-	                    if(placeholder) {
-	                        resolve(placeholder);
-	                    } else {
-	                        fail('timeout of ' + TIMEOUT + 'ms occured while fetching resource: ' + url);
-	                    }
-	                }
-
-	                function fail(message) {
-	                    console.error(message);
-	                    resolve('');
-	                }
-	            });
-	        }
-
-	        function dataAsUrl(content, type) {
-	            return 'data:' + type + ';base64,' + content;
-	        }
-
-	        function escape(string) {
-	            return string.replace(/([.*+?^${}()|\[\]\/\\])/g, '\\$1');
-	        }
-
-	        function delay(ms) {
-	            return function (arg) {
-	                return new Promise(function (resolve) {
-	                    setTimeout(function () {
-	                        resolve(arg);
-	                    }, ms);
-	                });
-	            };
-	        }
-
-	        function asArray(arrayLike) {
-	            var array = [];
-	            var length = arrayLike.length;
-	            for (var i = 0; i < length; i++) array.push(arrayLike[i]);
-	            return array;
-	        }
-
-	        function escapeXhtml(string) {
-	            return string.replace(/#/g, '%23').replace(/\n/g, '%0A');
-	        }
-
-	        function width(node) {
-	            var leftBorder = px(node, 'border-left-width');
-	            var rightBorder = px(node, 'border-right-width');
-	            return node.scrollWidth + leftBorder + rightBorder;
-	        }
-
-	        function height(node) {
-	            var topBorder = px(node, 'border-top-width');
-	            var bottomBorder = px(node, 'border-bottom-width');
-	            return node.scrollHeight + topBorder + bottomBorder;
-	        }
-
-	        function px(node, styleProperty) {
-	            var value = window.getComputedStyle(node).getPropertyValue(styleProperty);
-	            return parseFloat(value.replace('px', ''));
-	        }
-	    }
-
-	    function newInliner() {
-	        var URL_REGEX = /url\(['"]?([^'"]+?)['"]?\)/g;
-
-	        return {
-	            inlineAll: inlineAll,
-	            shouldProcess: shouldProcess,
-	            impl: {
-	                readUrls: readUrls,
-	                inline: inline
-	            }
-	        };
-
-	        function shouldProcess(string) {
-	            return string.search(URL_REGEX) !== -1;
-	        }
-
-	        function readUrls(string) {
-	            var result = [];
-	            var match;
-	            while ((match = URL_REGEX.exec(string)) !== null) {
-	                result.push(match[1]);
-	            }
-	            return result.filter(function (url) {
-	                return !util.isDataUrl(url);
-	            });
-	        }
-
-	        function inline(string, url, baseUrl, get) {
-	            return Promise.resolve(url)
-	                .then(function (url) {
-	                    return baseUrl ? util.resolveUrl(url, baseUrl) : url;
-	                })
-	                .then(get || util.getAndEncode)
-	                .then(function (data) {
-	                    return util.dataAsUrl(data, util.mimeType(url));
-	                })
-	                .then(function (dataUrl) {
-	                    return string.replace(urlAsRegex(url), '$1' + dataUrl + '$3');
-	                });
-
-	            function urlAsRegex(url) {
-	                return new RegExp('(url\\([\'"]?)(' + util.escape(url) + ')([\'"]?\\))', 'g');
-	            }
-	        }
-
-	        function inlineAll(string, baseUrl, get) {
-	            if (nothingToInline()) return Promise.resolve(string);
-
-	            return Promise.resolve(string)
-	                .then(readUrls)
-	                .then(function (urls) {
-	                    var done = Promise.resolve(string);
-	                    urls.forEach(function (url) {
-	                        done = done.then(function (string) {
-	                            return inline(string, url, baseUrl, get);
-	                        });
-	                    });
-	                    return done;
-	                });
-
-	            function nothingToInline() {
-	                return !shouldProcess(string);
-	            }
-	        }
-	    }
-
-	    function newFontFaces() {
-	        return {
-	            resolveAll: resolveAll,
-	            impl: {
-	                readAll: readAll
-	            }
-	        };
-
-	        function resolveAll() {
-	            return readAll()
-	                .then(function (webFonts) {
-	                    return Promise.all(
-	                        webFonts.map(function (webFont) {
-	                            return webFont.resolve();
-	                        })
-	                    );
-	                })
-	                .then(function (cssStrings) {
-	                    return cssStrings.join('\n');
-	                });
-	        }
-
-	        function readAll() {
-	            return Promise.resolve(util.asArray(document.styleSheets))
-	                .then(getCssRules)
-	                .then(selectWebFontRules)
-	                .then(function (rules) {
-	                    return rules.map(newWebFont);
-	                });
-
-	            function selectWebFontRules(cssRules) {
-	                return cssRules
-	                    .filter(function (rule) {
-	                        return rule.type === CSSRule.FONT_FACE_RULE;
-	                    })
-	                    .filter(function (rule) {
-	                        return inliner.shouldProcess(rule.style.getPropertyValue('src'));
-	                    });
-	            }
-
-	            function getCssRules(styleSheets) {
-	                var cssRules = [];
-	                styleSheets.forEach(function (sheet) {
-	                    try {
-	                        util.asArray(sheet.cssRules || []).forEach(cssRules.push.bind(cssRules));
-	                    } catch (e) {
-	                        console.log('Error while reading CSS rules from ' + sheet.href, e.toString());
-	                    }
-	                });
-	                return cssRules;
-	            }
-
-	            function newWebFont(webFontRule) {
-	                return {
-	                    resolve: function resolve() {
-	                        var baseUrl = (webFontRule.parentStyleSheet || {}).href;
-	                        return inliner.inlineAll(webFontRule.cssText, baseUrl);
-	                    },
-	                    src: function () {
-	                        return webFontRule.style.getPropertyValue('src');
-	                    }
-	                };
-	            }
-	        }
-	    }
-
-	    function newImages() {
-	        return {
-	            inlineAll: inlineAll,
-	            impl: {
-	                newImage: newImage
-	            }
-	        };
-
-	        function newImage(element) {
-	            return {
-	                inline: inline
-	            };
-
-	            function inline(get) {
-	                if (util.isDataUrl(element.src)) return Promise.resolve();
-
-	                return Promise.resolve(element.src)
-	                    .then(get || util.getAndEncode)
-	                    .then(function (data) {
-	                        return util.dataAsUrl(data, util.mimeType(element.src));
-	                    })
-	                    .then(function (dataUrl) {
-	                        return new Promise(function (resolve, reject) {
-	                            element.onload = resolve;
-	                            element.onerror = reject;
-	                            element.src = dataUrl;
-	                        });
-	                    });
-	            }
-	        }
-
-	        function inlineAll(node) {
-	            if (!(node instanceof Element)) return Promise.resolve(node);
-
-	            return inlineBackground(node)
-	                .then(function () {
-	                    if (node instanceof HTMLImageElement)
-	                        return newImage(node).inline();
-	                    else
-	                        return Promise.all(
-	                            util.asArray(node.childNodes).map(function (child) {
-	                                return inlineAll(child);
-	                            })
-	                        );
-	                });
-
-	            function inlineBackground(node) {
-	                var background = node.style.getPropertyValue('background');
-
-	                if (!background) return Promise.resolve(node);
-
-	                return inliner.inlineAll(background)
-	                    .then(function (inlined) {
-	                        node.style.setProperty(
-	                            'background',
-	                            inlined,
-	                            node.style.getPropertyPriority('background')
-	                        );
-	                    })
-	                    .then(function () {
-	                        return node;
-	                    });
-	            }
-	        }
-	    }
-	})();
-} (domToImage));
-
-var domtoimage = domToImage.exports;
-
-var fileDownload = function(data, filename, mime, bom) {
-    var blobData = (typeof bom !== 'undefined') ? [bom, data] : [data];
-    var blob = new Blob(blobData, {type: mime || 'application/octet-stream'});
-    if (typeof window.navigator.msSaveBlob !== 'undefined') {
-        // IE workaround for "HTML7007: One or more blob URLs were
-        // revoked by closing the blob for which they were created.
-        // These URLs will no longer resolve as the data backing
-        // the URL has been freed."
-        window.navigator.msSaveBlob(blob, filename);
-    }
-    else {
-        var blobURL = (window.URL && window.URL.createObjectURL) ? window.URL.createObjectURL(blob) : window.webkitURL.createObjectURL(blob);
-        var tempLink = document.createElement('a');
-        tempLink.style.display = 'none';
-        tempLink.href = blobURL;
-        tempLink.setAttribute('download', filename);
-
-        // Safari thinks _blank anchor are pop ups. We only want to set _blank
-        // target if the browser does not support the HTML5 download attribute.
-        // This allows you to download files in desktop safari if pop up blocking
-        // is enabled.
-        if (typeof tempLink.download === 'undefined') {
-            tempLink.setAttribute('target', '_blank');
-        }
-
-        document.body.appendChild(tempLink);
-        tempLink.click();
-
-        // Fixes "webkit blob resource error 1"
-        setTimeout(function() {
-            document.body.removeChild(tempLink);
-            window.URL.revokeObjectURL(blobURL);
-        }, 200);
-    }
-};
-
-var queryString = {};
-
-var strictUriEncode = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
-
-var token = '%[a-f0-9]{2}';
-var singleMatcher = new RegExp(token, 'gi');
-var multiMatcher = new RegExp('(' + token + ')+', 'gi');
-
-function decodeComponents(components, split) {
-	try {
-		// Try to decode the entire string first
-		return decodeURIComponent(components.join(''));
-	} catch (err) {
-		// Do nothing
-	}
-
-	if (components.length === 1) {
-		return components;
-	}
-
-	split = split || 1;
-
-	// Split the array in 2 parts
-	var left = components.slice(0, split);
-	var right = components.slice(split);
-
-	return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
-}
-
-function decode(input) {
-	try {
-		return decodeURIComponent(input);
-	} catch (err) {
-		var tokens = input.match(singleMatcher);
-
-		for (var i = 1; i < tokens.length; i++) {
-			input = decodeComponents(tokens, i).join('');
-
-			tokens = input.match(singleMatcher);
-		}
-
-		return input;
-	}
-}
-
-function customDecodeURIComponent(input) {
-	// Keep track of all the replacements and prefill the map with the `BOM`
-	var replaceMap = {
-		'%FE%FF': '\uFFFD\uFFFD',
-		'%FF%FE': '\uFFFD\uFFFD'
-	};
-
-	var match = multiMatcher.exec(input);
-	while (match) {
-		try {
-			// Decode as big chunks as possible
-			replaceMap[match[0]] = decodeURIComponent(match[0]);
-		} catch (err) {
-			var result = decode(match[0]);
-
-			if (result !== match[0]) {
-				replaceMap[match[0]] = result;
-			}
-		}
-
-		match = multiMatcher.exec(input);
-	}
-
-	// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
-	replaceMap['%C2'] = '\uFFFD';
-
-	var entries = Object.keys(replaceMap);
-
-	for (var i = 0; i < entries.length; i++) {
-		// Replace all decoded components
-		var key = entries[i];
-		input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
-	}
-
-	return input;
-}
-
-var decodeUriComponent = function (encodedURI) {
-	if (typeof encodedURI !== 'string') {
-		throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
-	}
-
-	try {
-		encodedURI = encodedURI.replace(/\+/g, ' ');
-
-		// Try the built in decoder first
-		return decodeURIComponent(encodedURI);
-	} catch (err) {
-		// Fallback to a more advanced decoder
-		return customDecodeURIComponent(encodedURI);
-	}
-};
-
-var splitOnFirst = (string, separator) => {
-	if (!(typeof string === 'string' && typeof separator === 'string')) {
-		throw new TypeError('Expected the arguments to be of type `string`');
-	}
-
-	if (separator === '') {
-		return [string];
-	}
-
-	const separatorIndex = string.indexOf(separator);
-
-	if (separatorIndex === -1) {
-		return [string];
-	}
-
-	return [
-		string.slice(0, separatorIndex),
-		string.slice(separatorIndex + separator.length)
-	];
-};
-
-(function (exports) {
-	const strictUriEncode$1 = strictUriEncode;
-	const decodeComponent = decodeUriComponent;
-	const splitOnFirst$1 = splitOnFirst;
-
-	const isNullOrUndefined = value => value === null || value === undefined;
-
-	function encoderForArrayFormat(options) {
-		switch (options.arrayFormat) {
-			case 'index':
-				return key => (result, value) => {
-					const index = result.length;
-
-					if (
-						value === undefined ||
-						(options.skipNull && value === null) ||
-						(options.skipEmptyString && value === '')
-					) {
-						return result;
-					}
-
-					if (value === null) {
-						return [...result, [encode(key, options), '[', index, ']'].join('')];
-					}
-
-					return [
-						...result,
-						[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')
-					];
-				};
-
-			case 'bracket':
-				return key => (result, value) => {
-					if (
-						value === undefined ||
-						(options.skipNull && value === null) ||
-						(options.skipEmptyString && value === '')
-					) {
-						return result;
-					}
-
-					if (value === null) {
-						return [...result, [encode(key, options), '[]'].join('')];
-					}
-
-					return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
-				};
-
-			case 'comma':
-			case 'separator':
-				return key => (result, value) => {
-					if (value === null || value === undefined || value.length === 0) {
-						return result;
-					}
-
-					if (result.length === 0) {
-						return [[encode(key, options), '=', encode(value, options)].join('')];
-					}
-
-					return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
-				};
-
-			default:
-				return key => (result, value) => {
-					if (
-						value === undefined ||
-						(options.skipNull && value === null) ||
-						(options.skipEmptyString && value === '')
-					) {
-						return result;
-					}
-
-					if (value === null) {
-						return [...result, encode(key, options)];
-					}
-
-					return [...result, [encode(key, options), '=', encode(value, options)].join('')];
-				};
-		}
-	}
-
-	function parserForArrayFormat(options) {
-		let result;
-
-		switch (options.arrayFormat) {
-			case 'index':
-				return (key, value, accumulator) => {
-					result = /\[(\d*)\]$/.exec(key);
-
-					key = key.replace(/\[\d*\]$/, '');
-
-					if (!result) {
-						accumulator[key] = value;
-						return;
-					}
-
-					if (accumulator[key] === undefined) {
-						accumulator[key] = {};
-					}
-
-					accumulator[key][result[1]] = value;
-				};
-
-			case 'bracket':
-				return (key, value, accumulator) => {
-					result = /(\[\])$/.exec(key);
-					key = key.replace(/\[\]$/, '');
-
-					if (!result) {
-						accumulator[key] = value;
-						return;
-					}
-
-					if (accumulator[key] === undefined) {
-						accumulator[key] = [value];
-						return;
-					}
-
-					accumulator[key] = [].concat(accumulator[key], value);
-				};
-
-			case 'comma':
-			case 'separator':
-				return (key, value, accumulator) => {
-					const isArray = typeof value === 'string' && value.split('').indexOf(options.arrayFormatSeparator) > -1;
-					const newValue = isArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);
-					accumulator[key] = newValue;
-				};
-
-			default:
-				return (key, value, accumulator) => {
-					if (accumulator[key] === undefined) {
-						accumulator[key] = value;
-						return;
-					}
-
-					accumulator[key] = [].concat(accumulator[key], value);
-				};
-		}
-	}
-
-	function validateArrayFormatSeparator(value) {
-		if (typeof value !== 'string' || value.length !== 1) {
-			throw new TypeError('arrayFormatSeparator must be single character string');
-		}
-	}
-
-	function encode(value, options) {
-		if (options.encode) {
-			return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
-		}
-
-		return value;
-	}
-
-	function decode(value, options) {
-		if (options.decode) {
-			return decodeComponent(value);
-		}
-
-		return value;
-	}
-
-	function keysSorter(input) {
-		if (Array.isArray(input)) {
-			return input.sort();
-		}
-
-		if (typeof input === 'object') {
-			return keysSorter(Object.keys(input))
-				.sort((a, b) => Number(a) - Number(b))
-				.map(key => input[key]);
-		}
-
-		return input;
-	}
-
-	function removeHash(input) {
-		const hashStart = input.indexOf('#');
-		if (hashStart !== -1) {
-			input = input.slice(0, hashStart);
-		}
-
-		return input;
-	}
-
-	function getHash(url) {
-		let hash = '';
-		const hashStart = url.indexOf('#');
-		if (hashStart !== -1) {
-			hash = url.slice(hashStart);
-		}
-
-		return hash;
-	}
-
-	function extract(input) {
-		input = removeHash(input);
-		const queryStart = input.indexOf('?');
-		if (queryStart === -1) {
-			return '';
-		}
-
-		return input.slice(queryStart + 1);
-	}
-
-	function parseValue(value, options) {
-		if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
-			value = Number(value);
-		} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
-			value = value.toLowerCase() === 'true';
-		}
-
-		return value;
-	}
-
-	function parse(input, options) {
-		options = Object.assign({
-			decode: true,
-			sort: true,
-			arrayFormat: 'none',
-			arrayFormatSeparator: ',',
-			parseNumbers: false,
-			parseBooleans: false
-		}, options);
-
-		validateArrayFormatSeparator(options.arrayFormatSeparator);
-
-		const formatter = parserForArrayFormat(options);
-
-		// Create an object with no prototype
-		const ret = Object.create(null);
-
-		if (typeof input !== 'string') {
-			return ret;
-		}
-
-		input = input.trim().replace(/^[?#&]/, '');
-
-		if (!input) {
-			return ret;
-		}
-
-		for (const param of input.split('&')) {
-			let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, ' ') : param, '=');
-
-			// Missing `=` should be `null`:
-			// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
-			value = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);
-			formatter(decode(key, options), value, ret);
-		}
-
-		for (const key of Object.keys(ret)) {
-			const value = ret[key];
-			if (typeof value === 'object' && value !== null) {
-				for (const k of Object.keys(value)) {
-					value[k] = parseValue(value[k], options);
-				}
-			} else {
-				ret[key] = parseValue(value, options);
-			}
-		}
-
-		if (options.sort === false) {
-			return ret;
-		}
-
-		return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
-			const value = ret[key];
-			if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
-				// Sort object keys, not values
-				result[key] = keysSorter(value);
-			} else {
-				result[key] = value;
-			}
-
-			return result;
-		}, Object.create(null));
-	}
-
-	exports.extract = extract;
-	exports.parse = parse;
-
-	exports.stringify = (object, options) => {
-		if (!object) {
-			return '';
-		}
-
-		options = Object.assign({
-			encode: true,
-			strict: true,
-			arrayFormat: 'none',
-			arrayFormatSeparator: ','
-		}, options);
-
-		validateArrayFormatSeparator(options.arrayFormatSeparator);
-
-		const shouldFilter = key => (
-			(options.skipNull && isNullOrUndefined(object[key])) ||
-			(options.skipEmptyString && object[key] === '')
-		);
-
-		const formatter = encoderForArrayFormat(options);
-
-		const objectCopy = {};
-
-		for (const key of Object.keys(object)) {
-			if (!shouldFilter(key)) {
-				objectCopy[key] = object[key];
-			}
-		}
-
-		const keys = Object.keys(objectCopy);
-
-		if (options.sort !== false) {
-			keys.sort(options.sort);
-		}
-
-		return keys.map(key => {
-			const value = object[key];
-
-			if (value === undefined) {
-				return '';
-			}
-
-			if (value === null) {
-				return encode(key, options);
-			}
-
-			if (Array.isArray(value)) {
-				return value
-					.reduce(formatter(key), [])
-					.join('&');
-			}
-
-			return encode(key, options) + '=' + encode(value, options);
-		}).filter(x => x.length > 0).join('&');
-	};
-
-	exports.parseUrl = (input, options) => {
-		return {
-			url: removeHash(input).split('?')[0] || '',
-			query: parse(extract(input), options)
-		};
-	};
-
-	exports.stringifyUrl = (input, options) => {
-		const url = removeHash(input.url).split('?')[0] || '';
-		const queryFromUrl = exports.extract(input.url);
-		const parsedQueryFromUrl = exports.parse(queryFromUrl);
-		const hash = getHash(input.url);
-		const query = Object.assign(parsedQueryFromUrl, input.query);
-		let queryString = exports.stringify(query, options);
-		if (queryString) {
-			queryString = `?${queryString}`;
-		}
-
-		return `${url}${queryString}${hash}`;
-	};
-} (queryString));
-
-export { domtoimage as d, fileDownload as f, queryString as q };