@d3plus/export 3.0.0-alpha.0

package/umd/d3plus-export.full.js

@@ -0,0 +1,1145 @@
+/*
+  @d3plus/export v3.0.0
+  Export methods for transforming and downloading SVG.
+  Copyright (c) 2025 D3plus - https://d3plus.org
+  @license MIT
+*/
+
+(function (factory) {
+  typeof define === 'function' && define.amd ? define(factory) :
+  factory();
+})((function () { 'use strict';
+
+  if (typeof window !== "undefined") {
+    (function () {
+      try {
+        if (typeof SVGElement === 'undefined' || Boolean(SVGElement.prototype.innerHTML)) {
+          return;
+        }
+      } catch (e) {
+          return;
+      }
+
+      function serializeNode (node) {
+        switch (node.nodeType) {
+          case 1:
+            return serializeElementNode(node);
+          case 3:
+            return serializeTextNode(node);
+          case 8:
+            return serializeCommentNode(node);
+        }
+      }
+
+      function serializeTextNode (node) {
+          return node.textContent.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      }
+
+      function serializeCommentNode (node) {
+          return '<!--' + node.nodeValue + '-->'
+      }
+
+      function serializeElementNode (node) {
+          var output = '';
+
+          output += '<' + node.tagName;
+
+          if (node.hasAttributes()) {
+              [].forEach.call(node.attributes, function(attrNode) {
+                  output += ' ' + attrNode.name + '="' + attrNode.value + '"';
+              });
+          }
+
+          output += '>';
+
+          if (node.hasChildNodes()) {
+              [].forEach.call(node.childNodes, function(childNode) {
+                  output += serializeNode(childNode);
+              });
+          }
+
+          output += '</' + node.tagName + '>';
+
+          return output;
+      }
+
+      Object.defineProperty(SVGElement.prototype, 'innerHTML', {
+        get: function () {
+          var output = '';
+
+          [].forEach.call(this.childNodes, function(childNode) {
+              output += serializeNode(childNode);
+          });
+
+          return output;
+        },
+        set: function (markup) {
+          while (this.firstChild) {
+            this.removeChild(this.firstChild);
+          }
+
+          try {
+            var dXML = new DOMParser();
+            dXML.async = false;
+
+            var sXML = '<svg xmlns=\'http://www.w3.org/2000/svg\' xmlns:xlink=\'http://www.w3.org/1999/xlink\'>' + markup + '</svg>';
+            var svgDocElement = dXML.parseFromString(sXML, 'text/xml').documentElement;
+
+            [].forEach.call(svgDocElement.childNodes, function(childNode) {
+                this.appendChild(this.ownerDocument.importNode(childNode, true));
+            }.bind(this));
+          } catch (e) {
+              throw new Error('Error parsing markup string');
+          }
+        }
+      });
+
+      Object.defineProperty(SVGElement.prototype, 'innerSVG', {
+        get: function () {
+          return this.innerHTML;
+        },
+        set: function (markup) {
+          this.innerHTML = markup;
+        }
+      });
+
+    })();
+  }
+
+}));
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define('@d3plus/export', ['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3plus = {}));
+})(this, (function (exports) {
+    function resolveUrl(url, baseUrl) {
+        // url is absolute already
+        if (url.match(/^[a-z]+:\/\//i)) {
+            return url;
+        }
+        // url is absolute already, without protocol
+        if (url.match(/^\/\//)) {
+            return window.location.protocol + url;
+        }
+        // dataURI, mailto:, tel:, etc.
+        if (url.match(/^[a-z]+:/i)) {
+            return url;
+        }
+        const doc = document.implementation.createHTMLDocument();
+        const base = doc.createElement('base');
+        const a = doc.createElement('a');
+        doc.head.appendChild(base);
+        doc.body.appendChild(a);
+        if (baseUrl) {
+            base.href = baseUrl;
+        }
+        a.href = url;
+        return a.href;
+    }
+    const uuid = (()=>{
+        // generate uuid for className of pseudo elements.
+        // We should not use GUIDs, otherwise pseudo elements sometimes cannot be captured.
+        let counter = 0;
+        // ref: http://stackoverflow.com/a/6248722/2519373
+        const random = ()=>// eslint-disable-next-line no-bitwise
+            `0000${(Math.random() * 36 ** 4 << 0).toString(36)}`.slice(-4);
+        return ()=>{
+            counter += 1;
+            return `u${random()}${counter}`;
+        };
+    })();
+    function toArray(arrayLike) {
+        const arr = [];
+        for(let i = 0, l = arrayLike.length; i < l; i++){
+            arr.push(arrayLike[i]);
+        }
+        return arr;
+    }
+    let styleProps = null;
+    function getStyleProperties(options = {}) {
+        if (styleProps) {
+            return styleProps;
+        }
+        if (options.includeStyleProperties) {
+            styleProps = options.includeStyleProperties;
+            return styleProps;
+        }
+        styleProps = toArray(window.getComputedStyle(document.documentElement));
+        return styleProps;
+    }
+    function px(node, styleProperty) {
+        const win = node.ownerDocument.defaultView || window;
+        const val = win.getComputedStyle(node).getPropertyValue(styleProperty);
+        return val ? parseFloat(val.replace('px', '')) : 0;
+    }
+    function getNodeWidth(node) {
+        const leftBorder = px(node, 'border-left-width');
+        const rightBorder = px(node, 'border-right-width');
+        return node.clientWidth + leftBorder + rightBorder;
+    }
+    function getNodeHeight(node) {
+        const topBorder = px(node, 'border-top-width');
+        const bottomBorder = px(node, 'border-bottom-width');
+        return node.clientHeight + topBorder + bottomBorder;
+    }
+    function getImageSize(targetNode, options = {}) {
+        const width = options.width || getNodeWidth(targetNode);
+        const height = options.height || getNodeHeight(targetNode);
+        return {
+            width,
+            height
+        };
+    }
+    function getPixelRatio() {
+        let ratio;
+        let FINAL_PROCESS;
+        try {
+            FINAL_PROCESS = process;
+        } catch (e) {
+        // pass
+        }
+        const val = FINAL_PROCESS && FINAL_PROCESS.env ? FINAL_PROCESS.env.devicePixelRatio : null;
+        if (val) {
+            ratio = parseInt(val, 10);
+            if (Number.isNaN(ratio)) {
+                ratio = 1;
+            }
+        }
+        return ratio || window.devicePixelRatio || 1;
+    }
+    // @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas#maximum_canvas_size
+    const canvasDimensionLimit = 16384;
+    function checkCanvasDimensions(canvas) {
+        if (canvas.width > canvasDimensionLimit || canvas.height > canvasDimensionLimit) {
+            if (canvas.width > canvasDimensionLimit && canvas.height > canvasDimensionLimit) {
+                if (canvas.width > canvas.height) {
+                    canvas.height *= canvasDimensionLimit / canvas.width;
+                    canvas.width = canvasDimensionLimit;
+                } else {
+                    canvas.width *= canvasDimensionLimit / canvas.height;
+                    canvas.height = canvasDimensionLimit;
+                }
+            } else if (canvas.width > canvasDimensionLimit) {
+                canvas.height *= canvasDimensionLimit / canvas.width;
+                canvas.width = canvasDimensionLimit;
+            } else {
+                canvas.width *= canvasDimensionLimit / canvas.height;
+                canvas.height = canvasDimensionLimit;
+            }
+        }
+    }
+    function canvasToBlob(canvas, options = {}) {
+        if (canvas.toBlob) {
+            return new Promise((resolve)=>{
+                canvas.toBlob(resolve, options.type ? options.type : 'image/png', options.quality ? options.quality : 1);
+            });
+        }
+        return new Promise((resolve)=>{
+            const binaryString = window.atob(canvas.toDataURL(options.type ? options.type : undefined, options.quality ? options.quality : undefined).split(',')[1]);
+            const len = binaryString.length;
+            const binaryArray = new Uint8Array(len);
+            for(let i = 0; i < len; i += 1){
+                binaryArray[i] = binaryString.charCodeAt(i);
+            }
+            resolve(new Blob([
+                binaryArray
+            ], {
+                type: options.type ? options.type : 'image/png'
+            }));
+        });
+    }
+    function createImage(url) {
+        return new Promise((resolve, reject)=>{
+            const img = new Image();
+            img.onload = ()=>{
+                img.decode().then(()=>{
+                    requestAnimationFrame(()=>resolve(img));
+                });
+            };
+            img.onerror = reject;
+            img.crossOrigin = 'anonymous';
+            img.decoding = 'async';
+            img.src = url;
+        });
+    }
+    async function svgToDataURL(svg) {
+        return Promise.resolve().then(()=>new XMLSerializer().serializeToString(svg)).then(encodeURIComponent).then((html)=>`data:image/svg+xml;charset=utf-8,${html}`);
+    }
+    async function nodeToDataURL(node, width, height) {
+        const xmlns = 'http://www.w3.org/2000/svg';
+        const svg = document.createElementNS(xmlns, 'svg');
+        const foreignObject = document.createElementNS(xmlns, 'foreignObject');
+        svg.setAttribute('width', `${width}`);
+        svg.setAttribute('height', `${height}`);
+        svg.setAttribute('viewBox', `0 0 ${width} ${height}`);
+        foreignObject.setAttribute('width', '100%');
+        foreignObject.setAttribute('height', '100%');
+        foreignObject.setAttribute('x', '0');
+        foreignObject.setAttribute('y', '0');
+        foreignObject.setAttribute('externalResourcesRequired', 'true');
+        svg.appendChild(foreignObject);
+        foreignObject.appendChild(node);
+        return svgToDataURL(svg);
+    }
+    const isInstanceOfElement = (node, instance)=>{
+        if (node instanceof instance) return true;
+        const nodePrototype = Object.getPrototypeOf(node);
+        if (nodePrototype === null) return false;
+        return nodePrototype.constructor.name === instance.name || isInstanceOfElement(nodePrototype, instance);
+    };
+
+    function formatCSSText(style) {
+        const content = style.getPropertyValue('content');
+        return `${style.cssText} content: '${content.replace(/'|"/g, '')}';`;
+    }
+    function formatCSSProperties(style, options) {
+        return getStyleProperties(options).map((name)=>{
+            const value = style.getPropertyValue(name);
+            const priority = style.getPropertyPriority(name);
+            return `${name}: ${value}${priority ? ' !important' : ''};`;
+        }).join(' ');
+    }
+    function getPseudoElementStyle(className, pseudo, style, options) {
+        const selector = `.${className}:${pseudo}`;
+        const cssText = style.cssText ? formatCSSText(style) : formatCSSProperties(style, options);
+        return document.createTextNode(`${selector}{${cssText}}`);
+    }
+    function clonePseudoElement(nativeNode, clonedNode, pseudo, options) {
+        const style = window.getComputedStyle(nativeNode, pseudo);
+        const content = style.getPropertyValue('content');
+        if (content === '' || content === 'none') {
+            return;
+        }
+        const className = uuid();
+        try {
+            clonedNode.className = `${clonedNode.className} ${className}`;
+        } catch (err) {
+            return;
+        }
+        const styleElement = document.createElement('style');
+        styleElement.appendChild(getPseudoElementStyle(className, pseudo, style, options));
+        clonedNode.appendChild(styleElement);
+    }
+    function clonePseudoElements(nativeNode, clonedNode, options) {
+        clonePseudoElement(nativeNode, clonedNode, ':before', options);
+        clonePseudoElement(nativeNode, clonedNode, ':after', options);
+    }
+
+    const WOFF = 'application/font-woff';
+    const JPEG = 'image/jpeg';
+    const mimes = {
+        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',
+        webp: 'image/webp'
+    };
+    function getExtension(url) {
+        const match = /\.([^./]*?)$/g.exec(url);
+        return match ? match[1] : '';
+    }
+    function getMimeType(url) {
+        const extension = getExtension(url).toLowerCase();
+        return mimes[extension] || '';
+    }
+
+    function getContentFromDataUrl(dataURL) {
+        return dataURL.split(/,/)[1];
+    }
+    function isDataUrl(url) {
+        return url.search(/^(data:)/) !== -1;
+    }
+    function makeDataUrl(content, mimeType) {
+        return `data:${mimeType};base64,${content}`;
+    }
+    async function fetchAsDataURL(url, init, process) {
+        const res = await fetch(url, init);
+        if (res.status === 404) {
+            throw new Error(`Resource "${res.url}" not found`);
+        }
+        const blob = await res.blob();
+        return new Promise((resolve, reject)=>{
+            const reader = new FileReader();
+            reader.onerror = reject;
+            reader.onloadend = ()=>{
+                try {
+                    resolve(process({
+                        res,
+                        result: reader.result
+                    }));
+                } catch (error) {
+                    reject(error);
+                }
+            };
+            reader.readAsDataURL(blob);
+        });
+    }
+    const cache = {};
+    function getCacheKey(url, contentType, includeQueryParams) {
+        let key = url.replace(/\?.*/, '');
+        if (includeQueryParams) {
+            key = url;
+        }
+        // font resource
+        if (/ttf|otf|eot|woff2?/i.test(key)) {
+            key = key.replace(/.*\//, '');
+        }
+        return contentType ? `[${contentType}]${key}` : key;
+    }
+    async function resourceToDataURL(resourceUrl, contentType, options) {
+        const cacheKey = getCacheKey(resourceUrl, contentType, options.includeQueryParams);
+        if (cache[cacheKey] != null) {
+            return cache[cacheKey];
+        }
+        // ref: https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest#Bypassing_the_cache
+        if (options.cacheBust) {
+            // eslint-disable-next-line no-param-reassign
+            resourceUrl += (/\?/.test(resourceUrl) ? '&' : '?') + new Date().getTime();
+        }
+        let dataURL;
+        try {
+            const content = await fetchAsDataURL(resourceUrl, options.fetchRequestInit, ({ res, result })=>{
+                if (!contentType) {
+                    // eslint-disable-next-line no-param-reassign
+                    contentType = res.headers.get('Content-Type') || '';
+                }
+                return getContentFromDataUrl(result);
+            });
+            dataURL = makeDataUrl(content, contentType);
+        } catch (error) {
+            dataURL = options.imagePlaceholder || '';
+            let msg = `Failed to fetch resource: ${resourceUrl}`;
+            if (error) {
+                msg = typeof error === 'string' ? error : error.message;
+            }
+            if (msg) {
+                console.warn(msg);
+            }
+        }
+        cache[cacheKey] = dataURL;
+        return dataURL;
+    }
+
+    async function cloneCanvasElement(canvas) {
+        const dataURL = canvas.toDataURL();
+        if (dataURL === 'data:,') {
+            return canvas.cloneNode(false);
+        }
+        return createImage(dataURL);
+    }
+    async function cloneVideoElement(video, options) {
+        if (video.currentSrc) {
+            const canvas = document.createElement('canvas');
+            const ctx = canvas.getContext('2d');
+            canvas.width = video.clientWidth;
+            canvas.height = video.clientHeight;
+            ctx === null || ctx === void 0 ? void 0 : ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+            const dataURL = canvas.toDataURL();
+            return createImage(dataURL);
+        }
+        const poster = video.poster;
+        const contentType = getMimeType(poster);
+        const dataURL = await resourceToDataURL(poster, contentType, options);
+        return createImage(dataURL);
+    }
+    async function cloneIFrameElement(iframe, options) {
+        var _a;
+        try {
+            if ((_a = iframe === null || iframe === void 0 ? void 0 : iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.body) {
+                return await cloneNode(iframe.contentDocument.body, options, true);
+            }
+        } catch (_b) {
+        // Failed to clone iframe
+        }
+        return iframe.cloneNode(false);
+    }
+    async function cloneSingleNode(node, options) {
+        if (isInstanceOfElement(node, HTMLCanvasElement)) {
+            return cloneCanvasElement(node);
+        }
+        if (isInstanceOfElement(node, HTMLVideoElement)) {
+            return cloneVideoElement(node, options);
+        }
+        if (isInstanceOfElement(node, HTMLIFrameElement)) {
+            return cloneIFrameElement(node, options);
+        }
+        return node.cloneNode(isSVGElement(node));
+    }
+    const isSlotElement = (node)=>node.tagName != null && node.tagName.toUpperCase() === 'SLOT';
+    const isSVGElement = (node)=>node.tagName != null && node.tagName.toUpperCase() === 'SVG';
+    async function cloneChildren(nativeNode, clonedNode, options) {
+        var _a, _b;
+        if (isSVGElement(clonedNode)) {
+            return clonedNode;
+        }
+        let children = [];
+        if (isSlotElement(nativeNode) && nativeNode.assignedNodes) {
+            children = toArray(nativeNode.assignedNodes());
+        } else if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && ((_a = nativeNode.contentDocument) === null || _a === void 0 ? void 0 : _a.body)) {
+            children = toArray(nativeNode.contentDocument.body.childNodes);
+        } else {
+            children = toArray(((_b = nativeNode.shadowRoot) !== null && _b !== void 0 ? _b : nativeNode).childNodes);
+        }
+        if (children.length === 0 || isInstanceOfElement(nativeNode, HTMLVideoElement)) {
+            return clonedNode;
+        }
+        await children.reduce((deferred, child)=>deferred.then(()=>cloneNode(child, options)).then((clonedChild)=>{
+                if (clonedChild) {
+                    clonedNode.appendChild(clonedChild);
+                }
+            }), Promise.resolve());
+        return clonedNode;
+    }
+    function cloneCSSStyle(nativeNode, clonedNode, options) {
+        const targetStyle = clonedNode.style;
+        if (!targetStyle) {
+            return;
+        }
+        const sourceStyle = window.getComputedStyle(nativeNode);
+        if (sourceStyle.cssText) {
+            targetStyle.cssText = sourceStyle.cssText;
+            targetStyle.transformOrigin = sourceStyle.transformOrigin;
+        } else {
+            getStyleProperties(options).forEach((name)=>{
+                let value = sourceStyle.getPropertyValue(name);
+                if (name === 'font-size' && value.endsWith('px')) {
+                    const reducedFont = Math.floor(parseFloat(value.substring(0, value.length - 2))) - 0.1;
+                    value = `${reducedFont}px`;
+                }
+                if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && name === 'display' && value === 'inline') {
+                    value = 'block';
+                }
+                if (name === 'd' && clonedNode.getAttribute('d')) {
+                    value = `path(${clonedNode.getAttribute('d')})`;
+                }
+                targetStyle.setProperty(name, value, sourceStyle.getPropertyPriority(name));
+            });
+        }
+    }
+    function cloneInputValue(nativeNode, clonedNode) {
+        if (isInstanceOfElement(nativeNode, HTMLTextAreaElement)) {
+            clonedNode.innerHTML = nativeNode.value;
+        }
+        if (isInstanceOfElement(nativeNode, HTMLInputElement)) {
+            clonedNode.setAttribute('value', nativeNode.value);
+        }
+    }
+    function cloneSelectValue(nativeNode, clonedNode) {
+        if (isInstanceOfElement(nativeNode, HTMLSelectElement)) {
+            const clonedSelect = clonedNode;
+            const selectedOption = Array.from(clonedSelect.children).find((child)=>nativeNode.value === child.getAttribute('value'));
+            if (selectedOption) {
+                selectedOption.setAttribute('selected', '');
+            }
+        }
+    }
+    function decorate(nativeNode, clonedNode, options) {
+        if (isInstanceOfElement(clonedNode, Element)) {
+            cloneCSSStyle(nativeNode, clonedNode, options);
+            clonePseudoElements(nativeNode, clonedNode, options);
+            cloneInputValue(nativeNode, clonedNode);
+            cloneSelectValue(nativeNode, clonedNode);
+        }
+        return clonedNode;
+    }
+    async function ensureSVGSymbols(clone, options) {
+        const uses = clone.querySelectorAll ? clone.querySelectorAll('use') : [];
+        if (uses.length === 0) {
+            return clone;
+        }
+        const processedDefs = {};
+        for(let i = 0; i < uses.length; i++){
+            const use = uses[i];
+            const id = use.getAttribute('xlink:href');
+            if (id) {
+                const exist = clone.querySelector(id);
+                const definition = document.querySelector(id);
+                if (!exist && definition && !processedDefs[id]) {
+                    // eslint-disable-next-line no-await-in-loop
+                    processedDefs[id] = await cloneNode(definition, options, true);
+                }
+            }
+        }
+        const nodes = Object.values(processedDefs);
+        if (nodes.length) {
+            const ns = 'http://www.w3.org/1999/xhtml';
+            const svg = document.createElementNS(ns, 'svg');
+            svg.setAttribute('xmlns', ns);
+            svg.style.position = 'absolute';
+            svg.style.width = '0';
+            svg.style.height = '0';
+            svg.style.overflow = 'hidden';
+            svg.style.display = 'none';
+            const defs = document.createElementNS(ns, 'defs');
+            svg.appendChild(defs);
+            for(let i = 0; i < nodes.length; i++){
+                defs.appendChild(nodes[i]);
+            }
+            clone.appendChild(svg);
+        }
+        return clone;
+    }
+    async function cloneNode(node, options, isRoot) {
+        if (!isRoot && options.filter && !options.filter(node)) {
+            return null;
+        }
+        return Promise.resolve(node).then((clonedNode)=>cloneSingleNode(clonedNode, options)).then((clonedNode)=>cloneChildren(node, clonedNode, options)).then((clonedNode)=>decorate(node, clonedNode, options)).then((clonedNode)=>ensureSVGSymbols(clonedNode, options));
+    }
+
+    const URL_REGEX = /url\((['"]?)([^'"]+?)\1\)/g;
+    const URL_WITH_FORMAT_REGEX = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g;
+    const FONT_SRC_REGEX = /src:\s*(?:url\([^)]+\)\s*format\([^)]+\)[,;]\s*)+/g;
+    function toRegex(url) {
+        // eslint-disable-next-line no-useless-escape
+        const escaped = url.replace(/([.*+?^${}()|\[\]\/\\])/g, '\\$1');
+        return new RegExp(`(url\\(['"]?)(${escaped})(['"]?\\))`, 'g');
+    }
+    function parseURLs(cssText) {
+        const urls = [];
+        cssText.replace(URL_REGEX, (raw, quotation, url)=>{
+            urls.push(url);
+            return raw;
+        });
+        return urls.filter((url)=>!isDataUrl(url));
+    }
+    async function embed(cssText, resourceURL, baseURL, options, getContentFromUrl) {
+        try {
+            const resolvedURL = baseURL ? resolveUrl(resourceURL, baseURL) : resourceURL;
+            const contentType = getMimeType(resourceURL);
+            let dataURL;
+            if (getContentFromUrl) ; else {
+                dataURL = await resourceToDataURL(resolvedURL, contentType, options);
+            }
+            return cssText.replace(toRegex(resourceURL), `$1${dataURL}$3`);
+        } catch (error) {
+        // pass
+        }
+        return cssText;
+    }
+    function filterPreferredFontFormat(str, { preferredFontFormat }) {
+        return !preferredFontFormat ? str : str.replace(FONT_SRC_REGEX, (match)=>{
+            // eslint-disable-next-line no-constant-condition
+            while(true){
+                const [src, , format] = URL_WITH_FORMAT_REGEX.exec(match) || [];
+                if (!format) {
+                    return '';
+                }
+                if (format === preferredFontFormat) {
+                    return `src: ${src};`;
+                }
+            }
+        });
+    }
+    function shouldEmbed(url) {
+        return url.search(URL_REGEX) !== -1;
+    }
+    async function embedResources(cssText, baseUrl, options) {
+        if (!shouldEmbed(cssText)) {
+            return cssText;
+        }
+        const filteredCSSText = filterPreferredFontFormat(cssText, options);
+        const urls = parseURLs(filteredCSSText);
+        return urls.reduce((deferred, url)=>deferred.then((css)=>embed(css, url, baseUrl, options)), Promise.resolve(filteredCSSText));
+    }
+
+    async function embedProp(propName, node, options) {
+        var _a;
+        const propValue = (_a = node.style) === null || _a === void 0 ? void 0 : _a.getPropertyValue(propName);
+        if (propValue) {
+            const cssString = await embedResources(propValue, null, options);
+            node.style.setProperty(propName, cssString, node.style.getPropertyPriority(propName));
+            return true;
+        }
+        return false;
+    }
+    async function embedBackground(clonedNode, options) {
+        await embedProp('background', clonedNode, options) || await embedProp('background-image', clonedNode, options);
+        await embedProp('mask', clonedNode, options) || await embedProp('-webkit-mask', clonedNode, options) || await embedProp('mask-image', clonedNode, options) || await embedProp('-webkit-mask-image', clonedNode, options);
+    }
+    async function embedImageNode(clonedNode, options) {
+        const isImageElement = isInstanceOfElement(clonedNode, HTMLImageElement);
+        if (!(isImageElement && !isDataUrl(clonedNode.src)) && !(isInstanceOfElement(clonedNode, SVGImageElement) && !isDataUrl(clonedNode.href.baseVal))) {
+            return;
+        }
+        const url = isImageElement ? clonedNode.src : clonedNode.href.baseVal;
+        const dataURL = await resourceToDataURL(url, getMimeType(url), options);
+        await new Promise((resolve, reject)=>{
+            clonedNode.onload = resolve;
+            clonedNode.onerror = options.onImageErrorHandler ? (...attributes)=>{
+                try {
+                    resolve(options.onImageErrorHandler(...attributes));
+                } catch (error) {
+                    reject(error);
+                }
+            } : reject;
+            const image = clonedNode;
+            if (image.decode) {
+                image.decode = resolve;
+            }
+            if (image.loading === 'lazy') {
+                image.loading = 'eager';
+            }
+            if (isImageElement) {
+                clonedNode.srcset = '';
+                clonedNode.src = dataURL;
+            } else {
+                clonedNode.href.baseVal = dataURL;
+            }
+        });
+    }
+    async function embedChildren(clonedNode, options) {
+        const children = toArray(clonedNode.childNodes);
+        const deferreds = children.map((child)=>embedImages(child, options));
+        await Promise.all(deferreds).then(()=>clonedNode);
+    }
+    async function embedImages(clonedNode, options) {
+        if (isInstanceOfElement(clonedNode, Element)) {
+            await embedBackground(clonedNode, options);
+            await embedImageNode(clonedNode, options);
+            await embedChildren(clonedNode, options);
+        }
+    }
+
+    function applyStyle(node, options) {
+        const { style } = node;
+        if (options.backgroundColor) {
+            style.backgroundColor = options.backgroundColor;
+        }
+        if (options.width) {
+            style.width = `${options.width}px`;
+        }
+        if (options.height) {
+            style.height = `${options.height}px`;
+        }
+        const manual = options.style;
+        if (manual != null) {
+            Object.keys(manual).forEach((key)=>{
+                style[key] = manual[key];
+            });
+        }
+        return node;
+    }
+
+    const cssFetchCache = {};
+    async function fetchCSS(url) {
+        let cache = cssFetchCache[url];
+        if (cache != null) {
+            return cache;
+        }
+        const res = await fetch(url);
+        const cssText = await res.text();
+        cache = {
+            url,
+            cssText
+        };
+        cssFetchCache[url] = cache;
+        return cache;
+    }
+    async function embedFonts(data, options) {
+        let cssText = data.cssText;
+        const regexUrl = /url\(["']?([^"')]+)["']?\)/g;
+        const fontLocs = cssText.match(/url\([^)]+\)/g) || [];
+        const loadFonts = fontLocs.map(async (loc)=>{
+            let url = loc.replace(regexUrl, '$1');
+            if (!url.startsWith('https://')) {
+                url = new URL(url, data.url).href;
+            }
+            return fetchAsDataURL(url, options.fetchRequestInit, ({ result })=>{
+                cssText = cssText.replace(loc, `url(${result})`);
+                return [
+                    loc,
+                    result
+                ];
+            });
+        });
+        return Promise.all(loadFonts).then(()=>cssText);
+    }
+    function parseCSS(source) {
+        if (source == null) {
+            return [];
+        }
+        const result = [];
+        const commentsRegex = /(\/\*[\s\S]*?\*\/)/gi;
+        // strip out comments
+        let cssText = source.replace(commentsRegex, '');
+        // eslint-disable-next-line prefer-regex-literals
+        const keyframesRegex = new RegExp('((@.*?keyframes [\\s\\S]*?){([\\s\\S]*?}\\s*?)})', 'gi');
+        // eslint-disable-next-line no-constant-condition
+        while(true){
+            const matches = keyframesRegex.exec(cssText);
+            if (matches === null) {
+                break;
+            }
+            result.push(matches[0]);
+        }
+        cssText = cssText.replace(keyframesRegex, '');
+        const importRegex = /@import[\s\S]*?url\([^)]*\)[\s\S]*?;/gi;
+        // to match css & media queries together
+        const combinedCSSRegex = '((\\s*?(?:\\/\\*[\\s\\S]*?\\*\\/)?\\s*?@media[\\s\\S]' + '*?){([\\s\\S]*?)}\\s*?})|(([\\s\\S]*?){([\\s\\S]*?)})';
+        // unified regex
+        const unifiedRegex = new RegExp(combinedCSSRegex, 'gi');
+        // eslint-disable-next-line no-constant-condition
+        while(true){
+            let matches = importRegex.exec(cssText);
+            if (matches === null) {
+                matches = unifiedRegex.exec(cssText);
+                if (matches === null) {
+                    break;
+                } else {
+                    importRegex.lastIndex = unifiedRegex.lastIndex;
+                }
+            } else {
+                unifiedRegex.lastIndex = importRegex.lastIndex;
+            }
+            result.push(matches[0]);
+        }
+        return result;
+    }
+    async function getCSSRules(styleSheets, options) {
+        const ret = [];
+        const deferreds = [];
+        // First loop inlines imports
+        styleSheets.forEach((sheet)=>{
+            if ('cssRules' in sheet) {
+                try {
+                    toArray(sheet.cssRules || []).forEach((item, index)=>{
+                        if (item.type === CSSRule.IMPORT_RULE) {
+                            let importIndex = index + 1;
+                            const url = item.href;
+                            const deferred = fetchCSS(url).then((metadata)=>embedFonts(metadata, options)).then((cssText)=>parseCSS(cssText).forEach((rule)=>{
+                                    try {
+                                        sheet.insertRule(rule, rule.startsWith('@import') ? importIndex += 1 : sheet.cssRules.length);
+                                    } catch (error) {
+                                        console.error('Error inserting rule from remote css', {
+                                            rule,
+                                            error
+                                        });
+                                    }
+                                })).catch((e)=>{
+                                console.error('Error loading remote css', e.toString());
+                            });
+                            deferreds.push(deferred);
+                        }
+                    });
+                } catch (e) {
+                    const inline = styleSheets.find((a)=>a.href == null) || document.styleSheets[0];
+                    if (sheet.href != null) {
+                        deferreds.push(fetchCSS(sheet.href).then((metadata)=>embedFonts(metadata, options)).then((cssText)=>parseCSS(cssText).forEach((rule)=>{
+                                inline.insertRule(rule, inline.cssRules.length);
+                            })).catch((err)=>{
+                            console.error('Error loading remote stylesheet', err);
+                        }));
+                    }
+                    console.error('Error inlining remote css file', e);
+                }
+            }
+        });
+        return Promise.all(deferreds).then(()=>{
+            // Second loop parses rules
+            styleSheets.forEach((sheet)=>{
+                if ('cssRules' in sheet) {
+                    try {
+                        toArray(sheet.cssRules || []).forEach((item)=>{
+                            ret.push(item);
+                        });
+                    } catch (e) {
+                        console.error(`Error while reading CSS rules from ${sheet.href}`, e);
+                    }
+                }
+            });
+            return ret;
+        });
+    }
+    function getWebFontRules(cssRules) {
+        return cssRules.filter((rule)=>rule.type === CSSRule.FONT_FACE_RULE).filter((rule)=>shouldEmbed(rule.style.getPropertyValue('src')));
+    }
+    async function parseWebFontRules(node, options) {
+        if (node.ownerDocument == null) {
+            throw new Error('Provided element is not within a Document');
+        }
+        const styleSheets = toArray(node.ownerDocument.styleSheets);
+        const cssRules = await getCSSRules(styleSheets, options);
+        return getWebFontRules(cssRules);
+    }
+    function normalizeFontFamily(font) {
+        return font.trim().replace(/["']/g, '');
+    }
+    function getUsedFonts(node) {
+        const fonts = new Set();
+        function traverse(node) {
+            const fontFamily = node.style.fontFamily || getComputedStyle(node).fontFamily;
+            fontFamily.split(',').forEach((font)=>{
+                fonts.add(normalizeFontFamily(font));
+            });
+            Array.from(node.children).forEach((child)=>{
+                if (child instanceof HTMLElement) {
+                    traverse(child);
+                }
+            });
+        }
+        traverse(node);
+        return fonts;
+    }
+    async function getWebFontCSS(node, options) {
+        const rules = await parseWebFontRules(node, options);
+        const usedFonts = getUsedFonts(node);
+        const cssTexts = await Promise.all(rules.filter((rule)=>usedFonts.has(normalizeFontFamily(rule.style.fontFamily))).map((rule)=>{
+            const baseUrl = rule.parentStyleSheet ? rule.parentStyleSheet.href : null;
+            return embedResources(rule.cssText, baseUrl, options);
+        }));
+        return cssTexts.join('\n');
+    }
+    async function embedWebFonts(clonedNode, options) {
+        const cssText = options.fontEmbedCSS != null ? options.fontEmbedCSS : options.skipFonts ? null : await getWebFontCSS(clonedNode, options);
+        if (cssText) {
+            const styleNode = document.createElement('style');
+            const sytleContent = document.createTextNode(cssText);
+            styleNode.appendChild(sytleContent);
+            if (clonedNode.firstChild) {
+                clonedNode.insertBefore(styleNode, clonedNode.firstChild);
+            } else {
+                clonedNode.appendChild(styleNode);
+            }
+        }
+    }
+
+    async function toSvg(node, options = {}) {
+        const { width, height } = getImageSize(node, options);
+        const clonedNode = await cloneNode(node, options, true);
+        await embedWebFonts(clonedNode, options);
+        await embedImages(clonedNode, options);
+        applyStyle(clonedNode, options);
+        const datauri = await nodeToDataURL(clonedNode, width, height);
+        return datauri;
+    }
+    async function toCanvas(node, options = {}) {
+        const { width, height } = getImageSize(node, options);
+        const svg = await toSvg(node, options);
+        const img = await createImage(svg);
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('2d');
+        const ratio = options.pixelRatio || getPixelRatio();
+        const canvasWidth = options.canvasWidth || width;
+        const canvasHeight = options.canvasHeight || height;
+        canvas.width = canvasWidth * ratio;
+        canvas.height = canvasHeight * ratio;
+        if (!options.skipAutoScale) {
+            checkCanvasDimensions(canvas);
+        }
+        canvas.style.width = `${canvasWidth}`;
+        canvas.style.height = `${canvasHeight}`;
+        if (options.backgroundColor) {
+            context.fillStyle = options.backgroundColor;
+            context.fillRect(0, 0, canvas.width, canvas.height);
+        }
+        context.drawImage(img, 0, 0, canvas.width, canvas.height);
+        return canvas;
+    }
+    async function toBlob(node, options = {}) {
+        const canvas = await toCanvas(node, options);
+        const blob = await canvasToBlob(canvas);
+        return blob;
+    }
+
+    var FileSaver$1 = {exports: {}};
+
+    /* FileSaver.js
+     * A saveAs() FileSaver implementation.
+     * 1.3.2
+     * 2016-06-16 18:25:19
+     *
+     * By Eli Grey, http://eligrey.com
+     * License: MIT
+     *   See https://github.com/eligrey/FileSaver.js/blob/master/LICENSE.md
+     */
+    var FileSaver = FileSaver$1.exports;
+
+    var hasRequiredFileSaver;
+
+    function requireFileSaver () {
+    	if (hasRequiredFileSaver) return FileSaver$1.exports;
+    	hasRequiredFileSaver = 1;
+    	(function (module) {
+    		/*global self */ /*jslint bitwise: true, indent: 4, laxbreak: true, laxcomma: true, smarttabs: true, plusplus: true */ /*! @source http://purl.eligrey.com/github/FileSaver.js/blob/master/FileSaver.js */ var saveAs = saveAs || function(view) {
+    		    // IE <10 is explicitly unsupported
+    		    if (typeof view === "undefined" || typeof navigator !== "undefined" && /MSIE [1-9]\./.test(navigator.userAgent)) {
+    		        return;
+    		    }
+    		    var doc = view.document, get_URL = function() {
+    		        return view.URL || view.webkitURL || view;
+    		    }, save_link = doc.createElementNS("http://www.w3.org/1999/xhtml", "a"), can_use_save_link = "download" in save_link, click = function(node) {
+    		        var event = new MouseEvent("click");
+    		        node.dispatchEvent(event);
+    		    }, is_safari = /constructor/i.test(view.HTMLElement) || view.safari, is_chrome_ios = /CriOS\/[\d]+/.test(navigator.userAgent), throw_outside = function(ex) {
+    		        (view.setImmediate || view.setTimeout)(function() {
+    		            throw ex;
+    		        }, 0);
+    		    }, force_saveable_type = "application/octet-stream", arbitrary_revoke_timeout = 1000 * 40 // in ms
+    		    , revoke = function(file) {
+    		        var revoker = function() {
+    		            if (typeof file === "string") {
+    		                get_URL().revokeObjectURL(file);
+    		            } else {
+    		                file.remove();
+    		            }
+    		        };
+    		        setTimeout(revoker, arbitrary_revoke_timeout);
+    		    }, dispatch = function(filesaver, event_types, event) {
+    		        event_types = [].concat(event_types);
+    		        var i = event_types.length;
+    		        while(i--){
+    		            var listener = filesaver["on" + event_types[i]];
+    		            if (typeof listener === "function") {
+    		                try {
+    		                    listener.call(filesaver, event || filesaver);
+    		                } catch (ex) {
+    		                    throw_outside(ex);
+    		                }
+    		            }
+    		        }
+    		    }, auto_bom = function(blob) {
+    		        // prepend BOM for UTF-8 XML and text/* types (including HTML)
+    		        // note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF
+    		        if (/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
+    		            return new Blob([
+    		                String.fromCharCode(0xFEFF),
+    		                blob
+    		            ], {
+    		                type: blob.type
+    		            });
+    		        }
+    		        return blob;
+    		    }, FileSaver = function(blob, name, no_auto_bom) {
+    		        if (!no_auto_bom) {
+    		            blob = auto_bom(blob);
+    		        }
+    		        // First try a.download, then web filesystem, then object URLs
+    		        var filesaver = this, type = blob.type, force = type === force_saveable_type, object_url, dispatch_all = function() {
+    		            dispatch(filesaver, "writestart progress write writeend".split(" "));
+    		        }, fs_error = function() {
+    		            if ((is_chrome_ios || force && is_safari) && view.FileReader) {
+    		                // Safari doesn't allow downloading of blob urls
+    		                var reader = new FileReader();
+    		                reader.onloadend = function() {
+    		                    var url = is_chrome_ios ? reader.result : reader.result.replace(/^data:[^;]*;/, 'data:attachment/file;');
+    		                    var popup = view.open(url, '_blank');
+    		                    if (!popup) view.location.href = url;
+    		                    url = undefined; // release reference before dispatching
+    		                    filesaver.readyState = filesaver.DONE;
+    		                    dispatch_all();
+    		                };
+    		                reader.readAsDataURL(blob);
+    		                filesaver.readyState = filesaver.INIT;
+    		                return;
+    		            }
+    		            // don't create more object URLs than needed
+    		            if (!object_url) {
+    		                object_url = get_URL().createObjectURL(blob);
+    		            }
+    		            if (force) {
+    		                view.location.href = object_url;
+    		            } else {
+    		                var opened = view.open(object_url, "_blank");
+    		                if (!opened) {
+    		                    // Apple does not allow window.open, see https://developer.apple.com/library/safari/documentation/Tools/Conceptual/SafariExtensionGuide/WorkingwithWindowsandTabs/WorkingwithWindowsandTabs.html
+    		                    view.location.href = object_url;
+    		                }
+    		            }
+    		            filesaver.readyState = filesaver.DONE;
+    		            dispatch_all();
+    		            revoke(object_url);
+    		        };
+    		        filesaver.readyState = filesaver.INIT;
+    		        if (can_use_save_link) {
+    		            object_url = get_URL().createObjectURL(blob);
+    		            setTimeout(function() {
+    		                save_link.href = object_url;
+    		                save_link.download = name;
+    		                click(save_link);
+    		                dispatch_all();
+    		                revoke(object_url);
+    		                filesaver.readyState = filesaver.DONE;
+    		            });
+    		            return;
+    		        }
+    		        fs_error();
+    		    }, FS_proto = FileSaver.prototype, saveAs = function(blob, name, no_auto_bom) {
+    		        return new FileSaver(blob, name || blob.name || "download", no_auto_bom);
+    		    };
+    		    // IE 10+ (native saveAs)
+    		    if (typeof navigator !== "undefined" && navigator.msSaveOrOpenBlob) {
+    		        return function(blob, name, no_auto_bom) {
+    		            name = name || blob.name || "download";
+    		            if (!no_auto_bom) {
+    		                blob = auto_bom(blob);
+    		            }
+    		            return navigator.msSaveOrOpenBlob(blob, name);
+    		        };
+    		    }
+    		    FS_proto.abort = function() {};
+    		    FS_proto.readyState = FS_proto.INIT = 0;
+    		    FS_proto.WRITING = 1;
+    		    FS_proto.DONE = 2;
+    		    FS_proto.error = FS_proto.onwritestart = FS_proto.onprogress = FS_proto.onwrite = FS_proto.onabort = FS_proto.onerror = FS_proto.onwriteend = null;
+    		    return saveAs;
+    		}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || FileSaver.content);
+    		// `self` is undefined in Firefox for Android content script context
+    		// while `this` is nsIContentFrameMessageManager
+    		// with an attribute `content` that corresponds to the window
+    		if (module.exports) {
+    		    module.exports.saveAs = saveAs;
+    		} 
+    	} (FileSaver$1));
+    	return FileSaver$1.exports;
+    }
+
+    var FileSaverExports = requireFileSaver();
+
+    const defaultOptions = {
+        filename: "download",
+        type: "png"
+    };
+    /**
+        @function saveElement
+        @desc Downloads an HTML Element as a bitmap PNG image.
+        @param {HTMLElement} elem A single element to be saved to one file.
+        @param {Object} [options] Additional options to specify.
+        @param {String} [options.filename = "download"] Filename for the downloaded file, without the extension.
+        @param {String} [options.type = "png"] File type of the saved document. Accepted values are `"png"` and `"jpg"`.
+        @param {Function} [options.callback] Function to be invoked after saving is complete.
+        @param {Object} [renderOptions] Custom options to be passed to the html-to-image function.
+    */ function saveElement(elem, options = {}, renderOptions = {}) {
+        if (!elem) return;
+        options = Object.assign({}, defaultOptions, options);
+        // rename renderOptions.background to backgroundColor for backwards compatibility
+        renderOptions = Object.assign({
+            backgroundColor: renderOptions.background
+        }, renderOptions);
+        function finish(blob) {
+            FileSaverExports.saveAs(blob, `${options.filename}.${options.type}`);
+            if (options.callback) options.callback();
+        }
+        if (options.type === "svg") {
+            toSvg(elem, renderOptions).then((dataUrl)=>{
+                const xhr = new XMLHttpRequest();
+                xhr.open("GET", dataUrl);
+                xhr.responseType = "blob";
+                xhr.onload = ()=>finish(xhr.response);
+                xhr.send();
+            });
+        } else {
+            toBlob(elem, renderOptions).then(finish);
+        }
+    }
+
+    exports.saveElement = saveElement;
+
+}));
+//# sourceMappingURL=d3plus-export.full.js.map