https://svgoptimizer.com/shared/js/svgo.browser.js

1const visitSkip=Symbol()
2const visit=(node,visitor,parentNode)=>{const callbacks=visitor[node.type]
3if(callbacks?.enter){const symbol=callbacks.enter(node,parentNode)
4if(symbol===visitSkip)return}if(node.type==="root")for(const child of node.children)visit(child,visitor,node)
5if(node.type==="element"&&parentNode.children.includes(node))for(const child of node.children)visit(child,visitor,node)
6callbacks?.exit&&callbacks.exit(node,parentNode)}
7const invokePlugins=(ast,info,plugins,overrides,globalOverrides)=>{for(const plugin of plugins){const override=overrides?.[plugin.name]
8if(override===false)continue
9const params={...plugin.params,...globalOverrides,...override}
10const visitor=plugin.fn(ast,params,info)
11visitor!=null&&visit(ast,visitor)}}
12const createPreset=({name:name,plugins:plugins})=>({name:name,isPreset:true,plugins:Object.freeze(plugins),fn:(ast,params,info)=>{const{floatPrecision:floatPrecision,overrides:overrides}=params
13const globalOverrides={}
14floatPrecision!=null&&(globalOverrides.floatPrecision=floatPrecision)
15if(overrides){const pluginNames=plugins.map((({name:name})=>name))
16for(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)}})
17var ElementType;(function(ElementType){ElementType["Root"]="root"
18ElementType["Text"]="text"
19ElementType["Directive"]="directive"
20ElementType["Comment"]="comment"
21ElementType["Script"]="script"
22ElementType["Style"]="style"
23ElementType["Tag"]="tag"
24ElementType["CDATA"]="cdata"
25ElementType["Doctype"]="doctype"})(ElementType||(ElementType={}))
26function isTag$2(elem){return elem.type===ElementType.Tag||elem.type===ElementType.Script||elem.type===ElementType.Style}const Root=ElementType.Root
27const Text=ElementType.Text
28const Directive=ElementType.Directive
29const Comment$4=ElementType.Comment
30const Script=ElementType.Script
31const Style=ElementType.Style
32const Tag=ElementType.Tag
33const CDATA=ElementType.CDATA
34const Doctype=ElementType.Doctype
35function isTag$1(node){return isTag$2(node)}function isCDATA(node){return node.type===ElementType.CDATA}function isText(node){return node.type===ElementType.Text}function isComment(node){return node.type===ElementType.Comment}function isDocument(node){return node.type===ElementType.Root}function hasChildren(node){return Object.prototype.hasOwnProperty.call(node,"children")}const xmlReplacer=/["&'<>$\x80-\uFFFF]/g
36const xmlCodeMap=new Map([[34,"&quot;"],[38,"&amp;"],[39,"&apos;"],[60,"&lt;"],[62,"&gt;"]])
37const getCodePoint=String.prototype.codePointAt!=null?(str,index)=>str.codePointAt(index):(c,index)=>(c.charCodeAt(index)&0xfc00)===0xd800?0x400*(c.charCodeAt(index)-0xd800)+c.charCodeAt(index+1)-0xdc00+0x10000:c.charCodeAt(index)
38function encodeXML(str){let ret=""
39let lastIdx=0
40let match
41while((match=xmlReplacer.exec(str))!==null){const i=match.index
42const char=str.charCodeAt(i)
43const next=xmlCodeMap.get(char)
44if(next!==void 0){ret+=str.substring(lastIdx,i)+next
45lastIdx=i+1}else{ret+=`${str.substring(lastIdx,i)}&#x${getCodePoint(str,i).toString(16)};`
46lastIdx=xmlReplacer.lastIndex+=Number((char&0xfc00)===0xd800)}}return ret+str.substr(lastIdx)}function getEscaper(regex,map){return function escape(data){let match
47let lastIdx=0
48let result=""
49while(match=regex.exec(data)){lastIdx!==match.index&&(result+=data.substring(lastIdx,match.index))
50result+=map.get(match[0].charCodeAt(0))
51lastIdx=match.index+1}return result+data.substring(lastIdx)}}const escapeAttribute=getEscaper(/["&\u00A0]/g,new Map([[34,"&quot;"],[38,"&amp;"],[160,"&nbsp;"]]))
52const escapeText=getEscaper(/[&<>\u00A0]/g,new Map([[38,"&amp;"],[60,"&lt;"],[62,"&gt;"],[160,"&nbsp;"]]))
53const elementNames=new Map(["altGlyph","altGlyphDef","altGlyphItem","animateColor","animateMotion","animateTransform","clipPath","feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feDropShadow","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feImage","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence","foreignObject","glyphRef","linearGradient","radialGradient","textPath"].map((val=>[val.toLowerCase(),val])))
54const attributeNames=new Map(["definitionURL","attributeName","attributeType","baseFrequency","baseProfile","calcMode","clipPathUnits","diffuseConstant","edgeMode","filterUnits","glyphRef","gradientTransform","gradientUnits","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","lengthAdjust","limitingConeAngle","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","numOctaves","pathLength","patternContentUnits","patternTransform","patternUnits","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","specularConstant","specularExponent","spreadMethod","startOffset","stdDeviation","stitchTiles","surfaceScale","systemLanguage","tableValues","targetX","targetY","textLength","viewBox","viewTarget","xChannelSelector","yChannelSelector","zoomAndPan"].map((val=>[val.toLowerCase(),val])))
55const unencodedElements=new Set(["style","script","xmp","iframe","noembed","noframes","plaintext","noscript"])
56function replaceQuotes(value){return value.replace(/"/g,"&quot;")}function formatAttributes(attributes,opts){var _a
57if(!attributes)return
58const encode=((_a=opts.encodeEntities)!==null&&_a!==void 0?_a:opts.decodeEntities)===false?replaceQuotes:opts.xmlMode||opts.encodeEntities!=="utf8"?encodeXML:escapeAttribute
59return Object.keys(attributes).map((key=>{var _a,_b
60const value=(_a=attributes[key])!==null&&_a!==void 0?_a:""
61opts.xmlMode==="foreign"&&(key=(_b=attributeNames.get(key))!==null&&_b!==void 0?_b:key)
62if(!opts.emptyAttrs&&!opts.xmlMode&&value==="")return key
63return`${key}="${encode(value)}"`})).join(" ")}const singleTag=new Set(["area","base","basefont","br","col","command","embed","frame","hr","img","input","isindex","keygen","link","meta","param","source","track","wbr"])
64function render(node,options={}){const nodes="length"in node?node:[node]
65let output=""
66for(let i=0;i<nodes.length;i++)output+=renderNode(nodes[i],options)
67return output}function renderNode(node,options){switch(node.type){case Root:return render(node.children,options)
68case Doctype:case Directive:return renderDirective(node)
69case Comment$4:return renderComment(node)
70case CDATA:return renderCdata(node)
71case Script:case Style:case Tag:return renderTag(node,options)
72case Text:return renderText(node,options)}}const foreignModeIntegrationPoints=new Set(["mi","mo","mn","ms","mtext","annotation-xml","foreignObject","desc","title"])
73const foreignElements=new Set(["svg","math"])
74function renderTag(elem,opts){var _a
75if(opts.xmlMode==="foreign"){elem.name=(_a=elementNames.get(elem.name))!==null&&_a!==void 0?_a:elem.name
76elem.parent&&foreignModeIntegrationPoints.has(elem.parent.name)&&(opts={...opts,xmlMode:false})}!opts.xmlMode&&foreignElements.has(elem.name)&&(opts={...opts,xmlMode:"foreign"})
77let tag=`<${elem.name}`
78const attribs=formatAttributes(elem.attribs,opts)
79attribs&&(tag+=` ${attribs}`)
80if(elem.children.length===0&&(opts.xmlMode?opts.selfClosingTags!==false:opts.selfClosingTags&&singleTag.has(elem.name))){opts.xmlMode||(tag+=" ")
81tag+="/>"}else{tag+=">"
82elem.children.length>0&&(tag+=render(elem.children,opts))
83!opts.xmlMode&&singleTag.has(elem.name)||(tag+=`</${elem.name}>`)}return tag}function renderDirective(elem){return`<${elem.data}>`}function renderText(elem,opts){var _a
84let data=elem.data||"";((_a=opts.encodeEntities)!==null&&_a!==void 0?_a:opts.decodeEntities)===false||!opts.xmlMode&&elem.parent&&unencodedElements.has(elem.parent.name)||(data=opts.xmlMode||opts.encodeEntities!=="utf8"?encodeXML(data):escapeText(data))
85return data}function renderCdata(elem){return`<![CDATA[${elem.children[0].data}]]>`}function renderComment(elem){return`\x3c!--${elem.data}--\x3e`}function getOuterHTML(node,options){return render(node,options)}function getInnerHTML(node,options){return hasChildren(node)?node.children.map((node=>getOuterHTML(node,options))).join(""):""}function getText$1(node){if(Array.isArray(node))return node.map(getText$1).join("")
86if(isTag$1(node))return node.name==="br"?"\n":getText$1(node.children)
87if(isCDATA(node))return getText$1(node.children)
88if(isText(node))return node.data
89return""}function textContent(node){if(Array.isArray(node))return node.map(textContent).join("")
90if(hasChildren(node)&&!isComment(node))return textContent(node.children)
91if(isText(node))return node.data
92return""}function innerText(node){if(Array.isArray(node))return node.map(innerText).join("")
93if(hasChildren(node)&&(node.type===ElementType.Tag||isCDATA(node)))return innerText(node.children)
94if(isText(node))return node.data
95return""}function getChildren$1(elem){return hasChildren(elem)?elem.children:[]}function getParent(elem){return elem.parent||null}function getSiblings(elem){const parent=getParent(elem)
96if(parent!=null)return getChildren$1(parent)
97const siblings=[elem]
98let{prev:prev,next:next}=elem
99while(prev!=null){siblings.unshift(prev);({prev:prev}=prev)}while(next!=null){siblings.push(next);({next:next}=next)}return siblings}function getAttributeValue$1(elem,name){var _a
100return(_a=elem.attribs)===null||_a===void 0?void 0:_a[name]}function hasAttrib$1(elem,name){return elem.attribs!=null&&Object.prototype.hasOwnProperty.call(elem.attribs,name)&&elem.attribs[name]!=null}function getName$1(elem){return elem.name}function nextElementSibling(elem){let{next:next}=elem
101while(next!==null&&!isTag$1(next))({next:next}=next)
102return next}function prevElementSibling(elem){let{prev:prev}=elem
103while(prev!==null&&!isTag$1(prev))({prev:prev}=prev)
104return prev}function removeElement(elem){elem.prev&&(elem.prev.next=elem.next)
105elem.next&&(elem.next.prev=elem.prev)
106if(elem.parent){const childs=elem.parent.children
107const childsIndex=childs.lastIndexOf(elem)
108childsIndex>=0&&childs.splice(childsIndex,1)}elem.next=null
109elem.prev=null
110elem.parent=null}function replaceElement(elem,replacement){const prev=replacement.prev=elem.prev
111prev&&(prev.next=replacement)
112const next=replacement.next=elem.next
113next&&(next.prev=replacement)
114const parent=replacement.parent=elem.parent
115if(parent){const childs=parent.children
116childs[childs.lastIndexOf(elem)]=replacement
117elem.parent=null}}function appendChild(parent,child){removeElement(child)
118child.next=null
119child.parent=parent
120if(parent.children.push(child)>1){const sibling=parent.children[parent.children.length-2]
121sibling.next=child
122child.prev=sibling}else child.prev=null}function append$1(elem,next){removeElement(next)
123const{parent:parent}=elem
124const currNext=elem.next
125next.next=currNext
126next.prev=elem
127elem.next=next
128next.parent=parent
129if(currNext){currNext.prev=next
130if(parent){const childs=parent.children
131childs.splice(childs.lastIndexOf(currNext),0,next)}}else parent&&parent.children.push(next)}function prependChild(parent,child){removeElement(child)
132child.parent=parent
133child.prev=null
134if(parent.children.unshift(child)!==1){const sibling=parent.children[1]
135sibling.prev=child
136child.next=sibling}else child.next=null}function prepend(elem,prev){removeElement(prev)
137const{parent:parent}=elem
138if(parent){const childs=parent.children
139childs.splice(childs.indexOf(elem),0,prev)}elem.prev&&(elem.prev.next=prev)
140prev.parent=parent
141prev.prev=elem.prev
142prev.next=elem
143elem.prev=prev}function filter(test,node,recurse=true,limit=1/0){return find$3(test,Array.isArray(node)?node:[node],recurse,limit)}function find$3(test,nodes,recurse,limit){const result=[]
144const nodeStack=[nodes]
145const indexStack=[0]
146for(;;){if(indexStack[0]>=nodeStack[0].length){if(indexStack.length===1)return result
147nodeStack.shift()
148indexStack.shift()
149continue}const elem=nodeStack[0][indexStack[0]++]
150if(test(elem)){result.push(elem)
151if(--limit<=0)return result}if(recurse&&hasChildren(elem)&&elem.children.length>0){indexStack.unshift(0)
152nodeStack.unshift(elem.children)}}}function findOneChild(test,nodes){return nodes.find(test)}function findOne$1(test,nodes,recurse=true){let elem=null
153for(let i=0;i<nodes.length&&!elem;i++){const node=nodes[i]
154if(!isTag$1(node))continue
155test(node)?elem=node:recurse&&node.children.length>0&&(elem=findOne$1(test,node.children,true))}return elem}function existsOne$1(test,nodes){return nodes.some((checked=>isTag$1(checked)&&(test(checked)||existsOne$1(test,checked.children))))}function findAll$4(test,nodes){const result=[]
156const nodeStack=[nodes]
157const indexStack=[0]
158for(;;){if(indexStack[0]>=nodeStack[0].length){if(nodeStack.length===1)return result
159nodeStack.shift()
160indexStack.shift()
161continue}const elem=nodeStack[0][indexStack[0]++]
162if(!isTag$1(elem))continue
163test(elem)&&result.push(elem)
164if(elem.children.length>0){indexStack.unshift(0)
165nodeStack.unshift(elem.children)}}}const Checks={tag_name(name){if(typeof name==="function")return elem=>isTag$1(elem)&&name(elem.name)
166if(name==="*")return isTag$1
167return elem=>isTag$1(elem)&&elem.name===name},tag_type(type){if(typeof type==="function")return elem=>type(elem.type)
168return elem=>elem.type===type},tag_contains(data){if(typeof data==="function")return elem=>isText(elem)&&data(elem.data)
169return elem=>isText(elem)&&elem.data===data}}
170function getAttribCheck(attrib,value){if(typeof value==="function")return elem=>isTag$1(elem)&&value(elem.attribs[attrib])
171return elem=>isTag$1(elem)&&elem.attribs[attrib]===value}function combineFuncs(a,b){return elem=>a(elem)||b(elem)}function compileTest(options){const funcs=Object.keys(options).map((key=>{const value=options[key]
172return Object.prototype.hasOwnProperty.call(Checks,key)?Checks[key](value):getAttribCheck(key,value)}))
173return funcs.length===0?null:funcs.reduce(combineFuncs)}function testElement(options,node){const test=compileTest(options)
174return!test||test(node)}function getElements(options,nodes,recurse,limit=1/0){const test=compileTest(options)
175return test?filter(test,nodes,recurse,limit):[]}function getElementById(id,nodes,recurse=true){Array.isArray(nodes)||(nodes=[nodes])
176return findOne$1(getAttribCheck("id",id),nodes,recurse)}function getElementsByTagName(tagName,nodes,recurse=true,limit=1/0){return filter(Checks["tag_name"](tagName),nodes,recurse,limit)}function getElementsByTagType(type,nodes,recurse=true,limit=1/0){return filter(Checks["tag_type"](type),nodes,recurse,limit)}function removeSubsets(nodes){let idx=nodes.length
177while(--idx>=0){const node=nodes[idx]
178if(idx>0&&nodes.lastIndexOf(node,idx-1)>=0){nodes.splice(idx,1)
179continue}for(let ancestor=node.parent;ancestor;ancestor=ancestor.parent)if(nodes.includes(ancestor)){nodes.splice(idx,1)
180break}}return nodes}var DocumentPosition;(function(DocumentPosition){DocumentPosition[DocumentPosition["DISCONNECTED"]=1]="DISCONNECTED"
181DocumentPosition[DocumentPosition["PRECEDING"]=2]="PRECEDING"
182DocumentPosition[DocumentPosition["FOLLOWING"]=4]="FOLLOWING"
183DocumentPosition[DocumentPosition["CONTAINS"]=8]="CONTAINS"
184DocumentPosition[DocumentPosition["CONTAINED_BY"]=16]="CONTAINED_BY"})(DocumentPosition||(DocumentPosition={}))
185function compareDocumentPosition(nodeA,nodeB){const aParents=[]
186const bParents=[]
187if(nodeA===nodeB)return 0
188let current=hasChildren(nodeA)?nodeA:nodeA.parent
189while(current){aParents.unshift(current)
190current=current.parent}current=hasChildren(nodeB)?nodeB:nodeB.parent
191while(current){bParents.unshift(current)
192current=current.parent}const maxIdx=Math.min(aParents.length,bParents.length)
193let idx=0
194while(idx<maxIdx&&aParents[idx]===bParents[idx])idx++
195if(idx===0)return DocumentPosition.DISCONNECTED
196const sharedParent=aParents[idx-1]
197const siblings=sharedParent.children
198const aSibling=aParents[idx]
199const bSibling=bParents[idx]
200if(siblings.indexOf(aSibling)>siblings.indexOf(bSibling)){if(sharedParent===nodeB)return DocumentPosition.FOLLOWING|DocumentPosition.CONTAINED_BY
201return DocumentPosition.FOLLOWING}if(sharedParent===nodeA)return DocumentPosition.PRECEDING|DocumentPosition.CONTAINS
202return DocumentPosition.PRECEDING}function uniqueSort(nodes){nodes=nodes.filter(((node,i,arr)=>!arr.includes(node,i+1)))
203nodes.sort(((a,b)=>{const relative=compareDocumentPosition(a,b)
204if(relative&DocumentPosition.PRECEDING)return-1
205if(relative&DocumentPosition.FOLLOWING)return 1
206return 0}))
207return nodes}function getFeed(doc){const feedRoot=getOneElement(isValidFeed,doc)
208return feedRoot?feedRoot.name==="feed"?getAtomFeed(feedRoot):getRssFeed(feedRoot):null}function getAtomFeed(feedRoot){var _a
209const childs=feedRoot.children
210const feed={type:"atom",items:getElementsByTagName("entry",childs).map((item=>{var _a
211const{children:children}=item
212const entry={media:getMediaElements(children)}
213addConditionally(entry,"id","id",children)
214addConditionally(entry,"title","title",children)
215const href=(_a=getOneElement("link",children))===null||_a===void 0?void 0:_a.attribs["href"]
216href&&(entry.link=href)
217const description=fetch("summary",children)||fetch("content",children)
218description&&(entry.description=description)
219const pubDate=fetch("updated",children)
220pubDate&&(entry.pubDate=new Date(pubDate))
221return entry}))}
222addConditionally(feed,"id","id",childs)
223addConditionally(feed,"title","title",childs)
224const href=(_a=getOneElement("link",childs))===null||_a===void 0?void 0:_a.attribs["href"]
225href&&(feed.link=href)
226addConditionally(feed,"description","subtitle",childs)
227const updated=fetch("updated",childs)
228updated&&(feed.updated=new Date(updated))
229addConditionally(feed,"author","email",childs,true)
230return feed}function getRssFeed(feedRoot){var _a,_b
231const childs=(_b=(_a=getOneElement("channel",feedRoot.children))===null||_a===void 0?void 0:_a.children)!==null&&_b!==void 0?_b:[]
232const feed={type:feedRoot.name.substr(0,3),id:"",items:getElementsByTagName("item",feedRoot.children).map((item=>{const{children:children}=item
233const entry={media:getMediaElements(children)}
234addConditionally(entry,"id","guid",children)
235addConditionally(entry,"title","title",children)
236addConditionally(entry,"link","link",children)
237addConditionally(entry,"description","description",children)
238const pubDate=fetch("pubDate",children)||fetch("dc:date",children)
239pubDate&&(entry.pubDate=new Date(pubDate))
240return entry}))}
241addConditionally(feed,"title","title",childs)
242addConditionally(feed,"link","link",childs)
243addConditionally(feed,"description","description",childs)
244const updated=fetch("lastBuildDate",childs)
245updated&&(feed.updated=new Date(updated))
246addConditionally(feed,"author","managingEditor",childs,true)
247return feed}const MEDIA_KEYS_STRING=["url","type","lang"]
248const MEDIA_KEYS_INT=["fileSize","bitrate","framerate","samplingrate","channels","duration","height","width"]
249function getMediaElements(where){return getElementsByTagName("media:content",where).map((elem=>{const{attribs:attribs}=elem
250const media={medium:attribs["medium"],isDefault:!!attribs["isDefault"]}
251for(const attrib of MEDIA_KEYS_STRING)attribs[attrib]&&(media[attrib]=attribs[attrib])
252for(const attrib of MEDIA_KEYS_INT)attribs[attrib]&&(media[attrib]=parseInt(attribs[attrib],10))
253attribs["expression"]&&(media.expression=attribs["expression"])
254return media}))}function getOneElement(tagName,node){return getElementsByTagName(tagName,node,true,1)[0]}function fetch(tagName,where,recurse=false){return textContent(getElementsByTagName(tagName,where,recurse,1)).trim()}function addConditionally(obj,prop,tagName,where,recurse=false){const val=fetch(tagName,where,recurse)
255val&&(obj[prop]=val)}function isValidFeed(value){return value==="rss"||value==="feed"||value==="rdf:RDF"}var DomUtils=Object.freeze({__proto__:null,get DocumentPosition(){return DocumentPosition},append:append$1,appendChild:appendChild,compareDocumentPosition:compareDocumentPosition,existsOne:existsOne$1,filter:filter,find:find$3,findAll:findAll$4,findOne:findOne$1,findOneChild:findOneChild,getAttributeValue:getAttributeValue$1,getChildren:getChildren$1,getElementById:getElementById,getElements:getElements,getElementsByTagName:getElementsByTagName,getElementsByTagType:getElementsByTagType,getFeed:getFeed,getInnerHTML:getInnerHTML,getName:getName$1,getOuterHTML:getOuterHTML,getParent:getParent,getSiblings:getSiblings,getText:getText$1,hasAttrib:hasAttrib$1,hasChildren:hasChildren,innerText:innerText,isCDATA:isCDATA,isComment:isComment,isDocument:isDocument,isTag:isTag$1,isText:isText,nextElementSibling:nextElementSibling,prepe

683})
684const 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"])}
685const textElems=new Set([...elemsGroups.textContent,"pre","title"])
686const pathElems=new Set(["glyph","missing-glyph","path"])
687const 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"])}
688const 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"}}
689const 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"])}}
690const 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"])}}}
691const editorNamespaces=new Set(["http://creativecommons.org/ns#","http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd","http://krita.org/namespaces/svg/krita","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#","https://boxy-svg.com"])
692const referencesProps=new Set(["clip-path","color-profile","fill","filter","marker-end","marker-mid","marker-start","mask","stroke","style"])
693const 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"])
694const presentationNonInheritableGroupAttrs=new Set(["clip-path","display","filter","mask","opacity","text-decoration","transform","unicode-bidi"])
695const 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"}
696const 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"}
697const colorsProps=new Set(["color","fill","flood-color","lighting-color","stop-color","stroke"])
698const pseudoClasses={displayState:new Set(["fullscreen","modal","picture-in-picture"]),input:new Set(["autofill","blank","checked","default","disabled","enabled","in-range","indeterminate","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

698: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"])}
699var _collections=Object.freeze({__proto__:null,attrsGroups:attrsGroups,attrsGroupsDefaults:attrsGroupsDefaults,attrsGroupsDeprecated:attrsGroupsDeprecated,colorsNames:colorsNames,colorsProps:colorsProps,colorsShortNames:colorsShortNames,editorNamespaces:editorNamespaces,elems:elems,elemsGroups:elemsGroups,inheritableAttrs:inheritableAttrs,pathElems:pathElems,presentationNonInheritableGroupAttrs:presentationNonInheritableGroupAttrs,pseudoClasses:pseudoClasses,referencesProps:referencesProps,textElems:textElems})
700const EOF$3=0
701const Ident$1=1
702const Function$3=2
703const AtKeyword$1=3
704const Hash$3=4
705const String$4=5
706const BadString$1=6
707const Url$4=7
708const BadUrl$1=8
709const Delim$1=9
710const Number$5=10
711const Percentage$3=11
712const Dimension$3=12
713const WhiteSpace$3=13
714const CDO$3=14
715const CDC$3=15
716const Colon$1=16
717const Semicolon$1=17
718const Comma$1=18
719const LeftSquareBracket$1=19
720const RightSquareBracket$1=20
721const LeftParenthesis$1=21
722const RightParenthesis$1=22
723const LeftCurlyBracket$1=23
724const RightCurlyBracket$1=24
725const Comment$3=25
726const EOF$2=0
727function isDigit$2(code){return code>=0x0030&&code<=0x0039}function isHexDigit$1(code){return isDigit$2(code)||code>=0x0041&&code<=0x0046||code>=0x0061&&code<=0x0066}function isUppercaseLetter$1(code){return code>=0x0041&&code<=0x005A}function isLowercaseLetter$1(code){return code>=0x0061&&code<=0x007A}function isLetter$1(code){return isUppercaseLetter$1(code)||isLowercaseLetter$1(code)}function isNonAscii$1(code){return code>=0x0080}function isNameStart$1(code){return isLetter$1(code)||isNonAscii$1(code)||code===0x005F}function isName$1(code){return isNameStart$1(code)||isDigit$2(code)||code===0x002D}function isNonPrintable$1(code){return code>=0x0000&&code<=0x0008||code===0x000B||code>=0x000E&&code<=0x001F||code===0x007F}function isNewline$1(code){return code===0x000A||code===0x000D||code===0x000C}function isWhiteSpace$2(code){return isNewline$1(code)||code===0x0020||code===0x0009}function isValidEscape$1(first,second){if(first!==0x005C)return false
728if(isNewline$1(second)||second===EOF$2)return false
729return true}function isIdentifierStart$1(first,second,third){if(first===0x002D)return isNameStart$1(second)||second===0x002D||isValidEscape$1(second,third)
730if(isNameStart$1(first))return true
731if(first===0x005C)return isValidEscape$1(first,second)
732return false}function isNumberStart$1(first,second,third){if(first===0x002B||first===0x002D){if(isDigit$2(second))return 2
733return second===0x002E&&isDigit$2(third)?3:0}if(first===0x002E)return isDigit$2(second)?2:0
734if(isDigit$2(first))return 1
735return 0}function isBOM$1(code){if(code===0xFEFF)return 1
736if(code===0xFFFE)return 1
737return 0}const CATEGORY$1=new Array(0x80)
738const EofCategory$1=0x80
739const WhiteSpaceCategory$1=0x82
740const DigitCategory$1=0x83
741const NameStartCategory$1=0x84
742const NonPrintableCategory$1=0x85
743for(let i=0;i<CATEGORY$1.length;i++)CATEGORY$1[i]=isWhiteSpace$2(i)&&WhiteSpaceCategory$1||isDigit$2(i)&&DigitCategory$1||isNameStart$1(i)&&NameStartCategory$1||isNonPrintable$1(i)&&NonPrintableCategory$1||i||EofCategory$1
744function charCodeCategory$1(code){return code<0x80?CATEGORY$1[code]:NameStartCategory$1}function getCharCode$1(source,offset){return offset<source.length?source.charCodeAt(offset):0}function getNewlineLength$1(source,offset,code){if(code===13&&getCharCode$1(source,offset+1)===10)return 2
745return 1}function cmpChar$1(testStr,offset,referenceCode){let code=testStr.charCodeAt(offset)
746isUppercaseLetter$1(code)&&(code|=32)
747return code===referenceCode}function cmpStr$1(testStr,start,end,referenceStr){if(end-start!==referenceStr.length)return false
748if(start<0||end>testStr.length)return false
749for(let i=start;i<end;i++){const referenceCode=referenceStr.charCodeAt(i-start)
750let testCode=testStr.charCodeAt(i)
751isUppercaseLetter$1(testCode)&&(testCode|=32)
752if(testCode!==referenceCode)return false}return true}function findWhiteSpaceStart$1(source,offset){for(;offset>=0;offset--)if(!isWhiteSpace$2(source.charCodeAt(offset)))break
753return offset+1}function findWhiteSpaceEnd$1(source,offset){for(;offset<source.length;offset++)if(!isWhiteSpace$2(source.charCodeAt(offset)))break
754return offset}function findDecimalNumberEnd$1(source,offset){for(;offset<source.length;offset++)if(!isDigit$2(source.charCodeAt(offset)))break
755return offset}function consumeEscaped$1(source,offset){offset+=2
756if(isHexDigit$1(getCharCode$1(source,offset-1))){for(const maxOffset=Math.min(source.length,offset+5);offset<maxOffset;offset++)if(!isHexDigit$1(getCharCode$1(source,offset)))break
757const code=getCharCode$1(source,offset)
758isWhiteSpace$2(code)&&(offset+=getNewlineLength$1(source,offset,code))}return offset}function consumeName$1(source,offset){for(;offset<source.length;offset++){const code=source.charCodeAt(offset)
759if(isName$1(code))continue
760if(isValidEscape$1(code,getCharCode$1(source,offset+1))){offset=consumeEscaped$1(source,offset)-1
761continue}break}return offset}function consumeNumber$2(source,offset){let code=source.charCodeAt(offset)
762code!==0x002B&&code!==0x002D||(code=source.charCodeAt(offset+=1))
763if(isDigit$2(code)){offset=findDecimalNumberEnd$1(source,offset+1)
764code=source.charCodeAt(offset)}if(code===0x002E&&isDigit$2(source.charCodeAt(offset+1))){offset+=2
765offset=findDecimalNumberEnd$1(source,offset)}if(cmpChar$1(source,offset,101)){let sign=0
766code=source.charCodeAt(offset+1)
767if(code===0x002D||code===0x002B){sign=1
768code=source.charCodeAt(offset+2)}isDigit$2(code)&&(offset=findDecimalNumberEnd$1(source,offset+1+sign+1))}return offset}function consumeBadUrlRemnants$1(source,offset){for(;offset<source.length;offset++){const code=source.charCodeAt(offset)
769if(code===0x0029){offset++
770break}isValidEscape$1(code,getCharCode$1(source,offset+1))&&(offset=consumeEscaped$1(source,offset))}return offset}function decodeEscaped$1(escaped){if(escaped.length===1&&!isHexDigit$1(escaped.charCodeAt(0)))return escaped[0]
771let code=parseInt(escaped,16);(code===0||code>=0xD800&&code<=0xDFFF||code>0x10FFFF)&&(code=0xFFFD)
772return String.fromCodePoint(code)}var tokenNames$1=["EOF-token","ident-token","function-token","at-keyword-token","hash-token","string-token","bad-string-token","url-token","bad-url-token","delim-token","number-token","percentage-token","dimension-token","whitespace-token","CDO-token","CDC-token","colon-token","semicolon-token","comma-token","[-token","]-token","(-token",")-token","{-token","}-token","comment-token"]
773const MIN_SIZE$1=16384
774function adoptBuffer$1(buffer=null,size){if(buffer===null||buffer.length<size)return new Uint32Array(Math.max(size+1024,MIN_SIZE$1))
775return buffer}const N$9=10
776const F$5=12
777const R$5=13
778function computeLinesAndColumns$1(host){const source=host.source
779const sourceLength=source.length
780const startOffset=source.length>0?isBOM$1(source.charCodeAt(0)):0
781const lines=adoptBuffer$1(host.lines,sourceLength)
782const columns=adoptBuffer$1(host.columns,sourceLength)
783let line=host.startLine
784let column=host.startColumn
785for(let i=startOffset;i<sourceLength;i++){const code=source.charCodeAt(i)
786lines[i]=line
787columns[i]=column++
788if(code===N$9||code===R$5||code===F$5){if(code===R$5&&i+1<sourceLength&&source.charCodeAt(i+1)===N$9){i++
789lines[i]=line
790columns[i]=column}line++
791column=1}}lines[sourceLength]=line
792columns[sourceLength]=column
793host.lines=lines
794host.columns=columns
795host.computed=true}let OffsetToLocation$1=class OffsetToLocation{constructor(

795){this.lines=null
796this.columns=null
797this.computed=false}setSource(source,startOffset=0,startLine=1,startColumn=1){this.source=source
798this.startOffset=startOffset
799this.startLine=startLine
800this.startColumn=startColumn
801this.computed=false}getLocation(offset,filename){this.computed||computeLinesAndColumns$1(this)
802return{source:filename,offset:this.startOffset+offset,line:this.lines[offset],column:this.columns[offset]}}getLocationRange(start,end,filename){this.computed||computeLinesAndColumns$1(this)
803return{source:filename,start:{offset:this.startOffset+start,line:this.lines[start],column:this.columns[start]},end:{offset:this.startOffset+end,line:this.lines[end],column:this.columns[end]}}}}
804const OFFSET_MASK$1=0x00FFFFFF
805const TYPE_SHIFT$1=24
806const balancePair$3=new Map([[Function$3,RightParenthesis$1],[LeftParenthesis$1,RightParenthesis$1],[LeftSquareBracket$1,RightSquareBracket$1],[LeftCurlyBracket$1,RightCurlyBracket$1]])
807let TokenStream$1=class TokenStream{constructor(source,tokenize){this.setSource(source,tokenize)}reset(){this.eof=false
808this.tokenIndex=-1
809this.tokenType=0
810this.tokenStart=this.firstCharOffset
811this.tokenEnd=this.firstCharOffset}setSource(source="",tokenize=(()=>{})){source=String(source||"")
812const sourceLength=source.length
813const offsetAndType=adoptBuffer$1(this.offsetAndType,source.length+1)
814const balance=adoptBuffer$1(this.balance,source.length+1)
815let tokenCount=0
816let balanceCloseType=0
817let balanceStart=0
818let firstCharOffset=-1
819this.offsetAndType=null
820this.balance=null
821tokenize(source,((type,start,end)=>{switch(type){default:balance[tokenCount]=sourceLength
822break
823case balanceCloseType:{let balancePrev=balanceStart&OFFSET_MASK$1
824balanceStart=balance[balancePrev]
825balanceCloseType=balanceStart>>TYPE_SHIFT$1
826balance[tokenCount]=balancePrev
827balance[balancePrev++]=tokenCount
828for(;balancePrev<tokenCount;balancePrev++)balance[balancePrev]===sourceLength&&(balance[balancePrev]=tokenCount)
829break}case LeftParenthesis$1:case Function$3:case LeftSquareBracket$1:case LeftCurlyBracket$1:balance[tokenCount]=balanceStart
830balanceCloseType=balancePair$3.get(type)
831balanceStart=balanceCloseType<<TYPE_SHIFT$1|tokenCount
832break}offsetAndType[tokenCount++]=type<<TYPE_SHIFT$1|end
833firstCharOffset===-1&&(firstCharOffset=start)}))
834offsetAndType[tokenCount]=EOF$3<<TYPE_SHIFT$1|sourceLength
835balance[tokenCount]=sourceLength
836balance[sourceLength]=sourceLength
837while(balanceStart!==0){const balancePrev=balanceStart&OFFSET_MASK$1
838balanceStart=balance[balancePrev]
839balance[balancePrev]=sourceLength}this.source=source
840this.firstCharOffset=firstCharOffset===-1?0:firstCharOffset
841this.tokenCount=tokenCount
842this.offsetAndType=offsetAndType
843this.balance=balance
844this.reset()
845this.next()}lookupType(offset){offset+=this.tokenIndex
846if(offset<this.tokenCount)return this.offsetAndType[offset]>>TYPE_SHIFT$1
847return EOF$3}lookupTypeNonSC(idx){for(let offset=this.tokenIndex;offset<this.tokenCount;offset++){const tokenType=this.offsetAndType[offset]>>TYPE_SHIFT$1
848if(tokenType!==WhiteSpace$3&&tokenType!==Comment$3&&idx--===0)return tokenType}return EOF$3}lookupOffset(offset){offset+=this.tokenIndex
849if(offset<this.tokenCount)return this.offsetAndType[offset-1]&OFFSET_MASK$1
850return this.source.length}lookupOffsetNonSC(idx){for(let offset=this.tokenIndex;offset<this.tokenCount;offset++){const tokenType=this.offsetAndType[offset]>>TYPE_SHIFT$1
851if(tokenType!==WhiteSpace$3&&tokenType!==Comment$3&&idx--===0)return offset-this.tokenIndex}return EOF$3}lookupValue(offset,referenceStr){offset+=this.tokenIndex
852if(offset<this.tokenCount)return cmpStr$1(this.source,this.offsetAndType[offset-1]&OFFSET_MASK$1,this.offsetAndType[offset]&OFFSET_MASK$1,referenceStr)
853return false}getTokenStart(tokenIndex){if(tokenIndex===this.tokenIndex)return this.tokenStart
854if(tokenIndex>0)return tokenIndex<this.tokenCount?this.offsetAndType[tokenIndex-1]&OFFSET_MASK$1:this.offsetAndType[this.tokenCount]&OFFSET_MASK$1
855return this.firstCharOffset}substrToCursor(start){return this.source.substring(start,this.tokenStart)}isBalanceEdge(pos){return this.balance[this.tokenIndex]<pos}isDelim(code,offset){if(offset)return this.lookupType(offset)===Delim$1&&this.source.charCodeAt(this.lookupOffset(offset))===code
856return this.tokenType===Delim$1&&this.source.charCodeAt(this.tokenStart)===code}skip(tokenCount){let next=this.tokenIndex+tokenCount
857if(next<this.tokenCount){this.tokenIndex=next
858this.tokenStart=this.offsetAndType[next-1]&OFFSET_MASK$1
859next=this.offsetAndType[next]
860this.tokenType=next>>TYPE_SHIFT$1
861this.tokenEnd=next&OFFSET_MASK$1}else{this.tokenIndex=this.tokenCount
862this.next()}}next(){let next=this.tokenIndex+1
863if(next<this.tokenCount){this.tokenIndex=next
864this.tokenStart=this.tokenEnd
865next=this.offsetAndType[next]
866this.tokenType=next>>TYPE_SHIFT$1
867this.tokenEnd=next&OFFSET_MASK$1}else{this.eof=true
868this.tokenIndex=this.tokenCount
869this.tokenType=EOF$3
870this.tokenStart=this.tokenEnd=this.source.length}}skipSC(){while(this.tokenType===WhiteSpace$3||this.tokenType===Comment$3)this.next()}skipUntilBalanced(startToken,stopConsume){let cursor=startToken
871let balanceEnd
872let offset
873loop:for(;cursor<this.tokenCount;cursor++){balanceEnd=this.balance[cursor]
874if(balanceEnd<startToken)break loop
875offset=cursor>0?this.offsetAndType[cursor-1]&OFFSET_MASK$1:this.firstCharOffset
876switch(stopConsume(this.source.charCodeAt(offset))){case 1:break loop
877case 2:cursor++
878break loop
879default:this.balance[balanceEnd]===cursor&&(cursor=balanceEnd)}}this.skip(cursor-this.tokenIndex)}forEachToken(fn){for(let i=0,offset=this.firstCharOffset;i<this.tokenCount;i++){const start=offset
880const item=this.offsetAndType[i]
881const end=item&OFFSET_MASK$1
882const type=item>>TYPE_SHIFT$1
883offset=end
884fn(type,start,end,i)}}dump(){const tokens=new Array(this.tokenCount)
885this.forEachToken(((type,start,end,index)=>{tokens[index]={idx:index,type:tokenNames$1[type],chunk:this.source.substring(start,end),balance:this.balance[index]}})

885)
886return tokens}}
887function tokenize$4(source,onToken){function getCharCode(offset){return offset<sourceLength?source.charCodeAt(offset):0}function consumeNumericToken(){offset=consumeNumber$2(source,offset)
888if(isIdentifierStart$1(getCharCode(offset),getCharCode(offset+1),getCharCode(offset+2))){type=Dimension$3
889offset=consumeName$1(source,offset)
890return}if(getCharCode(offset)===0x0025){type=Percentage$3
891offset++
892return}type=Number$5}function consumeIdentLikeToken(){const nameStartOffset=offset
893offset=consumeName$1(source,offset)
894if(cmpStr$1(source,nameStartOffset,offset,"url")&&getCharCode(offset)===0x0028){offset=findWhiteSpaceEnd$1(source,offset+1)
895if(getCharCode(offset)===0x0022||getCharCode(offset)===0x0027){type=Function$3
896offset=nameStartOffset+4
897return}consumeUrlToken()
898return}if(getCharCode(offset)===0x0028){type=Function$3
899offset++
900return}type=Ident$1}function consumeStringToken(endingCodePoint){endingCodePoint||(endingCodePoint=getCharCode(offset++))
901type=String$4
902for(;offset<source.length;offset++){const code=source.charCodeAt(offset)
903switch(charCodeCategory$1(code)){case endingCodePoint:offset++
904return
905case WhiteSpaceCategory$1:if(isNewline$1(code)){offset+=getNewlineLength$1(source,offset,code)
906type=BadString$1
907return}break
908case 0x005C:if(offset===source.length-1)break
909const nextCode=getCharCode(offset+1)
910isNewline$1(nextCode)?offset+=getNewlineLength$1(source,offset+1,nextCode):isValidEscape$1(code,nextCode)&&(offset=consumeEscaped$1(source,offset)-1)
911break}}}function consumeUrlToken(){type=Url$4
912offset=findWhiteSpaceEnd$1(source,offset)
913for(;offset<source.length;offset++){const code=source.charCodeAt(offset)
914switch(charCodeCategory$1(code)){case 0x0029:offset++
915return
916case WhiteSpaceCategory$1:offset=findWhiteSpaceEnd$1(source,offset)
917if(getCharCode(offset)===0x0029||offset>=source.length){offset<source.length&&offset++
918return}offset=consumeBadUrlRemnants$1(source,offset)
919type=BadUrl$1
920return
921case 0x0022:case 0x0027:case 0x0028:case NonPrintableCategory$1:offset=consumeBadUrlRemnants$1(source,offset)
922type=BadUrl$1
923return
924case 0x005C:if(isValidEscape$1(code,getCharCode(offset+1))){offset=consumeEscaped$1(source,offset)-1
925break}offset=consumeBadUrlRemnants$1(source,offset)
926type=BadUrl$1
927return}}}source=String(source||"")
928const sourceLength=source.length
929let start=isBOM$1(getCharCode(0))
930let offset=start
931let type
932while(offset<sourceLength){const code=source.charCodeAt(offset)
933switch(charCodeCategory$1(code)){case WhiteSpaceCategory$1:type=WhiteSpace$3
934offset=findWhiteSpaceEnd$1(source,offset+1)
935break
936case 0x0022:consumeStringToken()
937break
938case 0x0023:if(isName$1(getCharCode(offset+1))||isValidEscape$1(getCharCode(offset+1),getCharCode(offset+2))){type=Hash$3
939offset=consumeName$1(source,offset+1)}else{type=Delim$1
940offset++}break
941case 0x0027:consumeStringToken()
942break
943case 0x0028:type=LeftParenthesis$1
944offset++
945break
946case 0x0029:type=RightParenthesis$1
947offset++
948break
949case 0x002B:if(isNumberStart$1(code,getCharCode(offset+1),getCharCode(offset+2)))consumeNumericToken()
950else{type=Delim$1
951offset++}break
952case 0x002C:type=Comma$1
953offset++
954break
955case 0x002D:if(isNumberStart$1(code,getCharCode(offset+1),getCharCode(offset+2)))consumeNumericToken()
956else if(getCharCode(offset+1)===0x002D&&getCharCode(offset+2)===0x003E){type=CDC$3
957offset+=3}else if(isIdentifierStart$1(code,getCharCode(offset+1),getCharCode(offset+2)))consumeIdentLikeToken()
958else{type=Delim$1
959offset++}break
960case 0x002E:if(isNumberStart$1(code,getCharCode(offset+1),getCharCode(offset+2)))consumeNumericToken()
961else{type=Delim$1
962offset++}break
963case 0x002F:if(getCharCode(offset+1)===0x002A){type=Comment$3
964offset=source.indexOf("*/",offset+2)
965offset=offset===-1?source.length:offset+2}else{type=Delim$1
966offset++}break
967case 0x003A:type=Colon$1
968offset++
969break
970case 0x003B:type=Semicolon$1
971offset++
972break
973case 0x003C:if(getCharCode(offset+1)===0x0021&&getCharCode(offset+2)===0x002D&&getCharCode(offset+3)===0x002D){type=CDO$3
974offset+=4}else{type=Delim$1
975offset++}break
976case 0x0040:if(isIdentifierStart$1(getCharCode(offset+1),getCharCode(offset+2),getCharCode(offset+3))){type=AtKeyword$1
977offset=consumeName$1(source,offset+1)}else{type=Delim$1
978offset++}break
979case 0x005B:type=LeftSquareBracket$1
980offset++
981break
982case 0x005C:if(isValidEscape$1(code,getCharCode(offset+1)))consumeIdentLikeToken()
983else{type=Delim$1
984offset++}break
985case 0x005D:type=RightSquareBracket$1
986offset++
987break
988case 0x007B:type=LeftCurlyBracket$1
989offset++
990break
991case 0x007D:type=RightCurlyBracket$1
992offset++
993break
994case DigitCategory$1:consumeNumericToken()
995break
996case NameStartCategory$1:consumeIdentLikeToken()
997break
998default:type=Delim$1
999offset++}onToken(type,start,start=offset)}}let releasedCursors$1=null
1000let List$1=class List{static createItem(data){return{prev:null,next:null,data:data}}constructor(){this.head=null
1001this.tail=null
1002this.cursor=null}createItem(data){return List.createItem(data)}allocateCursor(prev,next){let cursor
1003if(releasedCursors$1!==null){cursor=releasedCursors$1
1004releasedCursors$1=releasedCursors$1.cursor
1005cursor.prev=prev
1006cursor.next=next
1007cursor.cursor=this.cursor}else cursor={prev:prev,next:next,cursor:this.cursor}
1008this.cursor=cursor
1009return cursor}releaseCursor(){const{cursor:cursor}=this
1010this.cursor=cursor.cursor
1011cursor.prev=null
1012cursor.next=null
1013cursor.cursor=releasedCursors$1
1014releasedCursors$1=cursor}updateCursors(prevOld,prevNew,nextOld,nextNew){let{cursor:cursor}=this
1015while(cursor!==null){cursor.prev===prevOld&&(cursor.prev=prevNew)
1016cursor.next===nextOld&&(cursor.next=nextNew)
1017cursor=cursor.cursor}}*[Symbol.iterator](){for(let cursor=this.head;cursor!==null;cursor=cursor.next)yield cursor.data}get size(){let size=0
1018for(let cursor=this.head;cursor!==null;cursor=cursor.next)size++
1019return size}get isEmpty(){return this.head===null}get first(){return this.head&&this.head.data}get last(){return this.tail&&this.tail.data}fromArray(array){let cursor=null
1020this.head=null
1021for(let data of array){const item=List.createItem(data)
1022cursor!==null?cursor.next=item:this.head=item
1023item.prev=cursor
1024cursor=item}this.tail=cursor
1025return this}toArray(){return[...this]}toJSON(){return[...this]}forEach(fn,thisArg=this){const cursor=this.allocateCursor(null,this.head)
1026while(cursor.next!==null){const item=cursor.next
1027cursor.next=item.next
1028fn.call(thisArg,item.data,item,this)}this.releaseCursor()}forEachRight(fn,thisArg=this){const cursor=this.allocateCursor(this.tail,null)
1029while(cursor.prev!==null){const item=cursor.prev
1030cursor.prev=item.prev
1031fn.call(thisArg,item.data,item,this)}this.releaseCursor()}reduce(fn,initialValue,thisArg=this){let cursor=this.allocateCursor(null,this.head)
1032let acc=initialValue
1033let item
1034while(cursor.next!==null){item=cursor.next
1035cursor.next=item.next
1036acc=fn.call(thisArg,acc,item.data,item,this)}this.releaseCursor()
1037return acc}reduceRight(fn,initialValue,thisArg=this){let cursor=this.allocateCursor(this.tail,null)
1038let acc=initialValue
1039let item
1040while(cursor.prev!==null){item=cursor.prev
1041cursor.prev=item.prev
1042acc=fn.call(thisArg,acc,item.data,item,this)}this.releaseCursor()
1043return acc}some(fn,thisArg=this){for(let cursor=this.head;cursor!==null;cursor=cursor.next)if(fn.call(thisArg,cursor.data,cursor,this))return true
1044return false}map(fn,thisArg=this){const result=new List
1045for(let cursor=this.head;cursor!==null;cursor=cursor.next)result.appendData(fn.call(thisArg,cursor.data,cursor,this))
1046return result}filter(fn,thisArg=this){const result=new List
1047for(let cursor=this.head;cursor!==null;cursor=cursor.next)fn.call(thisArg,cursor.data,cursor,this)&&result.appendData(cursor.data)
1048return result}nextUntil(start,fn,thisArg=this){if(start===null)return
1049const cursor=this.allocateCursor(null,start)
1050while(cursor.next!==null){const item=cursor.next
1051cursor.next=item.next
1052if(fn.call(thisArg,item.data,item,this))break}this.releaseCursor()}prevUntil(start,fn,thisArg=this){if(start===null)return
1053const cursor=this.allocateCursor(start,null)
1054while(cursor.prev!==null){const item=cursor.prev
1055cursor.prev=item.prev
1056if(fn.call(thisArg,item.data,item,this))break}this.releaseCursor()}clear(){this.head=null
1057this.tail=null}copy(){const result=new List
1058for(let data of this)result.appendData(data)
1059return result}prepend(item){this.updateCursors(null,item,this.head,item)
1060if(this.head!==null){this.head.prev=item
1061item.next=this.head}else this.tail=item
1062this.head=item
1063return this}prependData(data){return this.prepend(List.createItem(data))}append(item){return this.insert(item)}appendData(data){return this.insert(List.createItem(data))}insert(item,before=null){if(before!==null){this.updateCursors(before.prev,item,before,item)
1064if(before.prev===null){if(this.head!==before)throw new Error("before doesn't belong to list")
1065this.head=item
1066before.prev=item
1067item.next=before
1068this.updateCursors(null,item)}else{before.prev.next=item
1069item.prev=before.prev
1070before.prev=item
1071item.next=before}}else{this.updateCursors(this.tail,item,null,item)
1072if(this.tail!==null){this.tail.next=item
1073item.prev=this.tail}else this.head=item
1074this.tail=item}return this}insertData(data,before){return this.insert(List.createItem(data),before)}remove(item){this.updateCursors(item,item.prev,item,item.next)
1075if(item.prev!==null)item.prev.next=item.next
1076else{if(this.head!==item)throw new Error("item doesn't belong to list")
1077this.head=item.next}if(item.next!==null)item.next.prev=item.prev
1078else{if(this.tail!==item)throw new Error("item doesn't belong to list")
1079this.tail=item.prev}item.prev=null
1080item.next=null
1081return item}push(data){this.insert(List.createItem(data))}pop(){return this.tail!==null?this.remove(this.tail):null}unshift(data){this.prepend(List.createItem(data))}shift(){return this.head!==null?this.remove(this.head):null}prependList(list){return this.insertList(list,this.head)}appendList(list){return this.insertList(list)}insertList(list,before){if(list.head===null)return this
1082if(before!==void 0&&before!==null){this.updateCursors(before.prev,list.tail,before,list.head)
1083if(before.prev!==null){before.prev.next=list.head
1084list.head.prev=before.prev}else this.head=list.head
1085before.prev=list.tail
1086list.tail.next=before}else{this.updateCursors(this.tail,list.tail,null,list.head)
1087if(this.tail!==null){this.tail.next=list.head
1088list.head.prev=this.tail}else this.head=list.head
1089this.tail=list.tail}list.head=null
1090list.tail=null
1091return this}replace(oldItem,newItemOrList){"head"in newItemOrList?this.insertList(newItemOrList,oldItem):this.insert(newItemOrList,oldItem)
1092this.remove(oldItem)}}

1092
1093function createCustomError$1(name,message){const error=Object.create(SyntaxError.prototype)
1094const errorStack=new Error
1095return Object.assign(error,{name:name,message:message,get stack(){return(errorStack.stack||"").replace(/^(.+\n){1,3}/,`${name}: ${message}\n`)}})}const MAX_LINE_LENGTH$1=100
1096const OFFSET_CORRECTION$1=60
1097const TAB_REPLACEMENT$1="    "
1098function sourceFragment$1({source:source,line:line,column:column,baseLine:baseLine,baseColumn:baseColumn},extraLines){function processLines(start,end){return lines.slice(start,end).map(((line,idx)=>String(start+idx+1).padStart(maxNumLength)+" |"+line)).join("\n")}const prelines="\n".repeat(Math.max(baseLine-1,0))
1099const precolumns=" ".repeat(Math.max(baseColumn-1,0))
1100const lines=(prelines+precolumns+source).split(/\r\n?|\n|\f/)
1101const startLine=Math.max(1,line-extraLines)-1
1102const endLine=Math.min(line+extraLines,lines.length+1)
1103const maxNumLength=Math.max(4,String(endLine).length)+1
1104let cutLeft=0
1105column+=(TAB_REPLACEMENT$1.length-1)*(lines[line-1].substr(0,column-1).match(/\t/g)||[]).length
1106if(column>MAX_LINE_LENGTH$1){cutLeft=column-OFFSET_CORRECTION$1+3
1107column=OFFSET_CORRECTION$1-2}for(let i=startLine;i<=endLine;i++)if(i>=0&&i<lines.length){lines[i]=lines[i].replace(/\t/g,TAB_REPLACEMENT$1)
1108lines[i]=(cutLeft>0&&lines[i].length>cutLeft?"…":"")+lines[i].substr(cutLeft,MAX_LINE_LENGTH$1-2)+(lines[i].length>cutLeft+MAX_LINE_LENGTH$1-1?"…":"")}return[processLines(startLine,line),new Array(column+maxNumLength+2).join("-")+"^",processLines(line,endLine)].filter(Boolean).join("\n").replace(/^(\s+\d+\s+\|\n)+/,"").replace(/\n(\s+\d+\s+\|)+$/,"")}function SyntaxError$4(message,source,offset,line,column,baseLine=1,baseColumn=1){const error=Object.assign(createCustomError$1("SyntaxError",message),{source:source,offset:offset,line:line,column:column,sourceFragment:extraLines=>sourceFragment$1({source:source,line:line,column:column,baseLine:baseLine,baseColumn:baseColumn},isNaN(extraLines)?0:extraLines),get formattedMessage(){return`Parse error: ${message}\n`+sourceFragment$1({source:source,line:line,column:column,baseLine:baseLine,baseColumn:baseColumn},2)}})
1109return error}function readSequence$2(recognizer){const children=this.createList()
1110let space=false
1111const context={recognizer:recognizer}
1112while(!this.eof){switch(this.tokenType){case Comment$3:this.next()
1113continue
1114case WhiteSpace$3:space=true
1115this.next()
1116continue}let child=recognizer.getNode.call(this,context)
1117if(child===void 0)break
1118if(space){recognizer.onWhiteSpace&&recognizer.onWhiteSpace.call(this,child,children,context)
1119space=false}children.push(child)}space&&recognizer.onWhiteSpace&&recognizer.onWhiteSpace.call(this,null,children,context)
1120return children}const NOOP$1=()=>{}
1121const EXCLAMATIONMARK$7=0x0021
1122const NUMBERSIGN$9=0x0023
1123const SEMICOLON$1=0x003B
1124const LEFTCURLYBRACKET$3=0x007B
1125const NULL$1=0
1126function createParseContext$1(name){return function(){return this[name]()}}function fetchParseValues$1(dict){const result=Object.create(null)
1127for(const name of Object.keys(dict)){const item=dict[name]
1128const fn=item.parse||item
1129fn&&(result[name]=fn)}return result}function processConfig$1(config){const parseConfig={context:Object.create(null),features:Object.assign(Object.create(null),config.features),scope:Object.assign(Object.create(null),config.scope),atrule:fetchParseValues$1(config.atrule),pseudo:fetchParseValues$1(config.pseudo),node:fetchParseValues$1(config.node)}
1130for(const[name,context]of Object.entries(config.parseContext))switch(typeof context){case"function":parseConfig.context[name]=context
1131break
1132case"string":parseConfig.context[name]=createParseContext$1(context)
1133break}return{config:parseConfig,...parseConfig,...parseConfig.node}}function createParser$1(config){let source=""
1134let filename="<unknown>"
1135let needPositions=false
1136let onParseError=NOOP$1
1137let onParseErrorThrow=false
1138const locationMap=new OffsetToLocation$1
1139const parser=Object.assign(new TokenStream$1,processConfig$1(config||{}),{parseAtrulePrelude:true,parseRulePrelude:true,parseValue:true,parseCustomProperty:false,readSequence:readSequence$2,consumeUntilBalanceEnd:()=>0,consumeUntilLeftCurlyBracket:code=>code===LEFTCURLYBRACKET$3?1:0,consumeUntilLeftCurlyBracketOrSemicolon:code=>code===LEFTCURLYBRACKET$3||code===SEMICOLON$1?1:0,consumeUntilExclamationMarkOrSemicolon:code=>code===EXCLAMATIONMARK$7||code===SEMICOLON$1?1:0,consumeUntilSemicolonIncluded:code=>code===SEMICOLON$1?2:0,createList:()=>new List$1,createSingleNodeList:node=>(new List$1).appendData(node),getFirstListNode:list=>list&&list.first,getLastListNode:list=>list&&list.last,parseWithFallback(consumer,fallback){const startIndex=this.tokenIndex
1140try{return consumer.call(this)}catch(e){if(onParseErrorThrow)throw e
1141this.skip(startIndex-this.tokenIndex)
1142const fallbackNode=fallback.call(this)
1143onParseErrorThrow=true
1144onParseError(e,fallbackNode)
1145onParseErrorThrow=false
1146return fallbackNode}},lookupNonWSType(offset){let type
1147do{type=this.lookupType(offset++)
1148if(type!==WhiteSpace$3&&type!==Comment$3)return type}while(type!==NULL$1)
1149return NULL$1},charCodeAt:offset=>offset>=0&&offset<source.length?source.charCodeAt(offset):0,substring:(offsetStart,offsetEnd)=>source.substring(offsetStart,offsetEnd),substrToCursor(start){return this.source.substring(start,this.tokenStart)},cmpChar:(offset,charCode)=>cmpChar$1(source,offset,charCode),cmpStr:(offsetStart,offsetEnd,str)=>cmpStr$1(source,offsetStart,offsetEnd,str),consume(tokenType){const start=this.tokenStart
1150this.eat(tokenType)
1151return this.substrToCursor(start)},consumeFunctionName(){const name=source.substring(this.tokenStart,this.tokenEnd-1)
1152this.eat(Function$3)
1153return name},consumeNumber(type){const number=source.substring(this.tokenStart,consumeNumber$2(source,this.tokenStart))
1154this.eat(type)
1155return number},eat(tokenType){if(this.tokenType!==tokenType){const tokenName=tokenNames$1[tokenType].slice(0,-6).replace(/-/g," ").replace(/^./,(m=>m.toUpperCase()))
1156let message=`${/[[\](){}]/.test(tokenName)?`"${tokenName}"`:tokenName} is expected`
1157let offset=this.tokenStart
1158switch(tokenType){case Ident$1:if(this.tokenType===Function$3||this.tokenType===Url$4){offset=this.tokenEnd-1
1159message="Identifier is expected but function found"}else message="Identifier is expected"
1160break
1161case Hash$3:if(this.isDelim(NUMBERSIGN$9)){this.next()
1162offset++
1163message="Name is expected"}break
1164case Percentage$3:if(this.tokenType===Number$5){offset=this.tokenEnd
1165message="Percent sign is expected"}break}this.error(message,offset)}this.next()},eatIdent(name){this.tokenType===Ident$1&&this.lookupValue(0,name)!==false||this.error(`Identifier "${name}" is expected`)
1166this.next()},eatDelim(code){this.isDelim(code)||this.error(`Delim "${String.fromCharCode(code)}" is expected`)
1167this.next()},getLocation(start,end){if(needPositions)return locationMap.getLocationRange(start,end,filename)
1168return null},getLocationFromList(list){if(needPositions){const head=this.getFirstListNode(list)
1169const tail=this.getLastListNode(list)
1170return locationMap.getLocationRange(head!==null?head.loc.start.offset-locationMap.startOffset:this.tokenStart,tail!==null?tail.loc.end.offset-locationMap.startOffset:this.tokenStart,filename)}return null},error(message,offset){const location=typeof offset!=="undefined"&&offset<source.length?locationMap.getLocation(offset):this.eof?locationMap.getLocation(findWhiteSpaceStart$1(source,source.length-1)):locationMap.getLocation(this.tokenStart)
1171throw new SyntaxError$4(message||"Unexpected input",source,location.offset,location.line,location.column,locationMap.startLine,locationMap.startColumn)}})
1172const parse=function(source_,options){source=source_
1173options=options||{}
1174parser.setSource(source,tokenize$4)
1175locationMap.setSource(source,options.offset,options.line,options.column)
1176filename=options.filename||"<unknown>"
1177needPositions=Boolean(options.positions)
1178onParseError=typeof options.onParseError==="function"?options.onParseError:NOOP$1
1179onParseErrorThrow=false
1180parser.parseAtrulePrelude=!("parseAtrulePrelude"in options)||Boolean(options.parseAtrulePrelude)
1181parser.parseRulePrelude=!("parseRulePrelude"in options)||Boolean(options.parseRulePrelude)
1182parser.parseValue=!("parseValue"in options)||Boolean(options.parseValue)
1183parser.parseCustomProperty="parseCustomProperty"in options&&Boolean(options.parseCustomProperty)
1184const{context:context="default",onComment:onComment}=options
1185if(context in parser.context===false)throw new Error("Unknown context `"+context+"`")
1186typeof onComment==="function"&&parser.forEachToken(((type,start,end)=>{if(type===Comment$3){const loc=parser.getLocation(start,end)
1187const value=cmpStr$1(source,end-2,end,"*/")?source.slice(start+2,end-2):source.slice(start+2,end)
1188onComment(value,loc)}}))
1189const ast=parser.context[context].call(parser,options)
1190parser.eof||parser.error()
1191return ast}
1192return Object.assign(parse,{SyntaxError:SyntaxError$4,config:parser.config})}var base64Vlq={}
1193var base64$1={}
1194var intToCharMap="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("")
1195base64$1.encode=function(number){if(0<=number&&number<intToCharMap.length)return intToCharMap[number]
1196throw new TypeError("Must be between 0 and 63: "+number)}
1197base64$1.decode=function(charCode){var bigA=65
1198var bigZ=90
1199var littleA=97
1200var littleZ=122
1201var zero=48
1202var nine=57
1203var plus=43
1204var slash=47
1205var littleOffset=26
1206var numberOffset=52
1207if(bigA<=charCode&&charCode<=bigZ)return charCode-bigA
1208if(littleA<=charCode&&charCode<=littleZ)return charCode-littleA+littleOffset
1209if(zero<=charCode&&charCode<=nine)return charCode-zero+numberOffset
1210if(charCode==plus)return 62
1211if(charCode==slash)return 63
1212return-1}
1213var base64=base64$1
1214var VLQ_BASE_SHIFT=5
1215var VLQ_BASE=1<<VLQ_BASE_SHIFT
1216var VLQ_BASE_MASK=VLQ_BASE-1
1217var VLQ_CONTINUATION_BIT=VLQ_BASE
1218function toVLQSigned(aValue){return aValue<0?1+(-aValue<<1):0+(aValue<<1)}function fromVLQSigned(aValue){var isNegative=(aValue&1)===1
1219var shifted=aValue>>1
1220return isNegative?-shifted:shifted}base64Vlq.encode=function base64VLQ_encode(aValue){var encoded=""
1221var digit
1222var vlq=toVLQSigned(aValue)
1223do{digit=vlq&VLQ_BASE_MASK
1224vlq>>>=VLQ_BASE_SHIFT
1225vlq>0&&(digit|=VLQ_CONTINUATION_BIT)
1226encoded+=base64.encode(digit)}while(vlq>0)
1227return encoded}
1228base64Vlq.decode=function base64VLQ_decode(aStr,aIndex,aOutParam){var strLen=aStr.length
1229var result=0
1230var shift=0
1231var continuation,digit
1232do{if(aIndex>=strLen)throw new Error("Expected more digits in base 64 VLQ value.")
1233digit=base64.decode(aStr.charCodeAt(aIndex++))
1234if(digit===-1)throw new Error("Invalid base64 digit: "+aStr.charAt(aIndex-1))
1235continuation=!!(digit&VLQ_CONTINUATION_BIT)
1236digit&=VLQ_BASE_MASK
1237result+=digit<<shift
1238shift+=VLQ_BASE_SHIFT}while(continuation)
1239aOutParam.value=fromVLQSigned(result)
1240aOutParam.rest=aIndex}
1241var util$3={};(function(exports){function getArg(aArgs,aName,aDefaultValue){if(aName in aArgs)return aArgs[aName]
1242if(arguments.length===3)return aDefaultValue
1243throw new Error('"'+aName+'" is a required argument.')}exports.getArg=getArg
1244var urlRegexp=/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/
1245var dataUrlRegexp=/^data:.+\,.+$/
1246function urlParse(aUrl){var match=aUrl.match(urlRegexp)
1247if(!match)return null
1248return{scheme:match[1],auth:match[2],host:match[3],port:match[4],path:match[5]}}exports.urlParse=urlParse
1249function urlGenerate(aParsedUrl){var url=""
1250aParsedUrl.scheme&&(url+=aParsedUrl.scheme+":")
1251url+="//"
1252aParsedUrl.auth&&(url+=aParsedUrl.auth+"@")
1253aParsedUrl.host&&(url+=aParsedUrl.host)
1254aParsedUrl.port&&(url+=":"+aParsedUrl.port)
1255aParsedUrl.path&&(url+=aParsedUrl.path)
1256return url}exports.urlGenerate=urlGenerate
1257var MAX_CACHED_INPUTS=32
1258function lruMemoize(f){var cache=[]
1259return function(input){for(var i=0;i<cache.length;i++)if(cache[i].input===input){var temp=cache[0]
1260cache[0]=cache[i]
1261cache[i]=temp
1262return cache[0].result}var result=f(input)
1263cache.unshift({input:input,result:result})
1264cache.length>MAX_CACHED_INPUTS&&cache.pop()
1265return result}}var normalize=lruMemoize((function normalize(aPath){var path=aPath
1266var url=urlParse(aPath)
1267if(url){if(!url.path)return aPath
1268path=url.path}var isAbsolute=exports.isAbsolute(path)
1269var parts=[]
1270var start=0
1271var i=0
1272while(true){start=i
1273i=path.indexOf("/",start)
1274if(i===-1){parts.push(path.slice(start))
1275break}parts.push(path.slice(start,i))
1276while(i<path.length&&path[i]==="/")i++}for(var part,up=0,i=parts.length-1;i>=0;i--){part=parts[i]
1277if(part===".")parts.splice(i,1)
1278else if(part==="..")up++
1279else if(up>0)if(part===""){parts.splice(i+1,up)
1280up=0}else{parts.splice(i,2)
1281up--}}path=parts.join("/")
1282path===""&&(path=isAbsolute?"/":".")
1283if(url){url.path=path
1284return urlGenerate(url)}return path}))
1285exports.normalize=normalize
1286function join(aRoot,aPath){aRoot===""&&(aRoot=".")
1287aPath===""&&(aPath=".")
1288var aPathUrl=urlParse(aPath)
1289var aRootUrl=urlParse(aRoot)
1290aRootUrl&&(aRoot=aRootUrl.path||"/")
1291if(aPathUrl&&!aPathUrl.scheme){aRootUrl&&(aPathUrl.scheme=aRootUrl.scheme)
1292return urlGenerate(aPathUrl)}if(aPathUrl||aPath.match(dataUrlRegexp))return aPath
1293if(aRootUrl&&!aRootUrl.host&&!aRootUrl.path){aRootUrl.host=aPath
1294return urlGenerate(aRootUrl)}var joined=aPath.charAt(0)==="/"?aPath:normalize(aRoot.replace(/\/+$/,"")+"/"+aPath)
1295if(aRootUrl){aRootUrl.path=joined
1296return urlGenerate(aRootUrl)}return joined}exports.join=join
1297exports.isAbsolute=function(aPath){return aPath.charAt(0)==="/"||urlRegexp.test(aPath)}
1298function relative(aRoot,aPath){aRoot===""&&(aRoot=".")
1299aRoot=aRoot.replace(/\/$/,"")
1300var level=0
1301while(aPath.indexOf(aRoot+"/")!==0){var index=aRoot.lastIndexOf("/")
1302if(index<0)return aPath
1303aRoot=aRoot.slice(0,index)
1304if(aRoot.match(/^([^\/]+:\/)?\/*$/))return aPath;++level}return Array(level+1).join("../")+aPath.substr(aRoot.length+1)}exports.relative=relative
1305var supportsNullProto=function(){var obj=Object.create(null)
1306return!("__proto__"in obj)}()
1307function identity(s){return s}function toSetString(aStr){if(isProtoString(aStr))return"$"+aStr
1308return aStr}exports.toSetString=supportsNullProto?identity:toSetString
1309function fromSetString(aStr){if(isProtoString(aStr))return aStr.slice(1)
1310return aStr}exports.fromSetString=supportsNullProto?identity:fromSetString
1311function isProtoString(s){if(!s)return false
1312var length=s.length
1313if(length<9)return false
1314if(s.charCodeAt(length-1)!==95||s.charCodeAt(length-2)!==95||s.charCodeAt(length-3)!==111||s.charCodeAt(length-4)!==116||s.charCodeAt(length-5)!==111||s.charCodeAt(length-6)!==114||s.charCodeAt(length-7)!==112||s.charCodeAt(length-8)!==95||s.charCodeAt(length-9)!==95)return false
1315for(var i=length-10;i>=0;i--)if(s.charCodeAt(i)!==36)return false
1316return true}function compareByOriginalPositions(mappingA,mappingB,onlyCompareOriginal){var cmp=strcmp(mappingA.source,mappingB.source)
1317if(cmp!==0)return cmp
1318cmp=mappingA.originalLine-mappingB.originalLine
1319if(cmp!==0)return cmp
1320cmp=mappingA.originalColumn-mappingB.originalColumn
1321if(cmp!==0||onlyCompareOriginal)return cmp
1322cmp=mappingA.generatedColumn-mappingB.generatedColumn
1323if(cmp!==0)return cmp
1324cmp=mappingA.generatedLine-mappingB.generatedLine
1325if(cmp!==0)return cmp
1326return strcmp(mappingA.name,mappingB.name)}exports.compareByOriginalPositions=compareByOriginalPositions
1327function compareByOriginalPositionsNoSource(mappingA,mappingB,onlyCompareOriginal){var cmp
1328cmp=mappingA.originalLine-mappingB.originalLine
1329if(cmp!==0)return cmp
1330cmp=mappingA.originalColumn-mappingB.originalColumn
1331if(cmp!==0||onlyCompareOriginal)return cmp
1332cmp=mappingA.generatedColumn-mappingB.generatedColumn
1333if(cmp!==0)return cmp
1334cmp=mappingA.generatedLine-mappingB.generatedLine
1335if(cmp!==0)return cmp
1336return strcmp(mappingA.name,mappingB.name)}exports.compareByOriginalPositionsNoSource=compareByOriginalPositionsNoSource
1337function compareByGeneratedPositionsDeflated(mappingA,mappingB,onlyCompareGenerated){var cmp=mappingA.generatedLine-mappingB.generatedLine
1338if(cmp!==0)return cmp
1339cmp=mappingA.generatedColumn-mappingB.generatedColumn
1340if(cmp!==0||onlyCompareGenerated)return cmp
1341cmp=strcmp(mappingA.source,mappingB.source)
1342if(cmp!==0)return cmp
1343cmp=mappingA.originalLine-mappingB.originalLine
1344if(cmp!==0)return cmp
1345cmp=mappingA.originalColumn-mappingB.originalColumn
1346if(cmp!==0)return cmp
1347return strcmp(mappingA.name,mappingB.name)}exports.compareByGeneratedPositionsDeflated=compareByGeneratedPositionsDeflated
1348function compareByGeneratedPositionsDeflatedNoLine(mappingA,mappingB,onlyCompareGenerated){var cmp=mappingA.generatedColumn-mappingB.generatedColumn
1349if(cmp!==0||onlyCompareGenerated)return cmp
1350cmp=strcmp(mappingA.source,mappingB.source)
1351if(cmp!==0)return cmp
1352cmp=mappingA.originalLine-mappingB.originalLine
1353if(cmp!==0)return cmp
1354cmp=mappingA.originalColumn-mappingB.originalColumn
1355if(cmp!==0)return cmp
1356return strcmp(mappingA.name,mappingB.name)}exports.compareByGeneratedPositionsDeflatedNoLine=compareByGeneratedPositionsDeflatedNoLine
1357function strcmp(aStr1,aStr2){if(aStr1===aStr2)return 0
1358if(aStr1===null)return 1
1359if(aStr2===null)return-1
1360if(aStr1>aStr2)return 1
1361return-1}function compareByGeneratedPositionsInflated(mappingA,mappingB){var cmp=mappingA.generatedLine-mappingB.generatedLine
1362if(cmp!==0)return cmp
1363cmp=mappingA.generatedColumn-mappingB.generatedColumn
1364if(cmp!==0)return cmp
1365cmp=strcmp(mappingA.source,mappingB.source)
1366if(cmp!==0)return cmp
1367cmp=mappingA.originalLine-mappingB.originalLine
1368if(cmp!==0)return cmp
1369cmp=mappingA.originalColumn-mappingB.originalColumn
1370if(cmp!==0)return cmp
1371return strcmp(mappingA.name,mappingB.name)}exports.compareByGeneratedPositionsInflated=compareByGeneratedPositionsInflated
1372function parseSourceMapInput(str){return JSON.parse(str.replace(/^\)]}'[^\n]*\n/,""))}exports.parseSourceMapInput=parseSourceMapInput
1373function computeSourceURL(sourceRoot,sourceURL,sourceMapURL){sourceURL=sourceURL||""
1374if(sourceRoot){sourceRoot[sourceRoot.length-1]!=="/"&&sourceURL[0]!=="/"&&(sourceRoot+="/")
1375sourceURL=sourceRoot+sourceURL}if(sourceMapURL){var parsed=urlParse(sourceMapURL)
1376if(!parsed)throw new Error("sourceMapURL could not be parsed")

1438aSourceMapConsumer.sources.forEach((function(sourceFile){var sourceRelative=sourceFile
1439sourceRoot!==null&&(sourceRelative=util.relative(sourceRoot,sourceFile))
1440generator._sources.has(sourceRelative)||generator._sources.add(sourceRelative)
1441var content=aSourceMapConsumer.sourceContentFor(sourceFile)
1442content!=null&&generator.setSourceContent(sourceFile,content)}))
1443return generator}
1444SourceMapGenerator.prototype.addMapping=function SourceMapGenerator_addMapping(aArgs){var generated=util.getArg(aArgs,"generated")
1445var original=util.getArg(aArgs,"original",null)
1446var source=util.getArg(aArgs,"source",null)
1447var name=util.getArg(aArgs,"name",null)
1448if(!this._skipValidation&&this._validateMapping(generated,original,source,name)===false)return
1449if(source!=null){source=String(source)
1450this._sources.has(source)||this._sources.add(source)}if(name!=null){name=String(name)
1451this._names.has(name)||this._names.add(name)}this._mappings.add({generatedLine:generated.line,generatedColumn:generated.column,originalLine:original!=null&&original.line,originalColumn:original!=null&&original.column,source:source,name:name})}
1452SourceMapGenerator.prototype.setSourceContent=function SourceMapGenerator_setSourceContent(aSourceFile,aSourceContent){var source=aSourceFile
1453this._sourceRoot!=null&&(source=util.relative(this._sourceRoot,source))
1454if(aSourceContent!=null){this._sourcesContents||(this._sourcesContents=Object.create(null))
1455this._sourcesContents[util.toSetString(source)]=aSourceContent}else if(this._sourcesContents){delete this._sourcesContents[util.toSetString(source)]
1456Object.keys(this._sourcesContents).length===0&&(this._sourcesContents=null)}}
1457SourceMapGenerator.prototype.applySourceMap=function SourceMapGenerator_applySourceMap(aSourceMapConsumer,aSourceFile,aSourceMapPath){var sourceFile=aSourceFile
1458if(aSourceFile==null){if(aSourceMapConsumer.file==null)throw new Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map\'s "file" property. Both were omitted.')
1459sourceFile=aSourceMapConsumer.file}var sourceRoot=this._sourceRoot
1460sourceRoot!=null&&(sourceFile=util.relative(sourceRoot,sourceFile))
1461var newSources=new ArraySet
1462var newNames=new ArraySet
1463this._mappings.unsortedForEach((function(mapping){if(mapping.source===sourceFile&&mapping.originalLine!=null){var original=aSourceMapConsumer.originalPositionFor({line:mapping.originalLine,column:mapping.originalColumn})
1464if(original.source!=null){mapping.source=original.source
1465aSourceMapPath!=null&&(mapping.source=util.join(aSourceMapPath,mapping.source))
1466sourceRoot!=null&&(mapping.source=util.relative(sourceRoot,mapping.source))
1467mapping.originalLine=original.line
1468mapping.originalColumn=original.column
1469original.name!=null&&(mapping.name=original.name)}}var source=mapping.source
1470source==null||newSources.has(source)||newSources.add(source)
1471var name=mapping.name
1472name==null||newNames.has(name)||newNames.add(name)}),this)
1473this._sources=newSources
1474this._names=newNames
1475aSourceMapConsumer.sources.forEach((function(sourceFile){var content=aSourceMapConsumer.sourceContentFor(sourceFile)
1476if(content!=null){aSourceMapPath!=null&&(sourceFile=util.join(aSourceMapPath,sourceFile))
1477sourceRoot!=null&&(sourceFile=util.relative(sourceRoot,sourceFile))
1478this.setSourceContent(sourceFile,content)}}),this)}
1479SourceMapGenerator.prototype._validateMapping=function SourceMapGenerator_validateMapping(aGenerated,aOriginal,aSource,aName){if(aOriginal&&typeof aOriginal.line!=="number"&&typeof aOriginal.column!=="number"){var message="original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values."
1480if(this._ignoreInvalidMapping){typeof console!=="undefined"&&console.warn&&console.warn(message)
1481return false}throw new Error(message)}if(aGenerated&&"line"in aGenerated&&"column"in aGenerated&&aGenerated.line>0&&aGenerated.column>=0&&!aOriginal&&!aSource&&!aName)return
1482if(aGenerated&&"line"in aGenerated&&"column"in aGenerated&&aOriginal&&"line"in aOriginal&&"column"in aOriginal&&aGenerated.line>0&&aGenerated.column>=0&&aOriginal.line>0&&aOriginal.column>=0&&aSource)return
1483var message="Invalid mapping: "+JSON.stringify({generated:aGenerated,source:aSource,original:aOriginal,name:aName})
1484if(this._ignoreInvalidMapping){typeof console!=="undefined"&&console.warn&&console.warn(message)
1485return false}throw new Error(message)}
1486SourceMapGenerator.prototype._serializeMappings=function SourceMapGenerator_serializeMappings(){var previousGeneratedColumn=0
1487var previousGeneratedLine=1
1488var previousOriginalColumn=0
1489var previousOriginalLine=0
1490var previousName=0
1491var previousSource=0
1492var result=""
1493var next
1494var mapping
1495var nameIdx
1496var sourceIdx
1497var mappings=this._mappings.toArray()
1498for(var i=0,len=mappings.length;i<len;i++){mapping=mappings[i]
1499next=""
1500if(mapping.generatedLine!==previousGeneratedLine){previousGeneratedColumn=0
1501while(mapping.generatedLine!==previousGeneratedLine){next+=";"
1502previousGeneratedLine++}}else if(i>0){if(!util.compareByGeneratedPositionsInflated(mapping,mappings[i-1]))continue
1503next+=","}next+=base64VLQ.encode(mapping.generatedColumn-previousGeneratedColumn)
1504previousGeneratedColumn=mapping.generatedColumn
1505if(mapping.source!=null){sourceIdx=this._sources.indexOf(mapping.source)
1506next+=base64VLQ.encode(sourceIdx-previousSource)
1507previousSource=sourceIdx
1508next+=base64VLQ.encode(mapping.originalLine-1-previousOriginalLine)
1509previousOriginalLine=mapping.originalLine-1
1510next+=base64VLQ.encode(mapping.originalColumn-previousOriginalColumn)
1511previousOriginalColumn=mapping.originalColumn
1512if(mapping.name!=null){nameIdx=this._names.indexOf(mapping.name)
1513next+=base64VLQ.encode(nameIdx-previousName)
1514previousName=nameIdx}}result+=next}return result}
1515SourceMapGenerator.prototype._generateSourcesContent=function SourceMapGenerator_generateSourcesContent(aSources,aSourceRoot){return aSources.map((function(source){if(!this._sourcesContents)return null
1516aSourceRoot!=null&&(source=util.relative(aSourceRoot,source))
1517var key=util.toSetString(source)
1518return Object.prototype.hasOwnProperty.call(this._sourcesContents,key)?this._sourcesContents[key]:null}),this)}
1519SourceMapGenerator.prototype.toJSON=function SourceMapGenerator_toJSON(){var map={version:this._version,sources:this._sources.toArray(),names:this._names.toArray(),mappings:this._serializeMappings()}
1520this._file!=null&&(map.file=this._file)
1521this._sourceRoot!=null&&(map.sourceRoot=this._sourceRoot)
1522this._sourcesContents&&(map.sourcesContent=this._generateSourcesContent(map.sources,map.sourceRoot))
1523return map}
1524SourceMapGenerator.prototype.toString=function SourceMapGenerator_toString(){return JSON.stringify(this.toJSON())}
1525var SourceMapGenerator_1=SourceMapGenerator
1526const trackNodes$1=new Set(["Atrule","Selector","Declaration"])
1527function generateSourceMap$1(handlers){const map=new SourceMapGenerator_1
1528const generated={line:1,column:0}
1529const original={line:0,column:0}
1530const activatedGenerated={line:1,column:0}
1531const activatedMapping={generated:activatedGenerated}
1532let line=1
1533let column=0
1534let sourceMappingActive=false
1535const origHandlersNode=handlers.node
1536handlers.node=function(node){if(node.loc&&node.loc.start&&trackNodes$1.has(node.type)){const nodeLine=node.loc.start.line
1537const nodeColumn=node.loc.start.column-1
1538if(original.line!==nodeLine||original.column!==nodeColumn){original.line=nodeLine
1539original.column=nodeColumn
1540generated.line=line
1541generated.column=column
1542if(sourceMappingActive){sourceMappingActive=false
1543generated.line===activatedGenerated.line&&generated.column===activatedGenerated.column||map.addMapping(activatedMapping)}sourceMappingActive=true
1544map.addMapping({source:node.loc.source,original:original,generated:generated})}}origHandlersNode.call(this,node)
1545if(sourceMappingActive&&trackNodes$1.has(node.type)){activatedGenerated.line=line
1546activatedGenerated.column=column}}
1547const origHandlersEmit=handlers.emit
1548handlers.emit=function(value,type,auto){for(let i=0;i<value.length;i++)if(value.charCodeAt(i)===10){line++
1549column=0}else column++
1550origHandlersEmit(value,type,auto)}
1551const origHandlersResult=handlers.result
1552handlers.result=function(){sourceMappingActive&&map.addMapping(activatedMapping)
1553return{css:origHandlersResult(),map:map}}
1554return handlers}const PLUSSIGN$j=0x002B
1555const HYPHENMINUS$d=0x002D
1556const code$1=(type,value)=>{type===Delim$1&&(type=value)
1557if(typeof type==="string"){const charCode=type.charCodeAt(0)
1558return charCode>0x7F?0x8000:charCode<<8}return type}
1559const specPairs$1=[[Ident$1,Ident$1],[Ident$1,Function$3],[Ident$1,Url$4],[Ident$1,BadUrl$1],[Ident$1,"-"],[Ident$1,Number$5],[Ident$1,Percentage$3],[Ident$1,Dimension$3],[Ident$1,CDC$3],[Ident$1,LeftParenthesis$1],[AtKeyword$1,Ident$1],[AtKeyword$1,Function$3],[AtKeyword$1,Url$4],[AtKeyword$1,BadUrl$1],[AtKeyword$1,"-"],[AtKeyword$1,Number$5],[AtKeyword$1,Percentage$3],[AtKeyword$1,Dimension$3],[AtKeyword$1,CDC$3],[Hash$3,Ident$1],[Hash$3,Function$3],[Hash$3,Url$4],[Hash$3,BadUrl$1],[Hash$3,"-"],[Hash$3,Number$5],[Hash$3,Percentage$3],[Hash$3,Dimension$3],[Hash$3,CDC$3],[Dimension$3,Ident$1],[Dimension$3,Function$3],[Dimension$3,Url$4],[Dimension$3,BadUrl$1],[Dimension$3,"-"],[Dimension$3,Number$5],[Dimension$3,Percentage$3],[Dimension$3,Dimension$3],[Dimension$3,CDC$3],["#",Ident$1],["#",Function$3],["#",Url$4],["#",BadUrl$1],["#","-"],["#",Number$5],["#",Percentage$3],["#",Dimension$3],["#",CDC$3],["-",Ident$1],["-",Function$3],["-",Url$4],["-",BadUrl$1],["-","-"],["-",Number$5],["-",Percentage$3],["-",Dimension$3],["-",CDC$3],[Number$5,Ident$1],[Number$5,Function$3],[Number$5,Url$4],[Number$5,BadUrl$1],[Number$5,Number$5],[Number$5,Percentage$3],[Number$5,Dimension$3],[Number$5,"%"],[Number$5,CDC$3],["@",Ident$1],["@",Function$3],["@",Url$4],["@",BadUrl$1],["@","-"],["@",CDC$3],[".",Number$5],[".",Percentage$3],[".",Dimension$3],["+",Number$5],["+",Percentage$3],["+",Dimension$3],["/","*"]]
1560const safePairs$1=specPairs$1.concat([[Ident$1,Hash$3],[Dimension$3,Hash$3],[Hash$3,Hash$3],[AtKeyword$1,LeftParenthesis$1],[AtKeyword$1,String$4],[AtKeyword$1,Colon$1],[Percentage$3,Percentage$3],[Percentage$3,Dimension$3],[Percentage$3,Function$3],[Percentage$3,"-"],[RightParenthesis$1,Ident$1],[RightParenthesis$1,Function$3],[RightParenthesis$1,Percentage$3],[RightParenthesis$1,Dimension$3],[RightParenthesis$1,Hash$3],[RightParenthesis$1,"-"]])
1561function createMap$1(pairs){const isWhiteSpaceRequired=new Set(pairs.map((([prev,next])=>code$1(prev)<<16|code$1(next))))
1562return function(prevCode,type,value){const nextCode=code$1(type,value)
1563const nextCharCode=value.charCodeAt(0)
1564const emitWs=nextCharCode===HYPHENMINUS$d&&type!==Ident$1&&type!==Function$3&&type!==CDC$3||nextCharCode===PLUSSIGN$j?isWhiteSpaceRequired.has(prevCode<<16|nextCharCode<<8):isWhiteSpaceRequired.has(prevCode<<16|nextCode)
1565emitWs&&this.emit(" ",WhiteSpace$3,true)
1566return nextCode}}const spec$1=createMap$1(specPairs$1)
1567const safe$1=createMap$1(safePairs$1)
1568var tokenBefore$1=Object.freeze({__proto__:null,safe:safe$1,spec:spec$1})
1569const REVERSESOLIDUS$1=0x005c
1570function processChildren$1(node,delimeter){if(typeof delimeter==="function"){let prev=null
1571node.children.forEach((node=>{prev!==null&&delimeter.call(this,prev)
1572this.node(node)
1573prev=node}))
1574return}node.children.forEach(this.node,this)}function processChunk$1(chunk){tokenize$4(chunk,((type,start,end)=>{this.token(type,chunk.slice(start,end))}))}function createGenerator$1(config){const types=new Map
1575for(let[name,item]of Object.entries(config.node)){const fn=item.generate||item
1576typeof fn==="function"&&types.set(name,item.generate||item)}return function(node,options){let buffer=""
1577let prevCode=0
1578let handlers={node(node){if(!types.has(node.type))throw new Error("Unknown node type: "+node.type)
1579types.get(node.type).call(publicApi,node)},tokenBefore:safe$1,token(type,value){prevCode=this.tokenBefore(prevCode,type,value)
1580this.emit(value,type,false)
1581type===Delim$1&&value.charCodeAt(0)===REVERSESOLIDUS$1&&this.emit("\n",WhiteSpace$3,true)},emit(value){buffer+=value},result:()=>buffer}
1582if(options){typeof options.decorator==="function"&&(handlers=options.decorator(handlers))
1583options.sourceMap&&(handlers=generateSourceMap$1(handlers))
1584options.mode in tokenBefore$1&&(handlers.tokenBefore=tokenBefore$1[options.mode])}const publicApi={node:node=>handlers.node(node),children:processChildren$1,token:(type,value)=>handlers.token(type,value),tokenize:processChunk$1}
1585handlers.node(node)
1586return handlers.result()}}function createConvertor$1(walk){return{fromPlainObject(ast){walk(ast,{enter(node){node.children&&node.children instanceof List$1===false&&(node.children=(new List$1).fromArray(node.children))}})
1587return ast},toPlainObject(ast){walk(ast,{leave(node){node.children&&node.children instanceof List$1&&(node.children=node.children.toArray())}})
1588return ast}}}const{hasOwnProperty:hasOwnProperty$b}=Object.prototype
1589const noop$5=function(){}
1590function ensureFunction$3(value){return typeof value==="function"?value:noop$5}function invokeForType$1(fn,type){return function(node,item,list){node.type===type&&fn.call(this,node,item,list)}}function getWalkersFromStructure$1(name,nodeType){const structure=nodeType.structure
1591const walkers=[]
1592for(const key in structure){if(hasOwnProperty$b.call(structure,key)===false)continue
1593let fieldTypes=structure[key]
1594const walker={name:key,type:false,nullable:false}
1595Array.isArray(fieldTypes)||(fieldTypes=[fieldTypes])
1596for(const fieldType of fieldTypes)fieldType===null?walker.nullable=true:typeof fieldType==="string"?walker.type="node":Array.isArray(fieldType)&&(walker.type="list")
1597walker.type&&walkers.push(walker)}if(walkers.length)return{context:nodeType.walkContext,fields:walkers}
1598return null}function getTypesFromConfig$1(config){const types={}
1599for(const name in config.node)if(hasOwnProperty$b.call(config.node,name)){const nodeType=config.node[name]
1600if(!nodeType.structure)throw new Error("Missed `structure` field in `"+name+"` node type definition")
1601types[name]=getWalkersFromStructure$1(name,nodeType)}return types}function createTypeIterator$1(config,reverse){const fields=config.fields.slice()
1602const contextName=config.context
1603const useContext=typeof contextName==="string"
1604reverse&&fields.reverse()
1605return function(node,context,walk,walkReducer){let prevContextValue
1606if(useContext){prevContextValue=context[contextName]
1607context[contextName]=node}for(const field of fields){const ref=node[field.name]
1608if(!field.nullable||ref)if(field.type==="list"){const breakWalk=reverse?ref.reduceRight(walkReducer,false):ref.reduce(walkReducer,false)
1609if(breakWalk)return true}else if(walk(ref))return true}useContext&&(context[contextName]=prevContextValue)}}function createFastTraveralMap$1({StyleSheet:StyleSheet,Atrule:Atrule,Rule:Rule,Block:Block,DeclarationList:DeclarationList}){return{Atrule:{StyleSheet:StyleSheet,Atrule:Atrule,Rule:Rule,Block:Block},Rule:{StyleSheet:StyleSheet,Atrule:Atrule,Rule:Rule,Block:Block},Declaration:{StyleSheet:StyleSheet,Atrule:Atrule,Rule:Rule,Block:Block,DeclarationList:DeclarationList}}}function createWalker$1(config){const types=getTypesFromConfig$1(config)
1610const iteratorsNatural={}
1611const iteratorsReverse={}
1612const breakWalk=Symbol("break-walk")
1613const skipNode=Symbol("skip-node")
1614for(const name in types)if(hasOwnProperty$b.call(types,name)&&types[name]!==null){iteratorsNatural[name]=createTypeIterator$1(types[name],false)
1615iteratorsReverse[name]=createTypeIterator$1(types[name],true)}const fastTraversalIteratorsNatural=createFastTraveralMap$1(iteratorsNatural)
1616const fastTraversalIteratorsReverse=createFastTraveralMap$1(iteratorsReverse)
1617const walk=function(root,options){function walkNode(node,item,list){const enterRet=enter.call(context,node,item,list)
1618if(enterRet===breakWalk)return true
1619if(enterRet===skipNode)return false
1620if(iterators.hasOwnProperty(node.type)&&iterators[node.type](node,context,walkNode,walkReducer))return true
1621if(leave.call(context,node,item,list)===breakWalk)return true
1622return false}let enter=noop$5
1623let leave=noop$5
1624let iterators=iteratorsNatural
1625let walkReducer=(ret,data,item,list)=>ret||walkNode(data,item,list)
1626const context={break:breakWalk,skip:skipNode,root:root,stylesheet:null,atrule:null,atrulePrelude:null,rule:null,selector:null,block:null,declaration:null,function:null}
1627if(typeof options==="function")enter=options
1628else if(options){enter=ensureFunction$3(options.enter)
1629leave=ensureFunction$3(options.leave)
1630options.reverse&&(iterators=iteratorsReverse)
1631if(options.visit){if(fastTraversalIteratorsNatural.hasOwnProperty(options.visit))iterators=options.reverse?fastTraversalIteratorsReverse[options.visit]:fastTraversalIteratorsNatural[options.visit]
1632else if(!types.hasOwnProperty(options.visit))throw new Error("Bad value `"+options.visit+"` for `visit` option (should be: "+Object.keys(types).sort().join(", ")+")")
1633enter=invokeForType$1(enter,options.visit)
1634leave=invokeForType$1(leave,options.visit)}}if(enter===noop$5&&leave===noop$5)throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function")
1635walkNode(root)}
1636walk.break=breakWalk
1637walk.skip=skipNode
1638walk.find=function(ast,fn){let found=null
1639walk(ast,(function(node,item,list){if(fn.call(this,node,item,list)){found=node
1640return breakWalk}}))
1641return found}
1642walk.findLast=function(ast,fn){let found=null
1643walk(ast,{reverse:true,enter(node,item,list){if(fn.call(this,node,item,list)){found=node
1644return breakWalk}}})
1645return found}
1646walk.findAll=function(ast,fn){const found=[]
1647walk(ast,(function(node,item,list){fn.call(this,node,item,list)&&found.push(node)}))
1648return found}
1649return walk}function noop$4(value){return value}function generateMultiplier$1(multiplier){const{min:min,max:max,comma:comma}=multiplier
1650if(min===0&&max===0)return comma?"#?":"*"
1651if(min===0&&max===1)return"?"
1652if(min===1&&max===0)return comma?"#":"+"
1653if(min===1&&max===1)return""
1654return(comma?"#":"")+(min===max?"{"+min+"}":"{"+min+","+(max!==0?max:"")+"}")}function generateTypeOpts$1(node){switch(node.type){case"Range":return" ["+(node.min===null?"-∞":node.min)+","+(node.max===null?"∞":node.max)+"]"
1655default:throw new Error("Unknown node type `"+node.type+"`")}}function generateSequence$1(node,decorate,forceBraces,compact){const combinator=node.combinator===" "||compact?node.combinator:" "+node.combinator+" "
1656const result=node.terms.map((term=>internalGenerate$1(term,decorate,forceBraces,compact))).join(combinator)
1657if(node.explicit||forceBraces)return(compact||result[0]===","?"[":"[ ")+result+(compact?"]":" ]")
1658return result}function internalGenerate$1(node,decorate,forceBraces,compact){let result
1659switch(node.type){case"Group":result=generateSequence$1(node,decorate,forceBraces,compact)+(node.disallowEmpty?"!":"")
1660break
1661case"Multiplier":return internalGenerate$1(node.term,decorate,forceBraces,compact)+decorate(generateMultiplier$1(node),node)
1662case"Type":result="<"+node.name+(node.opts?decorate(generateTypeOpts$1(node.opts),node.opts):"")+">"
1663break
1664case"Property":result="<'"+node.name+"'>"
1665break
1666case"Keyword":result=node.name
1667break
1668case"AtKeyword":result="@"+node.name
1669break
1670case"Function":result=node.name+"("
1671break
1672case"String":case"Token":result=node.value
1673break
1674case"Comma":result=","
1675break
1676default:throw new Error("Unknown node type `"+node.type+"`")}return decorate(result,node)}function generate$1u(node,options){let decorate=noop$4
1677let forceBraces=false
1678let compact=false
1679if(typeof options==="function")decorate=options
1680else if(options){forceBraces=Boolean(options.forceBraces)
1681compact=Boolean(options.compact)
1682typeof options.decorate==="function"&&(decorate=options.decorate)}return internalGenerate$1(node,decorate,forceBraces,compact)}const defaultLoc$1={offset:0,line:1,column:1}
1683function locateMismatch$1(matchResult,node){const tokens=matchResult.tokens
1684const longestMatch=matchResult.longestMatch
1685const mismatchNode=longestMatch<tokens.length&&tokens[longestMatch].node||null
1686const badNode=mismatchNode!==node?mismatchNode:null
1687let mismatchOffset=0
1688let mismatchLength=0
1689let entries=0
1690let css=""
1691let start
1692let end
1693for(let i=0;i<tokens.length;i++){const token=tokens[i].value
1694if(i===longestMatch){mismatchLength=token.length
1695mismatchOffset=css.length}badNode!==null&&tokens[i].node===badNode&&(i<=longestMatch?entries++:entries=0)
1696css+=token}if(longestMatch===tokens.length||entries>1){start=fromLoc$1(badNode||node,"end")||buildLoc$1(defaultLoc$1,css)
1697end=buildLoc$1(start)}else{start=fromLoc$1(badNode,"start")||buildLoc$1(fromLoc$1(node,"start")||defaultLoc$1,css.slice(0,mismatchOffset))
1698end=fromLoc$1(badNode,"end")||buildLoc$1(start,css.substr(mismatchOffset,mismatchLength))}return{css:css,mismatchOffset:mismatchOffset,mismatchLength:mismatchLength,start:start,end:end}}function fromLoc$1(node,point){const value=node&&node.loc&&node.loc[point]
1699if(value)return"line"in value?buildLoc$1(value):value
1700return null}function buildLoc$1({offset:offset,line:line,column:column},extra){const loc={offset:offset,line:line,column:column}
1701if(extra){const lines=extra.split(/\n|\r\n?|\f/)
1702loc.offset+=extra.length
1703loc.line+=lines.length-1
1704loc.column=lines.length===1?loc.column+extra.length:lines.pop().length+1}return loc}const SyntaxReferenceError$1=function(type,referenceName){const error=createCustomError$1("SyntaxReferenceError",type+(referenceName?" `"+referenceName+"`":""))
1705error.reference=referenceName
1706return error}
1707const SyntaxMatchError$1=function(message,syntax,node,matchResult){const error=createCustomError$1("SyntaxMatchError",message)
1708const{css:css,mismatchOffset:mismatchOffset,mismatchLength:mismatchLength,start:start,end:end}=locateMismatch$1(matchResult,node)
1709error.rawMessage=message
1710error.syntax=syntax?generate$1u(syntax):"<generic>"
1711error.css=css
1712error.mismatchOffset=mismatchOffset
1713error.mismatchLength=mismatchLength
1714error.message=message+"\n  syntax: "+error.syntax+"\n   value: "+(css||"<empty string>")+"\n  --------"+new Array(error.mismatchOffset+1).join("-")+"^"
1715Object.assign(error,start)
1716error.loc={source:node&&node.loc&&node.loc.source||"<unknown>",start:start,end:end}
1717return error}
1718const keywords$1=new Map
1719const properties$1=new Map
1720const HYPHENMINUS$c=45
1721const keyword$1=getKeywordDescriptor$1
1722const property$1=getPropertyDescriptor$1
1723function isCustomProperty$1(str,offset){offset=offset||0
1724return str.length-offset>=2&&str.charCodeAt(offset)===HYPHENMINUS$c&&str.charCodeAt(offset+1)===HYPHENMINUS$c}function getVendorPrefix$1(str,offset){offset=offset||0
1725if(str.length-offset>=3&&str.charCodeAt(offset)===HYPHENMINUS$c&&str.charCodeAt(offset+1)!==HYPHENMINUS$c){const secondDashIndex=str.indexOf("-",offset+2)
1726if(secondDashIndex!==-1)return str.substring(offset,secondDashIndex+1)}return""}function getKeywordDescriptor$1(keyword){if(keywords$1.has(keyword))return keywords$1.get(keyword)
1727const name=keyword.toLowerCase()
1728let descriptor=keywords$1.get(name)
1729if(descriptor===void 0){const custom=isCustomProperty$1(name,0)
1730const vendor=custom?"":getVendorPrefix$1(name,0)
1731descriptor=Object.freeze({basename:name.substr(vendor.length),name:name,prefix:vendor,vendor:vendor,custom:custom})}keywords$1.set(keyword,descriptor)
1732return descriptor}function getPropertyDescriptor$1(property){if(properties$1.has(property))return properties$1.get(property)
1733let name=property
1734let hack=property[0]
1735hack==="/"?hack=property[1]==="/"?"//":"/":hack!=="_"&&hack!=="*"&&hack!=="$"&&hack!=="#"&&hack!=="+"&&hack!=="&"&&(hack="")
1736const custom=isCustomProperty$1(name,hack.length)
1737if(!custom){name=name.toLowerCase()
1738if(properties$1.has(name)){const descriptor=properties$1.get(name)
1739properties$1.set(property,descriptor)
1740return descriptor}}const vendor=custom?"":getVendorPrefix$1(name,hack.length)
1741const prefix=name.substr(0,hack.length+vendor.length)
1742const descriptor=Object.freeze({basename:name.substr(prefix.length),name:name.substr(hack.length),hack:hack,vendor:vendor,prefix:prefix,custom:custom})
1743properties$1.set(property,descriptor)
1744return descriptor}const cssWideKeywords$1=["initial","inherit","unset","revert","revert-layer"]
1745const PLUSSIGN$i=0x002B
1746const HYPHENMINUS$b=0x002D
1747const N$8=0x006E
1748const DISALLOW_SIGN$3=true
1749const ALLOW_SIGN$3=false
1750function isDelim$3(token,code){return token!==null&&token.type===Delim$1&&token.value.charCodeAt(0)===code}function skipSC$1(token,offset,getNextToken){while(token!==null&&(token.type===WhiteSpace$3||token.type===Comment$3))token=getNextToken(++offset)
1751return offset}function checkInteger$3(token,valueOffset,disallowSign,offset){if(!token)return 0
1752const code=token.value.charCodeAt(valueOffset)
1753if(code===PLUSSIGN$i||code===HYPHENMINUS$b){if(disallowSign)return 0
1754valueOffset++}for(;valueOffset<token.value.length;valueOffset++)if(!isDigit$2(token.value.charCodeAt(valueOffset)))return 0
1755return offset+1}function consumeB$3(token,offset_,getNextToken){let sign=false
1756let offset=skipSC$1(token,offset_,getNextToken)
1757token=getNextToken(offset)
1758if(token===null)return offset_
1759if(token.type!==Number$5){if(!isDelim$3(token,PLUSSIGN$i)&&!isDelim$3(token,HYPHENMINUS$b))return offset_
1760sign=true
1761offset=skipSC$1(getNextToken(++offset),offset,getNextToken)
1762token=getNextToken(offset)
1763if(token===null||token.type!==Number$5)return 0}if(!sign){const code=token.value.charCodeAt(0)
1764if(code!==PLUSSIGN$i&&code!==HYPHENMINUS$b)return 0}return checkInteger$3(token,sign?0:1,sign,offset)}function anPlusB$1(token,getNextToken){let offset=0
1765if(!token)return 0
1766if(token.type===Number$5)return checkInteger$3(token,0,ALLOW_SIGN$3,offset)
1767if(token.type===Ident$1&&token.value.charCodeAt(0)===HYPHENMINUS$b){if(!cmpChar$1(token.value,1,N$8))return 0
1768switch(token.value.length){case 2:return consumeB$3(getNextToken(++offset),offset,getNextToken)
1769case 3:if(token.value.charCodeAt(2)!==HYPHENMINUS$b)return 0
1770offset=skipSC$1(getNextToken(++offset),offset,getNextToken)
1771token=getNextToken(offset)
1772return checkInteger$3(token,0,DISALLOW_SIGN$3,offset)
1773default:if(token.value.charCodeAt(2)!==HYPHENMINUS$b)return 0
1774return checkInteger$3(token,3,DISALLOW_SIGN$3,offset)}}else if(token.type===Ident$1||isDelim$3(token,PLUSSIGN$i)&&getNextToken(offset+1).type===Ident$1){token.type!==Ident$1&&(token=getNextToken(++offset))
1775if(token===null||!cmpChar$1(token.value,0,N$8))return 0
1776switch(token.value.length){case 1:return consumeB$3(getNextToken(++offset),offset,getNextToken)
1777case 2:if(token.value.charCodeAt(1)!==HYPHENMINUS$b)return 0
1778offset=skipSC$1(getNextToken(++offset),offset,getNextToken)
1779token=getNextToken(offset)
1780return checkInteger$3(token,0,DISALLOW_SIGN$3,offset)
1781default:if(token.value.charCodeAt(1)!==HYPHENMINUS$b)return 0
1782return checkInteger$3(token,2,DISALLOW_SIGN$3,offset)}}else if(token.type===Dimension$3){let code=token.value.charCodeAt(0)
1783let sign=code===PLUSSIGN$i||code===HYPHENMINUS$b?1:0
1784let i=sign
1785for(;i<token.value.length;i++)if(!isDigit$2(token.value.charCodeAt(i)))break
1786if(i===sign)return 0
1787if(!cmpChar$1(token.value,i,N$8))return 0
1788if(i+1===token.value.length)return consumeB$3(getNextToken(++offset),offset,getNextToken)
1789if(token.value.charCodeAt(i+1)!==HYPHENMINUS$b)return 0
1790if(i+2===token.value.length){offset=skipSC$1(getNextToken(++offset),offset,getNextToken)
1791token=getNextToken(offset)
1792return checkInteger$3(token,0,DISALLOW_SIGN$3,offset)}return checkInteger$3(token,i+2,DISALLOW_SIGN$3,offset)}return 0}const PLUSSIGN$h=0x002B
1793const HYPHENMINUS$a=0x002D
1794const QUESTIONMARK$5=0x003F
1795const U$3=0x0075
1796function isDelim$2(token,code){return token!==null&&token.type===Delim$1&&token.value.charCodeAt(0)===code}function startsWith$3(token,code){return token.value.charCodeAt(0)===code}function hexSequence$1(token,offset,allowDash){let hexlen=0
1797for(let pos=offset;pos<token.value.length;pos++){const code=token.value.charCodeAt(pos)
1798if(code===HYPHENMINUS$a&&allowDash&&hexlen!==0){hexSequence$1(token,offset+hexlen+1,false)
1799return 6}if(!isHexDigit$1(code))return 0
1800if(++hexlen>6)return 0}return hexlen}function withQuestionMarkSequence$1(consumed,length,getNextToken){if(!consumed)return 0
1801while(isDelim$2(getNextToken(length),QUESTIONMARK$5)){if(++consumed>6)return 0
1802length++}return length}function urange$1(token,getNextToken){let length=0
1803if(token===null||token.type!==Ident$1||!cmpChar$1(token.value,0,U$3))return 0
1804token=getNextToken(++length)
1805if(token===null)return 0
1806if(isDelim$2(token,PLUSSIGN$h)){token=getNextToken(++length)
1807if(token===null)return 0
1808if(token.type===Ident$1)return withQuestionMarkSequence$1(hexSequence$1(token,0,true),++length,getNextToken)
1809if(isDelim$2(token,QUESTIONMARK$5))return withQuestionMarkSequence$1(1,++length,getNextToken)
1810return 0}if(token.type===Number$5){const consumedHexLength=hexSequence$1(token,1,true)
1811if(consumedHexLength===0)return 0
1812token=getNextToken(++length)
1813if(token===null)return length
1814if(token.type===Dimension$3||token.type===Number$5){if(!startsWith$3(token,HYPHENMINUS$a)||!hexSequence$1(token,1,false))return 0
1815return length+1}return withQuestionMarkSequence$1(consumedHexLength,length,getNextToken)}if(token.type===Dimension$3)return withQuestionMarkSequence$1(hexSequence$1(token,1,true),++length,getNextToken)
1816return 0}const calcFunctionNames$1=["calc(","-moz-calc(","-webkit-calc("]
1817const balancePair$2=new Map([[Function$3,RightParenthesis$1],[LeftParenthesis$1,RightParenthesis$1],[LeftSquareBracket$1,RightSquareBracket$1],[LeftCurlyBracket$1,RightCurlyBracket$1]])
1818function charCodeAt$1(str,index){return index<str.length?str.charCodeAt(index):0}function eqStr$1(actual,expected){return cmpStr$1(actual,0,actual.length,expected)}function eqStrAny$1(actual,expected){for(let i=0;i<expected.length;i++)if(eqStr$1(actual,expected[i]))return true
1819return false}function isPostfixIeHack$1(str,offset){if(offset!==str.length-2)return false
1820return charCodeAt$1(str,offset)===0x005C&&isDigit$2(charCodeAt$1(str,offset+1))}function outOfRange$1(opts,value,numEnd){if(opts&&opts.type==="Range"){const num=Number(numEnd!==void 0&&numEnd!==value.length?value.substr(0,numEnd):value)
1821if(isNaN(num))return true
1822if(opts.min!==null&&num<opts.min&&typeof opts.min!=="string")return true
1823if(opts.max!==null&&num>opts.max&&typeof opts.max!=="string")return true}return false}function consumeFunction$1(token,getNextToken){let balanceCloseType=0
1824let balanceStash=[]
1825let length=0
1826scan:do{switch(token.type){case RightCurlyBracket$1:case RightParenthesis$1:case RightSquareBracket$1:if(token.type!==balanceCloseType)break scan
1827balanceCloseType=balanceStash.pop()
1828if(balanceStash.length===0){length++
1829break scan}break
1830case Function$3:case LeftParenthesis$1:case LeftSquareBracket$1:case LeftCurlyBracket$1:balanceStash.push(balanceCloseType)
1831balanceCloseType=balancePair$2.get(token.type)
1832break}length++}while(token=getNextToken(length))
1833return length}function calc$1(next){return function(token,getNextToken,opts){if(token===null)return 0
1834if(token.type===Function$3&&eqStrAny$1(token.value,calcFunctionNames$1))return consumeFunction$1(token,getNextToken)
1835return next(token,getNextToken,opts)}}function tokenType$1(expectedTokenType){return function(token){if(token===null||token.type!==expectedTokenType)return 0
1836return 1}}function customIdent$1(token){if(token===null||token.type!==Ident$1)return 0
1837const name=token.value.toLowerCase()
1838if(eqStrAny$1(name,cssWideKeywords$1))return 0
1839if(eqStr$1(name,"default"))return 0
1840return 1}function dashedIdent(token){if(token===null||token.type!==Ident$1)return 0
1841if(charCodeAt$1(token.value,0)!==0x002D||charCodeAt$1(token.value,1)!==0x002D)return 0
1842return 1}function customPropertyName$1(token){if(!dashedIdent(token))return 0
1843if(token.value==="--")return 0
1844return 1}function hexColor$1(token){if(token===null||token.type!==Hash$3)return 0
1845const length=token.value.length
1846if(length!==4&&length!==5&&length!==7&&length!==9)return 0
1847for(let i=1;i<length;i++)if(!isHexDigit$1(charCodeAt$1(token.value,i)))return 0
1848return 1}function idSelector$1(token){if(token===null||token.type!==Hash$3)return 0
1849if(!isIdentifierStart$1(charCodeAt$1(token.value,1),charCodeAt$1(token.value,2),charCodeAt$1(token.value,3)))return 0
1850return 1}function declarationValue$1(token,getNextToken){if(!token)return 0
1851let balanceCloseType=0
1852let balanceStash=[]
1853let length=0
1854scan:do{switch(token.type){case BadString$1:case BadUrl$1:break scan
1855case RightCurlyBracket$1:case RightParenthesis$1:case RightSquareBracket$1:if(token.type!==balanceCloseType)break scan
1856balanceCloseType=balanceStash.pop()
1857break
1858case Semicolon$1:if(balanceCloseType===0)break scan
1859break
1860case Delim$1:if(balanceCloseType===0&&token.value==="!")break scan
1861break
1862case Function$3:case LeftParenthesis$1:case LeftSquareBracket$1:case LeftCurlyBracket$1:balanceStash.push(balanceCloseType)
1863balanceCloseType=balancePair$2.get(token.type)
1864break}length++}while(token=getNextToken(length))
1865return length}function anyValue$1(token,getNextToken){if(!token)return 0
1866let balanceCloseType=0
1867let balanceStash=[]
1868let length=0
1869scan:do{switch(token.type){case BadString$1:case BadUrl$1:break scan
1870case RightCurlyBracket$1:case RightParenthesis$1:case RightSquareBracket$1:if(token.type!==balanceCloseType)break scan
1871balanceCloseType=balanceStash.pop()
1872break
1873case Function$3:case LeftParenthesis$1:case LeftSquareBracket$1:case LeftCurlyBracket$1:balanceStash.push(balanceCloseType)
1874balanceCloseType=balancePair$2.get(token.type)
1875break}length++}while(token=getNextToken(length))
1876return length}function dimension$1(type){type&&(type=new Set(type))
1877return function(token,getNextToken,opts){if(token===null||token.type!==Dimension$3)return 0
1878const numberEnd=consumeNumber$2(token.value,0)
1879if(type!==null){const reverseSolidusOffset=token.value.indexOf("\\",numberEnd)
1880const unit=reverseSolidusOffset!==-1&&isPostfixIeHack$1(token.value,reverseSolidusOffset)?token.value.substring(numberEnd,reverseSolidusOffset):token.value.substr(numberEnd)
1881if(type.has(unit.toLowerCase())===false)return 0}if(outOfRange$1(opts,token.value,numberEnd))return 0
1882return 1}}function percentage$1(token,getNextToken,opts){if(token===null||token.type!==Percentage$3)return 0
1883if(outOfRange$1(opts,token.value,token.value.length-1))return 0
1884return 1}function zero$1(next){typeof next!=="function"&&(next=function(){return 0})
1885return function(token,getNextToken,opts){if(token!==null&&token.type===Number$5&&Number(token.value)===0)return 1
1886return next(token,getNextToken,opts)}}function number$1(token,getNextToken,opts){if(token===null)return 0
1887const numberEnd=consumeNumber$2(token.value,0)
1888const isNumber=numberEnd===token.value.length
1889if(!isNumber&&!isPostfixIeHack$1(token.value,numberEnd))return 0
1890if(outOfRange$1(opts,token.value,numberEnd))return 0
1891return 1}function integer$1(token,getNextToken,opts){if(token===null||token.type!==Number$5)return 0
1892let i=charCodeAt$1(token.value,0)===0x002B||charCodeAt$1(token.value,0)===0x002D?1:0
1893for(;i<token.value.length;i++)if(!isDigit$2(charCodeAt$1(token.value,i)))return 0
1894if(outOfRange$1(opts,token.value,i))return 0
1895return 1}const tokenTypes={"ident-token":tokenType$1(Ident$1),"function-token":tokenType$1(Function$3),"at-keyword-token":tokenType$1(AtKeyword$1),"hash-token":tokenType$1(Hash$3),"string-token":tokenType$1(String$4),"bad-string-token":tokenType$1(BadString$1),"url-token":tokenType$1(Url$4),"bad-url-token":tokenType$1(BadUrl$1),"delim-token":tokenType$1(Delim$1),"number-token":tokenType$1(Number$5),"percentage-token":tokenType$1(Percentage$3),"dimension-token":tokenType$1(Dimension$3),"whitespace-token":tokenType$1(WhiteSpace$3),"CDO-token":tokenType$1(CDO$3),"CDC-token":tokenType$1(CDC$3),"colon-token":tokenType$1(Colon$1),"semicolon-token":tokenType$1(Semicolon$1),"comma-token":tokenType$1(Comma$1),"[-token":tokenType$1(LeftSquareBracket$1),"]-token":tokenType$1(RightSquareBracket$1),"(-token":tokenType$1(LeftParenthesis$1),")-token":tokenType$1(RightParenthesis$1),"{-token":tokenType$1(LeftCurlyBracket$1),"}-token":tokenType$1(RightCurlyBracket$1)}
1896const productionTypes={string:tokenType$1(String$4),ident:tokenType$1(Ident$1),percentage:calc$1(percentage$1),zero:zero$1(),number:calc$1(number$1),integer:calc$1(integer$1),"custom-ident":customIdent$1,"dashed-ident":dashedIdent,"custom-property-name":customPropertyName$1,"hex-color":hexColor$1,"id-selector":idSelector$1,"an-plus-b":anPlusB$1,urange:urange$1,"declaration-value":declarationValue$1,"any-value":anyValue$1}
1897function createDemensionTypes(units){const{angle:angle,decibel:decibel,frequency:frequency,flex:flex,length:length,resolution:resolution,semitones:semitones,time:time}=units||{}
1898return{dimension:calc$1(dimension$1(null)),angle:calc$1(dimension$1(angle)),decibel:calc$1(dimension$1(decibel)),frequency:calc$1(dimension$1(frequency)),flex:calc$1(dimension$1(flex)),length:calc$1(zero$1(dimension$1(length))),resolution:calc$1(dimension$1(resolution)),semitones:calc$1(dimension$1(semitones)),time:calc$1(dimension$1(time))}}function createGenericTypes(units){return{...tokenTypes,...productionTypes,...createDemensionTypes(units)}}const length=["cm","mm","q","in","pt","pc","px","em","rem","ex","rex","cap","rcap","ch","rch","ic","ric","lh","rlh","vw","svw","lvw","dvw","vh","svh","lvh","dvh","vi","svi","lvi","dvi","vb","svb","lvb","dvb","vmin","svmin","lvmin","dvmin","vmax","svmax","lvmax","dvmax","cqw","cqh","cqi","cqb","cqmin","cqmax"]
1899const angle=["deg","grad","rad","turn"]
1900const time=["s","ms"]
1901const frequency=["hz","khz"]
1902const resolution=["dpi","dpcm","dppx","x"]
1903const flex=["fr"]
1904const decibel=["db"]
1905const semitones=["st"]
1906var units=Object.freeze({__proto__:null,angle:angle,decibel:decibel,flex:flex,frequency:frequency,length:length,resolution:resolution,semitones:semitones,time:time})
1907function SyntaxError$3(message,input,offset){return Object.assign(createCustomError$1("SyntaxError",message),{input:input,offset:offset,rawMessage:message,message:message+"\n  "+input+"\n--"+new Array((offset||input.length)+1).join("-")+"^"})}const TAB$3=9
1908const N$7=10
1909const F$4=12
1910const R$4=13
1911const SPACE$7=32
1912let Tokenizer$1=class Tokenizer{constructor(str){this.str=str
1913this.pos=0}charCodeAt(pos){return pos<this.str.length?this.str.charCodeAt(pos):0}charCode(){return this.charCodeAt(this.pos)}nextCharCode(){return this.charCodeAt(this.pos+1)}nextNonWsCode(pos){return this.charCodeAt(this.findWsEnd(pos))}skipWs(){this.pos=this.findWsEnd(this.pos)}findWsEnd(pos){for(;pos<this.str.length;pos++){const code=this.str.charCodeAt(pos)
1914if(code!==R$4&&code!==N$7&&code!==F$4&&code!==SPACE$7&&code!==TAB$3)break}return pos}substringToPos(end){return this.str.substring(this.pos,this.pos=end)}eat(code){this.charCode()!==code&&this.error("Expect `"+String.fromCharCode(code)+"`")
1915this.pos++}peek(){return this.pos<this.str.length?this.str.charAt(this.pos++):""}error(message){throw new SyntaxError$3(message,this.str,this.pos)}}
1916const TAB$2=9
1917const N$6=10
1918const F$3=12
1919const R$3=13
1920const SPACE$6=32
1921const EXCLAMATIONMARK$6=33
1922const NUMBERSIGN$8=35
1923const AMPERSAND$7=38
1924const APOSTROPHE$5=39
1925const LEFTPARENTHESIS$5=40
1926const RIGHTPARENTHESIS$5=41
1927const ASTERISK$d=42
1928const PLUSSIGN$g=43
1929const COMMA$1=44
1930const HYPERMINUS$1=45
1931const LESSTHANSIGN$2=60
1932const GREATERTHANSIGN$6=62
1933const QUESTIONMARK$4=63
1934const COMMERCIALAT$1=64
1935const LEFTSQUAREBRACKET$1=91
1936const RIGHTSQUAREBRACKET$1=93
1937const LEFTCURLYBRACKET$2=123
1938const VERTICALLINE$7=124
1939const RIGHTCURLYBRACKET$1=125
1940const INFINITY$1=8734
1941const NAME_CHAR$1=new Uint8Array(128).map(((_,idx)=>/[a-zA-Z0-9\-]/.test(String.fromCharCode(idx))?1:0))
1942const COMBINATOR_PRECEDENCE$1={" ":1,"&&":2,"||":3,"|":4}
1943function scanSpaces$1(tokenizer){return tokenizer.substringToPos(tokenizer.findWsEnd(tokenizer.pos))}function scanWord$1(tokenizer){let end=tokenizer.pos
1944for(;end<tokenizer.str.length;end++){const code=tokenizer.str.charCodeAt(end)
1945if(code>=128||NAME_CHAR$1[code]===0)break}tokenizer.pos===end&&tokenizer.error("Expect a keyword")
1946return tokenizer.substringToPos(end)}function scanNumber$1(tokenizer){let end=tokenizer.pos
1947for(;end<tokenizer.str.length;end++){const code=tokenizer.str.charCodeAt(end)
1948if(code<48||code>57)break}tokenizer.pos===end&&tokenizer.error("Expect a number")
1949return tokenizer.substringToPos(end)}function scanString$1(tokenizer){const end=tokenizer.str.indexOf("'",tokenizer.pos+1)
1950if(end===-1){tokenizer.pos=tokenizer.str.length
1951tokenizer.error("Expect an apostrophe")}return tokenizer.substringToPos(end+1)}function readMultiplierRange$1(tokenizer){let min=null
1952let max=null
1953tokenizer.eat(LEFTCURLYBRACKET$2)
1954tokenizer.skipWs()
1955min=scanNumber$1(tokenizer)
1956tokenizer.skipWs()
1957if(tokenizer.charCode()===COMMA$1){tokenizer.pos++
1958tokenizer.skipWs()
1959if(tokenizer.charCode()!==RIGHTCURLYBRACKET$1){max=scanNumber$1(tokenizer)
1960tokenizer.skipWs()}}else max=min
1961tokenizer.eat(RIGHTCURLYBRACKET$1)
1962return{min:Number(min),max:max?Number(max):0}}function readMultiplier$1(tokenizer){let range=null
1963let comma=false
1964switch(tokenizer.charCode()){case ASTERISK$d:tokenizer.pos++
1965range={min:0,max:0}
1966break
1967case PLUSSIGN$g:tokenizer.pos++
1968range={min:1,max:0}
1969break
1970case QUESTIONMARK$4:tokenizer.pos++
1971range={min:0,max:1}
1972break
1973case NUMBERSIGN$8:tokenizer.pos++
1974comma=true
1975if(tokenizer.charCode()===LEFTCURLYBRACKET$2)range=readMultiplierRange$1(tokenizer)
1976else if(tokenizer.charCode()===QUESTIONMARK$4){tokenizer.pos++
1977range={min:0,max:0}}else range={min:1,max:0}
1978break
1979case LEFTCURLYBRACKET$2:range=readMultiplierRange$1(tokenizer)
1980break
1981default:return null}return{type:"Multiplier",comma:comma,min:range.min,max:range.max,term:null}}function maybeMultiplied$1(tokenizer,node){const multiplier=readMultiplier$1(tokenizer)
1982if(multiplier!==null){multiplier.term=node
1983if(tokenizer.charCode()===NUMBERSIGN$8&&tokenizer.charCodeAt(tokenizer.pos-1)===PLUSSIGN$g)return maybeMultiplied$1(tokenizer,multiplier)
1984return multiplier}return node}function maybeToken$1(tokenizer){const ch=tokenizer.peek()
1985if(ch==="")return null
1986return{type:"Token",value:ch}}function readProperty$3(tokenizer){let name
1987tokenizer.eat(LESSTHANSIGN$2)
1988tokenizer.eat(APOSTROPHE$5)
1989name=scanWord$1(tokenizer)
1990tokenizer.eat(APOSTROPHE$5)
1991tokenizer.eat(GREATERTHANSIGN$6)
1992return maybeMultiplied$1(tokenizer,{type:"Property",name:name})}function readTypeRange$1(tokenizer){let min=null
1993let max=null
1994let sign=1
1995tokenizer.eat(LEFTSQUAREBRACKET$1)
1996if(tokenizer.charCode()===HYPERMINUS$1){tokenizer.peek()
1997sign=-1}if(sign==-1&&tokenizer.charCode()===INFINITY$1)tokenizer.peek()
1998else{min=sign*Number(scanNumber$1(tokenizer))
1999NAME_CHAR$1[tokenizer.charCode()]!==0&&(min+=scanWord$1(tokenizer))}scanSpaces$1(tokenizer)
2000tokenizer.eat(COMMA$1)
2001scanSpaces$1(tokenizer)
2002if(tokenizer.charCode()===INFINITY$1)tokenizer.peek()
2003else{sign=1
2004if(tokenizer.charCode()===HYPERMINUS$1){tokenizer.peek()
2005sign=-1}max=sign*Number(scanNumber$1(tokenizer))
2006NAME_CHAR$1[tokenizer.charCode()]!==0&&(max+=scanWord$1(tokenizer))}tokenizer.eat(RIGHTSQUAREBRACKET$1)
2007return{type:"Range",min:min,max:max}}function readType$1(tokenizer){let name
2008let opts=null
2009tokenizer.eat(LESSTHANSIGN$2)
2010name=scanWord$1(tokenizer)
2011if(tokenizer.charCode()===LEFTPARENTHESIS$5&&tokenizer.nextCharCode()===RIGHTPARENTHESIS$5){tokenizer.pos+=2
2012name+="()"}if(tokenizer.charCodeAt(tokenizer.findWsEnd(tokenizer.pos))===LEFTSQUAREBRACKET$1){scanSpaces$1(tokenizer)
2013opts=readTypeRange$1(tokenizer)}tokenizer.eat(GREATERTHANSIGN$6)
2014return maybeMultiplied$1(tokenizer,{type:"Type",name:name,opts:opts})}function readKeywordOrFunction$1(tokenizer){const name=scanWord$1(tokenizer)
2015if(tokenizer.charCode()===LEFTPARENTHESIS$5){tokenizer.pos++
2016return{type:"Function",name:name}}return maybeMultiplied$1(tokenizer,{type:"Keyword",name:name})}function regroupTerms$1(terms,combinators){function createGroup(terms,combinator){return{type:"Group",terms:terms,combinator:combinator,disallowEmpty:false,explicit:false}}let combinator
2017combinators=Object.keys(combinators).sort(((a,b)=>COMBINATOR_PRECEDENCE$1[a]-COMBINATOR_PRECEDENCE$1[b]))
2018while(combinators.length>0){combinator=combinators.shift()
2019let i=0
2020let subgroupStart=0
2021for(;i<terms.length;i++){const term=terms[i]
2022if(term.type==="Combinator")if(term.value===combinator){subgroupStart===-1&&(subgroupStart=i-1)
2023terms.splice(i,1)
2024i--}else{if(subgroupStart!==-1&&i-subgroupStart>1){terms.splice(subgroupStart,i-subgroupStart,createGroup(terms.slice(subgroupStart,i),combinator))
2025i=subgroupStart+1}subgroupStart=-1}}subgroupStart!==-1&&combinators.length&&terms.splice(subgroupStart,i-subgroupStart,createGroup(terms.slice(subgroupStart,i),combinator))}return combinator}function readImplicitGroup$1(tokenizer){const terms=[]
2026const combinators={}
2027let token
2028let prevToken=null
2029let prevTokenPos=tokenizer.pos
2030while(token=peek$1(tokenizer))if(token.type!=="Spaces"){if(token.type==="Combinator"){if(prevToken===null||prevToken.type==="Combinator"){tokenizer.pos=prevTokenPos
2031tokenizer.error("Unexpected combinator")}combinators[token.value]=true}else if(prevToken!==null&&prevToken.type!=="Combinator"){combinators[" "]=true
2032terms.push({type:"Combinator",value:" "})}terms.push(token)
2033prevToken=token
2034prevTokenPos=tokenizer.pos}if(prevToken!==null&&prevToken.type==="Combinator"){tokenizer.pos-=prevTokenPos
2035tokenizer.error("Unexpected combinator")}return{type:"Group",terms:terms,combinator:regroupTerms$1(terms,combinators)||" ",disallowEmpty:false,explicit:false}}function readGroup$1(tokenizer){let result
2036tokenizer.eat(LEFTSQUAREBRACKET$1)
2037result=readImplicitGroup$1(tokenizer)
2038tokenizer.eat(RIGHTSQUAREBRACKET$1)
2039result.explicit=true
2040if(tokenizer.charCode()===EXCLAMATIONMARK$6){tokenizer.pos++
2041result.disallowEmpty=true}return result}function peek$1(tokenizer){let code=tokenizer.charCode()
2042if(code<128&&NAME_CHAR$1[code]===1)return readKeywordOrFunction$1(tokenizer)
2043switch(code){case RIGHTSQUAREBRACKET$1:break
2044case LEFTSQUAREBRACKET$1:return maybeMultiplied$1(tokenizer,readGroup$1(tokenizer))
2045case LESSTHANSIGN$2:return tokenizer.nextCharCode()===APOSTROPHE$5?readProperty$3(tokenizer):readType$1(tokenizer)
2046case VERTICALLINE$7:return{type:"Combinator",value:tokenizer.substringToPos(tokenizer.pos+(tokenizer.nextCharCode()===VERTICALLINE$7?2:1))}
2047case AMPERSAND$7:tokenizer.pos++
2048tokenizer.eat(AMPERSAND$7)
2049return{type:"Combinator",value:"&&"}
2050case COMMA$1:tokenizer.pos++
2051return{type:"Comma"}
2052case APOSTROPHE$5:return maybeMultiplied$1(tokenizer,{type:"String",value:scanString$1(tokenizer)})
2053case SPACE$6:case TAB$2:case N$6:case R$3:case F$3:return{type:"Spaces",value:scanSpaces$1(tokenizer)}
2054case COMMERCIALAT$1:code=tokenizer.nextCharCode()
2055if(code<128&&NAME_CHAR$1[code]===1){tokenizer.pos++
2056return{type:"AtKeyword",name:scanWord$1(tokenizer)}}return maybeToken$1(tokenizer)
2057case ASTERISK$d:case PLUSSIGN$g:case QUESTIONMARK$4:case NUMBERSIGN$8:case EXCLAMATIONMARK$6:break
2058case LEFTCURLYBRACKET$2:code=tokenizer.nextCharCode()
2059if(code<48||code>57)return maybeToken$1(tokenizer)
2060break
2061default:return maybeToken$1(tokenizer)}}function parse$1u(source){const tokenizer=new Tokenizer$1(source)
2062const result=readImplicitGroup$1(tokenizer)
2063tokenizer.pos!==source.length&&tokenizer.error("Unexpected input")
2064if(result.terms.length===1&&result.terms[0].type==="Group")return result.terms[0]
2065return result}const noop$3=function(){}
2066function ensureFunction$2(value){return typeof value==="function"?value:noop$3}function walk$4(node,options,context){function walk(node){enter.call(context,node)
2067switch(node.type){case"Group":node.terms.forEach(walk)
2068break
2069case"Multiplier":walk(node.term)
2070break
2071case"Type":case"Property":case"Keyword":case"AtKeyword":case"Function":case"String":case"Token":case"Comma":break
2072default:throw new Error("Unknown type: "+node.type)}leave.call(context,node)}let enter=noop$3
2073let leave=noop$3
2074if(typeof options==="function")enter=options
2075else if(options){enter=ensureFunction$2(options.enter)
2076leave=ensureFunction$2(options.leave)}if(enter===noop$3&&leave===noop$3)throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function")
2077walk(node)}const astToTokens$1={decorator(handlers){const tokens=[]
2078let curNode=null
2079return{...handlers,node(node){const tmp=curNode
2080curNode=node
2081handlers.node.call(this,node)
2082curNode=tmp},emit(value,type,auto){tokens.push({type:type,value:value,node:auto?null:curNode})},result:()=>tokens}}}
2083function stringToTokens$1(str){const tokens=[]
2084tokenize$4(str,((type,start,end)=>tokens.push({type:type,value:str.slice(start,end),node:null})))
2085return tokens}function prepareTokens$1(value,syntax){if(typeof value==="string")return stringToTokens$1(value)
2086return syntax.generate(value,astToTokens$1)}const MATCH$1={type:"Match"}
2087const MISMATCH$1={type:"Mismatch"}
2088const DISALLOW_EMPTY$1={type:"DisallowEmpty"}
2089const LEFTPARENTHESIS$4=40
2090const RIGHTPARENTHESIS$4=41
2091function createCondition$1(match,thenBranch,elseBranch){if(thenBranch===MATCH$1&&elseBranch===MISMATCH$1)return match
2092if(match===MATCH$1&&thenBranch===MATCH$1&&elseBranch===MATCH$1)return match
2093if(match.type==="If"&&match.else===MISMATCH$1&&thenBranch===MATCH$1){thenBranch=match.then
2094match=match.match}return{type:"If",match:match,then:thenBranch,else:elseBranch}}function isFunctionType$1(name){return name.length>2&&name.charCodeAt(name.length-2)===LEFTPARENTHESIS$4&&name.charCodeAt(name.length-1)===RIGHTPARENTHESIS$4}function isEnumCapatible$1(term){return term.type==="Keyword"||term.type==="AtKeyword"||term.type==="Function"||term.type==="Type"&&isFunctionType$1(term.name)}function buildGroupMatchGraph$1(combinator,terms,atLeastOneTermMatched){switch(combinator){case" ":{let result=MATCH$1
2095for(let i=terms.length-1;i>=0;i--){const term=terms[i]
2096result=createCondition$1(term,result,MISMATCH$1)}return result}case"|":{let result=MISMATCH$1
2097let map=null
2098for(let i=terms.length-1;i>=0;i--){let term=terms[i]
2099if(isEnumCapatible$1(term)){if(map===null&&i>0&&isEnumCapatible$1(terms[i-1])){map=Object.create(null)
2100result=createCondition$1({type:"Enum",map:map},MATCH$1,result)}if(map!==null){const key=(isFunctionType$1(term.name)?term.name.slice(0,-1):term.name).toLowerCase()
2101if(key in map===false){map[key]=term
2102continue}}}map=null
2103result=createCondition$1(term,MATCH$1,result)}return result}case"&&":{if(terms.length>5)return{type:"MatchOnce",terms:terms,all:true}
2104let result=MISMATCH$1
2105for(let i=terms.length-1;i>=0;i--){const term=terms[i]
2106let thenClause
2107thenClause=terms.length>1?buildGroupMatchGraph$1(combinator,terms.filter((function(newGroupTerm){return newGroupTerm!==term})),false):MATCH$1
2108result=createCondition$1(term,thenClause,result)}return result}case"||":{if(terms.length>5)return{type:"MatchOnce",terms:terms,all:false}
2109let result=atLeastOneTermMatched?MATCH$1:MISMATCH$1
2110for(let i=terms.length-1;i>=0;i--){const term=terms[i]
2111let thenClause
2112thenClause=terms.length>1?buildGroupMatchGraph$1(combinator,terms.filter((function(newGroupTerm){return newGroupTerm!==term})),true):MATCH$1
2113result=createCondition$1(term,thenClause,result)}return result}}}function buildMultiplierMatchGraph$1(node){let result=MATCH$1
2114let matchTerm=buildMatchGraphInternal$1(node.term)
2115if(node.max===0){matchTerm=createCondition$1(matchTerm,DISALLOW_EMPTY$1,MISMATCH$1)
2116result=createCondition$1(matchTerm,null,MISMATCH$1)
2117result.then=createCondition$1(MATCH$1,MATCH$1,result)
2118node.comma&&(result.then.else=createCondition$1({type:"Comma",syntax:node},result,MISMATCH$1))}else for(let i=node.min||1;i<=node.max;i++){node.comma&&result!==MATCH$1&&(result=createCondition$1({type:"Comma",syntax:node},result,MISMATCH$1))
2119result=createCondition$1(matchTerm,createCondition$1(MATCH$1,MATCH$1,result),MISMATCH$1)}if(node.min===0)result=createCondition$1(MATCH$1,MATCH$1,result)
2120else for(let i=0;i<node.min-1;i++){node.comma&&result!==MATCH$1&&(result=createCondition$1({type:"Comma",syntax:node},result,MISMATCH$1))
2121result=createCondition$1(matchTerm,result,MISMATCH$1)}return result}function buildMatchGraphInternal$1(node){if(typeof node==="function")return{type:"Generic",fn:node}
2122switch(node.type){case"Group":{let result=buildGroupMatchGraph$1(node.combinator,node.terms.map(buildMatchGraphInternal$1),false)
2123node.disallowEmpty&&(result=createCondition$1(result,DISALLOW_EMPTY$1,MISMATCH$1))
2124return result}case"Multiplier":return buildMultiplierMatchGraph$1(node)
2125case"Type":case"Property":return{type:node.type,name:node.name,syntax:node}
2126case"Keyword":return{type:node.type,name:node.name.toLowerCase(),syntax:node}
2127case"AtKeyword":return{type:node.type,name:"@"+node.name.toLowerCase(),syntax:node}
2128case"Function":return{type:node.type,name:node.name.toLowerCase()+"(",syntax:node}
2129case"String":if(node.value.length===3)return{type:"Token",value:node.value.charAt(1),syntax:node}
2130return{type:node.type,value:node.value.substr(1,node.value.length-2).replace(/\\'/g,"'"),syntax:node}
2131case"Token":return{type:node.type,value:node.value,syntax:node}
2132case"Comma":return{type:node.type,syntax:node}
2133default:throw new Error("Unknown node type:",node.type)}}function buildMatchGraph$1(syntaxTree,ref){typeof syntaxTree==="string"&&(syntaxTree=parse$1u(syntaxTree))
2134return{type:"MatchGraph",match:buildMatchGraphInternal$1(syntaxTree),syntax:ref||null,source:syntaxTree}}const{hasOwnProperty:hasOwnProperty$a}=Object.prototype
2135const STUB$1=0
2136const TOKEN$1=1
2137const OPEN_SYNTAX$1=2
2138const CLOSE_SYNTAX$1=3
2139const EXIT_REASON_MATCH$1="Match"
2140const EXIT_REASON_MISMATCH$1="Mismatch"
2141const EXIT_REASON_ITERATION_LIMIT$1="Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)"
2142const ITERATION_LIMIT$1=15000
2143function reverseList$1(list){let prev=null
2144let next=null
2145let item=list
2146while(item!==null){next=item.prev
2147item.prev=prev
2148prev=item
2149item=next}return prev}function areStringsEqualCaseInsensitive$1(testStr,referenceStr){if(testStr.length!==referenceStr.length)return false
2150for(let i=0;i<testStr.length;i++){const referenceCode=referenceStr.charCodeAt(i)
2151let testCode=testStr.charCodeAt(i)
2152testCode>=0x0041&&testCode<=0x005A&&(testCode|=32)
2153if(testCode!==referenceCode)return false}return true}function isContextEdgeDelim$1(token){if(token.type!==Delim$1)return false
2154return token.value!=="?"}function isCommaContextStart$1(token){if(token===null)return true
2155return token.type===Comma$1||token.type===Function$3||token.type===LeftParenthesis$1||token.type===LeftSquareBracket$1||token.type===LeftCurlyBracket$1||isContextEdgeDelim$1(token)}function isCommaContextEnd$1(token){if(token===null)return true
2156return token.type===RightParenthesis$1||token.type===RightSquareBracket$1||token.type===RightCurlyBracket$1||token.type===Delim$1&&token.value==="/"}function internalMatch$1(tokens,state,syntaxes){function moveToNextToken(){do{tokenIndex++
2157token=tokenIndex<tokens.length?tokens[tokenIndex]:null}while(token!==null&&(token.type===WhiteSpace$3||token.type===Comment$3))}function getNextToken(offset){const nextIndex=tokenIndex+offset
2158return nextIndex<tokens.length?tokens[nextIndex]:null}function stateSnapshotFromSyntax(nextState,prev){return{nextState:nextState,matchStack:matchStack,syntaxStack:syntaxStack,thenStack:thenStack,tokenIndex:tokenIndex,prev:prev}}function pushThenStack(nextState){thenStack={nextState:nextState,matchStack:matchStack,syntaxStack:syntaxStack,prev:thenStack}}function pushElseStack(nextState){elseStack=stateSnapshotFromSyntax(nextState,elseStack)}function addTokenToMatch(){matchStack={type:TOKEN$1,syntax:state.syntax,token:token,prev:matchStack}
2159moveToNextToken()
2160syntaxStash=null
2161tokenIndex>longestMatch&&(longestMatch=tokenIndex)}function openSyntax(){syntaxStack={syntax:state.syntax,opts:state.syntax.opts||syntaxStack!==null&&syntaxStack.opts||null,prev:syntaxStack}
2162matchStack={type:OPEN_SYNTAX$1,syntax:state.syntax,token:matchStack.token,prev:matchStack}}function closeSyntax(){matchStack=matchStack.type===OPEN_SYNTAX$1?matchStack.prev:{type:CLOSE_SYNTAX$1,syntax:syntaxStack.syntax,token:matchStack.token,prev:matchStack}
2163syntaxStack=syntaxStack.prev}let syntaxStack=null
2164let thenStack=null
2165let elseStack=null
2166let syntaxStash=null
2167let iterationCount=0
2168let exitReason=null
2169let token=null
2170let tokenIndex=-1
2171let longestMatch=0
2172let matchStack={type:STUB$1,syntax:null,token:null,prev:null}
2173moveToNextToken()
2174while(exitReason===null&&++iterationCount<ITERATION_LIMIT$1)switch(state.type){case"Match":if(thenStack===null){if(token!==null&&(tokenIndex!==tokens.length-1||token.value!=="\\0"&&token.value!=="\\9")){state=MISMATCH$1
2175break}exitReason=EXIT_REASON_MATCH$1
2176break}state=thenStack.nextState
2177if(state===DISALLOW_EMPTY$1){if(thenStack.matchStack===matchStack){state=MISMATCH$1
2178break}state=MATCH$1}while(thenStack.syntaxStack!==syntaxStack)closeSyntax()
2179thenStack=thenStack.prev
2180break
2181case"Mismatch":if(syntaxStash!==null&&syntaxStash!==false){if(elseStack===null||tokenIndex>elseStack.tokenIndex){elseStack=syntaxStash
2182syntaxStash=false}}else if(elseStack===null){exitReason=EXIT_REASON_MISMATCH$1
2183break}state=elseStack.nextState
2184thenStack=elseStack.thenStack
2185syntaxStack=elseStack.syntaxStack
2186matchStack=elseStack.matchStack
2187tokenIndex=elseStack.tokenIndex
2188token=tokenIndex<tokens.length?tokens[tokenIndex]:null
2189elseStack=elseStack.prev
2190break
2191case"MatchGraph":state=state.match
2192break
2193case"If":state.else!==MISMATCH$1&&pushElseStack(state.else)
2194state.then!==MATCH$1&&pushThenStack(state.then)
2195state=state.match
2196break
2197case"MatchOnce":state={type:"MatchOnceBuffer",syntax:state,index:0,mask:0}
2198break
2199case"MatchOnceBuffer":{const terms=state.syntax.terms
2200if(state.index===terms.length){if(state.mask===0||state.syntax.all){state=MISMATCH$1
2201break}state=MATCH$1
2202break}if(state.mask===(1<<terms.length)-1){state=MATCH$1
2203break}for(;state.index<terms.length;state.index++){const matchFlag=1<<state.index
2204if((state.mask&matchFlag)===0){pushElseStack(state)
2205pushThenStack({type:"AddMatchOnce",syntax:state.syntax,mask:state.mask|matchFlag})
2206state=terms[state.index++]
2207break}}break}case"AddMatchOnce":state={type:"MatchOnceBuffer",syntax:state.syntax,index:0,mask:state.mask}
2208break
2209case"Enum":if(token!==null){let name=token.value.toLowerCase()
2210name.indexOf("\\")!==-1&&(name=name.replace(/\\[09].*$/,""))
2211if(hasOwnProperty$a.call(state.map,name)){state=state.map[name]
2212break}}state=MISMATCH$1
2213break
2214case"Generic":{const opts=syntaxStack!==null?syntaxStack.opts:null
2215const lastTokenIndex=tokenIndex+Math.floor(state.fn(token,getNextToken,opts))
2216if(!isNaN(lastTokenIndex)&&lastTokenIndex>tokenIndex){while(tokenIndex<lastTokenIndex)addTokenToMatch()
2217state=MATCH$1}else state=MISMATCH$1
2218break}case"Type":case"Property":{const syntaxDict=state.type==="Type"?"types":"properties"
2219const dictSyntax=hasOwnProperty$a.call(syntaxes,syntaxDict)?syntaxes[syntaxDict][state.name]:null
2220if(!dictSyntax||!dictSyntax.match)throw new Error("Bad syntax reference: "+(state.type==="Type"?"<"+state.name+">":"<'"+state.name+"'>"))
2221if(syntaxStash!==false&&token!==null&&state.type==="Type"){const lowPriorityMatching=state.name==="custom-ident"&&token.type===Ident$1||state.name==="length"&&token.value==="0"
2222if(lowPriorityMatching){syntaxStash===null&&(syntaxStash=stateSnapshotFromSyntax(state,elseStack))
2223state=MISMATCH$1
2224break}}openSyntax()
2225state=dictSyntax.matchRef||dictSyntax.match
2226break}case"Keyword":{const name=state.name
2227if(token!==null){let keywordName=token.value
2228keywordName.indexOf("\\")!==-1&&(keywordName=keywordName.replace(/\\[09].*$/,""))
2229if(areStringsEqualCaseInsensitive$1(keywordName,name)){addTokenToMatch()
2230state=MATCH$1
2231break}}state=MISMATCH$1
2232break}case"AtKeyword":case"Function":if(token!==null&&areStringsEqualCaseInsensitive$1(token.value,state.name)){addTokenToMatch()
2233state=MATCH$1
2234break}state=MISMATCH$1
2235break
2236case"Token":if(token!==null&&token.value===state.value){addTokenToMatch()
2237state=MATCH$1
2238break}state=MISMATCH$1
2239break
2240case"Comma":if(token!==null&&token.type===Comma$1)if(isCommaContextStart$1(matchStack.token))state=MISMATCH$1
2241else{addTokenToMatch()
2242state=isCommaContextEnd$1(token)?MISMATCH$1:MATCH$1}else state=isCommaContextStart$1(matchStack.token)||isCommaContextEnd$1(token)?MATCH$1:MISMATCH$1
2243break
2244case"String":let string=""
2245let lastTokenIndex=tokenIndex
2246for(;lastTokenIndex<tokens.length&&string.length<state.value.length;lastTokenIndex++)string+=tokens[lastTokenIndex].value
2247if(areStringsEqualCaseInsensitive$1(string,state.value)){while(tokenIndex<lastTokenIndex)addTokenToMatch()
2248state=MATCH$1}else state=MISMATCH$1
2249break
2250default:throw new Error("Unknown node type: "+state.type)}switch(exitReason){case null:console.warn("[csstree-match] BREAK after "+ITERATION_LIMIT$1+" iterations")
2251exitReason=EXIT_REASON_ITERATION_LIMIT$1
2252matchStack=null
2253break
2254case EXIT_REASON_MATCH$1:while(syntaxStack!==null)closeSyntax()
2255break
2256default:matchStack=null}return{tokens:tokens,reason:exitReason,iterations:iterationCount,match:matchStack,longestMatch:longestMatch}}function matchAsTree$1(tokens,matchGraph,syntaxes){const matchResult=internalMatch$1(tokens,matchGraph,syntaxes||{})
2257if(matchResult.match===null)return matchResult
2258let item=matchResult.match
2259let host=matchResult.match={syntax:matchGraph.syntax||null,match:[]}
2260const hostStack=[host]
2261item=reverseList$1(item).prev
2262while(item!==null){switch(item.type){case OPEN_SYNTAX$1:host.match.push(host={syntax:item.syntax,match:[]})
2263hostStack.push(host)
2264break
2265case CLOSE_SYNTAX$1:hostStack.pop()
2266host=hostStack[hostStack.length-1]
2267break
2268default:host.match.push({syntax:item.syntax||null,token:item.token.value,node:item.token.node})}item=item.prev}return matchResult}function getTrace$1(node){function shouldPutToTrace(syntax){if(syntax===null)return false
2269return syntax.type==="Type"||syntax.type==="Property"||syntax.type==="Keyword"}function hasMatch(matchNode){if(Array.isArray(matchNode.match)){for(let i=0;i<matchNode.match.length;i++)if(hasMatch(matchNode.match[i])){shouldPutToTrace(matchNode.syntax)&&result.unshift(matchNode.syntax)
2270return true}}else if(matchNode.node===node){result=shouldPutToTrace(matchNode.syntax)?[matchNode.syntax]:[]
2271return true}return false}let result=null
2272this.matched!==null&&hasMatch(this.matched)
2273return result}function isType$1(node,type){return testNode$1(this,node,(match=>match.type==="Type"&&match.name===type))}function isProperty$1(node,property){return testNode$1(this,node,(match=>match.type==="Property"&&match.name===property))}function isKeyword$1(node){return testNode$1(this,node,(match=>match.type==="Keyword"))}function testNode$1(match,node,fn){const trace=getTrace$1.call(match,node)
2274if(trace===null)return false
2275return trace.some(fn)}var trace$1=Object.freeze({__proto__:null,getTrace:getTrace$1,isKeyword:isKeyword$1,isProperty:isProperty$1,isType:isType$1})
2276function getFirstMatchNode$1(matchNode){if("node"in matchNode)return matchNode.node
2277return getFirstMatchNode$1(matchNode.match[0])}function getLastMatchNode$1(matchNode){if("node"in matchNode)return matchNode.node
2278return getLastMatchNode$1(matchNode.match[matchNode.match.length-1])}function matchFragments$1(lexer,ast,match,type,name){function findFragments(matchNode){if(matchNode.syntax!==null&&matchNode.syntax.type===type&&matchNode.syntax.name===name){const start=getFirstMatchNode$1(matchNode)
2279const end=getLastMatchNode$1(matchNode)
2280lexer.syntax.walk(ast,(function(node,item,list){if(node===start){const nodes=new List$1
2281do{nodes.appendData(item.data)
2282if(item.data===end)break
2283item=item.next}while(item!==null)
2284fragments.push({parent:list,nodes:nodes})}}))}Array.isArray(matchNode.match)&&matchNode.match.forEach(findFragments)}const fragments=[]
2285match.matched!==null&&findFragments(match.matched)
2286return fragments}const{hasOwnProperty:hasOwnProperty$9}=Object.prototype
2287function isValidNumber$1(value){return typeof value==="number"&&isFinite(value)&&Math.floor(value)===value&&value>=0}function isValidLocation$1(loc){return Boolean(loc)&&isValidNumber$1(loc.offset)&&isValidNumber$1(loc.line)&&isValidNumber$1(loc.column)}function createNodeStructureChecker$1(type,fields){return function checkNode(node,warn){if(!node||node.constructor!==Object)return warn(node,"Type of node should be an Object")
2288for(let key in node){let valid=true
2289if(hasOwnProperty$9.call(node,key)===false)continue
2290if(key==="type")node.type!==type&&warn(node,"Wrong node type `"+node.type+"`, expected `"+type+"`")
2291else if(key==="loc"){if(node.loc===null)continue
2292if(node.loc&&node.loc.constructor===Object)if(typeof node.loc.source!=="string")key+=".source"
2293else if(isValidLocation$1(node.loc.start)){if(isValidLocation$1(node.loc.end))continue
2294key+=".end"}else key+=".start"
2295valid=false}else if(fields.hasOwnProperty(key)){valid=false
2296for(let i=0;!valid&&i<fields[key].length;i++){const fieldType=fields[key][i]
2297switch(fieldType){case String:valid=typeof node[key]==="string"
2298break
2299case Boolean:valid=typeof node[key]==="boolean"
2300break
2301case null:valid=node[key]===null
2302break
2303default:typeof fieldType==="string"?valid=node[key]&&node[key].type===fieldType:Array.isArray(fieldType)&&(valid=node[key]instanceof List$1)}}}else warn(node,"Unknown field `"+key+"` for "+type+" node type")
2304valid||warn(node,"Bad value for `"+type+"."+key+"`")}for(const key in fields)hasOwnProperty$9.call(fields,key)&&hasOwnProperty$9.call(node,key)===false&&warn(node,"Field `"+type+"."+key+"` is missed")}}function genTypesList(fieldTypes,path){const docsTypes=[]
2305for(let i=0;i<fieldTypes.length;i++){const fieldType=fieldTypes[i]
2306if(fieldType===String||fieldType===Boolean)docsTypes.push(fieldType.name.toLowerCase())
2307else if(fieldType===null)docsTypes.push("null")
2308else if(typeof fieldType==="string")docsTypes.push(fieldType)
2309else{if(!Array.isArray(fieldType))throw new Error("Wrong value `"+fieldType+"` in `"+path+"` structure definition")
2310docsTypes.push("List<"+(genTypesList(fieldType,path)||"any")+">")}}return docsTypes.join(" | ")}function processStructure$1(name,nodeType){const structure=nodeType.structure
2311const fields={type:String,loc:true}
2312const docs={type:'"'+name+'"'}
2313for(const key in structure){if(hasOwnProperty$9.call(structure,key)===false)continue
2314const fieldTypes=fields[key]=Array.isArray(structure[key])?structure[key].slice():[structure[key]]
2315docs[key]=genTypesList(fieldTypes,name+"."+key)}return{docs:docs,check:createNodeStructureChecker$1(name,fields)}}function getStructureFromConfig$1(config){const structure={}
2316if(config.node)for(const name in config.node)if(hasOwnProperty$9.call(config.node,name)){const nodeType=config.node[name]
2317if(!nodeType.structure)throw new Error("Missed `structure` field in `"+name+"` node type definition")
2318structure[name]=processStructure$1(name,nodeType)}return structure}function dumpMapSyntax$1(map,compact,syntaxAsAst){const result={}
2319for(const name in map)map[name].syntax&&(result[name]=syntaxAsAst?map[name].syntax:generate$1u(map[name].syntax,{compact:compact}))
2320return result}function dumpAtruleMapSyntax$1(map,compact,syntaxAsAst){const result={}
2321for(const[name,atrule]of Object.entries(map))result[name]={prelude:atrule.prelude&&(syntaxAsAst?atrule.prelude.syntax:generate$1u(atrule.prelude.syntax,{compact:compact})),descriptors:atrule.descriptors&&dumpMapSyntax$1(atrule.descriptors,compact,syntaxAsAst)}
2322return result}function valueHasVar$1(tokens){for(let i=0;i<tokens.length;i++)if(tokens[i].value.toLowerCase()==="var(")return true
2323return false}function syntaxHasTopLevelCommaMultiplier(syntax){const singleTerm=syntax.terms[0]
2324return syntax.explicit===false&&syntax.terms.length===1&&singleTerm.type==="Multiplier"&&singleTerm.comma===true}function buildMatchResult$1(matched,error,iterations){return{matched:matched,iterations:iterations,error:error,...trace$1}}function matchSyntax$1(lexer,syntax,value,useCssWideKeywords){const tokens=prepareTokens$1(value,lexer.syntax)
2325let result
2326if(valueHasVar$1(tokens))return buildMatchResult$1(null,new Error("Matching for a tree with var() is not supported"))
2327useCssWideKeywords&&(result=matchAsTree$1(tokens,lexer.cssWideKeywordsSyntax,lexer))
2328if(!useCssWideKeywords||!result.match){result=matchAsTree$1(tokens,syntax.match,lexer)
2329if(!result.match)return buildMatchResult$1(null,new SyntaxMatchError$1(result.reason,syntax.syntax,value,result),result.iterations)}return buildMatchResult$1(result.match,null,result.iterations)}let Lexer$1=class Lexer{constructor(config,syntax,structure){this.cssWideKeywords=cssWideKeywords$1
2330this.syntax=syntax
2331this.generic=false
2332this.units={...units}
2333this.atrules=Object.create(null)
2334this.properties=Object.create(null)
2335this.types=Object.create(null)
2336this.structure=structure||getStructureFromConfig$1(config)
2337if(config){config.cssWideKeywords&&(this.cssWideKeywords=config.cssWideKeywords)
2338if(config.units)for(const group of Object.keys(units))Array.isArray(config.units[group])&&(this.units[group]=config.units[group])
2339if(config.types)for(const[name,type]of Object.entries(config.types))this.addType_(name,type)
2340if(config.generic){this.generic=true
2341for(const[name,value]of Object.entries(createGenericTypes(this.units)))this.addType_(name,value)}if(config.atrules)for(const[name,atrule]of Object.entries(config.atrules))this.addAtrule_(name,atrule)
2342if(config.properties)for(const[name,property]of Object.entries(config.properties))this.addProperty_(name,property)}this.cssWideKeywordsSyntax=buildMatchGraph$1(this.cssWideKeywords.join(" |  "))}checkStructure(ast){function collectWarning(node,message){warns.push({node:node,message:message})}const structure=this.structure
2343const warns=[]
2344this.syntax.walk(ast,(function(node){structure.hasOwnProperty(node.type)?structure[node.type].check(node,collectWarning):collectWarning(node,"Unknown node type `"+node.type+"`")}))
2345return!!warns.length&&warns}createDescriptor(syntax,type,name,parent=null){const ref={type:type,name:name}
2346const descriptor={type:type,name:name,parent:parent,serializable:typeof syntax==="string"||syntax&&typeof syntax.type==="string",syntax:null,match:null,matchRef:null}
2347if(typeof syntax==="function")descriptor.match=buildMatchGraph$1(syntax,ref)
2348else{typeof syntax==="string"?Object.defineProperty(descriptor,"syntax",{get(){Object.defineProperty(descriptor,"syntax",{value:parse$1u(syntax)})
2349return descriptor.syntax}}):descriptor.syntax=syntax
2350Object.defineProperty(descriptor,"match",{get(){Object.defineProperty(descriptor,"match",{value:buildMatchGraph$1(descriptor.syntax,ref)})
2351return descriptor.match}})
2352type==="Property"&&Object.defineProperty(descriptor,"matchRef",{get(){const syntax=descriptor.syntax
2353const value=syntaxHasTopLevelCommaMultiplier(syntax)?buildMatchGraph$1({...syntax,terms:[syntax.terms[0].term]},ref):null
2354Object.defineProperty(descriptor,"matchRef",{value:value})
2355return value}})}return descriptor}addAtrule_(name,syntax){if(!syntax)return
2356this.atrules[name]={type:"Atrule",name:name,prelude:syntax.prelude?this.createDescriptor(syntax.prelude,"AtrulePrelude",name):null,descriptors:syntax.descriptors?Object.keys(syntax.descriptors).reduce(((map,descName)=>{map[descName]=this.createDescriptor(syntax.descriptors[descName],"AtruleDescriptor",descName,name)
2357return map}),Object.create(null)):null}}addProperty_(name,syntax){if(!syntax)return
2358this.properties[name]=this.createDescriptor(syntax,"Property",name)}addType_(name,syntax){if(!syntax)return
2359this.types[name]=this.createDescriptor(syntax,"Type",name)}checkAtruleName(atruleName){if(!this.getAtrule(atruleName))return new SyntaxReferenceError$1("Unknown at-rule","@"+atruleName)}checkAtrulePrelude(atruleName,prelude){const error=this.checkAtruleName(atruleName)
2360if(error)return error
2361const atrule=this.getAtrule(atruleName)
2362if(!atrule.prelude&&prelude)return new SyntaxError("At-rule `@"+atruleName+"` should not contain a prelude")
2363if(atrule.prelude&&!prelude&&!matchSyntax$1(this,atrule.prelude,"",false).matched)return new SyntaxError("At-rule `@"+atruleName+"` should contain a prelude")}checkAtruleDescriptorName(atruleName,descriptorName){const error=this.checkAtruleName(atruleName)
2364if(error)return error
2365const atrule=this.getAtrule(atruleName)
2366const descriptor=keyword$1(descriptorName)
2367if(!atrule.descriptors)return new SyntaxError("At-rule `@"+atruleName+"` has no known descriptors")
2368if(!atrule.descriptors[descriptor.name]&&!atrule.descriptors[descriptor.basename])return new SyntaxReferenceError$1("Unknown at-rule descriptor",descriptorName)}checkPropertyName(propertyName){if(!this.getProperty(propertyName))return new SyntaxReferenceError$1("Unknown property",propertyName)}matchAtrulePrelude(atruleName,prelude){const error=this.checkAtrulePrelude(atruleName,prelude)
2369if(error)return buildMatchResult$1(null,error)
2370const atrule=this.getAtrule(atruleName)
2371if(!atrule.prelude)return buildMatchResult$1(null,null)
2372return matchSyntax$1(this,atrule.prelude,prelude||"",false)}matchAtruleDescriptor(atruleName,descriptorName,value){const error=this.checkAtruleDescriptorName(atruleName,descriptorName)
2373if(error)return buildMatchResult$1(null,error)
2374const atrule=this.getAtrule(atruleName)
2375const descriptor=keyword$1(descriptorName)
2376return matchSyntax$1(this,atrule.descriptors[descriptor.name]||atrule.descriptors[descriptor.basename],value,false)}matchDeclaration(node){if(node.type!=="Declaration")return buildMatchResult$1(null,new Error("Not a Declaration node"))
2377return this.matchProperty(node.property,node.value)}matchProperty(propertyName,value){if(property$1(propertyName).custom)return buildMatchResult$1(null,new Error("Lexer matching doesn't applicable for custom properties"))
2378const error=this.checkPropertyName(propertyName)
2379if(error)return buildMatchResult$1(null,error)
2380return matchSyntax$1(this,this.getProperty(propertyName),value,true)}matchType(typeName,value){const typeSyntax=this.getType(typeName)
2381if(!typeSyntax)return buildMatchResult$1(null,new SyntaxReferenceError$1("Unknown type",typeName))
2382return matchSyntax$1(this,typeSyntax,value,false)}match(syntax,value){if(typeof syntax!=="string"&&(!syntax||!syntax.type))return buildMatchResult$1(null,new SyntaxReferenceError$1("Bad syntax"))
2383typeof syntax!=="string"&&syntax.match||(syntax=this.createDescriptor(syntax,"Type","anonymous"))
2384return matchSyntax$1(this,syntax,value,false)}findValueFragments(propertyName,value,type,name){return matchFragments$1(this,value,this.matchProperty(propertyName,value),type,name)}findDeclarationValueFragments(declaration,type,name){return matchFragments$1(this,declaration.value,this.matchDeclaration(declaration),type,name)}findAllFragments(ast,type,name){const result=[]
2385this.syntax.walk(ast,{visit:"Declaration",enter:declaration=>{result.push.apply(result,this.findDeclarationValueFragments(declaration,type,name))}})
2386return result}getAtrule(atruleName,fallbackBasename=true){const atrule=keyword$1(atruleName)
2387const atruleEntry=atrule.vendor&&fallbackBasename?this.atrules[atrule.name]||this.atrules[atrule.basename]:this.atrules[atrule.name]
2388return atruleEntry||null}getAtrulePrelude(atruleName,fallbackBasename=true){const atrule=this.getAtrule(atruleName,fallbackBasename)
2389return atrule&&atrule.prelude||null}getAtruleDescriptor(atruleName,name){return this.atrules.hasOwnProperty(atruleName)&&this.atrules.declarators&&this.atrules[atruleName].declarators[name]||null}getProperty(propertyName,fallbackBasename=true){const property=property$1(propertyName)
2390const propertyEntry=property.vendor&&fallbackBasename?this.properties[property.name]||this.properties[property.basename]:this.properties[property.name]
2391return propertyEntry||null}getType(name){return hasOwnProperty.call(this.types,name)?this.types[name]:null}validate(){function syntaxRef(name,isType){return isType?`<${name}>`:`<'${name}'>`}function validate(syntax,name,broken,descriptor){if(broken.has(name))return broken.get(name)
2392broken.set(name,false)
2393descriptor.syntax!==null&&walk$4(descriptor.syntax,(function(node){if(node.type!=="Type"&&node.type!=="Property")return
2394const map=node.type==="Type"?syntax.types:syntax.properties
2395const brokenMap=node.type==="Type"?brokenTypes:brokenProperties
2396if(hasOwnProperty.call(map,node.name)){if(validate(syntax,node.name,brokenMap,map[node.name])){errors.push(`${syntaxRef(name,broken===brokenTypes)} used broken syntax definition ${syntaxRef(node.name,node.type==="Type")}`)
2397broken.set(name,true)}}else{errors.push(`${syntaxRef(name,broken===brokenTypes)} used missed syntax definition ${syntaxRef(node.name,node.type==="Type")}`)
2398broken.set(name,true)}}),this)}const errors=[]
2399let brokenTypes=new Map
2400let brokenProperties=new Map
2401for(const key in this.types)validate(this,key,brokenTypes,this.types[key])
2402for(const key in this.properties)validate(this,key,brokenProperties,this.properties[key])
2403const brokenTypesArray=[...brokenTypes.keys()].filter((name=>brokenTypes.get(name)))
2404const brokenPropertiesArray=[...brokenProperties.keys()].filter((name=>brokenProperties.get(name)))
2405if(brokenTypesArray.length||brokenPropertiesArray.length)return{errors:errors,types:brokenTypesArray,properties:brokenPropertiesArray}
2406return null}dump(syntaxAsAst,pretty){return{generic:this.generic,cssWideKeywords:this.cssWideKeywords,units:this.units,types:dumpMapSyntax$1(this.types,!pretty,syntaxAsAst),properties:dumpMapSyntax$1(this.properties,!pretty,syntaxAsAst),atrules:dumpAtruleMapSyntax$1(this.atrules,!pretty,syntaxAsAst)}}toString(){return JSON.stringify(this.dump())}}
2407function appendOrSet(a,b){if(typeof b==="string"&&/^\s*\|/.test(b))return typeof a==="string"?a+b:b.replace(/^\s*\|\s*/,"")
2408return b||null}function sliceProps(obj,props){const result=Object.create(null)
2409for(const[key,value]of Object.entries(obj))if(value){result[key]={}
2410for(const prop of Object.keys(value))props.includes(prop)&&(result[key][prop]=value[prop])}return result}function mix$2(dest,src){const result={...dest}
2411for(const[prop,value]of Object.entries(src))switch(prop){case"generic":result[prop]=Boolean(value)
2412break
2413case"cssWideKeywords":result[prop]=dest[prop]?[...dest[prop],...value]:value||[]
2414break
2415case"units":result[prop]={...dest[prop]}
2416for(const[name,patch]of Object.entries(value))result[prop][name]=Array.isArray(patch)?patch:[]
2417break
2418case"atrules":result[prop]={...dest[prop]}
2419for(const[name,atrule]of Object.entries(value)){const exists=result[prop][name]||{}
2420const current=result[prop][name]={prelude:exists.prelude||null,descriptors:{...exists.descriptors}}
2421if(!atrule)continue
2422current.prelude=atrule.prelude?appendOrSet(current.prelude,atrule.prelude):current.prelude||null
2423for(const[descriptorName,descriptorValue]of Object.entries(atrule.descriptors||{}))current.descriptors[descriptorName]=descriptorValue?appendOrSet(current.descriptors[descriptorName],descriptorValue):null
2424Object.keys(current.descriptors).length||(current.descriptors=null)}break
2425case"types":case"properties":result[prop]={...dest[prop]}
2426for(const[name,syntax]of Object.entries(value))result[prop][name]=appendOrSet(result[prop][name],syntax)
2427break
2428case"scope":case"features":result[prop]={...dest[prop]}
2429for(const[name,props]of Object.entries(value))result[prop][name]={...result[prop][name],...props}
2430break
2431case"parseContext":result[prop]={...dest[prop],...value}
2432break
2433case"atrule":case"pseudo":result[prop]={...dest[prop],...sliceProps(value,["parse"])}
2434break

2444"},properties:{"--*":"<declaration-value>","-ms-accelerator":"false|true","-ms-block-progression":"tb|rl|bt|lr","-ms-content-zoom-chaining":"none|chained","-ms-content-zooming":"none|zoom","-ms-content-zoom-limit":"<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>","-ms-content-zoom-limit-max":"<percentage>","-ms-content-zoom-limit-min":"<percentage>","-ms-content-zoom-snap":"<'-ms-content-zoom-snap-type'>||<'-ms-content-zoom-snap-points'>","-ms-content-zoom-snap-points":"snapInterval( <percentage> , <percentage> )|snapList( <percentage># )","-ms-content-zoom-snap-type":"none|proximity|mandatory","-ms-filter":"<string>","-ms-flow-from":"[none|<custom-ident>]#","-ms-flow-into":"[none|<custom-ident>]#","-ms-grid-columns":"none|<track-list>|<auto-track-list>","-ms-grid-rows":"none|<track-list>|<auto-track-list>","-ms-high-contrast-adjust":"auto|none","-ms-hyphenate-limit-chars":"auto|<integer>{1,3}","-ms-hyphenate-limit-lines":"no-limit|<integer>","-ms-hyphenate-limit-zone":"<percentage>|<length>","-ms-ime-align":"auto|after","-ms-overflow-style":"auto|none|scrollbar|-ms-autohiding-scrollbar","-ms-scrollbar-3dlight-color":"<color>","-ms-scrollbar-arrow-color":"<color>","-ms-scrollbar-base-color":"<color>","-ms-scrollbar-darkshadow-color":"<color>","-ms-scrollbar-face-color":"<color>","-ms-scrollbar-highlight-color":"<color>","-ms-scrollbar-shadow-color":"<color>","-ms-scrollbar-track-color":"<color>","-ms-scroll-chaining":"chained|none","-ms-scroll-limit":"<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>","-ms-scroll-limit-x-max":"auto|<length>","-ms-scroll-limit-x-min":"<length>","-ms-scroll-limit-y-max":"auto|<length>","-ms-scroll-limit-y-min":"<length>","-ms-scroll-rails":"none|railed","-ms-scroll-snap-points-x":"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )","-ms-scroll-snap-points-y":"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )","-ms-scroll-snap-type":"none|proximity|mandatory","-ms-scroll-snap-x":"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>","-ms-scroll-snap-y":"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>","-ms-scroll-translation":"none|vertical-to-horizontal","-ms-text-autospace":"none|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space","-ms-touch-select":"grippers|none","-ms-user-select":"none|element|text","-ms-wrap-flow":"auto|both|start|end|maximum|clear","-ms-wrap-margin":"<length>","-ms-wrap-through":"wrap|none","-moz-appearance":"none|button|button-arrow-down|button-arrow-next|button-arrow-previous|button-arrow-up|button-bevel|button-focus|caret|checkbox|checkbox-container|checkbox-label|checkmenuitem|dualbutton|groupbox|listbox|listitem|menuarrow|menubar|menucheckbox|menuimage|menuitem|menuitemtext|menulist|menulist-button|menulist-text|menulist-textfield|menupopup|menuradio|menuseparator|meterbar|meterchunk|progressbar|progressbar-vertical|progresschunk|progresschunk-vertical|radio|radio-container|radio-label|radiomenuitem|range|range-thumb|resizer|resizerpanel|scale-horizontal|scalethumbend|scalethumb-horizontal|scalethumbstart|scalethumbtick|scalethumb-vertical|scale-vertical|scrollbarbutton-down|scrollbarbutton-left|scrollbarbutton-right|scrollbarbutton-up|scrollbarthumb-horizontal|scrollbarthumb-vertical|scrollbartrack-horizontal|scrollbartrack-vertical|searchfield|separator|sheet|spinner|spinner-downbutton|spinner-textfield|spinner-upbutton|splitter|statusbar|statusbarpanel|tab|tabpanel|tabpanels|tab-scroll-arrow-back|tab-scroll-arrow-forward|textfield|textfield-multiline|toolbar|toolbarbutton|toolbarbutton-dropdown|toolbargripper|toolbox|tooltip|treeheader|treeheadercell|treeheadersortarrow|treeitem|treeline|treetwisty|treetwistyopen|treeview|-moz-mac-unified-toolbar|-moz-win-borderless-glass|-moz-win-browsertabbar-toolbox|-moz-win-communicationstext|-moz-win-communications-toolbox|-moz-win-exclude-glass|-moz-win-glass|-moz-win-mediatext|-moz-win-media-toolbox|-moz-window-button-box|-moz-window-button-box-maximized|-moz-window-button-close|-moz-window-button-maximize|-moz-window-button-minimize|-moz-window-button-restore|-moz-window-frame-bottom|-moz-window-frame-left|-moz-window-frame-right|-moz-window-titlebar|-moz-window-titlebar-maximized","-moz-binding":"<url>|none","-moz-border-bottom-colors":"<color>+|none","-moz-border-left-colors":"<color>+|none","-moz-border-right-colors":"<color>+|none","-moz-border-top-colors":"<color>+|none","-moz-context-properties":"none|[fill|fill-opacity|stroke|stroke-opacity]#","-moz-float-edge":"border-box|content-box|margin-box|padding-box","-moz-force-broken-image-icon":"0|1","-moz-image-region":"<shape>|auto","-moz-orient":"inline|block|horizontal|vertical","-moz-outline-radius":"<outline-radius>{1,4} [/ <outline-radius>{1,4}]?","-moz-outline-radius-bottomleft":"<outline-radius>","-moz-outline-radius-bottomright":"<outline-radius>","-moz-outline-radius-topleft":"<outline-radius>","-moz-outline-radius-topright":"<outline-radius>","-moz-stack-sizing":"ignore|stretch-to-fit","-moz-text-blink":"none|blink","-moz-user-focus":"ignore|normal|select-after|select-before|select-menu|select-same|select-all|none","-moz-user-input":"auto|none|enabled|disabled","-moz-user-modify":"read-only|read-write|write-only","-moz-window-dragging":"drag|no-drag","-moz-window-shadow":"default|menu|tooltip|sheet|none","-webkit-appearance":"none|button|button-bevel|caps-lock-indicator|caret|checkbox|default-button|inner-spin-button|listbox|listitem|media-controls-background|media-controls-fullscreen-background|media-current-time-display|media-enter-fullscreen-button|media-exit-fullscreen-button|media-fullscreen-button|media-mute-button|media-overlay-play-button|media-play-button|media-seek-back-button|media-seek-forward-button|media-slider|media-sliderthumb|media-time-remaining-display|media-toggle-closed-captions-button|media-volume-slider|media-volume-slider-container|media-volume-sliderthumb|menulist|menulist-button|menulist-text|menulist-textfield|meter|progress-bar|progress-bar-value|push-button|radio|scrollbarbutton-down|scrollbarbutton-left|scrollbarbutton-right|scrollbarbutton-up|scrollbargripper-horizontal|scrollbargripper-vertical|scrollbarthumb-horizontal|scrollbarthumb-vertical|scrollbartrack-horizontal|scrollbartrack-vertical|searchfield|searchfield-cancel-button|searchfield-decoration|searchfield-results-button|searchfield-results-decoration|slider-horizontal|slider-vertical|sliderthumb-horizontal|sliderthumb-vertical|square-button|textarea|textfield|-apple-pay-button","-webkit-border-before":"<'border-width'>||<'border-style'>||<color>","-webkit-border-before-color":"<color>","-webkit-border-before-style":"<'border-style'>","-webkit-border-before-width":"<'border-width'>","-webkit-box-reflect":"[above|below|right|left]? <length>? <image>?","-webkit-line-clamp":"none|<integer>","-webkit-mask":"[<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||[<box>|border|padding|content|text]||[<box>|border|padding|content]]#","-webkit-mask-attachment":"<attachment>#","-webkit-mask-clip":"[<box>|border|padding|content|text]#","-webkit-mask-composite":"<composite-style>#","-webkit-mask-image":"<mask-reference>#","-webkit-mask-origin":"[<box>|border|padding|content]#","-webkit-mask-position":"<position>#","-webkit-mask-position-x":"[<length-percentage>|left|center|right]#","-webkit-mask-position-y":"[<length-percentage>|top|center|bottom]#","-webkit-mask-repeat":"<repeat-style>#","-webkit-mask-repeat-x":"repeat|no-repeat|space|round","-webkit-mask-repeat-y":"repeat|no-repeat|space|round","-webkit-mask-size":"<bg-size>#","-webkit-overflow-scrolling":"auto|touch","-webkit-tap-highlight-color":"<color>","-webkit-text-fill-color":"<color>","-webkit-text-stroke":"<length>||<color>","-webkit-text-stroke-color":"<color>","-webkit-text-stroke-width":"<length>","-webkit-touch-callout":"default|none","-webkit-user-modify":"read-only|read-write|read-write-plaintext-only","accent-color":"auto|<color>","align-content":"normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>","align-items":"normal|stretch|<baseline-position>|[<overflow-position>? <self-position>]","align-self":"auto|normal|stretch|<baseline-position>|<overflow-position>? <self-position>","align-tracks":"[normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>]#",all:"initial|inherit|unset|revert|revert-layer",

2444}}}
2445const PLUSSIGN$f=0x002B
2446const HYPHENMINUS$9=0x002D
2447const N$5=0x006E
2448const DISALLOW_SIGN$2=true
2449const ALLOW_SIGN$2=false
2450function checkInteger$2(offset,disallowSign){let pos=this.tokenStart+offset
2451const code=this.charCodeAt(pos)
2452if(code===PLUSSIGN$f||code===HYPHENMINUS$9){disallowSign&&this.error("Number sign is not allowed")
2453pos++}for(;pos<this.tokenEnd;pos++)isDigit$2(this.charCodeAt(pos))||this.error("Integer is expected",pos)}function checkTokenIsInteger$1(disallowSign){return checkInteger$2.call(this,0,disallowSign)}function expectCharCode$1(offset,code){if(!this.cmpChar(this.tokenStart+offset,code)){let msg=""
2454switch(code){case N$5:msg="N is expected"
2455break
2456case HYPHENMINUS$9:msg="HyphenMinus is expected"
2457break}this.error(msg,this.tokenStart+offset)}}function consumeB$2(){let offset=0
2458let sign=0
2459let type=this.tokenType
2460while(type===WhiteSpace$3||type===Comment$3)type=this.lookupType(++offset)
2461if(type!==Number$5){if(!this.isDelim(PLUSSIGN$f,offset)&&!this.isDelim(HYPHENMINUS$9,offset))return null
2462sign=this.isDelim(PLUSSIGN$f,offset)?PLUSSIGN$f:HYPHENMINUS$9
2463do{type=this.lookupType(++offset)}while(type===WhiteSpace$3||type===Comment$3)
2464if(type!==Number$5){this.skip(offset)
2465checkTokenIsInteger$1.call(this,DISALLOW_SIGN$2)}}offset>0&&this.skip(offset)
2466if(sign===0){type=this.charCodeAt(this.tokenStart)
2467type!==PLUSSIGN$f&&type!==HYPHENMINUS$9&&this.error("Number sign is expected")}checkTokenIsInteger$1.call(this,sign!==0)
2468return sign===HYPHENMINUS$9?"-"+this.consume(Number$5):this.consume(Number$5)}const name$2a="AnPlusB"
2469const structure$1o={a:[String,null],b:[String,null]}
2470function parse$1t(){const start=this.tokenStart
2471let a=null
2472let b=null
2473if(this.tokenType===Number$5){checkTokenIsInteger$1.call(this,ALLOW_SIGN$2)
2474b=this.consume(Number$5)}else if(this.tokenType===Ident$1&&this.cmpChar(this.tokenStart,HYPHENMINUS$9)){a="-1"
2475expectCharCode$1.call(this,1,N$5)
2476switch(this.tokenEnd-this.tokenStart){case 2:this.next()
2477b=consumeB$2.call(this)
2478break
2479case 3:expectCharCode$1.call(this,2,HYPHENMINUS$9)
2480this.next()
2481this.skipSC()
2482checkTokenIsInteger$1.call(this,DISALLOW_SIGN$2)
2483b="-"+this.consume(Number$5)
2484break
2485default:expectCharCode$1.call(this,2,HYPHENMINUS$9)
2486checkInteger$2.call(this,3,DISALLOW_SIGN$2)
2487this.next()
2488b=this.substrToCursor(start+2)}}else if(this.tokenType===Ident$1||this.isDelim(PLUSSIGN$f)&&this.lookupType(1)===Ident$1){let sign=0
2489a="1"
2490if(this.isDelim(PLUSSIGN$f)){sign=1
2491this.next()}expectCharCode$1.call(this,0,N$5)
2492switch(this.tokenEnd-this.tokenStart){case 1:this.next()
2493b=consumeB$2.call(this)
2494break
2495case 2:expectCharCode$1.call(this,1,HYPHENMINUS$9)
2496this.next()
2497this.skipSC()
2498checkTokenIsInteger$1.call(this,DISALLOW_SIGN$2)
2499b="-"+this.consume(Number$5)
2500break
2501default:expectCharCode$1.call(this,1,HYPHENMINUS$9)
2502checkInteger$2.call(this,2,DISALLOW_SIGN$2)
2503this.next()
2504b=this.substrToCursor(start+sign+1)}}else if(this.tokenType===Dimension$3){const code=this.charCodeAt(this.tokenStart)
2505const sign=code===PLUSSIGN$f||code===HYPHENMINUS$9
2506let i=this.tokenStart+sign
2507for(;i<this.tokenEnd;i++)if(!isDigit$2(this.charCodeAt(i)))break
2508i===this.tokenStart+sign&&this.error("Integer is expected",this.tokenStart+sign)
2509expectCharCode$1.call(this,i-this.tokenStart,N$5)
2510a=this.substring(start,i)
2511if(i+1===this.tokenEnd){this.next()
2512b=consumeB$2.call(this)}else{expectCharCode$1.call(this,i-this.tokenStart+1,HYPHENMINUS$9)
2513if(i+2===this.tokenEnd){this.next()
2514this.skipSC()
2515checkTokenIsInteger$1.call(this,DISALLOW_SIGN$2)
2516b="-"+this.consume(Number$5)}else{checkInteger$2.call(this,i-this.tokenStart+2,DISALLOW_SIGN$2)
2517this.next()
2518b=this.substrToCursor(i+1)}}}else this.error()
2519a!==null&&a.charCodeAt(0)===PLUSSIGN$f&&(a=a.substr(1))
2520b!==null&&b.charCodeAt(0)===PLUSSIGN$f&&(b=b.substr(1))
2521return{type:"AnPlusB",loc:this.getLocation(start,this.tokenStart),a:a,b:b}}function generate$1t(node){if(node.a){const a=(node.a==="+1"||node.a==="1"?"n":node.a==="-1"&&"-n")||node.a+"n"
2522if(node.b){const b=node.b[0]==="-"||node.b[0]==="+"?node.b:"+"+node.b
2523this.tokenize(a+b)}else this.tokenize(a)}else this.tokenize(node.b)}var AnPlusB$1=Object.freeze({__proto__:null,generate:generate$1t,name:name$2a,parse:parse$1t,structure:structure$1o})
2524function consumeRaw$a(){return this.Raw(this.consumeUntilLeftCurlyBracketOrSemicolon,true)}function isDeclarationBlockAtrule$1(){for(let offset=1,type;type=this.lookupType(offset);offset++){if(type===RightCurlyBracket$1)return true
2525if(type===LeftCurlyBracket$1||type===AtKeyword$1)return false}return false}const name$29="Atrule"
2526const walkContext$j="atrule"
2527const structure$1n={name:String,prelude:["AtrulePrelude","Raw",null],block:["Block",null]}
2528function parse$1s(isDeclaration=false){const start=this.tokenStart
2529let name
2530let nameLowerCase
2531let prelude=null
2532let block=null
2533this.eat(AtKeyword$1)
2534name=this.substrToCursor(start+1)
2535nameLowerCase=name.toLowerCase()
2536this.skipSC()
2537if(this.eof===false&&this.tokenType!==LeftCurlyBracket$1&&this.tokenType!==Semicolon$1){prelude=this.parseAtrulePrelude?this.parseWithFallback(this.AtrulePrelude.bind(this,name,isDeclaration),consumeRaw$a):consumeRaw$a.call(this,this.tokenIndex)
2538this.skipSC()}switch(this.tokenType){case Semicolon$1:this.next()
2539break
2540case LeftCurlyBracket$1:block=hasOwnProperty.call(this.atrule,nameLowerCase)&&typeof this.atrule[nameLowerCase].block==="function"?this.atrule[nameLowerCase].block.call(this,isDeclaration):this.Block(isDeclarationBlockAtrule$1.call(this))
2541break}return{type:"Atrule",loc:this.getLocation(start,this.tokenStart),name:name,prelude:prelude,block:block}}function generate$1s(node){this.token(AtKeyword$1,"@"+node.name)
2542node.prelude!==null&&this.node(node.prelude)
2543node.block?this.node(node.block):this.token(Semicolon$1,";")}var Atrule$2=Object.freeze({__proto__:null,generate:generate$1s,name:name$29,parse:parse$1s,structure:structure$1n,walkContext:walkContext$j})
2544const name$28="AtrulePrelude"
2545const walkContext$i="atrulePrelude"
2546const structure$1m={children:[[]]}
2547function parse$1r(name){let children=null
2548name!==null&&(name=name.toLowerCase())
2549this.skipSC()
2550children=hasOwnProperty.call(this.atrule,name)&&typeof this.atrule[name].prelude==="function"?this.atrule[name].prelude.call(this):this.readSequence(this.scope.AtrulePrelude)
2551this.skipSC()
2552this.eof!==true&&this.tokenType!==LeftCurlyBracket$1&&this.tokenType!==Semicolon$1&&this.error("Semicolon or block is expected")
2553return{type:"AtrulePrelude",loc:this.getLocationFromList(children),children:children}}function generate$1r(node){this.children(node)}var AtrulePrelude$1=Object.freeze({__proto__:null,generate:generate$1r,name:name$28,parse:parse$1r,structure:structure$1m,walkContext:walkContext$i})
2554const DOLLARSIGN$3=0x0024
2555const ASTERISK$c=0x002A
2556const EQUALSSIGN$2=0x003D
2557const CIRCUMFLEXACCENT$1=0x005E
2558const VERTICALLINE$6=0x007C
2559const TILDE$5=0x007E
2560function getAttributeName$1(){this.eof&&this.error("Unexpected end of input")
2561const start=this.tokenStart
2562let expectIdent=false
2563if(this.isDelim(ASTERISK$c)){expectIdent=true
2564this.next()}else this.isDelim(VERTICALLINE$6)||this.eat(Ident$1)
2565if(this.isDelim(VERTICALLINE$6))if(this.charCodeAt(this.tokenStart+1)!==EQUALSSIGN$2){this.next()
2566this.eat(Ident$1)}else expectIdent&&this.error("Identifier is expected",this.tokenEnd)
2567else expectIdent&&this.error("Vertical line is expected")
2568return{type:"Identifier",loc:this.getLocation(start,this.tokenStart),name:this.substrToCursor(start)}}function getOperator$1(){const start=this.tokenStart
2569const code=this.charCodeAt(start)
2570code!==EQUALSSIGN$2&&code!==TILDE$5&&code!==CIRCUMFLEXACCENT$1&&code!==DOLLARSIGN$3&&code!==ASTERISK$c&&code!==VERTICALLINE$6&&this.error("Attribute selector (=, ~=, ^=, $=, *=, |=) is expected")
2571this.next()
2572if(code!==EQUALSSIGN$2){this.isDelim(EQUALSSIGN$2)||this.error("Equal sign is expected")
2573this.next()}return this.substrToCursor(start)}const name$27="AttributeSelector"
2574const structure$1l={name:"Identifier",matcher:[String,null],value:["String","Identifier",null],flags:[String,null]}
2575function parse$1q(){const start=this.tokenStart
2576let name
2577let matcher=null
2578let value=null
2579let flags=null
2580this.eat(LeftSquareBracket$1)
2581this.skipSC()
2582name=getAttributeName$1.call(this)
2583this.skipSC()
2584if(this.tokenType!==RightSquareBracket$1){if(this.tokenType!==Ident$1){matcher=getOperator$1.call(this)
2585this.skipSC()
2586value=this.tokenType===String$4?this.String():this.Identifier()
2587this.skipSC()}if(this.tokenType===Ident$1){flags=this.consume(Ident$1)
2588this.skipSC()}}this.eat(RightSquareBracket$1)
2589return{type:"AttributeSelector",loc:this.getLocation(start,this.tokenStart),name:name,matcher:matcher,value:value,flags:flags}}function generate$1q(node){this.token(Delim$1,"[")
2590this.node(node.name)
2591if(node.matcher!==null){this.tokenize(node.matcher)
2592this.node(node.value)}node.flags!==null&&this.token(Ident$1,node.flags)
2593this.token(Delim$1,"]")}var AttributeSelector$2=Object.freeze({__proto__:null,generate:generate$1q,name:name$27,parse:parse$1q,structure:structure$1l})
2594const AMPERSAND$6=0x0026
2595function consumeRaw$9(){return this.Raw(null,true)}function consumeRule$1(){return this.parseWithFallback(this.Rule,consumeRaw$9)}function consumeRawDeclaration$1(){return this.Raw(this.consumeUntilSemicolonIncluded,true)}function consumeDeclaration$1(){if(this.tokenType===Semicolon$1)return consumeRawDeclaration$1.call(this,this.tokenIndex)
2596const node=this.parseWithFallback(this.Declaration,consumeRawDeclaration$1)
2597this.tokenType===Semicolon$1&&this.next()
2598return node}const name$26="Block"
2599const walkContext$h="block"
2600const structure$1k={children:[["Atrule","Rule","Declaration"]]}
2601function parse$1p(isStyleBlock){const consumer=isStyleBlock?consumeDeclaration$1:consumeRule$1
2602const start=this.tokenStart
2603let children=this.createList()
2604this.eat(LeftCurlyBracket$1)
2605scan:while(!this.eof)switch(this.tokenType){case RightCurlyBracket$1:break scan
2606case WhiteSpace$3:case Comment$3:this.next()
2607break
2608case AtKeyword$1:children.push(this.parseWithFallback(this.Atrule.bind(this,isStyleBlock),consumeRaw$9))
2609break
2610default:isStyleBlock&&this.isDelim(AMPERSAND$6)?children.push(consumeRule$1.call(this)):children.push(consumer.call(this))}this.eof||this.eat(RightCurlyBracket$1)
2611return{type:"Block",loc:this.getLocation(start,this.tokenStart),children:children}}function generate$1p(node){this.token(LeftCurlyBracket$1,"{")
2612this.children(node,

2612(prev=>{prev.type==="Declaration"&&this.token(Semicolon$1,";")}))
2613this.token(RightCurlyBracket$1,"}")}var Block$1=Object.freeze({__proto__:null,generate:generate$1p,name:name$26,parse:parse$1p,structure:structure$1k,walkContext:walkContext$h})
2614const name$25="Brackets"
2615const structure$1j={children:[[]]}
2616function parse$1o(readSequence,recognizer){const start=this.tokenStart
2617let children=null
2618this.eat(LeftSquareBracket$1)
2619children=readSequence.call(this,recognizer)
2620this.eof||this.eat(RightSquareBracket$1)
2621return{type:"Brackets",loc:this.getLocation(start,this.tokenStart),children:children}}function generate$1o(node){this.token(Delim$1,"[")
2622this.children(node)
2623this.token(Delim$1,"]")}var Brackets$1=Object.freeze({__proto__:null,generate:generate$1o,name:name$25,parse:parse$1o,structure:structure$1j})
2624const name$24="CDC"
2625const structure$1i=[]
2626function parse$1n(){const start=this.tokenStart
2627this.eat(CDC$3)
2628return{type:"CDC",loc:this.getLocation(start,this.tokenStart)}}function generate$1n(){this.token(CDC$3,"--\x3e")}var CDC$2=Object.freeze({__proto__:null,generate:generate$1n,name:name$24,parse:parse$1n,structure:structure$1i})
2629const name$23="CDO"
2630const structure$1h=[]
2631function parse$1m(){const start=this.tokenStart
2632this.eat(CDO$3)
2633return{type:"CDO",loc:this.getLocation(start,this.tokenStart)}}function generate$1m(){this.token(CDO$3,"\x3c!--")}var CDO$2=Object.freeze({__proto__:null,generate:generate$1m,name:name$23,parse:parse$1m,structure:structure$1h})
2634const FULLSTOP$5=0x002E
2635const name$22="ClassSelector"
2636const structure$1g={name:String}
2637function parse$1l(){this.eatDelim(FULLSTOP$5)
2638return{type:"ClassSelector",loc:this.getLocation(this.tokenStart-1,this.tokenEnd),name:this.consume(Ident$1)}}function generate$1l(node){this.token(Delim$1,".")
2639this.token(Ident$1,node.name)}var ClassSelector$1=Object.freeze({__proto__:null,generate:generate$1l,name:name$22,parse:parse$1l,structure:structure$1g})
2640const PLUSSIGN$e=0x002B
2641const SOLIDUS$d=0x002F
2642const GREATERTHANSIGN$5=0x003E
2643const TILDE$4=0x007E
2644const name$21="Combinator"
2645const structure$1f={name:String}
2646function parse$1k(){const start=this.tokenStart
2647let name
2648switch(this.tokenType){case WhiteSpace$3:name=" "
2649break
2650case Delim$1:switch(this.charCodeAt(this.tokenStart)){case GREATERTHANSIGN$5:case PLUSSIGN$e:case TILDE$4:this.next()
2651break
2652case SOLIDUS$d:this.next()
2653this.eatIdent("deep")
2654this.eatDelim(SOLIDUS$d)
2655break
2656default:this.error("Combinator is expected")}name=this.substrToCursor(start)
2657break}return{type:"Combinator",loc:this.getLocation(start,this.tokenStart),name:name}}function generate$1k(node){this.tokenize(node.name)}var Combinator$1=Object.freeze({__proto__:null,generate:generate$1k,name:name$21,parse:parse$1k,structure:structure$1f})
2658const ASTERISK$b=0x002A
2659const SOLIDUS$c=0x002F
2660const name$20="Comment"
2661const structure$1e={value:String}
2662function parse$1j(){const start=this.tokenStart
2663let end=this.tokenEnd
2664this.eat(Comment$3)
2665end-start+2>=2&&this.charCodeAt(end-2)===ASTERISK$b&&this.charCodeAt(end-1)===SOLIDUS$c&&(end-=2)
2666return{type:"Comment",loc:this.getLocation(start,this.tokenStart),value:this.substring(start+2,end)}}function generate$1j(node){this.token(Comment$3,"/*"+node.value+"*/")}var Comment$2=Object.freeze({__proto__:null,generate:generate$1j,name:name$20,parse:parse$1j,structure:structure$1e})
2667const likelyFeatureToken=new Set([Colon$1,RightParenthesis$1,EOF$3])
2668const name$1$="Condition"
2669const structure$1d={kind:String,children:[["Identifier","Feature","FeatureFunction","FeatureRange","SupportsDeclaration"]]}
2670function featureOrRange(kind){if(this.lookupTypeNonSC(1)===Ident$1&&likelyFeatureToken.has(this.lookupTypeNonSC(2)))return this.Feature