| "use strict" |
| var os=require("os") |
| var fs=require("fs") |
| var url=require("url") |
| var path=require("path") |
| var SAX=require("@trysound/sax") |
| var cssSelect=require("css-select") |
| var csswhat=require("css-what") |
| var csstree=require("css-tree") |
| var csso=require("csso") |
| function _interopNamespaceDefault(e){var n=Object.create(null) |
| e&&Object.keys(e).forEach((function(k){if(k!=="default"){var d=Object.getOwnPropertyDescriptor(e,k) |
| Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}})}})) |
| n.default=e |
| return Object.freeze(n)}var csswhat__namespace=_interopNamespaceDefault(csswhat) |
| var csstree__namespace=_interopNamespaceDefault(csstree) |
| var csso__namespace=_interopNamespaceDefault(csso) |
| const elemsGroups={animation:new Set(["animate","animateColor","animateMotion","animateTransform","set"]),descriptive:new Set(["desc","metadata","title"]),shape:new Set(["circle","ellipse","line","path","polygon","polyline","rect"]),structural:new Set(["defs","g","svg","symbol","use"]),paintServer:new Set(["hatch","linearGradient","meshGradient","pattern","radialGradient","solidColor"]),nonRendering:new Set(["clipPath","filter","linearGradient","marker","mask","pattern","radialGradient","solidColor","symbol"]),container:new Set(["a","defs","foreignObject","g","marker","mask","missing-glyph","pattern","svg","switch","symbol"]),textContent:new Set(["a","altGlyph","altGlyphDef","altGlyphItem","glyph","glyphRef","text","textPath","tref","tspan"]),textContentChild:new Set(["altGlyph","textPath","tref","tspan"]),lightSource:new Set(["feDiffuseLighting","feDistantLight","fePointLight","feSpecularLighting","feSpotLight"]),filterPrimitive:new Set(["feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDropShadow","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feImage","feMerge","feMergeNode","feMorphology","feOffset","feSpecularLighting","feTile","feTurbulence"])} |
| const textElems=new Set([...elemsGroups.textContent,"pre","title"]) |
| const pathElems=new Set(["glyph","missing-glyph","path"]) |
| const attrsGroups={animationAddition:new Set(["additive","accumulate"]),animationAttributeTarget:new Set(["attributeType","attributeName"]),animationEvent:new Set(["onbegin","onend","onrepeat","onload"]),animationTiming:new Set(["begin","dur","end","fill","max","min","repeatCount","repeatDur","restart"]),animationValue:new Set(["by","calcMode","from","keySplines","keyTimes","to","values"]),conditionalProcessing:new Set(["requiredExtensions","requiredFeatures","systemLanguage"]),core:new Set(["id","tabindex","xml:base","xml:lang","xml:space"]),graphicalEvent:new Set(["onactivate","onclick","onfocusin","onfocusout","onload","onmousedown","onmousemove","onmouseout","onmouseover","onmouseup"]),presentation:new Set(["alignment-baseline","baseline-shift","clip-path","clip-rule","clip","color-interpolation-filters","color-interpolation","color-profile","color-rendering","color","cursor","direction","display","dominant-baseline","enable-background","fill-opacity","fill-rule","fill","filter","flood-color","flood-opacity","font-family","font-size-adjust","font-size","font-stretch","font-style","font-variant","font-weight","glyph-orientation-horizontal","glyph-orientation-vertical","image-rendering","letter-spacing","lighting-color","marker-end","marker-mid","marker-start","mask","opacity","overflow","paint-order","pointer-events","shape-rendering","stop-color","stop-opacity","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","stroke","text-anchor","text-decoration","text-overflow","text-rendering","transform-origin","transform","unicode-bidi","vector-effect","visibility","word-spacing","writing-mode"]),xlink:new Set(["xlink:actuate","xlink:arcrole","xlink:href","xlink:role","xlink:show","xlink:title","xlink:type"]),documentEvent:new Set(["onabort","onerror","onresize","onscroll","onunload","onzoom"]),documentElementEvent:new Set(["oncopy","oncut","onpaste"]),globalEvent:new Set(["oncancel","oncanplay","oncanplaythrough","onchange","onclick","onclose","oncuechange","ondblclick","ondrag","ondragend","ondragenter","ondragleave","ondragover","ondragstart","ondrop","ondurationchange","onemptied","onended","onerror","onfocus","oninput","oninvalid","onkeydown","onkeypress","onkeyup","onload","onloadeddata","onloadedmetadata","onloadstart","onmousedown","onmouseenter","onmouseleave","onmousemove","onmouseout","onmouseover","onmouseup","onmousewheel","onpause","onplay","onplaying","onprogress","onratechange","onreset","onresize","onscroll","onseeked","onseeking","onselect","onshow","onstalled","onsubmit","onsuspend","ontimeupdate","ontoggle","onvolumechange","onwaiting"]),filterPrimitive:new Set(["x","y","width","height","result"]),transferFunction:new Set(["amplitude","exponent","intercept","offset","slope","tableValues","type"])} |
| const attrsGroupsDefaults={core:{"xml:space":"default"},presentation:{clip:"auto","clip-path":"none","clip-rule":"nonzero",mask:"none",opacity:"1","stop-color":"#000","stop-opacity":"1","fill-opacity":"1","fill-rule":"nonzero",fill:"#000",stroke:"none","stroke-width":"1","stroke-linecap":"butt","stroke-linejoin":"miter","stroke-miterlimit":"4","stroke-dasharray":"none","stroke-dashoffset":"0","stroke-opacity":"1","paint-order":"normal","vector-effect":"none",display:"inline",visibility:"visible","marker-start":"none","marker-mid":"none","marker-end":"none","color-interpolation":"sRGB","color-interpolation-filters":"linearRGB","color-rendering":"auto","shape-rendering":"auto","text-rendering":"auto","image-rendering":"auto","font-style":"normal","font-variant":"normal","font-weight":"normal","font-stretch":"normal","font-size":"medium","font-size-adjust":"none",kerning:"auto","letter-spacing":"normal","word-spacing":"normal","text-decoration":"none","text-anchor":"start","text-overflow":"clip","writing-mode":"lr-tb","glyph-orientation-vertical":"auto","glyph-orientation-horizontal":"0deg",direction:"ltr","unicode-bidi":"normal","dominant-baseline":"auto","alignment-baseline":"baseline","baseline-shift":"baseline"},transferFunction:{slope:"1",intercept:"0",amplitude:"1",exponent:"1",offset:"0"}} |
| const attrsGroupsDeprecated={animationAttributeTarget:{unsafe:new Set(["attributeType"])},conditionalProcessing:{unsafe:new Set(["requiredFeatures"])},core:{unsafe:new Set(["xml:base","xml:lang","xml:space"])},presentation:{unsafe:new Set(["clip","color-profile","enable-background","glyph-orientation-horizontal","glyph-orientation-vertical","kerning"])}} |
| const elems={a:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation","xlink"]),attrs:new Set(["class","externalResourcesRequired","style","target","transform"]),defaults:{target:"_self"},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view","tspan"])},altGlyph:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation","xlink"]),attrs:new Set(["class","dx","dy","externalResourcesRequired","format","glyphRef","rotate","style","x","y"])},altGlyphDef:{attrsGroups:new Set(["core"]),content:new Set(["glyphRef"])},altGlyphItem:{attrsGroups:new Set(["core"]),content:new Set(["glyphRef","altGlyphItem"])},animate:{attrsGroups:new Set(["animationAddition","animationAttributeTarget","animationEvent","animationTiming","animationValue","conditionalProcessing","core","presentation","xlink"]),attrs:new Set(["externalResourcesRequired"]),contentGroups:new Set(["descriptive"])},animateColor:{attrsGroups:new Set(["animationAddition","animationAttributeTarget","animationEvent","animationTiming","animationValue","conditionalProcessing","core","presentation","xlink"]),attrs:new Set(["externalResourcesRequired"]),contentGroups:new Set(["descriptive"])},animateMotion:{attrsGroups:new Set(["animationAddition","animationEvent","animationTiming","animationValue","conditionalProcessing","core","xlink"]),attrs:new Set(["externalResourcesRequired","keyPoints","origin","path","rotate"]),defaults:{rotate:"0"},contentGroups:new Set(["descriptive"]),content:new Set(["mpath"])},animateTransform:{attrsGroups:new Set(["animationAddition","animationAttributeTarget","animationEvent","animationTiming","animationValue","conditionalProcessing","core","xlink"]),attrs:new Set(["externalResourcesRequired","type"]),contentGroups:new Set(["descriptive"])},circle:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","cx","cy","externalResourcesRequired","r","style","transform"]),defaults:{cx:"0",cy:"0"},contentGroups:new Set(["animation","descriptive"])},clipPath:{attrsGroups:new Set(["conditionalProcessing","core","presentation"]),attrs:new Set(["class","clipPathUnits","externalResourcesRequired","style","transform"]),defaults:{clipPathUnits:"userSpaceOnUse"},contentGroups:new Set(["animation","descriptive","shape"]),content:new Set(["text","use"])},"color-profile":{attrsGroups:new Set(["core","xlink"]),attrs:new Set(["local","name","rendering-intent"]),defaults:{name:"sRGB","rendering-intent":"auto"},deprecated:{unsafe:new Set(["name"])},contentGroups:new Set(["descriptive"])},cursor:{attrsGroups:new Set(["core","conditionalProcessing","xlink"]),attrs:new Set(["externalResourcesRequired","x","y"]),defaults:{x:"0",y:"0"},contentGroups:new Set(["descriptive"])},defs:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","style","transform"]),contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},desc:{attrsGroups:new Set(["core"]),attrs:new Set(["class","style"])},ellipse:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","cx","cy","externalResourcesRequired","rx","ry","style","transform"]),defaults:{cx:"0",cy:"0"},contentGroups:new Set(["animation","descriptive"])},feBlend:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style","in","in2","mode"]),defaults:{mode:"normal"},content:new Set(["animate","set"])},feColorMatrix:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style","in","type","values"]),defaults:{type:"matrix"},content:new Set(["animate","set"])},feComponentTransfer:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style","in"]),content:new Set(["feFuncA","feFuncB","feFuncG","feFuncR"])},feComposite:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","in","in2","k1","k2","k3","k4","operator","style"]),defaults:{operator:"over",k1:"0",k2:"0",k3:"0",k4:"0"},content:new Set(["animate","set"])},feConvolveMatrix:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","in","kernelMatrix","order","style","bias","divisor","edgeMode","targetX","targetY","kernelUnitLength","preserveAlpha"]),defaults:{order:"3",bias:"0",edgeMode:"duplicate",preserveAlpha:"false"},content:new Set(["animate","set"])},feDiffuseLighting:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","diffuseConstant","in","kernelUnitLength","style","surfaceScale"]),defaults:{surfaceScale:"1",diffuseConstant:"1"},contentGroups:new Set(["descriptive"]),content:new Set(["feDistantLight","fePointLight","feSpotLight"])},feDisplacementMap:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","in","in2","scale","style","xChannelSelector","yChannelSelector"]),defaults:{scale:"0",xChannelSelector:"A",yChannelSelector:"A"},content:new Set(["animate","set"])},feDistantLight:{attrsGroups:new Set(["core"]),attrs:new Set(["azimuth","elevation"]),defaults:{azimuth:"0",elevation:"0"},content:new Set(["animate","set"])},feFlood:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style"]),content:new Set(["animate","animateColor","set"])},feFuncA:{attrsGroups:new Set(["core","transferFunction"]),content:new Set(["set","animate"])},feFuncB:{attrsGroups:new Set(["core","transferFunction"]),content:new Set(["set","animate"])},feFuncG:{attrsGroups:new Set(["core","transferFunction"]),content:new Set(["set","animate"])},feFuncR:{attrsGroups:new Set(["core","transferFunction"]),content:new Set(["set","animate"])},feGaussianBlur:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style","in","stdDeviation"]),defaults:{stdDeviation:"0"},content:new Set(["set","animate"])},feImage:{attrsGroups:new Set(["core","presentation","filterPrimitive","xlink"]),attrs:new Set(["class","externalResourcesRequired","href","preserveAspectRatio","style","xlink:href"]),defaults:{preserveAspectRatio:"xMidYMid meet"},content:new Set(["animate","animateTransform","set"])},feMerge:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style"]),content:new Set(["feMergeNode"])},feMergeNode:{attrsGroups:new Set(["core"]),attrs:new Set(["in"]),content:new Set(["animate","set"])},feMorphology:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style","in","operator","radius"]),defaults:{operator:"erode",radius:"0"},content:new Set(["animate","set"])},feOffset:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style","in","dx","dy"]),defaults:{dx:"0",dy:"0"},content:new Set(["animate","set"])},fePointLight:{attrsGroups:new Set(["core"]),attrs:new Set(["x","y","z"]),defaults:{x:"0",y:"0",z:"0"},content:new Set(["animate","set"])},feSpecularLighting:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","in","kernelUnitLength","specularConstant","specularExponent","style","surfaceScale"]),defaults:{surfaceScale:"1",specularConstant:"1",specularExponent:"1"},contentGroups:new Set(["descriptive","lightSource"])},feSpotLight:{attrsGroups:new Set(["core"]),attrs:new Set(["limitingConeAngle","pointsAtX","pointsAtY","pointsAtZ","specularExponent","x","y","z"]),defaults:{x:"0",y:"0",z:"0",pointsAtX:"0",pointsAtY:"0",pointsAtZ:"0",specularExponent:"1"},content:new Set(["animate","set"])},feTile:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["class","style","in"]),content:new Set(["animate","set"])},feTurbulence:{attrsGroups:new Set(["core","presentation","filterPrimitive"]),attrs:new Set(["baseFrequency","class","numOctaves","seed","stitchTiles","style","type"]),defaults:{baseFrequency:"0",numOctaves:"1",seed:"0",stitchTiles:"noStitch",type:"turbulence"},content:new Set(["animate","set"])},filter:{attrsGroups:new Set(["core","presentation","xlink"]),attrs:new Set(["class","externalResourcesRequired","filterRes","filterUnits","height","href","primitiveUnits","style","width","x","xlink:href","y"]),defaults:{primitiveUnits:"userSpaceOnUse",x:"-10%",y:"-10%",width:"120%",height:"120%"},deprecated:{unsafe:new Set(["filterRes"])},contentGroups:new Set(["descriptive","filterPrimitive"]),content:new Set(["animate","set"])},font:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","externalResourcesRequired","horiz-adv-x","horiz-origin-x","horiz-origin-y","style","vert-adv-y","vert-origin-x","vert-origin-y"]),defaults:{"horiz-origin-x":"0","horiz-origin-y":"0"},deprecated:{unsafe:new Set(["horiz-origin-x","horiz-origin-y","vert-adv-y","vert-origin-x","vert-origin-y"])},contentGroups:new Set(["descriptive"]),content:new Set(["font-face","glyph","hkern","missing-glyph","vkern"])},"font-face":{attrsGroups:new Set(["core"]),attrs:new Set(["font-family","font-style","font-variant","font-weight","font-stretch","font-size","unicode-range","units-per-em","panose-1","stemv","stemh","slope","cap-height","x-height","accent-height","ascent","descent","widths","bbox","ideographic","alphabetic","mathematical","hanging","v-ideographic","v-alphabetic","v-mathematical","v-hanging","underline-position","underline-thickness","strikethrough-position","strikethrough-thickness","overline-position","overline-thickness"]),defaults:{"font-style":"all","font-variant":"normal","font-weight":"all","font-stretch":"normal","unicode-range":"U+0-10FFFF","units-per-em":"1000","panose-1":"0 0 0 0 0 0 0 0 0 0",slope:"0"},deprecated:{unsafe:new Set(["accent-height","alphabetic","ascent","bbox","cap-height","descent","hanging","ideographic","mathematical","panose-1","slope","stemh","stemv","unicode-range","units-per-em","v-alphabetic","v-hanging","v-ideographic","v-mathematical","widths","x-height"])},contentGroups:new Set(["descriptive"]),content:new Set(["font-face-src"])},"font-face-format":{attrsGroups:new Set(["core"]),attrs:new Set(["string"]),deprecated:{unsafe:new Set(["string"])}},"font-face-name":{attrsGroups:new Set(["core"]),attrs:new Set(["name"]),deprecated:{unsafe:new Set(["name"])}},"font-face-src":{attrsGroups:new Set(["core"]),content:new Set(["font-face-name","font-face-uri"])},"font-face-uri":{attrsGroups:new Set(["core","xlink"]),attrs:new Set(["href","xlink:href"]),content:new Set(["font-face-format"])},foreignObject:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","height","style","transform","width","x","y"]),defaults:{x:"0",y:"0"}},g:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","style","transform"]),contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},glyph:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["arabic-form","class","d","glyph-name","horiz-adv-x","lang","orientation","style","unicode","vert-adv-y","vert-origin-x","vert-origin-y"]),defaults:{"arabic-form":"initial"},deprecated:{unsafe:new Set(["arabic-form","glyph-name","horiz-adv-x","orientation","unicode","vert-adv-y","vert-origin-x","vert-origin-y"])},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},glyphRef:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","d","horiz-adv-x","style","vert-adv-y","vert-origin-x","vert-origin-y"]),deprecated:{unsafe:new Set(["horiz-adv-x","vert-adv-y","vert-origin-x","vert-origin-y"])},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},hatch:{attrsGroups:new Set(["core","presentation","xlink"]),attrs:new Set(["class","hatchContentUnits","hatchUnits","pitch","rotate","style","transform","x","y"]),defaults:{hatchUnits:"objectBoundingBox",hatchContentUnits:"userSpaceOnUse",x:"0",y:"0",pitch:"0",rotate:"0"},contentGroups:new Set(["animation","descriptive"]),content:new Set(["hatchPath"])},hatchPath:{attrsGroups:new Set(["core","presentation","xlink"]),attrs:new Set(["class","style","d","offset"]),defaults:{offset:"0"},contentGroups:new Set(["animation","descriptive"])},hkern:{attrsGroups:new Set(["core"]),attrs:new Set(["u1","g1","u2","g2","k"]),deprecated:{unsafe:new Set(["g1","g2","k","u1","u2"])}},image:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation","xlink"]),attrs:new Set(["class","externalResourcesRequired","height","href","preserveAspectRatio","style","transform","width","x","xlink:href","y"]),defaults:{x:"0",y:"0",preserveAspectRatio:"xMidYMid meet"},contentGroups:new Set(["animation","descriptive"])},line:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","style","transform","x1","x2","y1","y2"]),defaults:{x1:"0",y1:"0",x2:"0",y2:"0"},contentGroups:new Set(["animation","descriptive"])},linearGradient:{attrsGroups:new Set(["core","presentation","xlink"]),attrs:new Set(["class","externalResourcesRequired","gradientTransform","gradientUnits","href","spreadMethod","style","x1","x2","xlink:href","y1","y2"]),defaults:{x1:"0",y1:"0",x2:"100%",y2:"0",spreadMethod:"pad"},contentGroups:new Set(["descriptive"]),content:new Set(["animate","animateTransform","set","stop"])},marker:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","externalResourcesRequired","markerHeight","markerUnits","markerWidth","orient","preserveAspectRatio","refX","refY","style","viewBox"]),defaults:{markerUnits:"strokeWidth",refX:"0",refY:"0",markerWidth:"3",markerHeight:"3"},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},mask:{attrsGroups:new Set(["conditionalProcessing","core","presentation"]),attrs:new Set(["class","externalResourcesRequired","height","mask-type","maskContentUnits","maskUnits","style","width","x","y"]),defaults:{maskUnits:"objectBoundingBox",maskContentUnits:"userSpaceOnUse",x:"-10%",y:"-10%",width:"120%",height:"120%"},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},metadata:{attrsGroups:new Set(["core"])},"missing-glyph":{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","d","horiz-adv-x","style","vert-adv-y","vert-origin-x","vert-origin-y"]),deprecated:{unsafe:new Set(["horiz-adv-x","vert-adv-y","vert-origin-x","vert-origin-y"])},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},mpath:{attrsGroups:new Set(["core","xlink"]),attrs:new Set(["externalResourcesRequired","href","xlink:href"]),contentGroups:new Set(["descriptive"])},path:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","d","externalResourcesRequired","pathLength","style","transform"]),contentGroups:new Set(["animation","descriptive"])},pattern:{attrsGroups:new Set(["conditionalProcessing","core","presentation","xlink"]),attrs:new Set(["class","externalResourcesRequired","height","href","patternContentUnits","patternTransform","patternUnits","preserveAspectRatio","style","viewBox","width","x","xlink:href","y"]),defaults:{patternUnits:"objectBoundingBox",patternContentUnits:"userSpaceOnUse",x:"0",y:"0",width:"0",height:"0",preserveAspectRatio:"xMidYMid meet"},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},polygon:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","points","style","transform"]),contentGroups:new Set(["animation","descriptive"])},polyline:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","points","style","transform"]),contentGroups:new Set(["animation","descriptive"])},radialGradient:{attrsGroups:new Set(["core","presentation","xlink"]),attrs:new Set(["class","cx","cy","externalResourcesRequired","fr","fx","fy","gradientTransform","gradientUnits","href","r","spreadMethod","style","xlink:href"]),defaults:{gradientUnits:"objectBoundingBox",cx:"50%",cy:"50%",r:"50%"},contentGroups:new Set(["descriptive"]),content:new Set(["animate","animateTransform","set","stop"])},meshGradient:{attrsGroups:new Set(["core","presentation","xlink"]),attrs:new Set(["class","style","x","y","gradientUnits","transform"]),contentGroups:new Set(["descriptive","paintServer","animation"]),content:new Set(["meshRow"])},meshRow:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","style"]),contentGroups:new Set(["descriptive"]),content:new Set(["meshPatch"])},meshPatch:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","style"]),contentGroups:new Set(["descriptive"]),content:new Set(["stop"])},rect:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","height","rx","ry","style","transform","width","x","y"]),defaults:{x:"0",y:"0"},contentGroups:new Set(["animation","descriptive"])},script:{attrsGroups:new Set(["core","xlink"]),attrs:new Set(["externalResourcesRequired","type","href","xlink:href"])},set:{attrsGroups:new Set(["animation","animationAttributeTarget","animationTiming","conditionalProcessing","core","xlink"]),attrs:new Set(["externalResourcesRequired","to"]),contentGroups:new Set(["descriptive"])},solidColor:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","style"]),contentGroups:new Set(["paintServer"])},stop:{attrsGroups:new Set(["core","presentation"]),attrs:new Set(["class","style","offset","path"]),content:new Set(["animate","animateColor","set"])},style:{attrsGroups:new Set(["core"]),attrs:new Set(["type","media","title"]),defaults:{type:"text/css"}},svg:{attrsGroups:new Set(["conditionalProcessing","core","documentEvent","graphicalEvent","presentation"]),attrs:new Set(["baseProfile","class","contentScriptType","contentStyleType","height","preserveAspectRatio","style","version","viewBox","width","x","y","zoomAndPan"]),defaults:{x:"0",y:"0",width:"100%",height:"100%",preserveAspectRatio:"xMidYMid meet",zoomAndPan:"magnify",version:"1.1",baseProfile:"none",contentScriptType:"application/ecmascript",contentStyleType:"text/css"},deprecated:{safe:new Set(["version"]),unsafe:new Set(["baseProfile","contentScriptType","contentStyleType","zoomAndPan"])},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},switch:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","style","transform"]),contentGroups:new Set(["animation","descriptive","shape"]),content:new Set(["a","foreignObject","g","image","svg","switch","text","use"])},symbol:{attrsGroups:new Set(["core","graphicalEvent","presentation"]),attrs:new Set(["class","externalResourcesRequired","preserveAspectRatio","refX","refY","style","viewBox"]),defaults:{refX:"0",refY:"0"},contentGroups:new Set(["animation","descriptive","paintServer","shape","structural"]),content:new Set(["a","altGlyphDef","clipPath","color-profile","cursor","filter","font-face","font","foreignObject","image","marker","mask","pattern","script","style","switch","text","view"])},text:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","dx","dy","externalResourcesRequired","lengthAdjust","rotate","style","textLength","transform","x","y"]),defaults:{x:"0",y:"0",lengthAdjust:"spacing"},contentGroups:new Set(["animation","descriptive","textContentChild"]),content:new Set(["a"])},textPath:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation","xlink"]),attrs:new Set(["class","d","externalResourcesRequired","href","method","spacing","startOffset","style","xlink:href"]),defaults:{startOffset:"0",method:"align",spacing:"exact"},contentGroups:new Set(["descriptive"]),content:new Set(["a","altGlyph","animate","animateColor","set","tref","tspan"])},title:{attrsGroups:new Set(["core"]),attrs:new Set(["class","style"])},tref:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation","xlink"]),attrs:new Set(["class","externalResourcesRequired","href","style","xlink:href"]),contentGroups:new Set(["descriptive"]),content:new Set(["animate","animateColor","set"])},tspan:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation"]),attrs:new Set(["class","dx","dy","externalResourcesRequired","lengthAdjust","rotate","style","textLength","x","y"]),contentGroups:new Set(["descriptive"]),content:new Set(["a","altGlyph","animate","animateColor","set","tref","tspan"])},use:{attrsGroups:new Set(["conditionalProcessing","core","graphicalEvent","presentation","xlink"]),attrs:new Set(["class","externalResourcesRequired","height","href","style","transform","width","x","xlink:href","y"]),defaults:{x:"0",y:"0"},contentGroups:new Set(["animation","descriptive"])},view:{attrsGroups:new Set(["core"]),attrs:new Set(["externalResourcesRequired","preserveAspectRatio","viewBox","viewTarget","zoomAndPan"]),deprecated:{unsafe:new Set(["viewTarget","zoomAndPan"])},contentGroups:new Set(["descriptive"])},vkern:{attrsGroups:new Set(["core"]),attrs:new Set(["u1","g1","u2","g2","k"]),deprecated:{unsafe:new Set(["g1","g2","k","u1","u2"])}}} |
| const editorNamespaces=new Set(["http://creativecommons.org/ns#","http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd","http://ns.adobe.com/AdobeIllustrator/10.0/","http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/","http://ns.adobe.com/Extensibility/1.0/","http://ns.adobe.com/Flows/1.0/","http://ns.adobe.com/GenericCustomNamespace/1.0/","http://ns.adobe.com/Graphs/1.0/","http://ns.adobe.com/ImageReplacement/1.0/","http://ns.adobe.com/SaveForWeb/1.0/","http://ns.adobe.com/Variables/1.0/","http://ns.adobe.com/XPath/1.0/","http://purl.org/dc/elements/1.1/","http://schemas.microsoft.com/visio/2003/SVGExtensions/","http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd","http://taptrix.com/vectorillustrator/svg_extensions","http://www.bohemiancoding.com/sketch/ns","http://www.figma.com/figma/ns","http://www.inkscape.org/namespaces/inkscape","http://www.serif.com/","http://www.vector.evaxdesign.sk","http://www.w3.org/1999/02/22-rdf-syntax-ns#"]) |
| const referencesProps=new Set(["clip-path","color-profile","fill","filter","marker-end","marker-mid","marker-start","mask","stroke","style"]) |
| const inheritableAttrs=new Set(["clip-rule","color-interpolation-filters","color-interpolation","color-profile","color-rendering","color","cursor","direction","dominant-baseline","fill-opacity","fill-rule","fill","font-family","font-size-adjust","font-size","font-stretch","font-style","font-variant","font-weight","font","glyph-orientation-horizontal","glyph-orientation-vertical","image-rendering","letter-spacing","marker-end","marker-mid","marker-start","marker","paint-order","pointer-events","shape-rendering","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","stroke","text-anchor","text-rendering","transform","visibility","word-spacing","writing-mode"]) |
| const presentationNonInheritableGroupAttrs=new Set(["clip-path","display","filter","mask","opacity","text-decoration","transform","unicode-bidi"]) |
| const colorsNames={aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#0ff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000",blanchedalmond:"#ffebcd",blue:"#00f",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyan:"#0ff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#f0f",gainsboro:"#dcdcdc",ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",green:"#008000",greenyellow:"#adff2f",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgreen:"#90ee90",lightgrey:"#d3d3d3",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#789",lightslategrey:"#789",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#0f0",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#f0f",maroon:"#800000",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370db",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#db7093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",rebeccapurple:"#639",red:"#f00",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",steelblue:"#4682b4",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",tomato:"#ff6347",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#fff",whitesmoke:"#f5f5f5",yellow:"#ff0",yellowgreen:"#9acd32"} |
| const colorsShortNames={"#f0ffff":"azure","#f5f5dc":"beige","#ffe4c4":"bisque","#a52a2a":"brown","#ff7f50":"coral","#ffd700":"gold","#808080":"gray","#008000":"green","#4b0082":"indigo","#fffff0":"ivory","#f0e68c":"khaki","#faf0e6":"linen","#800000":"maroon","#000080":"navy","#808000":"olive","#ffa500":"orange","#da70d6":"orchid","#cd853f":"peru","#ffc0cb":"pink","#dda0dd":"plum","#800080":"purple","#f00":"red","#ff0000":"red","#fa8072":"salmon","#a0522d":"sienna","#c0c0c0":"silver","#fffafa":"snow","#d2b48c":"tan","#008080":"teal","#ff6347":"tomato","#ee82ee":"violet","#f5deb3":"wheat"} |
| const colorsProps=new Set(["color","fill","flood-color","lighting-color","stop-color","stroke"]) |
| const pseudoClasses={displayState:new Set(["fullscreen","modal","picture-in-picture"]),input:new Set(["autofill","blank","checked","default","disabled","enabled","in-range","indetermined","invalid","optional","out-of-range","placeholder-shown","read-only","read-write","required","user-invalid","valid"]),linguistic:new Set(["dir","lang"]),location:new Set(["any-link","link","local-link","scope","target-within","target","visited"]),resourceState:new Set(["playing","paused"]),timeDimensional:new Set(["current","past","future"]),treeStructural:new Set(["empty","first-child","first-of-type","last-child","last-of-type","nth-child","nth-last-child","nth-last-of-type","nth-of-type","only-child","only-of-type","root"]),userAction:new Set(["active","focus-visible","focus-within","focus","hover"]),functional:new Set(["is","not","where","has"])} |
| class SvgoParserError extends Error{constructor(message,line,column,source,file){super(message) |
| this.name="SvgoParserError" |
| this.message=`${file||"<input>"}:${line}:${column}: ${message}` |
| this.reason=message |
| this.line=line |
| this.column=column |
| this.source=source |
| Error.captureStackTrace&&Error.captureStackTrace(this,SvgoParserError)}toString(){const lines=this.source.split(/\r?\n/) |
| const startLine=Math.max(this.line-3,0) |
| const endLine=Math.min(this.line+2,lines.length) |
| const lineNumberWidth=String(endLine).length |
| const startColumn=Math.max(this.column-54,0) |
| const endColumn=Math.max(this.column+20,80) |
| const code=lines.slice(startLine,endLine).map(((line,index)=>{const lineSlice=line.slice(startColumn,endColumn) |
| let ellipsisPrefix="" |
| let ellipsisSuffix="" |
| startColumn!==0&&(ellipsisPrefix=startColumn>line.length-1?" ":"…") |
| endColumn<line.length-1&&(ellipsisSuffix="…") |
| const number=startLine+1+index |
| const gutter=` ${number.toString().padStart(lineNumberWidth)} | ` |
| if(number===this.line){const gutterSpacing=gutter.replace(/[^|]/g," ") |
| const lineSpacing=(ellipsisPrefix+line.slice(startColumn,this.column-1)).replace(/[^\t]/g," ") |
| const spacing=gutterSpacing+lineSpacing |
| return`>${gutter}${ellipsisPrefix}${lineSlice}${ellipsisSuffix}\n ${spacing}^`}return` ${gutter}${ellipsisPrefix}${lineSlice}${ellipsisSuffix}`})).join("\n") |
| return`${this.name}: ${this.message}\n\n${code}\n`}}const entityDeclaration=/<!ENTITY\s+(\S+)\s+(?:'([^']+)'|"([^"]+)")\s*>/g |
| const config={strict:true,trim:false,normalize:false,lowercase:true,xmlns:true,position:true} |
| const parseSvg=(data,from)=>{const sax=SAX.parser(config.strict,config) |
| const root={type:"root",children:[]} |
| let current=root |
| const stack=[root] |
| const pushToContent=node=>{Object.defineProperty(node,"parentNode",{writable:true,value:current}) |
| current.children.push(node)} |
| sax.ondoctype=doctype=>{const node={type:"doctype",name:"svg",data:{doctype:doctype}} |
| pushToContent(node) |
| const subsetStart=doctype.indexOf("[") |
| if(subsetStart>=0){entityDeclaration.lastIndex=subsetStart |
| let entityMatch=entityDeclaration.exec(data) |
| while(entityMatch!=null){sax.ENTITIES[entityMatch[1]]=entityMatch[2]||entityMatch[3] |
| entityMatch=entityDeclaration.exec(data)}}} |
| sax.onprocessinginstruction=data=>{const node={type:"instruction",name:data.name,value:data.body} |
| pushToContent(node)} |
| sax.oncomment=comment=>{const node={type:"comment",value:comment.trim()} |
| pushToContent(node)} |
| sax.oncdata=cdata=>{const node={type:"cdata",value:cdata} |
| pushToContent(node)} |
| sax.onopentag=data=>{let element={type:"element",name:data.name,attributes:{},children:[]} |
| for(const[name,attr]of Object.entries(data.attributes))element.attributes[name]=attr.value |
| pushToContent(element) |
| current=element |
| stack.push(element)} |
| sax.ontext=text=>{if(current.type==="element")if(textElems.has(current.name)){const node={type:"text",value:text} |
| pushToContent(node)}else if(/\S/.test(text)){const node={type:"text",value:text.trim()} |
| pushToContent(node)}} |
| sax.onclosetag=()=>{stack.pop() |
| current=stack[stack.length-1]} |
| sax.onerror=e=>{const error=new SvgoParserError(e.reason,e.line+1,e.column,data,from) |
| if(e.message.indexOf("Unexpected end")===-1)throw error} |
| sax.write(data).close() |
| return root} |
| const encodeEntity=char=>entities[char] |
| const defaults={doctypeStart:"<!DOCTYPE",doctypeEnd:">",procInstStart:"<?",procInstEnd:"?>",tagOpenStart:"<",tagOpenEnd:">",tagCloseStart:"</",tagCloseEnd:">",tagShortStart:"<",tagShortEnd:"/>",attrStart:'="',attrEnd:'"',commentStart:"\x3c!--",commentEnd:"--\x3e",cdataStart:"<![CDATA[",cdataEnd:"]]>",textStart:"",textEnd:"",indent:4,regEntities:/[&'"<>]/g,regValEntities:/[&"<>]/g,encodeEntity:encodeEntity,pretty:false,useShortTags:true,eol:"lf",finalNewline:false} |
| const entities={"&":"&","'":"'",'"':""",">":">","<":"<"} |
| const stringifySvg=(data,userOptions={})=>{const config={...defaults,...userOptions} |
| const indent=config.indent |
| let newIndent=" " |
| typeof indent==="number"&&Number.isNaN(indent)===false?newIndent=indent<0?"\t":" ".repeat(indent):typeof indent==="string"&&(newIndent=indent) |
| const state={indent:newIndent,textContext:null,indentLevel:0} |
| const eol=config.eol==="crlf"?"\r\n":"\n" |
| if(config.pretty){config.doctypeEnd+=eol |
| config.procInstEnd+=eol |
| config.commentEnd+=eol |
| config.cdataEnd+=eol |
| config.tagShortEnd+=eol |
| config.tagOpenEnd+=eol |
| config.tagCloseEnd+=eol |
| config.textEnd+=eol}let svg=stringifyNode(data,config,state) |
| config.finalNewline&&svg.length>0&&!svg.endsWith("\n")&&(svg+=eol) |
| return svg} |
| const stringifyNode=(data,config,state)=>{let svg="" |
| state.indentLevel+=1 |
| for(const item of data.children){item.type==="element"&&(svg+=stringifyElement(item,config,state)) |
| item.type==="text"&&(svg+=stringifyText(item,config,state)) |
| item.type==="doctype"&&(svg+=stringifyDoctype(item,config)) |
| item.type==="instruction"&&(svg+=stringifyInstruction(item,config)) |
| item.type==="comment"&&(svg+=stringifyComment(item,config)) |
| item.type==="cdata"&&(svg+=stringifyCdata(item,config,state))}state.indentLevel-=1 |
| return svg} |
| const createIndent=(config,state)=>{let indent="" |
| config.pretty&&state.textContext==null&&(indent=state.indent.repeat(state.indentLevel-1)) |
| return indent} |
| const stringifyDoctype=(node,config)=>config.doctypeStart+node.data.doctype+config.doctypeEnd |
| const stringifyInstruction=(node,config)=>config.procInstStart+node.name+" "+node.value+config.procInstEnd |
| const stringifyComment=(node,config)=>config.commentStart+node.value+config.commentEnd |
| const stringifyCdata=(node,config,state)=>createIndent(config,state)+config.cdataStart+node.value+config.cdataEnd |
| const stringifyElement=(node,config,state)=>{if(node.children.length===0)return config.useShortTags?createIndent(config,state)+config.tagShortStart+node.name+stringifyAttributes(node,config)+config.tagShortEnd:createIndent(config,state)+config.tagShortStart+node.name+stringifyAttributes(node,config)+config.tagOpenEnd+config.tagCloseStart+node.name+config.tagCloseEnd |
| {let tagOpenStart=config.tagOpenStart |
| let tagOpenEnd=config.tagOpenEnd |
| let tagCloseStart=config.tagCloseStart |
| let tagCloseEnd=config.tagCloseEnd |
| let openIndent=createIndent(config,state) |
| let closeIndent=createIndent(config,state) |
| if(state.textContext){tagOpenStart=defaults.tagOpenStart |
| tagOpenEnd=defaults.tagOpenEnd |
| tagCloseStart=defaults.tagCloseStart |
| tagCloseEnd=defaults.tagCloseEnd |
| openIndent=""}else if(textElems.has(node.name)){tagOpenEnd=defaults.tagOpenEnd |
| tagCloseStart=defaults.tagCloseStart |
| closeIndent="" |
| state.textContext=node}const children=stringifyNode(node,config,state) |
| state.textContext===node&&(state.textContext=null) |
| return openIndent+tagOpenStart+node.name+stringifyAttributes(node,config)+tagOpenEnd+children+closeIndent+tagCloseStart+node.name+tagCloseEnd}} |
| const stringifyAttributes=(node,config)=>{let attrs="" |
| for(const[name,value]of Object.entries(node.attributes))if(value!==void 0){const encodedValue=value.toString().replace(config.regValEntities,config.encodeEntity) |
| attrs+=" "+name+config.attrStart+encodedValue+config.attrEnd}else attrs+=" "+name |
| return attrs} |
| const stringifyText=(node,config,state)=>createIndent(config,state)+config.textStart+node.value.replace(config.regEntities,config.encodeEntity)+(state.textContext?"":config.textEnd) |
| const isTag=node=>node.type==="element" |
| const existsOne=(test,elems)=>elems.some((elem=>!!isTag(elem)&&(test(elem)||existsOne(test,getChildren(elem))))) |
| const getAttributeValue=(elem,name)=>elem.attributes[name] |
| const getChildren=node=>node.children||[] |
| const getName=elemAst=>elemAst.name |
| const getParent=node=>node.parentNode||null |
| const getSiblings=elem=>{var parent=getParent(elem) |
| return parent?getChildren(parent):[]} |
| const getText=node=>{if(node.children[0].type==="text"&&node.children[0].type==="cdata")return node.children[0].value |
| return""} |
| const hasAttrib=(elem,name)=>elem.attributes[name]!==void 0 |
| const removeSubsets=nodes=>{let idx=nodes.length |
| let node |
| let ancestor |
| let replace |
| while(--idx>-1){node=ancestor=nodes[idx] |
| nodes[idx]=null |
| replace=true |
| while(ancestor){if(nodes.includes(ancestor)){replace=false |
| nodes.splice(idx,1) |
| break}ancestor=getParent(ancestor)}replace&&(nodes[idx]=node)}return nodes} |
| const findAll=(test,elems)=>{const result=[] |
| for(const elem of elems)if(isTag(elem)){test(elem)&&result.push(elem) |
| result.push(...findAll(test,getChildren(elem)))}return result} |
| const findOne=(test,elems)=>{for(const elem of elems)if(isTag(elem)){if(test(elem))return elem |
| const result=findOne(test,getChildren(elem)) |
| if(result)return result}return null} |
| const svgoCssSelectAdapter={isTag:isTag,existsOne:existsOne,getAttributeValue:getAttributeValue,getChildren:getChildren,getName:getName,getParent:getParent,getSiblings:getSiblings,getText:getText,hasAttrib:hasAttrib,removeSubsets:removeSubsets,findAll:findAll,findOne:findOne} |
| const cssSelectOptions={xmlMode:true,adapter:svgoCssSelectAdapter} |
| const querySelectorAll=(node,selector)=>cssSelect.selectAll(selector,node,cssSelectOptions) |
| const querySelector=(node,selector)=>cssSelect.selectOne(selector,node,cssSelectOptions) |
| const matches=(node,selector)=>cssSelect.is(node,selector,cssSelectOptions) |
| const visitSkip=Symbol() |
| const visit=(node,visitor,parentNode)=>{const callbacks=visitor[node.type] |
| if(callbacks&&callbacks.enter){const symbol=callbacks.enter(node,parentNode) |
| if(symbol===visitSkip)return}if(node.type==="root")for(const child of node.children)visit(child,visitor,node) |
| if(node.type==="element"&&parentNode.children.includes(node))for(const child of node.children)visit(child,visitor,node) |
| callbacks&&callbacks.exit&&callbacks.exit(node,parentNode)} |
| const detachNodeFromParent=(node,parentNode)=>{parentNode.children=parentNode.children.filter((child=>child!==node))} |
| const invokePlugins=(ast,info,plugins,overrides,globalOverrides)=>{for(const plugin of plugins){const override=overrides?.[plugin.name] |
| if(override===false)continue |
| const params={...plugin.params,...globalOverrides,...override} |
| const visitor=plugin.fn(ast,params,info) |
| visitor!=null&&visit(ast,visitor)}} |
| const createPreset=({name:name,plugins:plugins})=>({name:name,fn:(ast,params,info)=>{const{floatPrecision:floatPrecision,overrides:overrides}=params |
| const globalOverrides={} |
| floatPrecision!=null&&(globalOverrides.floatPrecision=floatPrecision) |
| if(overrides){const pluginNames=plugins.map((({name:name})=>name)) |
| for(const pluginName of Object.keys(overrides))pluginNames.includes(pluginName)||console.warn(`You are trying to configure ${pluginName} which is not part of ${name}.\nTry to put it before or after, for example\n\nplugins: [\n {\n name: '${name}',\n },\n '${pluginName}'\n]\n`)}invokePlugins(ast,info,plugins,overrides,globalOverrides)}}) |
| const name$Q="removeDoctype" |
| const description$Q="removes doctype declaration" |
| const fn$Q=()=>({doctype:{enter:(node,parentNode)=>{detachNodeFromParent(node,parentNode)}}}) |
| var removeDoctype=Object.freeze({__proto__:null,description:description$Q,fn:fn$Q,name:name$Q}) |
| const name$P="removeXMLProcInst" |
| const description$P="removes XML processing instructions" |
| const fn$P=()=>({instruction:{enter:(node,parentNode)=>{node.name==="xml"&&detachNodeFromParent(node,parentNode)}}}) |
| var removeXMLProcInst=Object.freeze({__proto__:null,description:description$P,fn:fn$P,name:name$P}) |
| const name$O="removeComments" |
| const description$O="removes comments" |
| const DEFAULT_PRESERVE_PATTERNS=[/^!/] |
| const fn$O=(_root,params)=>{const{preservePatterns:preservePatterns=DEFAULT_PRESERVE_PATTERNS}=params |
| return{comment:{enter:(node,parentNode)=>{if(preservePatterns){if(!Array.isArray(preservePatterns))throw Error(`Expected array in removeComments preservePatterns parameter but received ${preservePatterns}`) |
| const matches=preservePatterns.some((pattern=>new RegExp(pattern).test(node.value))) |
| if(matches)return}detachNodeFromParent(node,parentNode)}}}} |
| var removeComments=Object.freeze({__proto__:null,description:description$O,fn:fn$O,name:name$O}) |
| const csstreeWalkSkip=csstree__namespace.walk.skip |
| const parseRule=(ruleNode,dynamic)=>{const declarations=[] |
| ruleNode.block.children.forEach((cssNode=>{cssNode.type==="Declaration"&&declarations.push({name:cssNode.property,value:csstree__namespace.generate(cssNode.value),important:cssNode.important===true})})) |
| const rules=[] |
| csstree__namespace.walk(ruleNode.prelude,(node=>{if(node.type==="Selector"){const newNode=csstree__namespace.clone(node) |
| let hasPseudoClasses=false |
| csstree__namespace.walk(newNode,((pseudoClassNode,item,list)=>{if(pseudoClassNode.type==="PseudoClassSelector"){hasPseudoClasses=true |
| list.remove(item)}})) |
| rules.push({specificity:csso.syntax.specificity(node),dynamic:hasPseudoClasses||dynamic,selector:csstree__namespace.generate(newNode),declarations:declarations})}})) |
| return rules} |
| const parseStylesheet=(css,dynamic)=>{const rules=[] |
| const ast=csstree__namespace.parse(css,{parseValue:false,parseAtrulePrelude:false}) |
| csstree__namespace.walk(ast,(cssNode=>{if(cssNode.type==="Rule"){rules.push(...parseRule(cssNode,dynamic||false)) |
| return csstreeWalkSkip}if(cssNode.type==="Atrule"){if(cssNode.name==="keyframes"||cssNode.name==="-webkit-keyframes")return csstreeWalkSkip |
| csstree__namespace.walk(cssNode,(ruleNode=>{if(ruleNode.type==="Rule"){rules.push(...parseRule(ruleNode,dynamic||true)) |
| return csstreeWalkSkip}})) |
| return csstreeWalkSkip}})) |
| return rules} |
| const parseStyleDeclarations=css=>{const declarations=[] |
| const ast=csstree__namespace.parse(css,{context:"declarationList",parseValue:false}) |
| csstree__namespace.walk(ast,(cssNode=>{cssNode.type==="Declaration"&&declarations.push({name:cssNode.property,value:csstree__namespace.generate(cssNode.value),important:cssNode.important===true})})) |
| return declarations} |
| const computeOwnStyle=(stylesheet,node)=>{const computedStyle={} |
| const importantStyles=new Map |
| for(const[name,value]of Object.entries(node.attributes))if(attrsGroups.presentation.has(name)){computedStyle[name]={type:"static",inherited:false,value:value} |
| importantStyles.set(name,false)}for(const{selector:selector,declarations:declarations,dynamic:dynamic}of stylesheet.rules)if(matches(node,selector))for(const{name:name,value:value,important:important}of declarations){const computed=computedStyle[name] |
| if(computed&&computed.type==="dynamic")continue |
| if(dynamic){computedStyle[name]={type:"dynamic",inherited:false} |
| continue}if(computed==null||important===true||importantStyles.get(name)===false){computedStyle[name]={type:"static",inherited:false,value:value} |
| importantStyles.set(name,important)}}const styleDeclarations=node.attributes.style==null?[]:parseStyleDeclarations(node.attributes.style) |
| for(const{name:name,value:value,important:important}of styleDeclarations){const computed=computedStyle[name] |
| if(computed&&computed.type==="dynamic")continue |
| if(computed==null||important===true||importantStyles.get(name)===false){computedStyle[name]={type:"static",inherited:false,value:value} |
| importantStyles.set(name,important)}}return computedStyle} |
| const compareSpecificity=(a,b)=>{for(let i=0;i<4;i+=1){if(a[i]<b[i])return-1 |
| if(a[i]>b[i])return 1}return 0} |
| const collectStylesheet=root=>{const rules=[] |
| const parents=new Map |
| visit(root,{element:{enter:(node,parentNode)=>{parents.set(node,parentNode) |
| if(node.name!=="style")return |
| if(node.attributes.type==null||node.attributes.type===""||node.attributes.type==="text/css"){const dynamic=node.attributes.media!=null&&node.attributes.media!=="all" |
| for(const child of node.children)child.type!=="text"&&child.type!=="cdata"||rules.push(...parseStylesheet(child.value,dynamic))}}}}) |
| rules.sort(((a,b)=>compareSpecificity(a.specificity,b.specificity))) |
| return{rules:rules,parents:parents}} |
| const computeStyle=(stylesheet,node)=>{const{parents:parents}=stylesheet |
| const computedStyles=computeOwnStyle(stylesheet,node) |
| let parent=parents.get(node) |
| while(parent!=null&&parent.type!=="root"){const inheritedStyles=computeOwnStyle(stylesheet,parent) |
| for(const[name,computed]of Object.entries(inheritedStyles))computedStyles[name]==null&&inheritableAttrs.has(name)&&!presentationNonInheritableGroupAttrs.has(name)&&(computedStyles[name]={...computed,inherited:true}) |
| parent=parents.get(parent)}return computedStyles} |
| const includesAttrSelector=(selector,name,value=null,traversed=false)=>{const selectors=typeof selector==="string"?csswhat__namespace.parse(selector):csswhat__namespace.parse(csstree__namespace.generate(selector.data)) |
| for(const subselector of selectors){const hasAttrSelector=subselector.some(((segment,index)=>{if(traversed){if(index===subselector.length-1)return false |
| const isNextTraversal=csswhat__namespace.isTraversal(subselector[index+1]) |
| if(!isNextTraversal)return false}if(segment.type!=="attribute"||segment.name!==name)return false |
| return value==null||segment.value===value})) |
| if(hasAttrSelector)return true}return false} |
| const name$N="removeDeprecatedAttrs" |
| const description$N="removes deprecated attributes" |
| function extractAttributesInStylesheet(stylesheet){const attributesInStylesheet=new Set |
| stylesheet.rules.forEach((rule=>{const selectors=csswhat__namespace.parse(rule.selector) |
| selectors.forEach((subselector=>{subselector.forEach((segment=>{if(segment.type!=="attribute")return |
| attributesInStylesheet.add(segment.name)}))}))})) |
| return attributesInStylesheet}function processAttributes(node,deprecatedAttrs,params,attributesInStylesheet){if(!deprecatedAttrs)return |
| deprecatedAttrs.safe&&deprecatedAttrs.safe.forEach((name=>{if(attributesInStylesheet.has(name))return |
| delete node.attributes[name]})) |
| params.removeUnsafe&&deprecatedAttrs.unsafe&&deprecatedAttrs.unsafe.forEach((name=>{if(attributesInStylesheet.has(name))return |
| delete node.attributes[name]}))}function fn$N(root,params){const stylesheet=collectStylesheet(root) |
| const attributesInStylesheet=extractAttributesInStylesheet(stylesheet) |
| return{element:{enter:node=>{const elemConfig=elems[node.name] |
| if(!elemConfig)return |
| elemConfig.attrsGroups.has("core")&&node.attributes["xml:lang"]&&!attributesInStylesheet.has("xml:lang")&&node.attributes["lang"]&&delete node.attributes["xml:lang"] |
| elemConfig.attrsGroups.forEach((attrsGroup=>{processAttributes(node,attrsGroupsDeprecated[attrsGroup],params,attributesInStylesheet)})) |
| processAttributes(node,elemConfig.deprecated,params,attributesInStylesheet)}}}}var removeDeprecatedAttrs=Object.freeze({__proto__:null,description:description$N,fn:fn$N,name:name$N}) |
| const name$M="removeMetadata" |
| const description$M="removes <metadata>" |
| const fn$M=()=>({element:{enter:(node,parentNode)=>{node.name==="metadata"&&detachNodeFromParent(node,parentNode)}}}) |
| var removeMetadata=Object.freeze({__proto__:null,description:description$M,fn:fn$M,name:name$M}) |
| const name$L="removeEditorsNSData" |
| const description$L="removes editors namespaces, elements and attributes" |
| const fn$L=(_root,params)=>{let namespaces=[...editorNamespaces] |
| Array.isArray(params.additionalNamespaces)&&(namespaces=[...editorNamespaces,...params.additionalNamespaces]) |
| const prefixes=[] |
| return{element:{enter:(node,parentNode)=>{if(node.name==="svg")for(const[name,value]of Object.entries(node.attributes))if(name.startsWith("xmlns:")&&namespaces.includes(value)){prefixes.push(name.slice(6)) |
| delete node.attributes[name]}for(const name of Object.keys(node.attributes))if(name.includes(":")){const[prefix]=name.split(":") |
| prefixes.includes(prefix)&&delete node.attributes[name]}if(node.name.includes(":")){const[prefix]=node.name.split(":") |
| prefixes.includes(prefix)&&detachNodeFromParent(node,parentNode)}}}}} |
| var removeEditorsNSData=Object.freeze({__proto__:null,description:description$L,fn:fn$L,name:name$L}) |
| const name$K="cleanupAttrs" |
| const description$K="cleanups attributes from newlines, trailing and repeating spaces" |
| const regNewlinesNeedSpace=/(\S)\r?\n(\S)/g |
| const regNewlines=/\r?\n/g |
| const regSpaces=/\s{2,}/g |
| const fn$K=(root,params)=>{const{newlines:newlines=true,trim:trim=true,spaces:spaces=true}=params |
| return{element:{enter:node=>{for(const name of Object.keys(node.attributes)){if(newlines){node.attributes[name]=node.attributes[name].replace(regNewlinesNeedSpace,((match,p1,p2)=>p1+" "+p2)) |
| node.attributes[name]=node.attributes[name].replace(regNewlines,"")}trim&&(node.attributes[name]=node.attributes[name].trim()) |
| spaces&&(node.attributes[name]=node.attributes[name].replace(regSpaces," "))}}}}} |
| var cleanupAttrs=Object.freeze({__proto__:null,description:description$K,fn:fn$K,name:name$K}) |
| const name$J="mergeStyles" |
| const description$J="merge multiple style elements into one" |
| const fn$J=()=>{let firstStyleElement=null |
| let collectedStyles="" |
| let styleContentType="text" |
| return{element:{enter:(node,parentNode)=>{if(node.name==="foreignObject")return visitSkip |
| if(node.name!=="style")return |
| if(node.attributes.type!=null&&node.attributes.type!==""&&node.attributes.type!=="text/css")return |
| let css="" |
| for(const child of node.children){child.type==="text"&&(css+=child.value) |
| if(child.type==="cdata"){styleContentType="cdata" |
| css+=child.value}}if(css.trim().length===0){detachNodeFromParent(node,parentNode) |
| return}if(node.attributes.media==null)collectedStyles+=css |
| else{collectedStyles+=`@media ${node.attributes.media}{${css}}` |
| delete node.attributes.media}if(firstStyleElement==null)firstStyleElement=node |
| else{detachNodeFromParent(node,parentNode) |
| const child={type:styleContentType,value:collectedStyles} |
| Object.defineProperty(child,"parentNode",{writable:true,value:firstStyleElement}) |
| firstStyleElement.children=[child]}}}}} |
| var mergeStyles=Object.freeze({__proto__:null,description:description$J,fn:fn$J,name:name$J}) |
| const name$I="inlineStyles" |
| const description$I="inline styles (additional options)" |
| const preservedPseudos=[...pseudoClasses.functional,...pseudoClasses.treeStructural] |
| const fn$I=(root,params)=>{const{onlyMatchedOnce:onlyMatchedOnce=true,removeMatchedSelectors:removeMatchedSelectors=true,useMqs:useMqs=["","screen"],usePseudos:usePseudos=[""]}=params |
| const styles=[] |
| let selectors=[] |
| return{element:{enter:(node,parentNode)=>{if(node.name==="foreignObject")return visitSkip |
| if(node.name!=="style"||node.children.length===0)return |
| if(node.attributes.type!=null&&node.attributes.type!==""&&node.attributes.type!=="text/css")return |
| const cssText=node.children.filter((child=>child.type==="text"||child.type==="cdata")).map((child=>child.value)).join("") |
| let cssAst=null |
| try{cssAst=csstree__namespace.parse(cssText,{parseValue:false,parseCustomProperty:false})}catch{return}cssAst.type==="StyleSheet"&&styles.push({node:node,parentNode:parentNode,cssAst:cssAst}) |
| csstree__namespace.walk(cssAst,{visit:"Rule",enter(node){const atrule=this.atrule |
| let mediaQuery="" |
| if(atrule!=null){mediaQuery=atrule.name |
| atrule.prelude!=null&&(mediaQuery+=` ${csstree__namespace.generate(atrule.prelude)}`)}if(!useMqs.includes(mediaQuery))return |
| node.prelude.type==="SelectorList"&&node.prelude.children.forEach(((childNode,item)=>{if(childNode.type==="Selector"){const pseudos=[] |
| childNode.children.forEach(((grandchildNode,grandchildItem,grandchildList)=>{const isPseudo=grandchildNode.type==="PseudoClassSelector"||grandchildNode.type==="PseudoElementSelector" |
| isPseudo&&!preservedPseudos.includes(grandchildNode.name)&&pseudos.push({item:grandchildItem,list:grandchildList})})) |
| const pseudoSelectors=csstree__namespace.generate({type:"Selector",children:(new csstree__namespace.List).fromArray(pseudos.map((pseudo=>pseudo.item.data)))}) |
| if(usePseudos.includes(pseudoSelectors))for(const pseudo of pseudos)pseudo.list.remove(pseudo.item) |
| selectors.push({node:childNode,rule:node,item:item})}}))}})}},root:{exit:()=>{if(styles.length===0)return |
| const sortedSelectors=selectors.slice().sort(((a,b)=>{const aSpecificity=csso.syntax.specificity(a.item.data) |
| const bSpecificity=csso.syntax.specificity(b.item.data) |
| return compareSpecificity(aSpecificity,bSpecificity)})).reverse() |
| for(const selector of sortedSelectors){const selectorText=csstree__namespace.generate(selector.item.data) |
| const matchedElements=[] |
| try{for(const node of querySelectorAll(root,selectorText))node.type==="element"&&matchedElements.push(node)}catch(selectError){continue}if(matchedElements.length===0)continue |
| if(onlyMatchedOnce&&matchedElements.length>1)continue |
| for(const selectedEl of matchedElements){const styleDeclarationList=csstree__namespace.parse(selectedEl.attributes.style??"",{context:"declarationList",parseValue:false}) |
| if(styleDeclarationList.type!=="DeclarationList")continue |
| const styleDeclarationItems=new Map |
| let firstListItem |
| csstree__namespace.walk(styleDeclarationList,{visit:"Declaration",enter(node,item){firstListItem==null&&(firstListItem=item) |
| styleDeclarationItems.set(node.property.toLowerCase(),item)}}) |
| csstree__namespace.walk(selector.rule,{visit:"Declaration",enter(ruleDeclaration){const property=ruleDeclaration.property |
| attrsGroups.presentation.has(property)&&!selectors.some((selector=>includesAttrSelector(selector.item,property)))&&delete selectedEl.attributes[property] |
| const matchedItem=styleDeclarationItems.get(property) |
| const ruleDeclarationItem=styleDeclarationList.children.createItem(ruleDeclaration) |
| if(matchedItem==null)styleDeclarationList.children.insert(ruleDeclarationItem,firstListItem) |
| else if(matchedItem.data.important!==true&&ruleDeclaration.important===true){styleDeclarationList.children.replace(matchedItem,ruleDeclarationItem) |
| styleDeclarationItems.set(property,ruleDeclarationItem)}}}) |
| const newStyles=csstree__namespace.generate(styleDeclarationList) |
| newStyles.length!==0&&(selectedEl.attributes.style=newStyles)}removeMatchedSelectors&&matchedElements.length!==0&&selector.rule.prelude.type==="SelectorList"&&selector.rule.prelude.children.remove(selector.item) |
| selector.matchedElements=matchedElements}if(!removeMatchedSelectors)return |
| for(const selector of sortedSelectors){if(selector.matchedElements==null)continue |
| if(onlyMatchedOnce&&selector.matchedElements.length>1)continue |
| for(const selectedEl of selector.matchedElements){const classList=new Set(selectedEl.attributes.class==null?null:selectedEl.attributes.class.split(" ")) |
| for(const child of selector.node.children)child.type!=="ClassSelector"||selectors.some((selector=>includesAttrSelector(selector.item,"class",child.name,true)))||classList.delete(child.name) |
| classList.size===0?delete selectedEl.attributes.class:selectedEl.attributes.class=Array.from(classList).join(" ") |
| const firstSubSelector=selector.node.children.first |
| firstSubSelector?.type!=="IdSelector"||selectedEl.attributes.id!==firstSubSelector.name||selectors.some((selector=>includesAttrSelector(selector.item,"id",firstSubSelector.name,true)))||delete selectedEl.attributes.id}}for(const style of styles){csstree__namespace.walk(style.cssAst,{visit:"Rule",enter:function(node,item,list){node.type==="Rule"&&node.prelude.type==="SelectorList"&&node.prelude.children.isEmpty&&list.remove(item)}}) |
| if(style.cssAst.children.isEmpty)detachNodeFromParent(style.node,style.parentNode) |
| else{const firstChild=style.node.children[0] |
| firstChild.type!=="text"&&firstChild.type!=="cdata"||(firstChild.value=csstree__namespace.generate(style.cssAst))}}}}}} |
| var inlineStyles=Object.freeze({__proto__:null,description:description$I,fn:fn$I,name:name$I}) |
| const regReferencesUrl=/\burl\((["'])?#(.+?)\1\)/g |
| const regReferencesHref=/^#(.+?)$/ |
| const regReferencesBegin=/(\w+)\.[a-zA-Z]/ |
| const encodeSVGDatauri=(str,type)=>{var prefix="data:image/svg+xml" |
| if(type&&type!=="base64")type==="enc"?str=prefix+","+encodeURIComponent(str):type==="unenc"&&(str=prefix+","+str) |
| else{prefix+=";base64," |
| str=prefix+Buffer.from(str).toString("base64")}return str} |
| const cleanupOutData=(data,params,command)=>{let str="" |
| let delimiter |
| let prev |
| data.forEach(((item,i)=>{delimiter=" " |
| i==0&&(delimiter="") |
| if(params.noSpaceAfterFlags&&(command=="A"||command=="a")){var pos=i%7 |
| pos!=4&&pos!=5||(delimiter="")}const itemStr=params.leadingZero?removeLeadingZero(item):item.toString() |
| params.negativeExtraSpace&&delimiter!=""&&(item<0||itemStr.charAt(0)==="."&&prev%1!==0)&&(delimiter="") |
| prev=item |
| str+=delimiter+itemStr})) |
| return str} |
| const removeLeadingZero=value=>{const strValue=value.toString() |
| if(0<value&&value<1&&strValue.startsWith("0"))return strValue.slice(1) |
| if(-1<value&&value<0&&strValue[1]==="0")return strValue[0]+strValue.slice(2) |
| return strValue} |
| const hasScripts=node=>{if(node.name==="script"&&node.children.length!==0)return true |
| if(node.name==="a"){const hasJsLinks=Object.entries(node.attributes).some((([attrKey,attrValue])=>(attrKey==="href"||attrKey.endsWith(":href"))&&attrValue!=null&&attrValue.trimStart().startsWith("javascript:"))) |
| if(hasJsLinks)return true}const eventAttrs=[...attrsGroups.animationEvent,...attrsGroups.documentEvent,...attrsGroups.documentElementEvent,...attrsGroups.globalEvent,...attrsGroups.graphicalEvent] |
| return eventAttrs.some((attr=>node.attributes[attr]!=null))} |
| const includesUrlReference=body=>new RegExp(regReferencesUrl).test(body) |
| const findReferences=(attribute,value)=>{const results=[] |
| if(referencesProps.has(attribute)){const matches=value.matchAll(regReferencesUrl) |
| for(const match of matches)results.push(match[2])}if(attribute==="href"||attribute.endsWith(":href")){const match=regReferencesHref.exec(value) |
| match!=null&&results.push(match[1])}if(attribute==="begin"){const match=regReferencesBegin.exec(value) |
| match!=null&&results.push(match[1])}return results.map((body=>decodeURI(body)))} |
| const toFixed=(num,precision)=>{const pow=10**precision |
| return Math.round(num*pow)/pow} |
| const name$H="minifyStyles" |
| const description$H="minifies styles and removes unused styles" |
| const fn$H=(_root,{usage:usage,...params})=>{const styleElements=new Map |
| const elementsWithStyleAttributes=[] |
| const tagsUsage=new Set |
| const idsUsage=new Set |
| const classesUsage=new Set |
| let enableTagsUsage=true |
| let enableIdsUsage=true |
| let enableClassesUsage=true |
| let forceUsageDeoptimized=false |
| if(typeof usage==="boolean"){enableTagsUsage=usage |
| enableIdsUsage=usage |
| enableClassesUsage=usage}else if(usage){enableTagsUsage=usage.tags==null||usage.tags |
| enableIdsUsage=usage.ids==null||usage.ids |
| enableClassesUsage=usage.classes==null||usage.classes |
| forceUsageDeoptimized=usage.force!=null&&usage.force}let deoptimized=false |
| return{element:{enter:(node,parentNode)=>{hasScripts(node)&&(deoptimized=true) |
| tagsUsage.add(node.name) |
| node.attributes.id!=null&&idsUsage.add(node.attributes.id) |
| if(node.attributes.class!=null)for(const className of node.attributes.class.split(/\s+/))classesUsage.add(className) |
| node.name==="style"&&node.children.length!==0?styleElements.set(node,parentNode):node.attributes.style!=null&&elementsWithStyleAttributes.push(node)}},root:{exit:()=>{const cssoUsage={} |
| if(!deoptimized||forceUsageDeoptimized){enableTagsUsage&&(cssoUsage.tags=Array.from(tagsUsage)) |
| enableIdsUsage&&(cssoUsage.ids=Array.from(idsUsage)) |
| enableClassesUsage&&(cssoUsage.classes=Array.from(classesUsage))}for(const[styleNode,styleNodeParent]of styleElements.entries())if(styleNode.children[0].type==="text"||styleNode.children[0].type==="cdata"){const cssText=styleNode.children[0].value |
| const minified=csso__namespace.minify(cssText,{...params,usage:cssoUsage}).css |
| if(minified.length===0){detachNodeFromParent(styleNode,styleNodeParent) |
| continue}if(cssText.indexOf(">")>=0||cssText.indexOf("<")>=0){styleNode.children[0].type="cdata" |
| styleNode.children[0].value=minified}else{styleNode.children[0].type="text" |
| styleNode.children[0].value=minified}}for(const node of elementsWithStyleAttributes){const elemStyle=node.attributes.style |
| node.attributes.style=csso__namespace.minifyBlock(elemStyle,{...params}).css}}}}} |
| var minifyStyles=Object.freeze({__proto__:null,description:description$H,fn:fn$H,name:name$H}) |
| const name$G="cleanupIds" |
| const description$G="removes unused IDs and minifies used" |
| const generateIdChars=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"] |
| const maxIdIndex=generateIdChars.length-1 |
| const hasStringPrefix=(string,prefixes)=>{for(const prefix of prefixes)if(string.startsWith(prefix))return true |
| return false} |
| const generateId=currentId=>{if(currentId==null)return[0] |
| currentId[currentId.length-1]+=1 |
| for(let i=currentId.length-1;i>0;i--)if(currentId[i]>maxIdIndex){currentId[i]=0 |
| currentId[i-1]!==void 0&¤tId[i-1]++}if(currentId[0]>maxIdIndex){currentId[0]=0 |
| currentId.unshift(0)}return currentId} |
| const getIdString=arr=>arr.map((i=>generateIdChars[i])).join("") |
| const fn$G=(_root,params)=>{const{remove:remove=true,minify:minify=true,preserve:preserve=[],preservePrefixes:preservePrefixes=[],force:force=false}=params |
| const preserveIds=new Set(Array.isArray(preserve)?preserve:preserve?[preserve]:[]) |
| const preserveIdPrefixes=Array.isArray(preservePrefixes)?preservePrefixes:preservePrefixes?[preservePrefixes]:[] |
| const nodeById=new Map |
| const referencesById=new Map |
| let deoptimized=false |
| return{element:{enter:node=>{if(!force){if(node.name==="style"&&node.children.length!==0||hasScripts(node)){deoptimized=true |
| return}if(node.name==="svg"){let hasDefsOnly=true |
| for(const child of node.children)if(child.type!=="element"||child.name!=="defs"){hasDefsOnly=false |
| break}if(hasDefsOnly)return visitSkip}}for(const[name,value]of Object.entries(node.attributes))if(name==="id"){const id=value |
| nodeById.has(id)?delete node.attributes.id:nodeById.set(id,node)}else{const ids=findReferences(name,value) |
| for(const id of ids){let refs=referencesById.get(id) |
| if(refs==null){refs=[] |
| referencesById.set(id,refs)}refs.push({element:node,name:name})}}}},root:{exit:()=>{if(deoptimized)return |
| const isIdPreserved=id=>preserveIds.has(id)||hasStringPrefix(id,preserveIdPrefixes) |
| let currentId=null |
| for(const[id,refs]of referencesById){const node=nodeById.get(id) |
| if(node!=null){if(minify&&isIdPreserved(id)===false){let currentIdString=null |
| do{currentId=generateId(currentId) |
| currentIdString=getIdString(currentId)}while(isIdPreserved(currentIdString)||referencesById.has(currentIdString)&&nodeById.get(currentIdString)==null) |
| node.attributes.id=currentIdString |
| for(const{element:element,name:name}of refs){const value=element.attributes[name] |
| value.includes("#")?element.attributes[name]=value.replace(`#${encodeURI(id)}`,`#${currentIdString}`).replace(`#${id}`,`#${currentIdString}`):element.attributes[name]=value.replace(`${id}.`,`${currentIdString}.`)}}nodeById.delete(id)}}if(remove)for(const[id,node]of nodeById)isIdPreserved(id)===false&&delete node.attributes.id}}}} |
| var cleanupIds=Object.freeze({__proto__:null,description:description$G,fn:fn$G,name:name$G}) |
| const name$F="removeUselessDefs" |
| const description$F="removes elements in <defs> without id" |
| const fn$F=()=>({element:{enter:(node,parentNode)=>{if(node.name==="defs"||elemsGroups.nonRendering.has(node.name)&&node.attributes.id==null){const usefulNodes=[] |
| collectUsefulNodes(node,usefulNodes) |
| usefulNodes.length===0&&detachNodeFromParent(node,parentNode) |
| for(const usefulNode of usefulNodes)Object.defineProperty(usefulNode,"parentNode",{writable:true,value:node}) |
| node.children=usefulNodes}}}}) |
| const collectUsefulNodes=(node,usefulNodes)=>{for(const child of node.children)child.type==="element"&&(child.attributes.id!=null||child.name==="style"?usefulNodes.push(child):collectUsefulNodes(child,usefulNodes))} |
| var removeUselessDefs=Object.freeze({__proto__:null,description:description$F,fn:fn$F,name:name$F}) |
| const name$E="cleanupNumericValues" |
| const description$E="rounds numeric values to the fixed precision, removes default ‘px’ units" |
| const regNumericValues$3=/^([-+]?\d*\.?\d+([eE][-+]?\d+)?)(px|pt|pc|mm|cm|m|in|ft|em|ex|%)?$/ |
| const absoluteLengths$1={cm:96/2.54,mm:96/25.4,in:96,pt:4/3,pc:16,px:1} |
| const fn$E=(_root,params)=>{const{floatPrecision:floatPrecision=3,leadingZero:leadingZero=true,defaultPx:defaultPx=true,convertToPx:convertToPx=true}=params |
| return{element:{enter:node=>{if(node.attributes.viewBox!=null){const nums=node.attributes.viewBox.split(/\s,?\s*|,\s*/g) |
| node.attributes.viewBox=nums.map((value=>{const num=Number(value) |
| return Number.isNaN(num)?value:Number(num.toFixed(floatPrecision))})).join(" ")}for(const[name,value]of Object.entries(node.attributes)){if(name==="version")continue |
| const match=value.match(regNumericValues$3) |
| if(match){let num=Number(Number(match[1]).toFixed(floatPrecision)) |
| let matchedUnit=match[3]||"" |
| let units=matchedUnit |
| if(convertToPx&&units!==""&&units in absoluteLengths$1){const pxNum=Number((absoluteLengths$1[units]*Number(match[1])).toFixed(floatPrecision)) |
| if(pxNum.toString().length<match[0].length){num=pxNum |
| units="px"}}let str |
| str=leadingZero?removeLeadingZero(num):num.toString() |
| defaultPx&&units==="px"&&(units="") |
| node.attributes[name]=str+units}}}}}} |
| var cleanupNumericValues=Object.freeze({__proto__:null,description:description$E,fn:fn$E,name:name$E}) |
| const name$D="convertColors" |
| const description$D="converts colors: rgb() to #rrggbb and #rrggbb to #rgb" |
| const rNumber="([+-]?(?:\\d*\\.\\d+|\\d+\\.?)%?)" |
| const rComma="\\s*,\\s*" |
| const regRGB=new RegExp("^rgb\\(\\s*"+rNumber+rComma+rNumber+rComma+rNumber+"\\s*\\)$") |
| const regHEX=/^#(([a-fA-F0-9])\2){3}$/ |
| const convertRgbToHex=([r,g,b])=>{const hexNumber=(256+r<<8|g)<<8|b |
| return"#"+hexNumber.toString(16).slice(1).toUpperCase()} |
| const fn$D=(_root,params)=>{const{currentColor:currentColor=false,names2hex:names2hex=true,rgb2hex:rgb2hex=true,convertCase:convertCase="lower",shorthex:shorthex=true,shortname:shortname=true}=params |
| return{element:{enter:node=>{for(const[name,value]of Object.entries(node.attributes))if(colorsProps.has(name)){let val=value |
| if(currentColor){let matched |
| matched=typeof currentColor==="string"?val===currentColor:currentColor instanceof RegExp?currentColor.exec(val)!=null:val!=="none" |
| matched&&(val="currentcolor")}if(names2hex){const colorName=val.toLowerCase() |
| colorsNames[colorName]!=null&&(val=colorsNames[colorName])}if(rgb2hex){let match=val.match(regRGB) |
| if(match!=null){let nums=match.slice(1,4).map((m=>{let n |
| n=m.indexOf("%")>-1?Math.round(parseFloat(m)*2.55):Number(m) |
| return Math.max(0,Math.min(n,255))})) |
| val=convertRgbToHex(nums)}}convertCase&&!includesUrlReference(val)&&(convertCase==="lower"?val=val.toLowerCase():convertCase==="upper"&&(val=val.toUpperCase())) |
| if(shorthex){let match=regHEX.exec(val) |
| match!=null&&(val="#"+match[0][1]+match[0][3]+match[0][5])}if(shortname){const colorName=val.toLowerCase() |
| colorsShortNames[colorName]!=null&&(val=colorsShortNames[colorName])}node.attributes[name]=val}}}}} |
| var convertColors=Object.freeze({__proto__:null,description:description$D,fn:fn$D,name:name$D}) |
| const name$C="removeUnknownsAndDefaults" |
| const description$C="removes unknown elements content and attributes, removes attrs with default values" |
| const allowedChildrenPerElement=new Map |
| const allowedAttributesPerElement=new Map |
| const attributesDefaultsPerElement=new Map |
| for(const[name,config]of Object.entries(elems)){const allowedChildren=new Set |
| if(config.content)for(const elementName of config.content)allowedChildren.add(elementName) |
| if(config.contentGroups)for(const contentGroupName of config.contentGroups){const elemsGroup=elemsGroups[contentGroupName] |
| if(elemsGroup)for(const elementName of elemsGroup)allowedChildren.add(elementName)}const allowedAttributes=new Set |
| if(config.attrs)for(const attrName of config.attrs)allowedAttributes.add(attrName) |
| const attributesDefaults=new Map |
| if(config.defaults)for(const[attrName,defaultValue]of Object.entries(config.defaults))attributesDefaults.set(attrName,defaultValue) |
| for(const attrsGroupName of config.attrsGroups){const attrsGroup=attrsGroups[attrsGroupName] |
| if(attrsGroup)for(const attrName of attrsGroup)allowedAttributes.add(attrName) |
| const groupDefaults=attrsGroupsDefaults[attrsGroupName] |
| if(groupDefaults)for(const[attrName,defaultValue]of Object.entries(groupDefaults))attributesDefaults.set(attrName,defaultValue)}allowedChildrenPerElement.set(name,allowedChildren) |
| allowedAttributesPerElement.set(name,allowedAttributes) |
| attributesDefaultsPerElement.set(name,attributesDefaults)}const fn$C=(root,params)=>{const{unknownContent:unknownContent=true,unknownAttrs:unknownAttrs=true,defaultAttrs:defaultAttrs=true,defaultMarkupDeclarations:defaultMarkupDeclarations=true,uselessOverrides:uselessOverrides=true,keepDataAttrs:keepDataAttrs=true,keepAriaAttrs:keepAriaAttrs=true,keepRoleAttr:keepRoleAttr=false}=params |
| const stylesheet=collectStylesheet(root) |
| return{instruction:{enter:node=>{defaultMarkupDeclarations&&(node.value=node.value.replace(/\s*standalone\s*=\s*(["'])no\1/,""))}},element:{enter:(node,parentNode)=>{if(node.name.includes(":"))return |
| if(node.name==="foreignObject")return visitSkip |
| if(unknownContent&&parentNode.type==="element"){const allowedChildren=allowedChildrenPerElement.get(parentNode.name) |
| if(allowedChildren==null||allowedChildren.size===0){if(allowedChildrenPerElement.get(node.name)==null){detachNodeFromParent(node,parentNode) |
| return}}else if(allowedChildren.has(node.name)===false){detachNodeFromParent(node,parentNode) |
| return}}const allowedAttributes=allowedAttributesPerElement.get(node.name) |
| const attributesDefaults=attributesDefaultsPerElement.get(node.name) |
| const computedParentStyle=parentNode.type==="element"?computeStyle(stylesheet,parentNode):null |
| for(const[name,value]of Object.entries(node.attributes)){if(keepDataAttrs&&name.startsWith("data-"))continue |
| if(keepAriaAttrs&&name.startsWith("aria-"))continue |
| if(keepRoleAttr&&name==="role")continue |
| if(name==="xmlns")continue |
| if(name.includes(":")){const[prefix]=name.split(":") |
| if(prefix!=="xml"&&prefix!=="xlink")continue}unknownAttrs&&allowedAttributes&&allowedAttributes.has(name)===false&&delete node.attributes[name] |
| defaultAttrs&&node.attributes.id==null&&attributesDefaults&&attributesDefaults.get(name)===value&&computedParentStyle?.[name]==null&&delete node.attributes[name] |
| if(uselessOverrides&&node.attributes.id==null){const style=computedParentStyle?.[name] |
| presentationNonInheritableGroupAttrs.has(name)===false&&style!=null&&style.type==="static"&&style.value===value&&delete node.attributes[name]}}}}}} |
| var removeUnknownsAndDefaults=Object.freeze({__proto__:null,description:description$C,fn:fn$C,name:name$C}) |
| const name$B="removeNonInheritableGroupAttrs" |
| const description$B="removes non-inheritable group’s presentational attributes" |
| const fn$B=()=>({element:{enter:node=>{if(node.name==="g")for(const name of Object.keys(node.attributes))!attrsGroups.presentation.has(name)||inheritableAttrs.has(name)||presentationNonInheritableGroupAttrs.has(name)||delete node.attributes[name]}}}) |
| var removeNonInheritableGroupAttrs=Object.freeze({__proto__:null,description:description$B,fn:fn$B,name:name$B}) |
| const name$A="removeUselessStrokeAndFill" |
| const description$A="removes useless stroke and fill attributes" |
| const fn$A=(root,params)=>{const{stroke:removeStroke=true,fill:removeFill=true,removeNone:removeNone=false}=params |
| let hasStyleOrScript=false |
| visit(root,{element:{enter:node=>{(node.name==="style"||hasScripts(node))&&(hasStyleOrScript=true)}}}) |
| if(hasStyleOrScript)return null |
| const stylesheet=collectStylesheet(root) |
| return{element:{enter:(node,parentNode)=>{if(node.attributes.id!=null)return visitSkip |
| if(!elemsGroups.shape.has(node.name))return |
| const computedStyle=computeStyle(stylesheet,node) |
| const stroke=computedStyle.stroke |
| const strokeOpacity=computedStyle["stroke-opacity"] |
| const strokeWidth=computedStyle["stroke-width"] |
| const markerEnd=computedStyle["marker-end"] |
| const fill=computedStyle.fill |
| const fillOpacity=computedStyle["fill-opacity"] |
| const computedParentStyle=parentNode.type==="element"?computeStyle(stylesheet,parentNode):null |
| const parentStroke=computedParentStyle==null?null:computedParentStyle.stroke |
| if(removeStroke&&(stroke==null||stroke.type==="static"&&stroke.value=="none"||strokeOpacity!=null&&strokeOpacity.type==="static"&&strokeOpacity.value==="0"||strokeWidth!=null&&strokeWidth.type==="static"&&strokeWidth.value==="0")&&(strokeWidth!=null&&strokeWidth.type==="static"&&strokeWidth.value==="0"||markerEnd==null)){for(const name of Object.keys(node.attributes))name.startsWith("stroke")&&delete node.attributes[name] |
| parentStroke!=null&&parentStroke.type==="static"&&parentStroke.value!=="none"&&(node.attributes.stroke="none")}if(removeFill&&(fill!=null&&fill.type==="static"&&fill.value==="none"||fillOpacity!=null&&fillOpacity.type==="static"&&fillOpacity.value==="0")){for(const name of Object.keys(node.attributes))name.startsWith("fill-")&&delete node.attributes[name];(fill==null||fill.type==="static"&&fill.value!=="none")&&(node.attributes.fill="none")}removeNone&&(stroke!=null&&node.attributes.stroke!=="none"||(fill==null||fill.type!=="static"||fill.value!=="none")&&node.attributes.fill!=="none"||detachNodeFromParent(node,parentNode))}}}} |
| var removeUselessStrokeAndFill=Object.freeze({__proto__:null,description:description$A,fn:fn$A,name:name$A}) |
| const name$z="removeViewBox" |
| const description$z="removes viewBox attribute when possible" |
| const viewBoxElems=new Set(["pattern","svg","symbol"]) |
| const fn$z=()=>({element:{enter:(node,parentNode)=>{if(viewBoxElems.has(node.name)&&node.attributes.viewBox!=null&&node.attributes.width!=null&&node.attributes.height!=null){if(node.name==="svg"&&parentNode.type!=="root")return |
| const nums=node.attributes.viewBox.split(/[ ,]+/g) |
| nums[0]==="0"&&nums[1]==="0"&&node.attributes.width.replace(/px$/,"")===nums[2]&&node.attributes.height.replace(/px$/,"")===nums[3]&&delete node.attributes.viewBox}}}}) |
| var removeViewBox=Object.freeze({__proto__:null,description:description$z,fn:fn$z,name:name$z}) |
| const name$y="cleanupEnableBackground" |
| const description$y="remove or cleanup enable-background attribute when possible" |
| const regEnableBackground=/^new\s0\s0\s([-+]?\d*\.?\d+([eE][-+]?\d+)?)\s([-+]?\d*\.?\d+([eE][-+]?\d+)?)$/ |
| const fn$y=root=>{let hasFilter=false |
| visit(root,{element:{enter:node=>{node.name==="filter"&&(hasFilter=true)}}}) |
| return{element:{enter:node=>{let newStyle=null |
| let enableBackgroundDeclaration=null |
| if(node.attributes.style!=null){newStyle=csstree__namespace.parse(node.attributes.style,{context:"declarationList"}) |
| if(newStyle.type==="DeclarationList"){const enableBackgroundDeclarations=[] |
| csstree__namespace.walk(newStyle,((node,nodeItem)=>{if(node.type==="Declaration"&&node.property==="enable-background"){enableBackgroundDeclarations.push(nodeItem) |
| enableBackgroundDeclaration=nodeItem}})) |
| for(let i=0;i<enableBackgroundDeclarations.length-1;i++)newStyle.children.remove(enableBackgroundDeclarations[i])}}if(!hasFilter){delete node.attributes["enable-background"] |
| if(newStyle?.type==="DeclarationList"){enableBackgroundDeclaration&&newStyle.children.remove(enableBackgroundDeclaration) |
| newStyle.children.isEmpty?delete node.attributes.style:node.attributes.style=csstree__namespace.generate(newStyle)}return}const hasDimensions=node.attributes.width!=null&&node.attributes.height!=null |
| if((node.name==="svg"||node.name==="mask"||node.name==="pattern")&&hasDimensions){const attrValue=node.attributes["enable-background"] |
| const attrCleaned=cleanupValue(attrValue,node.name,node.attributes.width,node.attributes.height) |
| attrCleaned?node.attributes["enable-background"]=attrCleaned:delete node.attributes["enable-background"] |
| if(newStyle?.type==="DeclarationList"&&enableBackgroundDeclaration){const styleValue=csstree__namespace.generate(enableBackgroundDeclaration.data.value) |
| const styleCleaned=cleanupValue(styleValue,node.name,node.attributes.width,node.attributes.height) |
| styleCleaned?enableBackgroundDeclaration.data.value={type:"Raw",value:styleCleaned}:newStyle.children.remove(enableBackgroundDeclaration)}}newStyle?.type==="DeclarationList"&&(newStyle.children.isEmpty?delete node.attributes.style:node.attributes.style=csstree__namespace.generate(newStyle))}}}} |
| const cleanupValue=(value,nodeName,width,height)=>{const match=regEnableBackground.exec(value) |
| if(match!=null&&width===match[1]&&height===match[3])return nodeName==="svg"?void 0:"new" |
| return value} |
| var cleanupEnableBackground=Object.freeze({__proto__:null,description:description$y,fn:fn$y,name:name$y}) |
| const argsCountPerCommand={M:2,m:2,Z:0,z:0,L:2,l:2,H:1,h:1,V:1,v:1,C:6,c:6,S:4,s:4,Q:4,q:4,T:2,t:2,A:7,a:7} |
| const isCommand=c=>c in argsCountPerCommand |
| const isWsp=c=>{const codePoint=c.codePointAt(0) |
| return codePoint===0x20||codePoint===0x9||codePoint===0xd||codePoint===0xa} |
| const isDigit=c=>{const codePoint=c.codePointAt(0) |
| if(codePoint==null)return false |
| return 48<=codePoint&&codePoint<=57} |
| const readNumber=(string,cursor)=>{let i=cursor |
| let value="" |
| let state="none" |
| for(;i<string.length;i+=1){const c=string[i] |
| if(c==="+"||c==="-"){if(state==="none"){state="sign" |
| value+=c |
| continue}if(state==="e"){state="exponent_sign" |
| value+=c |
| continue}}if(isDigit(c)){if(state==="none"||state==="sign"||state==="whole"){state="whole" |
| value+=c |
| continue}if(state==="decimal_point"||state==="decimal"){state="decimal" |
| value+=c |
| continue}if(state==="e"||state==="exponent_sign"||state==="exponent"){state="exponent" |
| value+=c |
| continue}}if(c==="."&&(state==="none"||state==="sign"||state==="whole")){state="decimal_point" |
| value+=c |
| continue}if((c==="E"||c=="e")&&(state==="whole"||state==="decimal_point"||state==="decimal")){state="e" |
| value+=c |
| continue}break}const number=Number.parseFloat(value) |
| return Number.isNaN(number)?[cursor,null]:[i-1,number]} |
| const parsePathData=string=>{const pathData=[] |
| let command=null |
| let args=[] |
| let argsCount=0 |
| let canHaveComma=false |
| let hadComma=false |
| for(let i=0;i<string.length;i+=1){const c=string.charAt(i) |
| if(isWsp(c))continue |
| if(canHaveComma&&c===","){if(hadComma)break |
| hadComma=true |
| continue}if(isCommand(c)){if(hadComma)return pathData |
| if(command==null){if(c!=="M"&&c!=="m")return pathData}else if(args.length!==0)return pathData |
| command=c |
| args=[] |
| argsCount=argsCountPerCommand[command] |
| canHaveComma=false |
| argsCount===0&&pathData.push({command:command,args:args}) |
| continue}if(command==null)return pathData |
| let newCursor=i |
| let number=null |
| if(command==="A"||command==="a"){const position=args.length |
| position!==0&&position!==1||c!=="+"&&c!=="-"&&([newCursor,number]=readNumber(string,i)) |
| position!==2&&position!==5&&position!==6||([newCursor,number]=readNumber(string,i)) |
| if(position===3||position===4){c==="0"&&(number=0) |
| c==="1"&&(number=1)}}else[newCursor,number]=readNumber(string,i) |
| if(number==null)return pathData |
| args.push(number) |
| canHaveComma=true |
| hadComma=false |
| i=newCursor |
| if(args.length===argsCount){pathData.push({command:command,args:args}) |
| command==="M"&&(command="L") |
| command==="m"&&(command="l") |
| args=[]}}return pathData} |
| const roundAndStringify=(number,precision)=>{precision!=null&&(number=toFixed(number,precision)) |
| return{roundedStr:removeLeadingZero(number),rounded:number}} |
| const stringifyArgs=(command,args,precision,disableSpaceAfterFlags)=>{let result="" |
| let previous |
| for(let i=0;i<args.length;i++){const{roundedStr:roundedStr,rounded:rounded}=roundAndStringify(args[i],precision) |
| !disableSpaceAfterFlags||command!=="A"&&command!=="a"||i%7!==4&&i%7!==5?i===0||rounded<0?result+=roundedStr:Number.isInteger(previous)||isDigit(roundedStr[0])?result+=` ${roundedStr}`:result+=roundedStr:result+=roundedStr |
| previous=rounded}return result} |
| const stringifyPathData=({pathData:pathData,precision:precision,disableSpaceAfterFlags:disableSpaceAfterFlags})=>{if(pathData.length===1){const{command:command,args:args}=pathData[0] |
| return command+stringifyArgs(command,args,precision,disableSpaceAfterFlags)}let result="" |
| let prev={...pathData[0]} |
| pathData[1].command==="L"?prev.command="M":pathData[1].command==="l"&&(prev.command="m") |
| for(let i=1;i<pathData.length;i++){const{command:command,args:args}=pathData[i] |
| if(prev.command===command&&prev.command!=="M"&&prev.command!=="m"||prev.command==="M"&&command==="L"||prev.command==="m"&&command==="l"){prev.args=[...prev.args,...args] |
| i===pathData.length-1&&(result+=prev.command+stringifyArgs(prev.command,prev.args,precision,disableSpaceAfterFlags))}else{result+=prev.command+stringifyArgs(prev.command,prev.args,precision,disableSpaceAfterFlags) |
| i===pathData.length-1?result+=command+stringifyArgs(command,args,precision,disableSpaceAfterFlags):prev={command:command,args:args}}}return result} |
| const nonRendering=elemsGroups.nonRendering |
| const name$x="removeHiddenElems" |
| const description$x="removes hidden elements (zero sized, with absent attributes)" |
| const fn$x=(root,params)=>{const{isHidden:isHidden=true,displayNone:displayNone=true,opacity0:opacity0=true,circleR0:circleR0=true,ellipseRX0:ellipseRX0=true,ellipseRY0:ellipseRY0=true,rectWidth0:rectWidth0=true,rectHeight0:rectHeight0=true,patternWidth0:patternWidth0=true,patternHeight0:patternHeight0=true,imageWidth0:imageWidth0=true,imageHeight0:imageHeight0=true,pathEmptyD:pathEmptyD=true,polylineEmptyPoints:polylineEmptyPoints=true,polygonEmptyPoints:polygonEmptyPoints=true}=params |
| const stylesheet=collectStylesheet(root) |
| const nonRenderedNodes=new Map |
| const removedDefIds=new Set |
| const allDefs=new Map |
| const allReferences=new Set |
| const referencesById=new Map |
| let deoptimized=false |
| function canRemoveNonRenderingNode(node){if(allReferences.has(node.attributes.id))return false |
| for(const child of node.children)if(child.type==="element"&&!canRemoveNonRenderingNode(child))return false |
| return true}function removeElement(node,parentNode){node.type==="element"&&node.attributes.id!=null&&parentNode.type==="element"&&parentNode.name==="defs"&&removedDefIds.add(node.attributes.id) |
| detachNodeFromParent(node,parentNode)}visit(root,{element:{enter:(node,parentNode)=>{if(nonRendering.has(node.name)){nonRenderedNodes.set(node,parentNode) |
| return visitSkip}const computedStyle=computeStyle(stylesheet,node) |
| if(opacity0&&computedStyle.opacity&&computedStyle.opacity.type==="static"&&computedStyle.opacity.value==="0"){if(node.name==="path"){nonRenderedNodes.set(node,parentNode) |
| return visitSkip}removeElement(node,parentNode)}}}}) |
| return{element:{enter:(node,parentNode)=>{if(node.name==="style"&&node.children.length!==0||hasScripts(node)){deoptimized=true |
| return}node.name==="defs"&&allDefs.set(node,parentNode) |
| if(node.name==="use")for(const attr of Object.keys(node.attributes)){if(attr!=="href"&&!attr.endsWith(":href"))continue |
| const value=node.attributes[attr] |
| const id=value.slice(1) |
| let refs=referencesById.get(id) |
| if(!refs){refs=[] |
| referencesById.set(id,refs)}refs.push({node:node,parentNode:parentNode})}const computedStyle=computeStyle(stylesheet,node) |
| if(isHidden&&computedStyle.visibility&&computedStyle.visibility.type==="static"&&computedStyle.visibility.value==="hidden"&&querySelector(node,"[visibility=visible]")==null){removeElement(node,parentNode) |
| return}if(displayNone&&computedStyle.display&&computedStyle.display.type==="static"&&computedStyle.display.value==="none"&&node.name!=="marker"){removeElement(node,parentNode) |
| return}if(circleR0&&node.name==="circle"&&node.children.length===0&&node.attributes.r==="0"){removeElement(node,parentNode) |
| return}if(ellipseRX0&&node.name==="ellipse"&&node.children.length===0&&node.attributes.rx==="0"){removeElement(node,parentNode) |
| return}if(ellipseRY0&&node.name==="ellipse"&&node.children.length===0&&node.attributes.ry==="0"){removeElement(node,parentNode) |
| return}if(rectWidth0&&node.name==="rect"&&node.children.length===0&&node.attributes.width==="0"){removeElement(node,parentNode) |
| return}if(rectHeight0&&rectWidth0&&node.name==="rect"&&node.children.length===0&&node.attributes.height==="0"){removeElement(node,parentNode) |
| return}if(patternWidth0&&node.name==="pattern"&&node.attributes.width==="0"){removeElement(node,parentNode) |
| return}if(patternHeight0&&node.name==="pattern"&&node.attributes.height==="0"){removeElement(node,parentNode) |
| return}if(imageWidth0&&node.name==="image"&&node.attributes.width==="0"){removeElement(node,parentNode) |
| return}if(imageHeight0&&node.name==="image"&&node.attributes.height==="0"){removeElement(node,parentNode) |
| return}if(pathEmptyD&&node.name==="path"){if(node.attributes.d==null){removeElement(node,parentNode) |
| return}const pathData=parsePathData(node.attributes.d) |
| if(pathData.length===0){removeElement(node,parentNode) |
| return}if(pathData.length===1&&computedStyle["marker-start"]==null&&computedStyle["marker-end"]==null){removeElement(node,parentNode) |
| return}}if(polylineEmptyPoints&&node.name==="polyline"&&node.attributes.points==null){removeElement(node,parentNode) |
| return}if(polygonEmptyPoints&&node.name==="polygon"&&node.attributes.points==null){removeElement(node,parentNode) |
| return}for(const[name,value]of Object.entries(node.attributes)){const ids=findReferences(name,value) |
| for(const id of ids)allReferences.add(id)}}},root:{exit:()=>{for(const id of removedDefIds){const refs=referencesById.get(id) |
| if(refs)for(const{node:node,parentNode:parentNode}of refs)detachNodeFromParent(node,parentNode)}if(!deoptimized)for(const[nonRenderedNode,nonRenderedParent]of nonRenderedNodes.entries())canRemoveNonRenderingNode(nonRenderedNode)&&detachNodeFromParent(nonRenderedNode,nonRenderedParent) |
| for(const[node,parentNode]of allDefs.entries())node.children.length===0&&detachNodeFromParent(node,parentNode)}}}} |
| var removeHiddenElems=Object.freeze({__proto__:null,description:description$x,fn:fn$x,name:name$x}) |
| const name$w="removeEmptyText" |
| const description$w="removes empty <text> elements" |
| const fn$w=(root,params)=>{const{text:text=true,tspan:tspan=true,tref:tref=true}=params |
| return{element:{enter:(node,parentNode)=>{text&&node.name==="text"&&node.children.length===0&&detachNodeFromParent(node,parentNode) |
| tspan&&node.name==="tspan"&&node.children.length===0&&detachNodeFromParent(node,parentNode) |
| tref&&node.name==="tref"&&node.attributes["xlink:href"]==null&&detachNodeFromParent(node,parentNode)}}}} |
| var removeEmptyText=Object.freeze({__proto__:null,description:description$w,fn:fn$w,name:name$w}) |
| const name$v="convertShapeToPath" |
| const description$v="converts basic shapes to more compact path form" |
| const regNumber=/[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g |
| const fn$v=(root,params)=>{const{convertArcs:convertArcs=false,floatPrecision:precision}=params |
| return{element:{enter:(node,parentNode)=>{if(node.name==="rect"&&node.attributes.width!=null&&node.attributes.height!=null&&node.attributes.rx==null&&node.attributes.ry==null){const x=Number(node.attributes.x||"0") |
| const y=Number(node.attributes.y||"0") |
| const width=Number(node.attributes.width) |
| const height=Number(node.attributes.height) |
| if(Number.isNaN(x-y+width-height))return |
| const pathData=[{command:"M",args:[x,y]},{command:"H",args:[x+width]},{command:"V",args:[y+height]},{command:"H",args:[x]},{command:"z",args:[]}] |
| node.name="path" |
| node.attributes.d=stringifyPathData({pathData:pathData,precision:precision}) |
| delete node.attributes.x |
| delete node.attributes.y |
| delete node.attributes.width |
| delete node.attributes.height}if(node.name==="line"){const x1=Number(node.attributes.x1||"0") |
| const y1=Number(node.attributes.y1||"0") |
| const x2=Number(node.attributes.x2||"0") |
| const y2=Number(node.attributes.y2||"0") |
| if(Number.isNaN(x1-y1+x2-y2))return |
| const pathData=[{command:"M",args:[x1,y1]},{command:"L",args:[x2,y2]}] |
| node.name="path" |
| node.attributes.d=stringifyPathData({pathData:pathData,precision:precision}) |
| delete node.attributes.x1 |
| delete node.attributes.y1 |
| delete node.attributes.x2 |
| delete node.attributes.y2}if((node.name==="polyline"||node.name==="polygon")&&node.attributes.points!=null){const coords=(node.attributes.points.match(regNumber)||[]).map(Number) |
| if(coords.length<4){detachNodeFromParent(node,parentNode) |
| return}const pathData=[] |
| for(let i=0;i<coords.length;i+=2)pathData.push({command:i===0?"M":"L",args:coords.slice(i,i+2)}) |
| node.name==="polygon"&&pathData.push({command:"z",args:[]}) |
| node.name="path" |
| node.attributes.d=stringifyPathData({pathData:pathData,precision:precision}) |
| delete node.attributes.points}if(node.name==="circle"&&convertArcs){const cx=Number(node.attributes.cx||"0") |
| const cy=Number(node.attributes.cy||"0") |
| const r=Number(node.attributes.r||"0") |
| if(Number.isNaN(cx-cy+r))return |
| const pathData=[{command:"M",args:[cx,cy-r]},{command:"A",args:[r,r,0,1,0,cx,cy+r]},{command:"A",args:[r,r,0,1,0,cx,cy-r]},{command:"z",args:[]}] |
| node.name="path" |
| node.attributes.d=stringifyPathData({pathData:pathData,precision:precision}) |
| delete node.attributes.cx |
| delete node.attributes.cy |
| delete node.attributes.r}if(node.name==="ellipse"&&convertArcs){const ecx=Number(node.attributes.cx||"0") |
| const ecy=Number(node.attributes.cy||"0") |
| const rx=Number(node.attributes.rx||"0") |
| const ry=Number(node.attributes.ry||"0") |
| if(Number.isNaN(ecx-ecy+rx-ry))return |
| const pathData=[{command:"M",args:[ecx,ecy-ry]},{command:"A",args:[rx,ry,0,1,0,ecx,ecy+ry]},{command:"A",args:[rx,ry,0,1,0,ecx,ecy-ry]},{command:"z",args:[]}] |
| node.name="path" |
| node.attributes.d=stringifyPathData({pathData:pathData,precision:precision}) |
| delete node.attributes.cx |
| delete node.attributes.cy |
| delete node.attributes.rx |
| delete node.attributes.ry}}}}} |
| var convertShapeToPath=Object.freeze({__proto__:null,description:description$v,fn:fn$v,name:name$v}) |
| const name$u="convertEllipseToCircle" |
| const description$u="converts non-eccentric <ellipse>s to <circle>s" |
| const fn$u=()=>({element:{enter:node=>{if(node.name==="ellipse"){const rx=node.attributes.rx||"0" |
| const ry=node.attributes.ry||"0" |
| if(rx===ry||rx==="auto"||ry==="auto"){node.name="circle" |
| const radius=rx==="auto"?ry:rx |
| delete node.attributes.rx |
| delete node.attributes.ry |
| node.attributes.r=radius}}}}}) |
| var convertEllipseToCircle=Object.freeze({__proto__:null,description:description$u,fn:fn$u,name:name$u}) |
| const name$t="moveElemsAttrsToGroup" |
| const description$t="Move common attributes of group children to the group" |
| const fn$t=root=>{let deoptimizedWithStyles=false |
| visit(root,{element:{enter:node=>{node.name==="style"&&(deoptimizedWithStyles=true)}}}) |
| return{element:{exit:node=>{if(node.name!=="g"||node.children.length<=1)return |
| if(deoptimizedWithStyles)return |
| const commonAttributes=new Map |
| let initial=true |
| let everyChildIsPath=true |
| for(const child of node.children)if(child.type==="element"){pathElems.has(child.name)||(everyChildIsPath=false) |
| if(initial){initial=false |
| for(const[name,value]of Object.entries(child.attributes))inheritableAttrs.has(name)&&commonAttributes.set(name,value)}else for(const[name,value]of commonAttributes)child.attributes[name]!==value&&commonAttributes.delete(name)}node.attributes["filter"]==null&&node.attributes["clip-path"]==null&&node.attributes.mask==null||commonAttributes.delete("transform") |
| everyChildIsPath&&commonAttributes.delete("transform") |
| for(const[name,value]of commonAttributes)name==="transform"?node.attributes.transform!=null?node.attributes.transform=`${node.attributes.transform} ${value}`:node.attributes.transform=value:node.attributes[name]=value |
| for(const child of node.children)if(child.type==="element")for(const[name]of commonAttributes)delete child.attributes[name]}}}} |
| var moveElemsAttrsToGroup=Object.freeze({__proto__:null,description:description$t,fn:fn$t,name:name$t}) |
| const name$s="moveGroupAttrsToElems" |
| const description$s="moves some group attributes to the content elements" |
| const pathElemsWithGroupsAndText=[...pathElems,"g","text"] |
| const fn$s=()=>({element:{enter:node=>{if(node.name==="g"&&node.children.length!==0&&node.attributes.transform!=null&&Object.entries(node.attributes).some((([name,value])=>referencesProps.has(name)&&includesUrlReference(value)))===false&&node.children.every((child=>child.type==="element"&&pathElemsWithGroupsAndText.includes(child.name)&&child.attributes.id==null))){for(const child of node.children){const value=node.attributes.transform |
| child.type==="element"&&(child.attributes.transform!=null?child.attributes.transform=`${value} ${child.attributes.transform}`:child.attributes.transform=value)}delete node.attributes.transform}}}}) |
| var moveGroupAttrsToElems=Object.freeze({__proto__:null,description:description$s,fn:fn$s,name:name$s}) |
| const name$r="collapseGroups" |
| const description$r="collapses useless groups" |
| const hasAnimatedAttr=(node,name)=>{if(node.type==="element"){if(elemsGroups.animation.has(node.name)&&node.attributes.attributeName===name)return true |
| for(const child of node.children)if(hasAnimatedAttr(child,name))return true}return false} |
| const fn$r=root=>{const stylesheet=collectStylesheet(root) |
| return{element:{exit:(node,parentNode)=>{if(parentNode.type==="root"||parentNode.name==="switch")return |
| if(node.name!=="g"||node.children.length===0)return |
| if(Object.keys(node.attributes).length!==0&&node.children.length===1){const firstChild=node.children[0] |
| const nodeHasFilter=!!(node.attributes.filter||computeStyle(stylesheet,node).filter) |
| if(firstChild.type==="element"&&firstChild.attributes.id==null&&!nodeHasFilter&&(node.attributes.class==null||firstChild.attributes.class==null)&&(node.attributes["clip-path"]==null&&node.attributes.mask==null||firstChild.name==="g"&&node.attributes.transform==null&&firstChild.attributes.transform==null)){const newChildElemAttrs={...firstChild.attributes} |
| for(const[name,value]of Object.entries(node.attributes)){if(hasAnimatedAttr(firstChild,name))return |
| if(newChildElemAttrs[name]==null)newChildElemAttrs[name]=value |
| else if(name==="transform")newChildElemAttrs[name]=value+" "+newChildElemAttrs[name] |
| else if(newChildElemAttrs[name]==="inherit")newChildElemAttrs[name]=value |
| else if(!inheritableAttrs.has(name)&&newChildElemAttrs[name]!==value)return}node.attributes={} |
| firstChild.attributes=newChildElemAttrs}}if(Object.keys(node.attributes).length===0){for(const child of node.children)if(child.type==="element"&&elemsGroups.animation.has(child.name))return |
| const index=parentNode.children.indexOf(node) |
| parentNode.children.splice(index,1,...node.children) |
| for(const child of node.children)Object.defineProperty(child,"parentNode",{writable:true,value:parentNode})}}}}} |
| var collapseGroups=Object.freeze({__proto__:null,description:description$r,fn:fn$r,name:name$r}) |
| var prevCtrlPoint |
| const path2js=path=>{if(path.pathJS)return path.pathJS |
| const pathData=[] |
| const newPathData=parsePathData(path.attributes.d) |
| for(const{command:command,args:args}of newPathData)pathData.push({command:command,args:args}) |
| pathData.length&&pathData[0].command=="m"&&(pathData[0].command="M") |
| path.pathJS=pathData |
| return pathData} |
| const convertRelativeToAbsolute=data=>{const newData=[] |
| let start=[0,0] |
| let cursor=[0,0] |
| for(let{command:command,args:args}of data){args=args.slice() |
| if(command==="m"){args[0]+=cursor[0] |
| args[1]+=cursor[1] |
| command="M"}if(command==="M"){cursor[0]=args[0] |
| cursor[1]=args[1] |
| start[0]=cursor[0] |
| start[1]=cursor[1]}if(command==="h"){args[0]+=cursor[0] |
| command="H"}command==="H"&&(cursor[0]=args[0]) |
| if(command==="v"){args[0]+=cursor[1] |
| command="V"}command==="V"&&(cursor[1]=args[0]) |
| if(command==="l"){args[0]+=cursor[0] |
| args[1]+=cursor[1] |
| command="L"}if(command==="L"){cursor[0]=args[0] |
| cursor[1]=args[1]}if(command==="c"){args[0]+=cursor[0] |
| args[1]+=cursor[1] |
| args[2]+=cursor[0] |
| args[3]+=cursor[1] |
| args[4]+=cursor[0] |
| args[5]+=cursor[1] |
| command="C"}if(command==="C"){cursor[0]=args[4] |
| cursor[1]=args[5]}if(command==="s"){args[0]+=cursor[0] |
| args[1]+=cursor[1] |
| args[2]+=cursor[0] |
| args[3]+=cursor[1] |
| command="S"}if(command==="S"){cursor[0]=args[2] |
| cursor[1]=args[3]}if(command==="q"){args[0]+=cursor[0] |
| args[1]+=cursor[1] |
| args[2]+=cursor[0] |
| args[3]+=cursor[1] |
| command="Q"}if(command==="Q"){cursor[0]=args[2] |
| cursor[1]=args[3]}if(command==="t"){args[0]+=cursor[0] |
| args[1]+=cursor[1] |
| command="T"}if(command==="T"){cursor[0]=args[0] |
| cursor[1]=args[1]}if(command==="a"){args[5]+=cursor[0] |
| args[6]+=cursor[1] |
| command="A"}if(command==="A"){cursor[0]=args[5] |
| cursor[1]=args[6]}if(command==="z"||command==="Z"){cursor[0]=start[0] |
| cursor[1]=start[1] |
| command="z"}newData.push({command:command,args:args})}return newData} |
| const js2path=function(path,data,params){path.pathJS=data |
| const pathData=[] |
| for(const item of data){if(pathData.length!==0&&(item.command==="M"||item.command==="m")){const last=pathData[pathData.length-1] |
| last.command!=="M"&&last.command!=="m"||pathData.pop()}pathData.push({command:item.command,args:item.args})}path.attributes.d=stringifyPathData({pathData:pathData,precision:params.floatPrecision,disableSpaceAfterFlags:params.noSpaceAfterFlags})} |
| function set(dest,source){dest[0]=source[source.length-2] |
| dest[1]=source[source.length-1] |
| return dest}const intersects=function(path1,path2){const points1=gatherPoints(convertRelativeToAbsolute(path1)) |
| const points2=gatherPoints(convertRelativeToAbsolute(path2)) |
| if(points1.maxX<=points2.minX||points2.maxX<=points1.minX||points1.maxY<=points2.minY||points2.maxY<=points1.minY||points1.list.every((set1=>points2.list.every((set2=>set1.list[set1.maxX][0]<=set2.list[set2.minX][0]||set2.list[set2.maxX][0]<=set1.list[set1.minX][0]||set1.list[set1.maxY][1]<=set2.list[set2.minY][1]||set2.list[set2.maxY][1]<=set1.list[set1.minY][1])))))return false |
| const hullNest1=points1.list.map(convexHull) |
| const hullNest2=points2.list.map(convexHull) |
| return hullNest1.some((function(hull1){if(hull1.list.length<3)return false |
| return hullNest2.some((function(hull2){if(hull2.list.length<3)return false |
| var simplex=[getSupport(hull1,hull2,[1,0])],direction=minus(simplex[0]) |
| var iterations=1e4 |
| while(true){if(iterations--==0){console.error("Error: infinite loop while processing mergePaths plugin.") |
| return true}simplex.push(getSupport(hull1,hull2,direction)) |
| if(dot(direction,simplex[simplex.length-1])<=0)return false |
| if(processSimplex(simplex,direction))return true}}))})) |
| function getSupport(a,b,direction){return sub(supportPoint(a,direction),supportPoint(b,minus(direction)))}function supportPoint(polygon,direction){var index=direction[1]>=0?direction[0]<0?polygon.maxY:polygon.maxX:direction[0]<0?polygon.minX:polygon.minY,max=-1/0,value |
| while((value=dot(polygon.list[index],direction))>max){max=value |
| index=++index%polygon.list.length}return polygon.list[(index||polygon.list.length)-1]}} |
| function processSimplex(simplex,direction){if(simplex.length==2){let a=simplex[1],b=simplex[0],AO=minus(simplex[1]),AB=sub(b,a) |
| if(dot(AO,AB)>0)set(direction,orth(AB,a)) |
| else{set(direction,AO) |
| simplex.shift()}}else{let a=simplex[2],b=simplex[1],c=simplex[0],AB=sub(b,a),AC=sub(c,a),AO=minus(a),ACB=orth(AB,AC),ABC=orth(AC,AB) |
| if(dot(ACB,AO)>0)if(dot(AB,AO)>0){set(direction,ACB) |
| simplex.shift()}else{set(direction,AO) |
| simplex.splice(0,2)}else{if(!(dot(ABC,AO)>0))return true |
| if(dot(AC,AO)>0){set(direction,ABC) |
| simplex.splice(1,1)}else{set(direction,AO) |
| simplex.splice(0,2)}}}return false}function minus(v){return[-v[0],-v[1]]}function sub(v1,v2){return[v1[0]-v2[0],v1[1]-v2[1]]}function dot(v1,v2){return v1[0]*v2[0]+v1[1]*v2[1]}function orth(v,from){var o=[-v[1],v[0]] |
| return dot(o,minus(from))<0?minus(o):o}function gatherPoints(pathData){const points={list:[],minX:0,minY:0,maxX:0,maxY:0} |
| const addPoint=(path,point)=>{if(!path.list.length||point[1]>path.list[path.maxY][1]){path.maxY=path.list.length |
| points.maxY=points.list.length?Math.max(point[1],points.maxY):point[1]}if(!path.list.length||point[0]>path.list[path.maxX][0]){path.maxX=path.list.length |
| points.maxX=points.list.length?Math.max(point[0],points.maxX):point[0]}if(!path.list.length||point[1]<path.list[path.minY][1]){path.minY=path.list.length |
| points.minY=points.list.length?Math.min(point[1],points.minY):point[1]}if(!path.list.length||point[0]<path.list[path.minX][0]){path.minX=path.list.length |
| points.minX=points.list.length?Math.min(point[0],points.minX):point[0]}path.list.push(point)} |
| for(let i=0;i<pathData.length;i+=1){const pathDataItem=pathData[i] |
| let subPath=points.list.length===0?{list:[],minX:0,minY:0,maxX:0,maxY:0}:points.list[points.list.length-1] |
| let prev=i===0?null:pathData[i-1] |
| let basePoint=subPath.list.length===0?null:subPath.list[subPath.list.length-1] |
| let data=pathDataItem.args |
| let ctrlPoint=basePoint |
| const toAbsolute=(n,i)=>n+(basePoint==null?0:basePoint[i%2]) |
| switch(pathDataItem.command){case"M":subPath={list:[],minX:0,minY:0,maxX:0,maxY:0} |
| points.list.push(subPath) |
| break |
| case"H":basePoint!=null&&addPoint(subPath,[data[0],basePoint[1]]) |
| break |
| case"V":basePoint!=null&&addPoint(subPath,[basePoint[0],data[0]]) |
| break |
| case"Q":addPoint(subPath,data.slice(0,2)) |
| prevCtrlPoint=[data[2]-data[0],data[3]-data[1]] |
| break |
| case"T":if(basePoint!=null&&prev!=null&&(prev.command=="Q"||prev.command=="T")){ctrlPoint=[basePoint[0]+prevCtrlPoint[0],basePoint[1]+prevCtrlPoint[1]] |
| addPoint(subPath,ctrlPoint) |
| prevCtrlPoint=[data[0]-ctrlPoint[0],data[1]-ctrlPoint[1]]}break |
| case"C":basePoint!=null&&addPoint(subPath,[0.5*(basePoint[0]+data[0]),0.5*(basePoint[1]+data[1])]) |
| addPoint(subPath,[0.5*(data[0]+data[2]),0.5*(data[1]+data[3])]) |
| addPoint(subPath,[0.5*(data[2]+data[4]),0.5*(data[3]+data[5])]) |
| prevCtrlPoint=[data[4]-data[2],data[5]-data[3]] |
| break |
| case"S":if(basePoint!=null&&prev!=null&&(prev.command=="C"||prev.command=="S")){addPoint(subPath,[basePoint[0]+0.5*prevCtrlPoint[0],basePoint[1]+0.5*prevCtrlPoint[1]]) |
| ctrlPoint=[basePoint[0]+prevCtrlPoint[0],basePoint[1]+prevCtrlPoint[1]]}ctrlPoint!=null&&addPoint(subPath,[0.5*(ctrlPoint[0]+data[0]),0.5*(ctrlPoint[1]+data[1])]) |
| addPoint(subPath,[0.5*(data[0]+data[2]),0.5*(data[1]+data[3])]) |
| prevCtrlPoint=[data[2]-data[0],data[3]-data[1]] |
| break |
| case"A":if(basePoint!=null){var curves=a2c.apply(0,basePoint.concat(data)) |
| for(var cData;(cData=curves.splice(0,6).map(toAbsolute)).length;){basePoint!=null&&addPoint(subPath,[0.5*(basePoint[0]+cData[0]),0.5*(basePoint[1]+cData[1])]) |
| addPoint(subPath,[0.5*(cData[0]+cData[2]),0.5*(cData[1]+cData[3])]) |
| addPoint(subPath,[0.5*(cData[2]+cData[4]),0.5*(cData[3]+cData[5])]) |
| curves.length&&addPoint(subPath,basePoint=cData.slice(-2))}}break}data.length>=2&&addPoint(subPath,data.slice(-2))}return points}function convexHull(points){points.list.sort((function(a,b){return a[0]==b[0]?a[1]-b[1]:a[0]-b[0]})) |
| var lower=[],minY=0,bottom=0 |
| for(let i=0;i<points.list.length;i++){while(lower.length>=2&&cross(lower[lower.length-2],lower[lower.length-1],points.list[i])<=0)lower.pop() |
| if(points.list[i][1]<points.list[minY][1]){minY=i |
| bottom=lower.length}lower.push(points.list[i])}var upper=[],maxY=points.list.length-1,top=0 |
| for(let i=points.list.length;i--;){while(upper.length>=2&&cross(upper[upper.length-2],upper[upper.length-1],points.list[i])<=0)upper.pop() |
| if(points.list[i][1]>points.list[maxY][1]){maxY=i |
| top=upper.length}upper.push(points.list[i])}upper.pop() |
| lower.pop() |
| const hullList=lower.concat(upper) |
| const hull={list:hullList,minX:0,maxX:lower.length,minY:bottom,maxY:(lower.length+top)%hullList.length} |
| return hull}function cross(o,a,b){return(a[0]-o[0])*(b[1]-o[1])-(a[1]-o[1])*(b[0]-o[0])}const a2c=(x1,y1,rx,ry,angle,large_arc_flag,sweep_flag,x2,y2,recursive)=>{const _120=Math.PI*120/180 |
| const rad=Math.PI/180*(+angle||0) |
| let res=[] |
| const rotateX=(x,y,rad)=>x*Math.cos(rad)-y*Math.sin(rad) |
| const rotateY=(x,y,rad)=>x*Math.sin(rad)+y*Math.cos(rad) |
| if(recursive){f1=recursive[0] |
| f2=recursive[1] |
| cx=recursive[2] |
| cy=recursive[3]}else{x1=rotateX(x1,y1,-rad) |
| y1=rotateY(x1,y1,-rad) |
| x2=rotateX(x2,y2,-rad) |
| y2=rotateY(x2,y2,-rad) |
| var x=(x1-x2)/2,y=(y1-y2)/2 |
| var h=x*x/(rx*rx)+y*y/(ry*ry) |
| if(h>1){h=Math.sqrt(h) |
| rx*=h |
| ry*=h}var rx2=rx*rx |
| var ry2=ry*ry |
| var k=(large_arc_flag==sweep_flag?-1:1)*Math.sqrt(Math.abs((rx2*ry2-rx2*y*y-ry2*x*x)/(rx2*y*y+ry2*x*x))) |
| var cx=k*rx*y/ry+(x1+x2)/2 |
| var cy=k*-ry*x/rx+(y1+y2)/2 |
| var f1=Math.asin(Number(((y1-cy)/ry).toFixed(9))) |
| var f2=Math.asin(Number(((y2-cy)/ry).toFixed(9))) |
| f1=x1<cx?Math.PI-f1:f1 |
| f2=x2<cx?Math.PI-f2:f2 |
| f1<0&&(f1=Math.PI*2+f1) |
| f2<0&&(f2=Math.PI*2+f2) |
| sweep_flag&&f1>f2&&(f1-=Math.PI*2) |
| !sweep_flag&&f2>f1&&(f2-=Math.PI*2)}var df=f2-f1 |
| if(Math.abs(df)>_120){var f2old=f2,x2old=x2,y2old=y2 |
| f2=f1+_120*(sweep_flag&&f2>f1?1:-1) |
| x2=cx+rx*Math.cos(f2) |
| y2=cy+ry*Math.sin(f2) |
| res=a2c(x2,y2,rx,ry,angle,0,sweep_flag,x2old,y2old,[f2,f2old,cx,cy])}df=f2-f1 |
| var c1=Math.cos(f1),s1=Math.sin(f1),c2=Math.cos(f2),s2=Math.sin(f2),t=Math.tan(df/4),hx=4/3*rx*t,hy=4/3*ry*t,m=[-hx*s1,hy*c1,x2+hx*s2-x1,y2-hy*c2-y1,x2-x1,y2-y1] |
| if(recursive)return m.concat(res) |
| res=m.concat(res) |
| var newres=[] |
| for(var i=0,n=res.length;i<n;i++)newres[i]=i%2?rotateY(res[i-1],res[i],rad):rotateX(res[i],res[i+1],rad) |
| return newres} |
| const transformTypes=new Set(["matrix","rotate","scale","skewX","skewY","translate"]) |
| const regTransformSplit=/\s*(matrix|translate|scale|rotate|skewX|skewY)\s*\(\s*(.+?)\s*\)[\s,]*/ |
| const regNumericValues$2=/[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g |
| const transform2js=transformString=>{const transforms=[] |
| let currentTransform=null |
| for(const item of transformString.split(regTransformSplit)){if(!item)continue |
| if(transformTypes.has(item)){currentTransform={name:item,data:[]} |
| transforms.push(currentTransform)}else{let num |
| while(num=regNumericValues$2.exec(item)){num=Number(num) |
| currentTransform!=null&¤tTransform.data.push(num)}}}return currentTransform==null||currentTransform.data.length==0?[]:transforms} |
| const transformsMultiply=transforms=>{const matrixData=transforms.map((transform=>{if(transform.name==="matrix")return transform.data |
| return transformToMatrix(transform)})) |
| const matrixTransform={name:"matrix",data:matrixData.length>0?matrixData.reduce(multiplyTransformMatrices):[]} |
| return matrixTransform} |
| const mth={rad:deg=>deg*Math.PI/180,deg:rad=>rad*180/Math.PI,cos:deg=>Math.cos(mth.rad(deg)),acos:(val,floatPrecision)=>toFixed(mth.deg(Math.acos(val)),floatPrecision),sin:deg=>Math.sin(mth.rad(deg)),asin:(val,floatPrecision)=>toFixed(mth.deg(Math.asin(val)),floatPrecision),tan:deg=>Math.tan(mth.rad(deg)),atan:(val,floatPrecision)=>toFixed(mth.deg(Math.atan(val)),floatPrecision)} |
| const getDecompositions=matrix=>{const decompositions=[] |
| const qrab=decomposeQRAB(matrix) |
| const qrcd=decomposeQRCD(matrix) |
| qrab&&decompositions.push(qrab) |
| qrcd&&decompositions.push(qrcd) |
| return decompositions} |
| const decomposeQRAB=matrix=>{const data=matrix.data |
| const[a,b,c,d,e,f]=data |
| const delta=a*d-b*c |
| if(delta===0)return |
| const r=Math.hypot(a,b) |
| if(r===0)return |
| const decomposition=[] |
| const cosOfRotationAngle=a/r;(e||f)&&decomposition.push({name:"translate",data:[e,f]}) |
| if(cosOfRotationAngle!==1){const rotationAngleRads=Math.acos(cosOfRotationAngle) |
| decomposition.push({name:"rotate",data:[mth.deg(b<0?-rotationAngleRads:rotationAngleRads),0,0]})}const sx=r |
| const sy=delta/sx |
| sx===1&&sy===1||decomposition.push({name:"scale",data:[sx,sy]}) |
| const ac_plus_bd=a*c+b*d |
| ac_plus_bd&&decomposition.push({name:"skewX",data:[mth.deg(Math.atan(ac_plus_bd/(a*a+b*b)))]}) |
| return decomposition} |
| const decomposeQRCD=matrix=>{const data=matrix.data |
| const[a,b,c,d,e,f]=data |
| const delta=a*d-b*c |
| if(delta===0)return |
| const s=Math.hypot(c,d) |
| if(s===0)return |
| const decomposition=[];(e||f)&&decomposition.push({name:"translate",data:[e,f]}) |
| const rotationAngleRads=Math.PI/2-(d<0?-1:1)*Math.acos(-c/s) |
| decomposition.push({name:"rotate",data:[mth.deg(rotationAngleRads),0,0]}) |
| const sx=delta/s |
| const sy=s |
| sx===1&&sy===1||decomposition.push({name:"scale",data:[sx,sy]}) |
| const ac_plus_bd=a*c+b*d |
| ac_plus_bd&&decomposition.push({name:"skewY",data:[mth.deg(Math.atan(ac_plus_bd/(c*c+d*d)))]}) |
| return decomposition} |
| const mergeTranslateAndRotate=(tx,ty,a)=>{const rotationAngleRads=mth.rad(a) |
| const d=1-Math.cos(rotationAngleRads) |
| const e=Math.sin(rotationAngleRads) |
| const cy=(d*ty+e*tx)/(d*d+e*e) |
| const cx=(tx-e*cy)/d |
| return{name:"rotate",data:[a,cx,cy]}} |
| const isIdentityTransform=t=>{switch(t.name){case"rotate":case"skewX":case"skewY":return t.data[0]===0 |
| case"scale":return t.data[0]===1&&t.data[1]===1 |
| case"translate":return t.data[0]===0&&t.data[1]===0}return false} |
| const optimize$2=(roundedTransforms,rawTransforms)=>{const optimizedTransforms=[] |
| for(let index=0;index<roundedTransforms.length;index++){const roundedTransform=roundedTransforms[index] |
| if(isIdentityTransform(roundedTransform))continue |
| const data=roundedTransform.data |
| switch(roundedTransform.name){case"rotate":switch(data[0]){case 180:case-180:{const next=roundedTransforms[index+1] |
| if(next&&next.name==="scale"){optimizedTransforms.push(createScaleTransform(next.data.map((v=>-v)))) |
| index++}else optimizedTransforms.push({name:"scale",data:[-1]})}continue}optimizedTransforms.push({name:"rotate",data:data.slice(0,data[1]||data[2]?3:1)}) |
| break |
| case"scale":optimizedTransforms.push(createScaleTransform(data)) |
| break |
| case"skewX":case"skewY":optimizedTransforms.push({name:roundedTransform.name,data:[data[0]]}) |
| break |
| case"translate":{const next=roundedTransforms[index+1] |
| if(next&&next.name==="rotate"&&next.data[0]!==180&&next.data[0]!==-180&&next.data[0]!==0&&next.data[1]===0&&next.data[2]===0){const data=rawTransforms[index].data |
| optimizedTransforms.push(mergeTranslateAndRotate(data[0],data[1],rawTransforms[index+1].data[0])) |
| index++ |
| continue}}optimizedTransforms.push({name:"translate",data:data.slice(0,data[1]?2:1)}) |
| break}}return optimizedTransforms.length?optimizedTransforms:[{name:"scale",data:[1]}]} |
| const createScaleTransform=data=>{const scaleData=data.slice(0,data[0]===data[1]?1:2) |
| return{name:"scale",data:scaleData}} |
| const matrixToTransform=(origMatrix,params)=>{const decomposed=getDecompositions(origMatrix) |
| let shortest |
| let shortestLen=Number.MAX_VALUE |
| for(const decomposition of decomposed){const roundedTransforms=decomposition.map((transformItem=>{const transformCopy={name:transformItem.name,data:[...transformItem.data]} |
| return roundTransform(transformCopy,params)})) |
| const optimized=optimize$2(roundedTransforms,decomposition) |
| const len=js2transform(optimized,params).length |
| if(len<shortestLen){shortest=optimized |
| shortestLen=len}}return shortest??[origMatrix]} |
| const transformToMatrix=transform=>{if(transform.name==="matrix")return transform.data |
| switch(transform.name){case"translate":return[1,0,0,1,transform.data[0],transform.data[1]||0] |
| case"scale":return[transform.data[0],0,0,transform.data[1]??transform.data[0],0,0] |
| case"rotate":var cos=mth.cos(transform.data[0]),sin=mth.sin(transform.data[0]),cx=transform.data[1]||0,cy=transform.data[2]||0 |
| return[cos,sin,-sin,cos,(1-cos)*cx+sin*cy,(1-cos)*cy-sin*cx] |
| case"skewX":return[1,0,mth.tan(transform.data[0]),1,0,0] |
| case"skewY":return[1,mth.tan(transform.data[0]),0,1,0,0] |
| default:throw Error(`Unknown transform ${transform.name}`)}} |
| const transformArc=(cursor,arc,transform)=>{const x=arc[5]-cursor[0] |
| const y=arc[6]-cursor[1] |
| let a=arc[0] |
| let b=arc[1] |
| const rot=arc[2]*Math.PI/180 |
| const cos=Math.cos(rot) |
| const sin=Math.sin(rot) |
| if(a>0&&b>0){let h=Math.pow(x*cos+y*sin,2)/(4*a*a)+Math.pow(y*cos-x*sin,2)/(4*b*b) |
| if(h>1){h=Math.sqrt(h) |
| a*=h |
| b*=h}}const ellipse=[a*cos,a*sin,-b*sin,b*cos,0,0] |
| const m=multiplyTransformMatrices(transform,ellipse) |
| const lastCol=m[2]*m[2]+m[3]*m[3] |
| const squareSum=m[0]*m[0]+m[1]*m[1]+lastCol |
| const root=Math.hypot(m[0]-m[3],m[1]+m[2])*Math.hypot(m[0]+m[3],m[1]-m[2]) |
| if(root){const majorAxisSqr=(squareSum+root)/2 |
| const minorAxisSqr=(squareSum-root)/2 |
| const major=Math.abs(majorAxisSqr-lastCol)>1e-6 |
| const sub=(major?majorAxisSqr:minorAxisSqr)-lastCol |
| const rowsSum=m[0]*m[2]+m[1]*m[3] |
| const term1=m[0]*sub+m[2]*rowsSum |
| const term2=m[1]*sub+m[3]*rowsSum |
| arc[0]=Math.sqrt(majorAxisSqr) |
| arc[1]=Math.sqrt(minorAxisSqr) |
| arc[2]=((major?term2<0:term1>0)?-1:1)*Math.acos((major?term1:term2)/Math.hypot(term1,term2))*180/Math.PI}else{arc[0]=arc[1]=Math.sqrt(squareSum/2) |
| arc[2]=0}transform[0]<0!==transform[3]<0&&(arc[4]=1-arc[4]) |
| return arc} |
| const multiplyTransformMatrices=(a,b)=>[a[0]*b[0]+a[2]*b[1],a[1]*b[0]+a[3]*b[1],a[0]*b[2]+a[2]*b[3],a[1]*b[2]+a[3]*b[3],a[0]*b[4]+a[2]*b[5]+a[4],a[1]*b[4]+a[3]*b[5]+a[5]] |
| const roundTransform=(transform,params)=>{switch(transform.name){case"translate":transform.data=floatRound(transform.data,params) |
| break |
| case"rotate":transform.data=[...degRound(transform.data.slice(0,1),params),...floatRound(transform.data.slice(1),params)] |
| break |
| case"skewX":case"skewY":transform.data=degRound(transform.data,params) |
| break |
| case"scale":transform.data=transformRound(transform.data,params) |
| break |
| case"matrix":transform.data=[...transformRound(transform.data.slice(0,4),params),...floatRound(transform.data.slice(4),params)] |
| break}return transform} |
| const degRound=(data,params)=>params.degPrecision!=null&¶ms.degPrecision>=1&¶ms.floatPrecision<20?smartRound(params.degPrecision,data):round$1(data) |
| const floatRound=(data,params)=>params.floatPrecision>=1&¶ms.floatPrecision<20?smartRound(params.floatPrecision,data):round$1(data) |
| const transformRound=(data,params)=>params.transformPrecision>=1&¶ms.floatPrecision<20?smartRound(params.transformPrecision,data):round$1(data) |
| const round$1=data=>data.map(Math.round) |
| const smartRound=(precision,data)=>{for(var i=data.length,tolerance=+Math.pow(0.1,precision).toFixed(precision);i--;)if(toFixed(data[i],precision)!==data[i]){var rounded=+data[i].toFixed(precision-1) |
| data[i]=+Math.abs(rounded-data[i]).toFixed(precision+1)>=tolerance?+data[i].toFixed(precision):rounded}return data} |
| const js2transform=(transformJS,params)=>{const transformString=transformJS.map((transform=>{roundTransform(transform,params) |
| return`${transform.name}(${cleanupOutData(transform.data,params)})`})).join("") |
| return transformString} |
| const regNumericValues$1=/[-+]?(\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g |
| const applyTransforms=(root,params)=>{const stylesheet=collectStylesheet(root) |
| return{element:{enter:node=>{if(node.attributes.d==null)return |
| if(node.attributes.id!=null)return |
| if(node.attributes.transform==null||node.attributes.transform===""||node.attributes.style!=null||Object.entries(node.attributes).some((([name,value])=>referencesProps.has(name)&&includesUrlReference(value))))return |
| const computedStyle=computeStyle(stylesheet,node) |
| const transformStyle=computedStyle.transform |
| if(transformStyle.type==="static"&&transformStyle.value!==node.attributes.transform)return |
| const matrix=transformsMultiply(transform2js(node.attributes.transform)) |
| const stroke=computedStyle.stroke?.type==="static"?computedStyle.stroke.value:null |
| const strokeWidth=computedStyle["stroke-width"]?.type==="static"?computedStyle["stroke-width"].value:null |
| const transformPrecision=params.transformPrecision |
| if(computedStyle.stroke?.type==="dynamic"||computedStyle["stroke-width"]?.type==="dynamic")return |
| const scale=Number(Math.hypot(matrix.data[0],matrix.data[1]).toFixed(transformPrecision)) |
| if(stroke&&stroke!="none"){if(!params.applyTransformsStroked)return |
| if((matrix.data[0]!==matrix.data[3]||matrix.data[1]!==-matrix.data[2])&&(matrix.data[0]!==-matrix.data[3]||matrix.data[1]!==matrix.data[2]))return |
| if(scale!==1&&node.attributes["vector-effect"]!=="non-scaling-stroke"){node.attributes["stroke-width"]=(strokeWidth||attrsGroupsDefaults.presentation["stroke-width"]).trim().replace(regNumericValues$1,(num=>removeLeadingZero(Number(num)*scale))) |
| node.attributes["stroke-dashoffset"]!=null&&(node.attributes["stroke-dashoffset"]=node.attributes["stroke-dashoffset"].trim().replace(regNumericValues$1,(num=>removeLeadingZero(Number(num)*scale)))) |
| node.attributes["stroke-dasharray"]!=null&&(node.attributes["stroke-dasharray"]=node.attributes["stroke-dasharray"].trim().replace(regNumericValues$1,(num=>removeLeadingZero(Number(num)*scale))))}}const pathData=path2js(node) |
| applyMatrixToPathData(pathData,matrix.data) |
| delete node.attributes.transform}}}} |
| const transformAbsolutePoint=(matrix,x,y)=>{const newX=matrix[0]*x+matrix[2]*y+matrix[4] |
| const newY=matrix[1]*x+matrix[3]*y+matrix[5] |
| return[newX,newY]} |
| const transformRelativePoint=(matrix,x,y)=>{const newX=matrix[0]*x+matrix[2]*y |
| const newY=matrix[1]*x+matrix[3]*y |
| return[newX,newY]} |
| const applyMatrixToPathData=(pathData,matrix)=>{const start=[0,0] |
| const cursor=[0,0] |
| for(const pathItem of pathData){let{command:command,args:args}=pathItem |
| if(command==="M"){cursor[0]=args[0] |
| cursor[1]=args[1] |
| start[0]=cursor[0] |
| start[1]=cursor[1] |
| const[x,y]=transformAbsolutePoint(matrix,args[0],args[1]) |
| args[0]=x |
| args[1]=y}if(command==="m"){cursor[0]+=args[0] |
| cursor[1]+=args[1] |
| start[0]=cursor[0] |
| start[1]=cursor[1] |
| const[x,y]=transformRelativePoint(matrix,args[0],args[1]) |
| args[0]=x |
| args[1]=y}if(command==="H"){command="L" |
| args=[args[0],cursor[1]]}if(command==="h"){command="l" |
| args=[args[0],0]}if(command==="V"){command="L" |
| args=[cursor[0],args[0]]}if(command==="v"){command="l" |
| args=[0,args[0]]}if(command==="L"){cursor[0]=args[0] |
| cursor[1]=args[1] |
| const[x,y]=transformAbsolutePoint(matrix,args[0],args[1]) |
| args[0]=x |
| args[1]=y}if(command==="l"){cursor[0]+=args[0] |
| cursor[1]+=args[1] |
| const[x,y]=transformRelativePoint(matrix,args[0],args[1]) |
| args[0]=x |
| args[1]=y}if(command==="C"){cursor[0]=args[4] |
| cursor[1]=args[5] |
| const[x1,y1]=transformAbsolutePoint(matrix,args[0],args[1]) |
| const[x2,y2]=transformAbsolutePoint(matrix,args[2],args[3]) |
| const[x,y]=transformAbsolutePoint(matrix,args[4],args[5]) |
| args[0]=x1 |
| args[1]=y1 |
| args[2]=x2 |
| args[3]=y2 |
| args[4]=x |
| args[5]=y}if(command==="c"){cursor[0]+=args[4] |
| cursor[1]+=args[5] |
| const[x1,y1]=transformRelativePoint(matrix,args[0],args[1]) |
| const[x2,y2]=transformRelativePoint(matrix,args[2],args[3]) |
| const[x,y]=transformRelativePoint(matrix,args[4],args[5]) |
| args[0]=x1 |
| args[1]=y1 |
| args[2]=x2 |
| args[3]=y2 |
| args[4]=x |
| args[5]=y}if(command==="S"){cursor[0]=args[2] |
| cursor[1]=args[3] |
| const[x2,y2]=transformAbsolutePoint(matrix,args[0],args[1]) |
| const[x,y]=transformAbsolutePoint(matrix,args[2],args[3]) |
| args[0]=x2 |
| args[1]=y2 |
| args[2]=x |
| args[3]=y}if(command==="s"){cursor[0]+=args[2] |
| cursor[1]+=args[3] |
| const[x2,y2]=transformRelativePoint(matrix,args[0],args[1]) |
| const[x,y]=transformRelativePoint(matrix,args[2],args[3]) |
| args[0]=x2 |
| args[1]=y2 |
| args[2]=x |
| args[3]=y}if(command==="Q"){cursor[0]=args[2] |
| cursor[1]=args[3] |
| const[x1,y1]=transformAbsolutePoint(matrix,args[0],args[1]) |
| const[x,y]=transformAbsolutePoint(matrix,args[2],args[3]) |
| args[0]=x1 |
| args[1]=y1 |
| args[2]=x |
| args[3]=y}if(command==="q"){cursor[0]+=args[2] |
| cursor[1]+=args[3] |
| const[x1,y1]=transformRelativePoint(matrix,args[0],args[1]) |
| const[x,y]=transformRelativePoint(matrix,args[2],args[3]) |
| args[0]=x1 |
| args[1]=y1 |
| args[2]=x |
| args[3]=y}if(command==="T"){cursor[0]=args[0] |
| cursor[1]=args[1] |
| const[x,y]=transformAbsolutePoint(matrix,args[0],args[1]) |
| args[0]=x |
| args[1]=y}if(command==="t"){cursor[0]+=args[0] |
| cursor[1]+=args[1] |
| const[x,y]=transformRelativePoint(matrix,args[0],args[1]) |
| args[0]=x |
| args[1]=y}if(command==="A"){transformArc(cursor,args,matrix) |
| cursor[0]=args[5] |
| cursor[1]=args[6] |
| if(Math.abs(args[2])>80){const a=args[0] |
| const rotation=args[2] |
| args[0]=args[1] |
| args[1]=a |
| args[2]=rotation+(rotation>0?-90:90)}const[x,y]=transformAbsolutePoint(matrix,args[5],args[6]) |
| args[5]=x |
| args[6]=y}if(command==="a"){transformArc([0,0],args,matrix) |
| cursor[0]+=args[5] |
| cursor[1]+=args[6] |
| if(Math.abs(args[2])>80){const a=args[0] |
| const rotation=args[2] |
| args[0]=args[1] |
| args[1]=a |
| args[2]=rotation+(rotation>0?-90:90)}const[x,y]=transformRelativePoint(matrix,args[5],args[6]) |
| args[5]=x |
| args[6]=y}if(command==="z"||command==="Z"){cursor[0]=start[0] |
| cursor[1]=start[1]}pathItem.command=command |
| pathItem.args=args}} |
| const name$q="convertPathData" |
| const description$q="optimizes path data: writes in shorter form, applies transformations" |
| let roundData |
| let precision |
| let error |
| let arcThreshold |
| let arcTolerance |
| const fn$q=(root,params)=>{const{applyTransforms:_applyTransforms=true,applyTransformsStroked:applyTransformsStroked=true,makeArcs:makeArcs={threshold:2.5,tolerance:0.5},straightCurves:straightCurves=true,convertToQ:convertToQ=true,lineShorthands:lineShorthands=true,convertToZ:convertToZ=true,curveSmoothShorthands:curveSmoothShorthands=true,floatPrecision:floatPrecision=3,transformPrecision:transformPrecision=5,smartArcRounding:smartArcRounding=true,removeUseless:removeUseless=true,collapseRepeated:collapseRepeated=true,utilizeAbsolute:utilizeAbsolute=true,leadingZero:leadingZero=true,negativeExtraSpace:negativeExtraSpace=true,noSpaceAfterFlags:noSpaceAfterFlags=false,forceAbsolutePath:forceAbsolutePath=false}=params |
| const newParams={applyTransforms:_applyTransforms,applyTransformsStroked:applyTransformsStroked,makeArcs:makeArcs,straightCurves:straightCurves,convertToQ:convertToQ,lineShorthands:lineShorthands,convertToZ:convertToZ,curveSmoothShorthands:curveSmoothShorthands,floatPrecision:floatPrecision,transformPrecision:transformPrecision,smartArcRounding:smartArcRounding,removeUseless:removeUseless,collapseRepeated:collapseRepeated,utilizeAbsolute:utilizeAbsolute,leadingZero:leadingZero,negativeExtraSpace:negativeExtraSpace,noSpaceAfterFlags:noSpaceAfterFlags,forceAbsolutePath:forceAbsolutePath} |
| _applyTransforms&&visit(root,applyTransforms(root,{transformPrecision:transformPrecision,applyTransformsStroked:applyTransformsStroked})) |
| const stylesheet=collectStylesheet(root) |
| return{element:{enter:node=>{if(pathElems.has(node.name)&&node.attributes.d!=null){const computedStyle=computeStyle(stylesheet,node) |
| precision=floatPrecision |
| error=precision!==false?+Math.pow(0.1,precision).toFixed(precision):1e-2 |
| roundData=precision&&precision>0&&precision<20?strongRound:round |
| if(makeArcs){arcThreshold=makeArcs.threshold |
| arcTolerance=makeArcs.tolerance}const hasMarkerMid=computedStyle["marker-mid"]!=null |
| const maybeHasStroke=computedStyle.stroke&&(computedStyle.stroke.type==="dynamic"||computedStyle.stroke.value!=="none") |
| const maybeHasLinecap=computedStyle["stroke-linecap"]&&(computedStyle["stroke-linecap"].type==="dynamic"||computedStyle["stroke-linecap"].value!=="butt") |
| const maybeHasStrokeAndLinecap=maybeHasStroke&&maybeHasLinecap |
| const isSafeToUseZ=!maybeHasStroke||computedStyle["stroke-linecap"]?.type==="static"&&computedStyle["stroke-linecap"].value==="round"&&computedStyle["stroke-linejoin"]?.type==="static"&&computedStyle["stroke-linejoin"].value==="round" |
| let data=path2js(node) |
| if(data.length){const includesVertices=data.some((item=>item.command!=="m"&&item.command!=="M")) |
| convertToRelative(data) |
| data=filters(data,newParams,{isSafeToUseZ:isSafeToUseZ,maybeHasStrokeAndLinecap:maybeHasStrokeAndLinecap,hasMarkerMid:hasMarkerMid}) |
| utilizeAbsolute&&(data=convertToMixed(data,newParams)) |
| const hasMarker=node.attributes["marker-start"]!=null||node.attributes["marker-end"]!=null |
| const isMarkersOnlyPath=hasMarker&&includesVertices&&data.every((item=>item.command==="m"||item.command==="M")) |
| isMarkersOnlyPath&&data.push({command:"z",args:[]}) |
| js2path(node,data,newParams)}}}}}} |
| const convertToRelative=pathData=>{let start=[0,0] |
| let cursor=[0,0] |
| let prevCoords=[0,0] |
| for(let i=0;i<pathData.length;i+=1){const pathItem=pathData[i] |
| let{command:command,args:args}=pathItem |
| if(command==="m"){cursor[0]+=args[0] |
| cursor[1]+=args[1] |
| start[0]=cursor[0] |
| start[1]=cursor[1]}if(command==="M"){i!==0&&(command="m") |
| args[0]-=cursor[0] |
| args[1]-=cursor[1] |
| cursor[0]+=args[0] |
| cursor[1]+=args[1] |
| start[0]=cursor[0] |
| start[1]=cursor[1]}if(command==="l"){cursor[0]+=args[0] |
| cursor[1]+=args[1]}if(command==="L"){command="l" |
| args[0]-=cursor[0] |
| args[1]-=cursor[1] |
| cursor[0]+=args[0] |
| cursor[1]+=args[1]}command==="h"&&(cursor[0]+=args[0]) |
| if(command==="H"){command="h" |
| args[0]-=cursor[0] |
| cursor[0]+=args[0]}command==="v"&&(cursor[1]+=args[0]) |
| if(command==="V"){command="v" |
| args[0]-=cursor[1] |
| cursor[1]+=args[0]}if(command==="c"){cursor[0]+=args[4] |
| cursor[1]+=args[5]}if(command==="C"){command="c" |
| args[0]-=cursor[0] |
| args[1]-=cursor[1] |
| args[2]-=cursor[0] |
| args[3]-=cursor[1] |
| args[4]-=cursor[0] |
| args[5]-=cursor[1] |
| cursor[0]+=args[4] |
| cursor[1]+=args[5]}if(command==="s"){cursor[0]+=args[2] |
| cursor[1]+=args[3]}if(command==="S"){command="s" |
| args[0]-=cursor[0] |
| args[1]-=cursor[1] |
| args[2]-=cursor[0] |
| args[3]-=cursor[1] |
| cursor[0]+=args[2] |
| cursor[1]+=args[3]}if(command==="q"){cursor[0]+=args[2] |
| cursor[1]+=args[3]}if(command==="Q"){command="q" |
| args[0]-=cursor[0] |
| args[1]-=cursor[1] |
| args[2]-=cursor[0] |
| args[3]-=cursor[1] |
| cursor[0]+=args[2] |
| cursor[1]+=args[3]}if(command==="t"){cursor[0]+=args[0] |
| cursor[1]+=args[1]}if(command==="T"){command="t" |
| args[0]-=cursor[0] |
| args[1]-=cursor[1] |
| cursor[0]+=args[0] |
| cursor[1]+=args[1]}if(command==="a"){cursor[0]+=args[5] |
| cursor[1]+=args[6]}if(command==="A"){command="a" |
| args[5]-=cursor[0] |
| args[6]-=cursor[1] |
| cursor[0]+=args[5] |
| cursor[1]+=args[6]}if(command==="Z"||command==="z"){cursor[0]=start[0] |
| cursor[1]=start[1]}pathItem.command=command |
| pathItem.args=args |
| pathItem.base=prevCoords |
| pathItem.coords=[cursor[0],cursor[1]] |
| prevCoords=pathItem.coords}return pathData} |
| function filters(path,params,{isSafeToUseZ:isSafeToUseZ,maybeHasStrokeAndLinecap:maybeHasStrokeAndLinecap,hasMarkerMid:hasMarkerMid}){const stringify=data2Path.bind(null,params) |
| const relSubpoint=[0,0] |
| const pathBase=[0,0] |
| let prev={} |
| let prevQControlPoint |
| path=path.filter((function(item,index,path){const qControlPoint=prevQControlPoint |
| let command=item.command |
| let data=item.args |
| let next=path[index+1] |
| if(command!=="Z"&&command!=="z"){var sdata=data,circle |
| if(command==="s"){sdata=[0,0].concat(data) |
| const pdata=prev.args |
| const n=pdata.length |
| sdata[0]=pdata[n-2]-pdata[n-4] |
| sdata[1]=pdata[n-1]-pdata[n-3]}if(params.makeArcs&&(command=="c"||command=="s")&&isConvex(sdata)&&(circle=findCircle(sdata))){var r=roundData([circle.radius])[0],angle=findArcAngle(sdata,circle),sweep=sdata[5]*sdata[0]-sdata[4]*sdata[1]>0?1:0,arc={command:"a",args:[r,r,0,0,sweep,sdata[4],sdata[5]],coords:item.coords.slice(),base:item.base},output=[arc],relCenter=[circle.center[0]-sdata[4],circle.center[1]-sdata[5]],relCircle={center:relCenter,radius:circle.radius},arcCurves=[item],hasPrev=0,suffix="",nextLonghand |
| if(prev.command=="c"&&isConvex(prev.args)&&isArcPrev(prev.args,circle)||prev.command=="a"&&prev.sdata&&isArcPrev(prev.sdata,circle)){arcCurves.unshift(prev) |
| arc.base=prev.base |
| arc.args[5]=arc.coords[0]-arc.base[0] |
| arc.args[6]=arc.coords[1]-arc.base[1] |
| var prevData=prev.command=="a"?prev.sdata:prev.args |
| var prevAngle=findArcAngle(prevData,{center:[prevData[4]+circle.center[0],prevData[5]+circle.center[1]],radius:circle.radius}) |
| angle+=prevAngle |
| angle>Math.PI&&(arc.args[3]=1) |
| hasPrev=1}for(var j=index;(next=path[++j])&&(next.command==="c"||next.command==="s");){var nextData=next.args |
| if(next.command=="s"){nextLonghand=makeLonghand({command:"s",args:next.args.slice()},path[j-1].args) |
| nextData=nextLonghand.args |
| nextLonghand.args=nextData.slice(0,2) |
| suffix=stringify([nextLonghand])}if(!isConvex(nextData)||!isArc(nextData,relCircle))break |
| angle+=findArcAngle(nextData,relCircle) |
| if(angle-2*Math.PI>1e-3)break |
| angle>Math.PI&&(arc.args[3]=1) |
| arcCurves.push(next) |
| if(!(2*Math.PI-angle>1e-3)){arc.args[5]=2*(relCircle.center[0]-nextData[4]) |
| arc.args[6]=2*(relCircle.center[1]-nextData[5]) |
| arc.coords=[arc.base[0]+arc.args[5],arc.base[1]+arc.args[6]] |
| arc={command:"a",args:[r,r,0,0,sweep,next.coords[0]-arc.coords[0],next.coords[1]-arc.coords[1]],coords:next.coords,base:arc.coords} |
| output.push(arc) |
| j++ |
| break}arc.coords=next.coords |
| arc.args[5]=arc.coords[0]-arc.base[0] |
| arc.args[6]=arc.coords[1]-arc.base[1] |
| relCenter[0]-=nextData[4] |
| relCenter[1]-=nextData[5]}if((stringify(output)+suffix).length<stringify(arcCurves).length){path[j]&&path[j].command=="s"&&makeLonghand(path[j],path[j-1].args) |
| if(hasPrev){var prevArc=output.shift() |
| roundData(prevArc.args) |
| relSubpoint[0]+=prevArc.args[5]-prev.args[prev.args.length-2] |
| relSubpoint[1]+=prevArc.args[6]-prev.args[prev.args.length-1] |
| prev.command="a" |
| prev.args=prevArc.args |
| item.base=prev.coords=prevArc.coords}arc=output.shift() |
| arcCurves.length==1?item.sdata=sdata.slice():arcCurves.length-1-hasPrev>0&&path.splice(index+1,arcCurves.length-1-hasPrev,...output) |
| if(!arc)return false |
| command="a" |
| data=arc.args |
| item.coords=arc.coords}}if(precision!==false){if(command==="m"||command==="l"||command==="t"||command==="q"||command==="s"||command==="c")for(var i=data.length;i--;)data[i]+=item.base[i%2]-relSubpoint[i%2] |
| else if(command=="h")data[0]+=item.base[0]-relSubpoint[0] |
| else if(command=="v")data[0]+=item.base[1]-relSubpoint[1] |
| else if(command=="a"){data[5]+=item.base[0]-relSubpoint[0] |
| data[6]+=item.base[1]-relSubpoint[1]}roundData(data) |
| if(command=="h")relSubpoint[0]+=data[0] |
| else if(command=="v")relSubpoint[1]+=data[0] |
| else{relSubpoint[0]+=data[data.length-2] |
| relSubpoint[1]+=data[data.length-1]}roundData(relSubpoint) |
| if(command==="M"||command==="m"){pathBase[0]=relSubpoint[0] |
| pathBase[1]=relSubpoint[1]}}const sagitta=command==="a"?calculateSagitta(data):void 0 |
| if(params.smartArcRounding&&sagitta!==void 0&&precision)for(let precisionNew=precision;precisionNew>=0;precisionNew--){const radius=toFixed(data[0],precisionNew) |
| const sagittaNew=calculateSagitta([radius,radius,...data.slice(2)]) |
| if(!(Math.abs(sagitta-sagittaNew)<error))break |
| data[0]=radius |
| data[1]=radius}if(params.straightCurves)if(command==="c"&&isCurveStraightLine(data)||command==="s"&&isCurveStraightLine(sdata)){next&&next.command=="s"&&makeLonghand(next,data) |
| command="l" |
| data=data.slice(-2)}else if(command==="q"&&isCurveStraightLine(data)){next&&next.command=="t"&&makeLonghand(next,data) |
| command="l" |
| data=data.slice(-2)}else if(command==="t"&&prev.command!=="q"&&prev.command!=="t"){command="l" |
| data=data.slice(-2)}else if(command==="a"&&(data[0]===0||data[1]===0||sagitta!==void 0&&sagitta<error)){command="l" |
| data=data.slice(-2)}if(params.convertToQ&&command=="c"){const x1=0.75*(item.base[0]+data[0])-0.25*item.base[0] |
| const x2=0.75*(item.base[0]+data[2])-0.25*(item.base[0]+data[4]) |
| if(Math.abs(x1-x2)<error*2){const y1=0.75*(item.base[1]+data[1])-0.25*item.base[1] |
| const y2=0.75*(item.base[1]+data[3])-0.25*(item.base[1]+data[5]) |
| if(Math.abs(y1-y2)<error*2){const newData=data.slice() |
| newData.splice(0,4,x1+x2-item.base[0],y1+y2-item.base[1]) |
| roundData(newData) |
| const originalLength=cleanupOutData(data,params).length,newLength=cleanupOutData(newData,params).length |
| if(newLength<originalLength){command="q" |
| data=newData |
| next&&next.command=="s"&&makeLonghand(next,data)}}}}if(params.lineShorthands&&command==="l")if(data[1]===0){command="h" |
| data.pop()}else if(data[0]===0){command="v" |
| data.shift()}if(params.collapseRepeated&&hasMarkerMid===false&&(command==="m"||command==="h"||command==="v")&&prev.command&&command==prev.command.toLowerCase()&&(command!="h"&&command!="v"||prev.args[0]>=0==data[0]>=0)){prev.args[0]+=data[0] |
| command!="h"&&command!="v"&&(prev.args[1]+=data[1]) |
| prev.coords=item.coords |
| path[index]=prev |
| return false}if(params.curveSmoothShorthands&&prev.command)if(command==="c"){if(prev.command==="c"&&Math.abs(data[0]- -(prev.args[2]-prev.args[4]))<error&&Math.abs(data[1]- -(prev.args[3]-prev.args[5]))<error){command="s" |
| data=data.slice(2)}else if(prev.command==="s"&&Math.abs(data[0]- -(prev.args[0]-prev.args[2]))<error&&Math.abs(data[1]- -(prev.args[1]-prev.args[3]))<error){command="s" |
| data=data.slice(2)}else if(prev.command!=="c"&&prev.command!=="s"&&Math.abs(data[0])<error&&Math.abs(data[1])<error){command="s" |
| data=data.slice(2)}}else if(command==="q")if(prev.command==="q"&&Math.abs(data[0]-(prev.args[2]-prev.args[0]))<error&&Math.abs(data[1]-(prev.args[3]-prev.args[1]))<error){command="t" |
| data=data.slice(2)}else if(prev.command==="t"){const predictedControlPoint=reflectPoint(qControlPoint,item.base) |
| const realControlPoint=[data[0]+item.base[0],data[1]+item.base[1]] |
| if(Math.abs(predictedControlPoint[0]-realControlPoint[0])<error&&Math.abs(predictedControlPoint[1]-realControlPoint[1])<error){command="t" |
| data=data.slice(2)}}if(params.removeUseless&&!maybeHasStrokeAndLinecap){if((command==="l"||command==="h"||command==="v"||command==="q"||command==="t"||command==="c"||command==="s")&&data.every((function(i){return i===0}))){path[index]=prev |
| return false}if(command==="a"&&data[5]===0&&data[6]===0){path[index]=prev |
| return false}}if(params.convertToZ&&(isSafeToUseZ||next?.command==="Z"||next?.command==="z")&&(command==="l"||command==="h"||command==="v")&&Math.abs(pathBase[0]-item.coords[0])<error&&Math.abs(pathBase[1]-item.coords[1])<error){command="z" |
| data=[]}item.command=command |
| item.args=data}else{relSubpoint[0]=pathBase[0] |
| relSubpoint[1]=pathBase[1] |
| if(prev.command==="Z"||prev.command==="z")return false}if((command==="Z"||command==="z")&¶ms.removeUseless&&isSafeToUseZ&&Math.abs(item.base[0]-item.coords[0])<error/10&&Math.abs(item.base[1]-item.coords[1])<error/10)return false |
| prevQControlPoint=command==="q"?[data[0]+item.base[0],data[1]+item.base[1]]:command==="t"?qControlPoint?reflectPoint(qControlPoint,item.base):item.coords:void 0 |
| prev=item |
| return true})) |
| return path}function convertToMixed(path,params){var prev=path[0] |
| path=path.filter((function(item,index){if(index==0)return true |
| if(item.command==="Z"||item.command==="z"){prev=item |
| return true}var command=item.command,data=item.args,adata=data.slice(),rdata=data.slice() |
| if(command==="m"||command==="l"||command==="t"||command==="q"||command==="s"||command==="c")for(var i=adata.length;i--;)adata[i]+=item.base[i%2] |
| else if(command=="h")adata[0]+=item.base[0] |
| else if(command=="v")adata[0]+=item.base[1] |
| else if(command=="a"){adata[5]+=item.base[0] |
| adata[6]+=item.base[1]}roundData(adata) |
| roundData(rdata) |
| var absoluteDataStr=cleanupOutData(adata,params),relativeDataStr=cleanupOutData(rdata,params) |
| if(params.forceAbsolutePath||absoluteDataStr.length<relativeDataStr.length&&!(params.negativeExtraSpace&&command==prev.command&&prev.command.charCodeAt(0)>96&&absoluteDataStr.length==relativeDataStr.length-1&&(data[0]<0||Math.floor(data[0])===0&&!Number.isInteger(data[0])&&prev.args[prev.args.length-1]%1))){item.command=command.toUpperCase() |
| item.args=adata}prev=item |
| return true})) |
| return path}function isConvex(data){var center=getIntersection([0,0,data[2],data[3],data[0],data[1],data[4],data[5]]) |
| return center!=null&&data[2]<center[0]==center[0]<0&&data[3]<center[1]==center[1]<0&&data[4]<center[0]==center[0]<data[0]&&data[5]<center[1]==center[1]<data[1]}function getIntersection(coords){var a1=coords[1]-coords[3],b1=coords[2]-coords[0],c1=coords[0]*coords[3]-coords[2]*coords[1],a2=coords[5]-coords[7],b2=coords[6]-coords[4],c2=coords[4]*coords[7]-coords[5]*coords[6],denom=a1*b2-a2*b1 |
| if(!denom)return |
| var cross=[(b1*c2-b2*c1)/denom,(a1*c2-a2*c1)/-denom] |
| if(!isNaN(cross[0])&&!isNaN(cross[1])&&isFinite(cross[0])&&isFinite(cross[1]))return cross}function strongRound(data){const precisionNum=precision||0 |
| for(let i=data.length;i-- >0;){const fixed=toFixed(data[i],precisionNum) |
| if(fixed!==data[i]){const rounded=toFixed(data[i],precisionNum-1) |
| data[i]=toFixed(Math.abs(rounded-data[i]),precisionNum+1)>=error?fixed:rounded}}return data}function round(data){for(var i=data.length;i-- >0;)data[i]=Math.round(data[i]) |
| return data}function isCurveStraightLine(data){var i=data.length-2,a=-data[i+1],b=data[i],d=1/(a*a+b*b) |
| if(i<=1||!isFinite(d))return false |
| while((i-=2)>=0)if(Math.sqrt(Math.pow(a*data[i]+b*data[i+1],2)*d)>error)return false |
| return true}function calculateSagitta(data){if(data[3]===1)return |
| const[rx,ry]=data |
| if(Math.abs(rx-ry)>error)return |
| const chord=Math.hypot(data[5],data[6]) |
| if(chord>rx*2)return |
| return rx-Math.sqrt(rx**2-0.25*chord**2)}function makeLonghand(item,data){switch(item.command){case"s":item.command="c" |
| break |
| case"t":item.command="q" |
| break}item.args.unshift(data[data.length-2]-data[data.length-4],data[data.length-1]-data[data.length-3]) |
| return item}function getDistance(point1,point2){return Math.hypot(point1[0]-point2[0],point1[1]-point2[1])}function reflectPoint(controlPoint,base){return[2*base[0]-controlPoint[0],2*base[1]-controlPoint[1]]}function getCubicBezierPoint(curve,t){var sqrT=t*t,cubT=sqrT*t,mt=1-t,sqrMt=mt*mt |
| return[3*sqrMt*t*curve[0]+3*mt*sqrT*curve[2]+cubT*curve[4],3*sqrMt*t*curve[1]+3*mt*sqrT*curve[3]+cubT*curve[5]]}function findCircle(curve){var midPoint=getCubicBezierPoint(curve,.5),m1=[midPoint[0]/2,midPoint[1]/2],m2=[(midPoint[0]+curve[4])/2,(midPoint[1]+curve[5])/2],center=getIntersection([m1[0],m1[1],m1[0]+m1[1],m1[1]-m1[0],m2[0],m2[1],m2[0]+(m2[1]-midPoint[1]),m2[1]-(m2[0]-midPoint[0])]),radius=center&&getDistance([0,0],center),tolerance=Math.min(arcThreshold*error,arcTolerance*radius/100) |
| if(center&&radius<1e15&&[1/4,3/4].every((function(point){return Math.abs(getDistance(getCubicBezierPoint(curve,point),center)-radius)<=tolerance})))return{center:center,radius:radius}}function isArc(curve,circle){var tolerance=Math.min(arcThreshold*error,arcTolerance*circle.radius/100) |
| return[0,1/4,.5,3/4,1].every((function(point){return Math.abs(getDistance(getCubicBezierPoint(curve,point),circle.center)-circle.radius)<=tolerance}))}function isArcPrev(curve,circle){return isArc(curve,{center:[circle.center[0]+curve[4],circle.center[1]+curve[5]],radius:circle.radius})}function findArcAngle(curve,relCircle){var x1=-relCircle.center[0],y1=-relCircle.center[1],x2=curve[4]-relCircle.center[0],y2=curve[5]-relCircle.center[1] |
| return Math.acos((x1*x2+y1*y2)/Math.sqrt((x1*x1+y1*y1)*(x2*x2+y2*y2)))}function data2Path(params,pathData){return pathData.reduce((function(pathString,item){var strData="" |
| item.args&&(strData=cleanupOutData(roundData(item.args.slice()),params)) |
| return pathString+item.command+strData}),"")}var convertPathData=Object.freeze({__proto__:null,description:description$q,fn:fn$q,name:name$q}) |
| const name$p="convertTransform" |
| const description$p="collapses multiple transformations and optimizes it" |
| const fn$p=(_root,params)=>{const{convertToShorts:convertToShorts=true,degPrecision:degPrecision,floatPrecision:floatPrecision=3,transformPrecision:transformPrecision=5,matrixToTransform:matrixToTransform=true,shortTranslate:shortTranslate=true,shortScale:shortScale=true,shortRotate:shortRotate=true,removeUseless:removeUseless=true,collapseIntoOne:collapseIntoOne=true,leadingZero:leadingZero=true,negativeExtraSpace:negativeExtraSpace=false}=params |
| const newParams={convertToShorts:convertToShorts,degPrecision:degPrecision,floatPrecision:floatPrecision,transformPrecision:transformPrecision,matrixToTransform:matrixToTransform,shortTranslate:shortTranslate,shortScale:shortScale,shortRotate:shortRotate,removeUseless:removeUseless,collapseIntoOne:collapseIntoOne,leadingZero:leadingZero,negativeExtraSpace:negativeExtraSpace} |
| return{element:{enter:node=>{node.attributes.transform!=null&&convertTransform(node,"transform",newParams) |
| node.attributes.gradientTransform!=null&&convertTransform(node,"gradientTransform",newParams) |
| node.attributes.patternTransform!=null&&convertTransform(node,"patternTransform",newParams)}}}} |
| const convertTransform=(item,attrName,params)=>{let data=transform2js(item.attributes[attrName]) |
| params=definePrecision(data,params) |
| params.collapseIntoOne&&data.length>1&&(data=[transformsMultiply(data)]) |
| params.convertToShorts?data=convertToShorts(data,params):data.forEach((item=>roundTransform(item,params))) |
| params.removeUseless&&(data=removeUseless(data)) |
| data.length?item.attributes[attrName]=js2transform(data,params):delete item.attributes[attrName]} |
| const definePrecision=(data,{...newParams})=>{const matrixData=[] |
| for(const item of data)item.name=="matrix"&&matrixData.push(...item.data.slice(0,4)) |
| let numberOfDigits=newParams.transformPrecision |
| if(matrixData.length){newParams.transformPrecision=Math.min(newParams.transformPrecision,Math.max.apply(Math,matrixData.map(floatDigits))||newParams.transformPrecision) |
| numberOfDigits=Math.max.apply(Math,matrixData.map((n=>n.toString().replace(/\D+/g,"").length)))}newParams.degPrecision==null&&(newParams.degPrecision=Math.max(0,Math.min(newParams.floatPrecision,numberOfDigits-2))) |
| return newParams} |
| const floatDigits=n=>{const str=n.toString() |
| return str.slice(str.indexOf(".")).length-1} |
| const convertToShorts=(transforms,params)=>{for(var i=0;i<transforms.length;i++){let transform=transforms[i] |
| if(params.matrixToTransform&&transform.name==="matrix"){var decomposed=matrixToTransform(transform,params) |
| js2transform(decomposed,params).length<=js2transform([transform],params).length&&transforms.splice(i,1,...decomposed) |
| transform=transforms[i]}roundTransform(transform,params) |
| params.shortTranslate&&transform.name==="translate"&&transform.data.length===2&&!transform.data[1]&&transform.data.pop() |
| params.shortScale&&transform.name==="scale"&&transform.data.length===2&&transform.data[0]===transform.data[1]&&transform.data.pop() |
| if(params.shortRotate&&transforms[i-2]?.name==="translate"&&transforms[i-1].name==="rotate"&&transforms[i].name==="translate"&&transforms[i-2].data[0]===-transforms[i].data[0]&&transforms[i-2].data[1]===-transforms[i].data[1]){transforms.splice(i-2,3,{name:"rotate",data:[transforms[i-1].data[0],transforms[i-2].data[0],transforms[i-2].data[1]]}) |
| i-=2}}return transforms} |
| const removeUseless=transforms=>transforms.filter((transform=>{if(["translate","rotate","skewX","skewY"].indexOf(transform.name)>-1&&(transform.data.length==1||transform.name=="rotate")&&!transform.data[0]||transform.name=="translate"&&!transform.data[0]&&!transform.data[1]||transform.name=="scale"&&transform.data[0]==1&&(transform.data.length<2||transform.data[1]==1)||transform.name=="matrix"&&transform.data[0]==1&&transform.data[3]==1&&!(transform.data[1]||transform.data[2]||transform.data[4]||transform.data[5]))return false |
| return true})) |
| var convertTransform$1=Object.freeze({__proto__:null,description:description$p,fn:fn$p,name:name$p}) |
| const name$o="removeEmptyAttrs" |
| const description$o="removes empty attributes" |
| const fn$o=()=>({element:{enter:node=>{for(const[name,value]of Object.entries(node.attributes))value!==""||attrsGroups.conditionalProcessing.has(name)||delete node.attributes[name]}}}) |
| var removeEmptyAttrs=Object.freeze({__proto__:null,description:description$o,fn:fn$o,name:name$o}) |
| const name$n="removeEmptyContainers" |
| const description$n="removes empty container elements" |
| const fn$n=()=>({element:{exit:(node,parentNode)=>{if(node.name==="svg"||!elemsGroups.container.has(node.name)||node.children.length!==0)return |
| if(node.name==="pattern"&&Object.keys(node.attributes).length!==0)return |
| if(node.name==="g"&&node.attributes.filter!=null)return |
| if(node.name==="mask"&&node.attributes.id!=null)return |
| if(parentNode.type==="element"&&parentNode.name==="switch")return |
| detachNodeFromParent(node,parentNode)}}}) |
| var removeEmptyContainers=Object.freeze({__proto__:null,description:description$n,fn:fn$n,name:name$n}) |
| const name$m="mergePaths" |
| const description$m="merges multiple paths in one if possible" |
| function elementHasUrl(computedStyle,attName){const style=computedStyle[attName] |
| if(style?.type==="static")return includesUrlReference(style.value) |
| return false}const fn$m=(root,params)=>{const{force:force=false,floatPrecision:floatPrecision=3,noSpaceAfterFlags:noSpaceAfterFlags=false}=params |
| const stylesheet=collectStylesheet(root) |
| return{element:{enter:node=>{if(node.children.length<=1)return |
| const elementsToRemove=[] |
| let prevChild=node.children[0] |
| let prevPathData=null |
| const updatePreviousPath=(child,pathData)=>{js2path(child,pathData,{floatPrecision:floatPrecision,noSpaceAfterFlags:noSpaceAfterFlags}) |
| prevPathData=null} |
| for(let i=1;i<node.children.length;i++){const child=node.children[i] |
| if(prevChild.type!=="element"||prevChild.name!=="path"||prevChild.children.length!==0||prevChild.attributes.d==null){prevPathData&&prevChild.type==="element"&&updatePreviousPath(prevChild,prevPathData) |
| prevChild=child |
| continue}if(child.type!=="element"||child.name!=="path"||child.children.length!==0||child.attributes.d==null){prevPathData&&updatePreviousPath(prevChild,prevPathData) |
| prevChild=child |
| continue}const computedStyle=computeStyle(stylesheet,child) |
| if(computedStyle["marker-start"]||computedStyle["marker-mid"]||computedStyle["marker-end"]||computedStyle["clip-path"]||computedStyle["mask"]||computedStyle["mask-image"]||["fill","filter","stroke"].some((attName=>elementHasUrl(computedStyle,attName)))){prevPathData&&updatePreviousPath(prevChild,prevPathData) |
| prevChild=child |
| continue}const childAttrs=Object.keys(child.attributes) |
| if(childAttrs.length!==Object.keys(prevChild.attributes).length){prevPathData&&updatePreviousPath(prevChild,prevPathData) |
| prevChild=child |
| continue}const areAttrsEqual=childAttrs.some((attr=>attr!=="d"&&prevChild.type==="element"&&prevChild.attributes[attr]!==child.attributes[attr])) |
| if(areAttrsEqual){prevPathData&&updatePreviousPath(prevChild,prevPathData) |
| prevChild=child |
| continue}const hasPrevPath=prevPathData!=null |
| const currentPathData=path2js(child) |
| prevPathData=prevPathData??path2js(prevChild) |
| if(force||!intersects(prevPathData,currentPathData)){prevPathData.push(...currentPathData) |
| elementsToRemove.push(child) |
| continue}hasPrevPath&&updatePreviousPath(prevChild,prevPathData) |
| prevChild=child |
| prevPathData=null}prevPathData&&prevChild.type==="element"&&updatePreviousPath(prevChild,prevPathData) |
| node.children=node.children.filter((child=>!elementsToRemove.includes(child)))}}}} |
| var mergePaths=Object.freeze({__proto__:null,description:description$m,fn:fn$m,name:name$m}) |
| const name$l="removeUnusedNS" |
| const description$l="removes unused namespaces declaration" |
| const fn$l=()=>{const unusedNamespaces=new Set |
| return{element:{enter:(node,parentNode)=>{if(node.name==="svg"&&parentNode.type==="root")for(const name of Object.keys(node.attributes))if(name.startsWith("xmlns:")){const local=name.slice(6) |
| unusedNamespaces.add(local)}if(unusedNamespaces.size!==0){if(node.name.includes(":")){const[ns]=node.name.split(":") |
| unusedNamespaces.has(ns)&&unusedNamespaces.delete(ns)}for(const name of Object.keys(node.attributes))if(name.includes(":")){const[ns]=name.split(":") |
| unusedNamespaces.delete(ns)}}},exit:(node,parentNode)=>{if(node.name==="svg"&&parentNode.type==="root")for(const name of unusedNamespaces)delete node.attributes[`xmlns:${name}`]}}}} |
| var removeUnusedNS=Object.freeze({__proto__:null,description:description$l,fn:fn$l,name:name$l}) |
| const name$k="sortAttrs" |
| const description$k="Sort element attributes for better compression" |
| const fn$k=(_root,params)=>{const{order:order=["id","width","height","x","x1","x2","y","y1","y2","cx","cy","r","fill","stroke","marker","d","points"],xmlnsOrder:xmlnsOrder="front"}=params |
| const getNsPriority=name=>{if(xmlnsOrder==="front"){if(name==="xmlns")return 3 |
| if(name.startsWith("xmlns:"))return 2}if(name.includes(":"))return 1 |
| return 0} |
| const compareAttrs=([aName],[bName])=>{const aPriority=getNsPriority(aName) |
| const bPriority=getNsPriority(bName) |
| const priorityNs=bPriority-aPriority |
| if(priorityNs!==0)return priorityNs |
| const[aPart]=aName.split("-") |
| const[bPart]=bName.split("-") |
| if(aPart!==bPart){const aInOrderFlag=order.includes(aPart)?1:0 |
| const bInOrderFlag=order.includes(bPart)?1:0 |
| if(aInOrderFlag===1&&bInOrderFlag===1)return order.indexOf(aPart)-order.indexOf(bPart) |
| const priorityOrder=bInOrderFlag-aInOrderFlag |
| if(priorityOrder!==0)return priorityOrder}return aName<bName?-1:1} |
| return{element:{enter:node=>{const attrs=Object.entries(node.attributes) |
| attrs.sort(compareAttrs) |
| const sortedAttributes={} |
| for(const[name,value]of attrs)sortedAttributes[name]=value |
| node.attributes=sortedAttributes}}}} |
| var sortAttrs=Object.freeze({__proto__:null,description:description$k,fn:fn$k,name:name$k}) |
| const name$j="sortDefsChildren" |
| const description$j="Sorts children of <defs> to improve compression" |
| const fn$j=()=>({element:{enter:node=>{if(node.name==="defs"){const frequencies=new Map |
| for(const child of node.children)if(child.type==="element"){const frequency=frequencies.get(child.name) |
| frequency==null?frequencies.set(child.name,1):frequencies.set(child.name,frequency+1)}node.children.sort(((a,b)=>{if(a.type!=="element"||b.type!=="element")return 0 |
| const aFrequency=frequencies.get(a.name) |
| const bFrequency=frequencies.get(b.name) |
| if(aFrequency!=null&&bFrequency!=null){const frequencyComparison=bFrequency-aFrequency |
| if(frequencyComparison!==0)return frequencyComparison}const lengthComparison=b.name.length-a.name.length |
| if(lengthComparison!==0)return lengthComparison |
| if(a.name!==b.name)return a.name>b.name?-1:1 |
| return 0}))}}}}) |
| var sortDefsChildren=Object.freeze({__proto__:null,description:description$j,fn:fn$j,name:name$j}) |
| const name$i="removeTitle" |
| const description$i="removes <title>" |
| const fn$i=()=>({element:{enter:(node,parentNode)=>{node.name==="title"&&detachNodeFromParent(node,parentNode)}}}) |
| var removeTitle=Object.freeze({__proto__:null,description:description$i,fn:fn$i,name:name$i}) |
| const name$h="removeDesc" |
| const description$h="removes <desc>" |
| const standardDescs=/^(Created with|Created using)/ |
| const fn$h=(root,params)=>{const{removeAny:removeAny=false}=params |
| return{element:{enter:(node,parentNode)=>{node.name==="desc"&&(removeAny||node.children.length===0||node.children[0].type==="text"&&standardDescs.test(node.children[0].value))&&detachNodeFromParent(node,parentNode)}}}} |
| var removeDesc=Object.freeze({__proto__:null,description:description$h,fn:fn$h,name:name$h}) |
| const presetDefault=createPreset({name:"preset-default",plugins:[removeDoctype,removeXMLProcInst,removeComments,removeDeprecatedAttrs,removeMetadata,removeEditorsNSData,cleanupAttrs,mergeStyles,inlineStyles,minifyStyles,cleanupIds,removeUselessDefs,cleanupNumericValues,convertColors,removeUnknownsAndDefaults,removeNonInheritableGroupAttrs,removeUselessStrokeAndFill,removeViewBox,cleanupEnableBackground,removeHiddenElems,removeEmptyText,convertShapeToPath,convertEllipseToCircle,moveElemsAttrsToGroup,moveGroupAttrsToElems,collapseGroups,convertPathData,convertTransform$1,removeEmptyAttrs,removeEmptyContainers,mergePaths,removeUnusedNS,sortAttrs,sortDefsChildren,removeTitle,removeDesc]}) |
| const name$g="addAttributesToSVGElement" |
| const description$g="adds attributes to an outer <svg> element" |
| var ENOCLS$1='Error in plugin "addAttributesToSVGElement": absent parameters.\nIt should have a list of "attributes" or one "attribute".\nConfig example:\n\nplugins: [\n {\n name: \'addAttributesToSVGElement\',\n params: {\n attribute: "mySvg"\n }\n }\n]\n\nplugins: [\n {\n name: \'addAttributesToSVGElement\',\n params: {\n attributes: ["mySvg", "size-big"]\n }\n }\n]\n\nplugins: [\n {\n name: \'addAttributesToSVGElement\',\n params: {\n attributes: [\n {\n focusable: false\n },\n {\n \'data-image\': icon\n }\n ]\n }\n }\n]\n' |
| const fn$g=(root,params)=>{if(!Array.isArray(params.attributes)&&!params.attribute){console.error(ENOCLS$1) |
| return null}const attributes=params.attributes||[params.attribute] |
| return{element:{enter:(node,parentNode)=>{if(node.name==="svg"&&parentNode.type==="root")for(const attribute of attributes){typeof attribute==="string"&&node.attributes[attribute]==null&&(node.attributes[attribute]=void 0) |
| if(typeof attribute==="object")for(const key of Object.keys(attribute))node.attributes[key]==null&&(node.attributes[key]=attribute[key])}}}}} |
| var addAttributesToSVGElement=Object.freeze({__proto__:null,description:description$g,fn:fn$g,name:name$g}) |
| const name$f="addClassesToSVGElement" |
| const description$f="adds classnames to an outer <svg> element" |
| var ENOCLS='Error in plugin "addClassesToSVGElement": absent parameters.\nIt should have a list of classes in "classNames" or one "className".\nConfig example:\n\nplugins: [\n {\n name: "addClassesToSVGElement",\n params: {\n className: "mySvg"\n }\n }\n]\n\nplugins: [\n {\n name: "addClassesToSVGElement",\n params: {\n classNames: ["mySvg", "size-big"]\n }\n }\n]\n' |
| const fn$f=(root,params,info)=>{if(!(Array.isArray(params.classNames)&¶ms.classNames.length!==0)&&!params.className){console.error(ENOCLS) |
| return null}const classNames=params.classNames||[params.className] |
| return{element:{enter:(node,parentNode)=>{if(node.name==="svg"&&parentNode.type==="root"){const classList=new Set(node.attributes.class==null?null:node.attributes.class.split(" ")) |
| for(const className of classNames)if(className!=null){const classToAdd=typeof className==="string"?className:className(node,info) |
| classList.add(classToAdd)}node.attributes.class=Array.from(classList).join(" ")}}}}} |
| var addClassesToSVGElement=Object.freeze({__proto__:null,description:description$f,fn:fn$f,name:name$f}) |
| const name$e="cleanupListOfValues" |
| const description$e="rounds list of values to the fixed precision" |
| const regNumericValues=/^([-+]?\d*\.?\d+([eE][-+]?\d+)?)(px|pt|pc|mm|cm|m|in|ft|em|ex|%)?$/ |
| const regSeparator=/\s+,?\s*|,\s*/ |
| const absoluteLengths={cm:96/2.54,mm:96/25.4,in:96,pt:4/3,pc:16,px:1} |
| const fn$e=(_root,params)=>{const{floatPrecision:floatPrecision=3,leadingZero:leadingZero=true,defaultPx:defaultPx=true,convertToPx:convertToPx=true}=params |
| const roundValues=lists=>{const roundedList=[] |
| for(const elem of lists.split(regSeparator)){const match=elem.match(regNumericValues) |
| const matchNew=elem.match(/new/) |
| if(match){let num=Number(Number(match[1]).toFixed(floatPrecision)) |
| let matchedUnit=match[3]||"" |
| let units=matchedUnit |
| if(convertToPx&&units&&units in absoluteLengths){const pxNum=Number((absoluteLengths[units]*Number(match[1])).toFixed(floatPrecision)) |
| if(pxNum.toString().length<match[0].length){num=pxNum |
| units="px"}}let str |
| str=leadingZero?removeLeadingZero(num):num.toString() |
| defaultPx&&units==="px"&&(units="") |
| roundedList.push(str+units)}else matchNew?roundedList.push("new"):elem&&roundedList.push(elem)}return roundedList.join(" ")} |
| return{element:{enter:node=>{node.attributes.points!=null&&(node.attributes.points=roundValues(node.attributes.points)) |
| node.attributes["enable-background"]!=null&&(node.attributes["enable-background"]=roundValues(node.attributes["enable-background"])) |
| node.attributes.viewBox!=null&&(node.attributes.viewBox=roundValues(node.attributes.viewBox)) |
| node.attributes["stroke-dasharray"]!=null&&(node.attributes["stroke-dasharray"]=roundValues(node.attributes["stroke-dasharray"])) |
| node.attributes.dx!=null&&(node.attributes.dx=roundValues(node.attributes.dx)) |
| node.attributes.dy!=null&&(node.attributes.dy=roundValues(node.attributes.dy)) |
| node.attributes.x!=null&&(node.attributes.x=roundValues(node.attributes.x)) |
| node.attributes.y!=null&&(node.attributes.y=roundValues(node.attributes.y))}}}} |
| var cleanupListOfValues=Object.freeze({__proto__:null,description:description$e,fn:fn$e,name:name$e}) |
| const name$d="convertOneStopGradients" |
| const description$d="converts one-stop (single color) gradients to a plain color" |
| const fn$d=root=>{const stylesheet=collectStylesheet(root) |
| const effectedDefs=new Set |
| const allDefs=new Map |
| const gradientsToDetach=new Map |
| let xlinkHrefCount=0 |
| return{element:{enter:(node,parentNode)=>{node.attributes["xlink:href"]!=null&&xlinkHrefCount++ |
| if(node.name==="defs"){allDefs.set(node,parentNode) |
| return}if(node.name!=="linearGradient"&&node.name!=="radialGradient")return |
| const stops=node.children.filter((child=>child.type==="element"&&child.name==="stop")) |
| const href=node.attributes["xlink:href"]||node.attributes["href"] |
| let effectiveNode=stops.length===0&&href!=null&&href.startsWith("#")?querySelector(root,href):node |
| if(effectiveNode==null||effectiveNode.type!=="element"){gradientsToDetach.set(node,parentNode) |
| return}const effectiveStops=effectiveNode.children.filter((child=>child.type==="element"&&child.name==="stop")) |
| if(effectiveStops.length!==1||effectiveStops[0].type!=="element")return |
| parentNode.type==="element"&&parentNode.name==="defs"&&effectedDefs.add(parentNode) |
| gradientsToDetach.set(node,parentNode) |
| let color |
| const style=computeStyle(stylesheet,effectiveStops[0])["stop-color"] |
| style!=null&&style.type==="static"&&(color=style.value) |
| const selectorVal=`url(#${node.attributes.id})` |
| const selector=[...colorsProps].map((attr=>`[${attr}="${selectorVal}"]`)).join(",") |
| const elements=querySelectorAll(root,selector) |
| for(const element of elements){if(element.type!=="element")continue |
| for(const attr of colorsProps){if(element.attributes[attr]!==selectorVal)continue |
| color!=null?element.attributes[attr]=color:delete element.attributes[attr]}}const styledElements=querySelectorAll(root,`[style*=${selectorVal}]`) |
| for(const element of styledElements){if(element.type!=="element")continue |
| element.attributes.style=element.attributes.style.replace(selectorVal,color||attrsGroupsDefaults.presentation["stop-color"])}},exit:node=>{if(node.name==="svg"){for(const[gradient,parent]of gradientsToDetach.entries()){gradient.attributes["xlink:href"]!=null&&xlinkHrefCount-- |
| detachNodeFromParent(gradient,parent)}xlinkHrefCount===0&&delete node.attributes["xmlns:xlink"] |
| for(const[defs,parent]of allDefs.entries())effectedDefs.has(defs)&&defs.children.length===0&&detachNodeFromParent(defs,parent)}}}}} |
| var convertOneStopGradients=Object.freeze({__proto__:null,description:description$d,fn:fn$d,name:name$d}) |
| const name$c="convertStyleToAttrs" |
| const description$c="converts style to attributes" |
| const g=(...args)=>"(?:"+args.join("|")+")" |
| const stylingProps=attrsGroups.presentation |
| const rEscape="\\\\(?:[0-9a-f]{1,6}\\s?|\\r\\n|.)" |
| const rAttr="\\s*("+g("[^:;\\\\]",rEscape)+"*?)\\s*" |
| const rSingleQuotes="'(?:[^'\\n\\r\\\\]|"+rEscape+")*?(?:'|$)" |
| const rQuotes='"(?:[^"\\n\\r\\\\]|'+rEscape+')*?(?:"|$)' |
| const rQuotedString=new RegExp("^"+g(rSingleQuotes,rQuotes)+"$") |
| const rParenthesis="\\("+g("[^'\"()\\\\]+",rEscape,rSingleQuotes,rQuotes)+"*?\\)" |
| const rValue="\\s*("+g("[^!'\"();\\\\]+?",rEscape,rSingleQuotes,rQuotes,rParenthesis,"[^;]*?")+"*?)" |
| const rDeclEnd="\\s*(?:;\\s*|$)" |
| const rImportant="(\\s*!important(?![-(\\w]))?" |
| const regDeclarationBlock=new RegExp(rAttr+":"+rValue+rImportant+rDeclEnd,"ig") |
| const regStripComments=new RegExp(g(rEscape,rSingleQuotes,rQuotes,"/\\*[^]*?\\*/"),"ig") |
| const fn$c=(_root,params)=>{const{keepImportant:keepImportant=false}=params |
| return{element:{enter:node=>{if(node.attributes.style!=null){let styles=[] |
| const newAttributes={} |
| const styleValue=node.attributes.style.replace(regStripComments,(match=>match[0]=="/"?"":match[0]=="\\"&&/[-g-z]/i.test(match[1])?match[1]:match)) |
| regDeclarationBlock.lastIndex=0 |
| for(var rule;rule=regDeclarationBlock.exec(styleValue);)keepImportant&&rule[3]||styles.push([rule[1],rule[2]]) |
| if(styles.length){styles=styles.filter((function(style){if(style[0]){var prop=style[0].toLowerCase(),val=style[1] |
| rQuotedString.test(val)&&(val=val.slice(1,-1)) |
| if(stylingProps.has(prop)){newAttributes[prop]=val |
| return false}}return true})) |
| Object.assign(node.attributes,newAttributes) |
| styles.length?node.attributes.style=styles.map((declaration=>declaration.join(":"))).join(";"):delete node.attributes.style}}}}}} |
| var convertStyleToAttrs=Object.freeze({__proto__:null,description:description$c,fn:fn$c,name:name$c}) |
| const name$b="prefixIds" |
| const description$b="prefix IDs" |
| const getBasename=path=>{const matched=/[/\\]?([^/\\]+)$/.exec(path) |
| if(matched)return matched[1] |
| return""} |
| const escapeIdentifierName=str=>str.replace(/[. ]/g,"_") |
| const unquote=string=>{if(string.startsWith('"')&&string.endsWith('"')||string.startsWith("'")&&string.endsWith("'"))return string.slice(1,-1) |
| return string} |
| const prefixId=(prefixGenerator,body)=>{const prefix=prefixGenerator(body) |
| if(body.startsWith(prefix))return body |
| return prefix+body} |
| const prefixReference=(prefixGenerator,reference)=>{if(reference.startsWith("#"))return"#"+prefixId(prefixGenerator,reference.slice(1)) |
| return null} |
| const generatePrefix=(body,node,info,prefixGenerator,delim,history)=>{if(typeof prefixGenerator==="function"){let prefix=history.get(body) |
| if(prefix!=null)return prefix |
| prefix=prefixGenerator(node,info)+delim |
| history.set(body,prefix) |
| return prefix}if(typeof prefixGenerator==="string")return prefixGenerator+delim |
| if(prefixGenerator===false)return"" |
| if(info.path!=null&&info.path.length>0)return escapeIdentifierName(getBasename(info.path))+delim |
| return"prefix"+delim} |
| const fn$b=(_root,params,info)=>{const{delim:delim="__",prefix:prefix,prefixIds:prefixIds=true,prefixClassNames:prefixClassNames=true}=params |
| const prefixMap=new Map |
| return{element:{enter:node=>{const prefixGenerator=id=>generatePrefix(id,node,info,prefix,delim,prefixMap) |
| if(node.name==="style"){if(node.children.length===0)return |
| for(const child of node.children){if(child.type!=="text"&&child.type!=="cdata")continue |
| const cssText=child.value |
| let cssAst=null |
| try{cssAst=csstree__namespace.parse(cssText,{parseValue:true,parseCustomProperty:false})}catch{return}csstree__namespace.walk(cssAst,(node=>{if(prefixIds&&node.type==="IdSelector"||prefixClassNames&&node.type==="ClassSelector"){node.name=prefixId(prefixGenerator,node.name) |
| return}if(node.type==="Url"&&node.value.length>0){const prefixed=prefixReference(prefixGenerator,unquote(node.value)) |
| prefixed!=null&&(node.value=prefixed)}})) |
| child.value=csstree__namespace.generate(cssAst)}}prefixIds&&node.attributes.id!=null&&node.attributes.id.length!==0&&(node.attributes.id=prefixId(prefixGenerator,node.attributes.id)) |
| prefixClassNames&&node.attributes.class!=null&&node.attributes.class.length!==0&&(node.attributes.class=node.attributes.class.split(/\s+/).map((name=>prefixId(prefixGenerator,name))).join(" ")) |
| for(const name of["href","xlink:href"])if(node.attributes[name]!=null&&node.attributes[name].length!==0){const prefixed=prefixReference(prefixGenerator,node.attributes[name]) |
| prefixed!=null&&(node.attributes[name]=prefixed)}for(const name of referencesProps)node.attributes[name]!=null&&node.attributes[name].length!==0&&(node.attributes[name]=node.attributes[name].replace(/\burl\((["'])?(#.+?)\1\)/gi,((match,_,url)=>{const prefixed=prefixReference(prefixGenerator,url) |
| if(prefixed==null)return match |
| return`url(${prefixed})`}))) |
| for(const name of["begin","end"])if(node.attributes[name]!=null&&node.attributes[name].length!==0){const parts=node.attributes[name].split(/\s*;\s+/).map((val=>{if(val.endsWith(".end")||val.endsWith(".start")){const[id,postfix]=val.split(".") |
| return`${prefixId(prefixGenerator,id)}.${postfix}`}return val})) |
| node.attributes[name]=parts.join("; ")}}}}} |
| var prefixIds=Object.freeze({__proto__:null,description:description$b,fn:fn$b,name:name$b}) |
| const name$a="removeAttributesBySelector" |
| const description$a="removes attributes of elements that match a css selector" |
| const fn$a=(root,params)=>{const selectors=Array.isArray(params.selectors)?params.selectors:[params] |
| for(const{selector:selector,attributes:attributes}of selectors){const nodes=querySelectorAll(root,selector) |
| for(const node of nodes)if(node.type==="element")if(Array.isArray(attributes))for(const name of attributes)delete node.attributes[name] |
| else delete node.attributes[attributes]}return{}} |
| var removeAttributesBySelector=Object.freeze({__proto__:null,description:description$a,fn:fn$a,name:name$a}) |
| const name$9="removeAttrs" |
| const description$9="removes specified attributes" |
| const DEFAULT_SEPARATOR=":" |
| const ENOATTRS='Warning: The plugin "removeAttrs" requires the "attrs" parameter.\nIt should have a pattern to remove, otherwise the plugin is a noop.\nConfig example:\n\nplugins: [\n {\n name: "removeAttrs",\n params: {\n attrs: "(fill|stroke)"\n }\n }\n]\n' |
| const fn$9=(root,params)=>{if(typeof params.attrs=="undefined"){console.warn(ENOATTRS) |
| return null}const elemSeparator=typeof params.elemSeparator=="string"?params.elemSeparator:DEFAULT_SEPARATOR |
| const preserveCurrentColor=typeof params.preserveCurrentColor=="boolean"&¶ms.preserveCurrentColor |
| const attrs=Array.isArray(params.attrs)?params.attrs:[params.attrs] |
| return{element:{enter:node=>{for(let pattern of attrs){pattern.includes(elemSeparator)?pattern.split(elemSeparator).length<3&&(pattern=[pattern,".*"].join(elemSeparator)):pattern=[".*",pattern,".*"].join(elemSeparator) |
| const list=pattern.split(elemSeparator).map((value=>{value==="*"&&(value=".*") |
| return new RegExp(["^",value,"$"].join(""),"i")})) |
| if(list[0].test(node.name))for(const[name,value]of Object.entries(node.attributes)){const isCurrentColor=value.toLowerCase()==="currentcolor" |
| const isFillCurrentColor=preserveCurrentColor&&name=="fill"&&isCurrentColor |
| const isStrokeCurrentColor=preserveCurrentColor&&name=="stroke"&&isCurrentColor |
| !isFillCurrentColor&&!isStrokeCurrentColor&&list[1].test(name)&&list[2].test(value)&&delete node.attributes[name]}}}}}} |
| var removeAttrs=Object.freeze({__proto__:null,description:description$9,fn:fn$9,name:name$9}) |
| const name$8="removeDimensions" |
| const description$8="removes width and height in presence of viewBox (opposite to removeViewBox, disable it first)" |
| const fn$8=()=>({element:{enter:node=>{if(node.name==="svg")if(node.attributes.viewBox!=null){delete node.attributes.width |
| delete node.attributes.height}else if(node.attributes.width!=null&&node.attributes.height!=null&&Number.isNaN(Number(node.attributes.width))===false&&Number.isNaN(Number(node.attributes.height))===false){const width=Number(node.attributes.width) |
| const height=Number(node.attributes.height) |
| node.attributes.viewBox=`0 0 ${width} ${height}` |
| delete node.attributes.width |
| delete node.attributes.height}}}}) |
| var removeDimensions=Object.freeze({__proto__:null,description:description$8,fn:fn$8,name:name$8}) |
| const name$7="removeElementsByAttr" |
| const description$7="removes arbitrary elements by ID or className (disabled by default)" |
| const fn$7=(root,params)=>{const ids=params.id==null?[]:Array.isArray(params.id)?params.id:[params.id] |
| const classes=params.class==null?[]:Array.isArray(params.class)?params.class:[params.class] |
| return{element:{enter:(node,parentNode)=>{node.attributes.id!=null&&ids.length!==0&&ids.includes(node.attributes.id)&&detachNodeFromParent(node,parentNode) |
| if(node.attributes.class&&classes.length!==0){const classList=node.attributes.class.split(" ") |
| for(const item of classes)if(classList.includes(item)){detachNodeFromParent(node,parentNode) |
| break}}}}}} |
| var removeElementsByAttr=Object.freeze({__proto__:null,description:description$7,fn:fn$7,name:name$7}) |
| const name$6="removeOffCanvasPaths" |
| const description$6="removes elements that are drawn outside of the viewbox (disabled by default)" |
| const fn$6=()=>{let viewBoxData=null |
| return{element:{enter:(node,parentNode)=>{if(node.name==="svg"&&parentNode.type==="root"){let viewBox="" |
| node.attributes.viewBox!=null?viewBox=node.attributes.viewBox:node.attributes.height!=null&&node.attributes.width!=null&&(viewBox=`0 0 ${node.attributes.width} ${node.attributes.height}`) |
| viewBox=viewBox.replace(/[,+]|px/g," ").replace(/\s+/g," ").replace(/^\s*|\s*$/g,"") |
| const m=/^(-?\d*\.?\d+) (-?\d*\.?\d+) (\d*\.?\d+) (\d*\.?\d+)$/.exec(viewBox) |
| if(m==null)return |
| const left=Number.parseFloat(m[1]) |
| const top=Number.parseFloat(m[2]) |
| const width=Number.parseFloat(m[3]) |
| const height=Number.parseFloat(m[4]) |
| viewBoxData={left:left,top:top,right:left+width,bottom:top+height,width:width,height:height}}if(node.attributes.transform!=null)return visitSkip |
| if(node.name==="path"&&node.attributes.d!=null&&viewBoxData!=null){const pathData=parsePathData(node.attributes.d) |
| let visible=false |
| for(const pathDataItem of pathData)if(pathDataItem.command==="M"){const[x,y]=pathDataItem.args |
| x>=viewBoxData.left&&x<=viewBoxData.right&&y>=viewBoxData.top&&y<=viewBoxData.bottom&&(visible=true)}if(visible)return |
| pathData.length===2&&pathData.push({command:"z",args:[]}) |
| const{left:left,top:top,width:width,height:height}=viewBoxData |
| const viewBoxPathData=[{command:"M",args:[left,top]},{command:"h",args:[width]},{command:"v",args:[height]},{command:"H",args:[left]},{command:"z",args:[]}] |
| intersects(viewBoxPathData,pathData)===false&&detachNodeFromParent(node,parentNode)}}}}} |
| var removeOffCanvasPaths=Object.freeze({__proto__:null,description:description$6,fn:fn$6,name:name$6}) |
| const name$5="removeRasterImages" |
| const description$5="removes raster images (disabled by default)" |
| const fn$5=()=>({element:{enter:(node,parentNode)=>{node.name==="image"&&node.attributes["xlink:href"]!=null&&/(\.|image\/)(jpe?g|png|gif)/.test(node.attributes["xlink:href"])&&detachNodeFromParent(node,parentNode)}}}) |
| var removeRasterImages=Object.freeze({__proto__:null,description:description$5,fn:fn$5,name:name$5}) |
| const name$4="removeScriptElement" |
| const description$4="removes scripts (disabled by default)" |
| const eventAttrs=[...attrsGroups.animationEvent,...attrsGroups.documentEvent,...attrsGroups.documentElementEvent,...attrsGroups.globalEvent,...attrsGroups.graphicalEvent] |
| const fn$4=()=>({element:{enter:(node,parentNode)=>{if(node.name==="script"){detachNodeFromParent(node,parentNode) |
| return}for(const attr of eventAttrs)node.attributes[attr]!=null&&delete node.attributes[attr]},exit:(node,parentNode)=>{if(node.name!=="a")return |
| for(const attr of Object.keys(node.attributes))if(attr==="href"||attr.endsWith(":href")){if(node.attributes[attr]==null||!node.attributes[attr].trimStart().startsWith("javascript:"))continue |
| const index=parentNode.children.indexOf(node) |
| const usefulChildren=node.children.filter((child=>!(child.type==="text"&&/\s*/.test(child.value)))) |
| parentNode.children.splice(index,1,...usefulChildren) |
| for(const child of node.children)Object.defineProperty(child,"parentNode",{writable:true,value:parentNode})}}}}) |
| var removeScriptElement=Object.freeze({__proto__:null,description:description$4,fn:fn$4,name:name$4}) |
| const name$3="removeStyleElement" |
| const description$3="removes <style> element (disabled by default)" |
| const fn$3=()=>({element:{enter:(node,parentNode)=>{node.name==="style"&&detachNodeFromParent(node,parentNode)}}}) |
| var removeStyleElement=Object.freeze({__proto__:null,description:description$3,fn:fn$3,name:name$3}) |
| const name$2="removeXlink" |
| const description$2="remove xlink namespace and replaces attributes with the SVG 2 equivalent where applicable" |
| const XLINK_NAMESPACE="http://www.w3.org/1999/xlink" |
| const SHOW_TO_TARGET={new:"_blank",replace:"_self"} |
| const LEGACY_ELEMENTS=new Set(["cursor","filter","font-face-uri","glyphRef","tref"]) |
| const findPrefixedAttrs=(node,prefixes,attr)=>prefixes.map((prefix=>`${prefix}:${attr}`)).filter((attr=>node.attributes[attr]!=null)) |
| const fn$2=(_,params)=>{const{includeLegacy:includeLegacy}=params |
| const xlinkPrefixes=[] |
| const overriddenPrefixes=[] |
| const usedInLegacyElement=[] |
| return{element:{enter:node=>{for(const[key,value]of Object.entries(node.attributes))if(key.startsWith("xmlns:")){const prefix=key.split(":",2)[1] |
| if(value===XLINK_NAMESPACE){xlinkPrefixes.push(prefix) |
| continue}xlinkPrefixes.includes(prefix)&&overriddenPrefixes.push(prefix)}if(overriddenPrefixes.some((prefix=>xlinkPrefixes.includes(prefix))))return |
| const showAttrs=findPrefixedAttrs(node,xlinkPrefixes,"show") |
| let showHandled=node.attributes.target!=null |
| for(let i=showAttrs.length-1;i>=0;i--){const attr=showAttrs[i] |
| const value=node.attributes[attr] |
| const mapping=SHOW_TO_TARGET[value] |
| if(showHandled||mapping==null){delete node.attributes[attr] |
| continue}mapping!==elems[node.name]?.defaults?.target&&(node.attributes.target=mapping) |
| delete node.attributes[attr] |
| showHandled=true}const titleAttrs=findPrefixedAttrs(node,xlinkPrefixes,"title") |
| for(let i=titleAttrs.length-1;i>=0;i--){const attr=titleAttrs[i] |
| const value=node.attributes[attr] |
| const hasTitle=node.children.filter((child=>child.type==="element"&&child.name==="title")) |
| if(hasTitle.length>0){delete node.attributes[attr] |
| continue}const titleTag={type:"element",name:"title",attributes:{},children:[{type:"text",value:value}]} |
| Object.defineProperty(titleTag,"parentNode",{writable:true,value:node}) |
| node.children.unshift(titleTag) |
| delete node.attributes[attr]}const hrefAttrs=findPrefixedAttrs(node,xlinkPrefixes,"href") |
| if(hrefAttrs.length>0&&LEGACY_ELEMENTS.has(node.name)&&!includeLegacy){hrefAttrs.map((attr=>attr.split(":",1)[0])).forEach((prefix=>usedInLegacyElement.push(prefix))) |
| return}for(let i=hrefAttrs.length-1;i>=0;i--){const attr=hrefAttrs[i] |
| const value=node.attributes[attr] |
| if(node.attributes.href!=null){delete node.attributes[attr] |
| continue}node.attributes.href=value |
| delete node.attributes[attr]}},exit:node=>{for(const[key,value]of Object.entries(node.attributes)){const[prefix,attr]=key.split(":",2) |
| if(xlinkPrefixes.includes(prefix)&&!overriddenPrefixes.includes(prefix)&&!usedInLegacyElement.includes(prefix)&&!includeLegacy){delete node.attributes[key] |
| continue}if(key.startsWith("xmlns:")&&!usedInLegacyElement.includes(attr)){if(value===XLINK_NAMESPACE){const index=xlinkPrefixes.indexOf(attr) |
| xlinkPrefixes.splice(index,1) |
| delete node.attributes[key] |
| continue}if(overriddenPrefixes.includes(prefix)){const index=overriddenPrefixes.indexOf(attr) |
| overriddenPrefixes.splice(index,1)}}}}}}} |
| var removeXlink=Object.freeze({__proto__:null,description:description$2,fn:fn$2,name:name$2}) |
| const name$1="removeXMLNS" |
| const description$1="removes xmlns attribute (for inline svg, disabled by default)" |
| const fn$1=()=>({element:{enter:node=>{node.name==="svg"&&delete node.attributes.xmlns}}}) |
| var removeXMLNS=Object.freeze({__proto__:null,description:description$1,fn:fn$1,name:name$1}) |
| const name="reusePaths" |
| const description="Finds <path> elements with the same d, fill, and stroke, and converts them to <use> elements referencing a single <path> def." |
| const fn=root=>{const stylesheet=collectStylesheet(root) |
| const paths=new Map |
| let svgDefs |
| const hrefs=new Set |
| return{element:{enter:(node,parentNode)=>{if(node.name==="path"&&node.attributes.d!=null){const d=node.attributes.d |
| const fill=node.attributes.fill||"" |
| const stroke=node.attributes.stroke||"" |
| const key=d+";s:"+stroke+";f:"+fill |
| let list=paths.get(key) |
| if(list==null){list=[] |
| paths.set(key,list)}list.push(node)}svgDefs==null&&node.name==="defs"&&parentNode.type==="element"&&parentNode.name==="svg"&&(svgDefs=node) |
| if(node.name==="use")for(const name of["href","xlink:href"]){const href=node.attributes[name] |
| href!=null&&href.startsWith("#")&&href.length>1&&hrefs.add(href.slice(1))}},exit:(node,parentNode)=>{if(node.name==="svg"&&parentNode.type==="root"){let defsTag=svgDefs |
| if(defsTag==null){defsTag={type:"element",name:"defs",attributes:{},children:[]} |
| Object.defineProperty(defsTag,"parentNode",{writable:true,value:node})}let index=0 |
| for(const list of paths.values())if(list.length>1){const reusablePath={type:"element",name:"path",attributes:{},children:[]} |
| for(const attr of["fill","stroke","d"])list[0].attributes[attr]!=null&&(reusablePath.attributes[attr]=list[0].attributes[attr]) |
| const originalId=list[0].attributes.id |
| if(originalId==null||hrefs.has(originalId)||stylesheet.rules.some((rule=>rule.selector===`#${originalId}`)))reusablePath.attributes.id="reuse-"+index++ |
| else{reusablePath.attributes.id=originalId |
| delete list[0].attributes.id}Object.defineProperty(reusablePath,"parentNode",{writable:true,value:defsTag}) |
| defsTag.children.push(reusablePath) |
| for(const pathNode of list){delete pathNode.attributes.d |
| delete pathNode.attributes.stroke |
| delete pathNode.attributes.fill |
| if(defsTag.children.includes(pathNode)&&pathNode.children.length===0){if(Object.keys(pathNode.attributes).length===0){detachNodeFromParent(pathNode,defsTag) |
| continue}if(Object.keys(pathNode.attributes).length===1&&pathNode.attributes.id!=null){detachNodeFromParent(pathNode,defsTag) |
| const selector=`[xlink\\:href=#${pathNode.attributes.id}], [href=#${pathNode.attributes.id}]` |
| for(const child of querySelectorAll(node,selector)){if(child.type!=="element")continue |
| for(const name of["href","xlink:href"])child.attributes[name]!=null&&(child.attributes[name]="#"+reusablePath.attributes.id)}continue}}pathNode.name="use" |
| pathNode.attributes["xlink:href"]="#"+reusablePath.attributes.id}}if(defsTag.children.length!==0){node.attributes["xmlns:xlink"]==null&&(node.attributes["xmlns:xlink"]="http://www.w3.org/1999/xlink") |
| svgDefs==null&&node.children.unshift(defsTag)}}}}}} |
| var reusePaths=Object.freeze({__proto__:null,description:description,fn:fn,name:name}) |
| const builtin=[presetDefault,addAttributesToSVGElement,addClassesToSVGElement,cleanupAttrs,cleanupEnableBackground,cleanupIds,cleanupListOfValues,cleanupNumericValues,collapseGroups,convertColors,convertEllipseToCircle,convertOneStopGradients,convertPathData,convertShapeToPath,convertStyleToAttrs,convertTransform$1,mergeStyles,inlineStyles,mergePaths,minifyStyles,moveElemsAttrsToGroup,moveGroupAttrsToElems,prefixIds,removeAttributesBySelector,removeAttrs,removeComments,removeDeprecatedAttrs,removeDesc,removeDimensions,removeDoctype,removeEditorsNSData,removeElementsByAttr,removeEmptyAttrs,removeEmptyContainers,removeEmptyText,removeHiddenElems,removeMetadata,removeNonInheritableGroupAttrs,removeOffCanvasPaths,removeRasterImages,removeScriptElement,removeStyleElement,removeTitle,removeUnknownsAndDefaults,removeUnusedNS,removeUselessDefs,removeUselessStrokeAndFill,removeViewBox,removeXlink,removeXMLNS,removeXMLProcInst,reusePaths,sortAttrs,sortDefsChildren] |
| const pluginsMap={} |
| for(const plugin of builtin)pluginsMap[plugin.name]=plugin |
| const resolvePluginConfig=plugin=>{if(typeof plugin==="string"){const builtinPlugin=pluginsMap[plugin] |
| if(builtinPlugin==null)throw Error(`Unknown builtin plugin "${plugin}" specified.`) |
| return{name:plugin,params:{},fn:builtinPlugin.fn}}if(typeof plugin==="object"&&plugin!=null){if(plugin.name==null)throw Error("Plugin name should be specified") |
| let fn=plugin.fn |
| if(fn==null){const builtinPlugin=pluginsMap[plugin.name] |
| if(builtinPlugin==null)throw Error(`Unknown builtin plugin "${plugin.name}" specified.`) |
| fn=builtinPlugin.fn}return{name:plugin.name,params:plugin.params,fn:fn}}return null} |
| const optimize$1=(input,config)=>{config==null&&(config={}) |
| if(typeof config!=="object")throw Error("Config should be an object") |
| const maxPassCount=config.multipass?10:1 |
| let prevResultSize=Number.POSITIVE_INFINITY |
| let output="" |
| const info={} |
| config.path!=null&&(info.path=config.path) |
| for(let i=0;i<maxPassCount;i+=1){info.multipassCount=i |
| const ast=parseSvg(input,config.path) |
| const plugins=config.plugins||["preset-default"] |
| if(!Array.isArray(plugins))throw Error("malformed config, `plugins` property must be an array.\nSee more info here: https://github.com/svg/svgo#configuration") |
| const resolvedPlugins=plugins.filter((plugin=>plugin!=null)).map(resolvePluginConfig) |
| resolvedPlugins.length<plugins.length&&console.warn("Warning: plugins list includes null or undefined elements, these will be ignored.") |
| const globalOverrides={} |
| config.floatPrecision!=null&&(globalOverrides.floatPrecision=config.floatPrecision) |
| invokePlugins(ast,info,resolvedPlugins,null,globalOverrides) |
| output=stringifySvg(ast,config.js2svg) |
| if(!(output.length<prevResultSize))break |
| input=output |
| prevResultSize=output.length}config.datauri&&(output=encodeSVGDatauri(output,config.datauri)) |
| return{data:output}} |
| const importConfig=async configFile=>{const imported=await import(url.pathToFileURL(configFile)) |
| const config=imported.default |
| if(config==null||typeof config!=="object"||Array.isArray(config))throw Error(`Invalid config file "${configFile}"`) |
| return config} |
| const isFile=async file=>{try{const stats=await fs.promises.stat(file) |
| return stats.isFile()}catch{return false}} |
| const loadConfig=async(configFile,cwd=process.cwd())=>{if(configFile!=null)return path.isAbsolute(configFile)?await importConfig(configFile):await importConfig(path.join(cwd,configFile)) |
| let dir=cwd |
| while(true){const js=path.join(dir,"svgo.config.js") |
| if(await isFile(js))return await importConfig(js) |
| const mjs=path.join(dir,"svgo.config.mjs") |
| if(await isFile(mjs))return await importConfig(mjs) |
| const cjs=path.join(dir,"svgo.config.cjs") |
| if(await isFile(cjs))return await importConfig(cjs) |
| const parent=path.dirname(dir) |
| if(dir===parent)return null |
| dir=parent}} |
| const optimize=(input,config)=>{config==null&&(config={}) |
| if(typeof config!=="object")throw Error("Config should be an object") |
| return optimize$1(input,{...config,js2svg:{eol:os.EOL==="\r\n"?"crlf":"lf",...config.js2svg}})} |
| exports.loadConfig=loadConfig |
| exports.optimize=optimize |
