From 8fe2928ea1f273053d5159e846414d1053a495c6 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@byui.edu>
Date: Wed, 5 Aug 2020 17:06:08 -0600
Subject: [PATCH 01/20] first draft of CSS from pagedown

---
 media/pagedown-resume.css | 434 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 434 insertions(+)
 create mode 100644 media/pagedown-resume.css

diff --git a/media/pagedown-resume.css b/media/pagedown-resume.css
new file mode 100644
index 0000000000..659f959ad4
--- /dev/null
+++ b/media/pagedown-resume.css
@@ -0,0 +1,434 @@
+@page{
+  size: letter portrait;
+  margin: 1in 0.5in 1in 0.25in;
+}
+
+*{
+  box-sizing: border-box;
+}
+
+:root{
+  --page-width: 8.5in;
+  --margin-right: 0.5in;
+  --margin-left: 0.25in;
+  --content-width: calc(var(--page-width) - var(--margin-right) - var(--margin-left));
+  --root-font-size: 12pt;
+  --sidebar-width: 15rem;
+  --sidebar-background-color: #f2f2f2;
+  --main-width: calc(var(--content-width) - var(--sidebar-width));
+  --decorator-horizontal-margin: 0.2in;
+
+  --sidebar-horizontal-padding: 0.2in;
+
+  /* XXX: using px for very good precision control */
+  --decorator-outer-offset-top: 10px;
+  --decorator-outer-offset-left: -5.5px;
+  --decorator-border-width: 1px;
+  --decorator-outer-dim: 9px;
+  --decorator-border: 1px solid #ccc;
+
+  --row-blocks-padding-top: 0.5rem;
+  --date-block-width: 0.7in;
+
+  --main-blocks-title-icon-offset-left: calc(-17pt - 0.25 * var(--root-font-size));
+
+  --viewer-background-color: #dcdcdc;
+  --viewer-pages-spacing: 12px;
+  --viewer-shadow-color: #313131;
+}
+
+.pagedjs_page {
+  --content-area-height: calc(var(--pagedjs-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
+  --sidebar-background-width: calc(var(--pagedjs-margin-right) + var(--sidebar-width));
+}
+
+@page{
+  background: linear-gradient(to left, var(--sidebar-background-color), var(--sidebar-background-color) var(--sidebar-background-width), white var(--sidebar-background-width));
+}
+
+html {
+  font-size: var(--root-font-size);
+}
+
+body{
+  width: var(--content-width);
+  font-family: "Open Sans", sans-serif;
+  font-weight: 300;
+  line-height: 1.3;
+  color: #444;
+  hyphens: auto;
+}
+
+h1, h2, h3{
+  margin: 0;
+  color: #000;
+}
+
+#main > h1, #aside > h1, #disclaimer > h2 {
+  display: none;
+}
+
+li{
+  list-style-type: none;
+}
+
+a{
+  text-decoration: none;
+}
+
+img{
+  max-width: 100%;
+}
+
+#main{
+  width: var(--main-width);
+  padding: 0 0.25in 0 0.25in;
+  font-size: 0.7rem;
+  float: left;
+}
+
+#aside{
+  position: relative; /* for disclaimer */
+  height: var(--content-area-height);
+}
+
+.aside{
+  width: var(--sidebar-width);
+  padding: 0.6in var(--sidebar-horizontal-padding);
+  font-size: 0.8rem;
+  float: right;
+  position: absolute;
+  right: 0;
+}
+
+/* main */
+
+/** big title **/
+h1, h2{
+  text-transform: uppercase;
+}
+
+#title{
+  position: relative;
+  left: 0.55in;
+  margin: auto 0.55in 0.3in auto;
+  line-height: 1.2;
+}
+
+#title h1{
+  font-weight: 300;
+  font-size: 1.8rem;
+  line-height: 1.5;
+}
+
+#title h3{
+  font-size: 0.8rem;
+}
+
+
+/*** categorial blocks ***/
+
+.main-block{
+  margin-top: 0.1in;
+}
+
+#main h2{
+  position: relative;
+  top: var(--row-blocks-padding-top);
+  /* XXX: 0.5px for aligning fx printing */
+  left: calc((var(--date-block-width) + var(--decorator-horizontal-margin)));
+  font-weight: 400;
+  font-size: 1.1rem;
+  color: #555;
+}
+
+#main h2 > i{
+  /* use absolute position to prevent icon's width from misaligning title */
+  /* assigning a fixed width here is no better due to needing to align decorator
+     line too */
+  position: absolute;
+  left: var(--main-blocks-title-icon-offset-left);
+  z-index: 1; /* over decorator line */
+  color: #444;
+}
+
+#main h2::after{ /* extends the decorator line */
+  height: calc(var(--row-blocks-padding-top) * 2);
+  position: relative;
+  top: calc(-1 * var(--row-blocks-padding-top));
+  /* XXX: 0.5px for aligning fx printing */
+  left: calc(-1 * var(--decorator-horizontal-margin));
+  display: block;
+  border-left: var(--decorator-border);
+  z-index: 0;
+  line-height: 0;
+  font-size: 0;
+  content: ' ';
+}
+
+/**** minor tweaks on the icon fonts ****/
+#main h2 > .fa-graduation-cap{
+  left: calc(var(--main-blocks-title-icon-offset-left) - 2pt);
+  top: 2pt;
+}
+
+#main h2 > .fa-suitcase{
+  top: 1pt;
+}
+
+#main h2 > .fa-folder-open{
+  top: 1.5pt;
+}
+
+/**** individual row blocks (date - decorator - details) ****/
+
+.blocks{
+  display: flex;
+  flex-flow: row nowrap;
+}
+
+.blocks > div{
+  padding-top: var(--row-blocks-padding-top);
+}
+
+.date{
+  flex: 0 0 var(--date-block-width);
+  padding-top: calc(var(--row-blocks-padding-top) + 0.25rem) !important;
+  padding-right: var(--decorator-horizontal-margin);
+  font-size: 0.7rem;
+  text-align: right;
+  line-height: 1;
+  max-width: var(--date-block-width);
+}
+
+.date span{
+  display: block;
+  text-align: center;
+}
+
+.date span:nth-child(2)::before{
+  position: relative;
+  top: 0.1rem;
+  right: 0;
+  display: block;
+  height: 1rem;
+  content: '|';
+}
+
+.decorator{
+  flex: 0 0 0;
+  position: relative;
+  width: 2pt;
+  min-height: 100%;
+  border-left: var(--decorator-border);
+}
+
+/*
+ * XXX: Use two filled circles to achieve the circle-with-white-border effect.
+ * The normal technique of only using one pseudo element and
+ * border: 1px solid white; style makes firefox erroneously either:
+ * 1) overflows the grayshade background (if no background-clip is set), or
+ * 2) shows decorator line which should've been masked by the white border
+ *
+ */
+
+.decorator::before{
+  position: absolute;
+  top: var(--decorator-outer-offset-top);
+  left: var(--decorator-outer-offset-left);
+  content: ' ';
+  display: block;
+  width: var(--decorator-outer-dim);
+  height: var(--decorator-outer-dim);
+  border-radius: calc(var(--decorator-outer-dim) / 2);
+  background-color: #fff;
+}
+
+.decorator::after{
+  position: absolute;
+  top: calc(var(--decorator-outer-offset-top) + var(--decorator-border-width));
+  left: calc(var(--decorator-outer-offset-left) + var(--decorator-border-width));
+  content: ' ';
+  display: block;
+  width: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
+  height: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
+  border-radius: calc((var(--decorator-outer-dim) - (var(--decorator-border-width) * 2)) / 2);
+  background-color: #555;
+}
+
+.blocks:last-child .decorator{ /* slightly shortens it */
+  margin-bottom: 0.25in;
+}
+
+/***** fine-tunes on the details block where the real juice is *****/
+
+.details{
+  flex: 1 0 0;
+  padding-left: var(--decorator-horizontal-margin);
+  padding-top: calc(var(--row-blocks-padding-top) - 0.05rem) !important; /* not sure why but this is needed for better alignment */
+}
+
+.details header{
+  color: #000;
+}
+
+.details h3{
+  font-size: 0.8rem;
+}
+
+.main-block:not(.concise) .details div{
+  margin: 0.18in 0 0.1in 0;
+}
+
+.main-block:not(.concise) .details div:empty {
+  margin: 0;
+}
+
+.main-block:not(.concise) .blocks:last-child .details div{
+  margin-bottom: 0;
+}
+
+.main-block.concise .details div:not(.concise){
+  /* use padding to work around the fact that margin doesn't affect floated
+     neighboring elements */
+  padding: 0.05in 0 0.07in 0;
+}
+
+.details .place{
+  float: left;
+  font-size: 0.75rem;
+}
+
+.details .location{
+  float: right;
+}
+
+.details div{
+  clear: both;
+}
+
+/***** fine-tunes on the lists... *****/
+
+#main ul{
+  padding-left: 0.07in;
+  margin: 0.08in 0;
+}
+
+#main li{
+  margin: 0 0 0.025in 0;
+}
+
+/****** customize list symbol style ******/
+#main li::before{
+  position: relative;
+  margin-left: -4.25pt;
+  content: '• ';
+}
+
+.aside li::before {
+  content: none;
+}
+
+.details .concise ul{
+  margin: 0 !important;
+  -webkit-columns: 2;
+  -moz-columns: 2;
+  columns: 2;
+}
+
+.details .concise li{
+  margin: 0 !important;
+}
+
+.details .concise li{
+  margin-left: 0 !important;
+}
+
+
+
+/* sidebar */
+
+.aside h2{
+  font-weight: 400;
+  font-size: 1.1rem;
+}
+
+.aside .level2{
+  margin-top: 0.5in;
+}
+
+#contact ul{
+  margin-top: 0.05in;
+  padding-left: 0;
+  font-weight: 400;
+  line-height: 1.75;
+}
+
+#contact li > i{
+  width: 0.9rem; /* for text alignment */
+  text-align: right;
+}
+
+#skills{
+  line-height: 1.5;
+}
+
+#skills ul{
+  margin: 0.05in 0 0.15in;
+  padding: 0;
+}
+
+#disclaimer{
+  position: absolute;
+  bottom: 0;
+  right: var(--sidebar-horizontal-padding);
+  font-size: 0.75rem;
+  font-style: italic;
+  line-height: 1.1;
+  text-align: right;
+  color: #777;
+}
+
+#disclaimer code{
+  color: #666;
+  font-family: "Source Code Pro";
+  font-weight: 400;
+  font-style: normal;
+}
+
+/* Page breaks */
+
+h2 {
+  break-after: avoid;
+}
+
+.blocks {
+  break-inside: avoid;
+}
+
+/* Paged.js viewer */
+
+@media screen {
+  body {
+    background-color: var(--viewer-background-color);
+    margin: 0; /* for mobile */
+    width: calc(var(--pagedjs-width) + 2 * var(--viewer-pages-spacing)); /* for mobile */
+  }
+   .pagedjs_pages {
+    max-width: var(--pagedjs-width);
+    margin: 0 auto;
+    display: flex;
+    flex-direction: column;
+  }
+   .pagedjs_page {
+    box-shadow: 0 0 calc(0.66667 * var(--viewer-pages-spacing)) var(--viewer-shadow-color);
+    margin: var(--viewer-pages-spacing) 0;
+  }
+}
+ @media screen and (min-width: 8.5in) {
+  /* not a mobile */
+  body {
+    margin: auto;
+    width: unset;
+  }
+}

From e899af342c5c7a89582f32940419f38cd8734c27 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@byui.edu>
Date: Wed, 5 Aug 2020 17:11:35 -0600
Subject: [PATCH 02/20] changed to resume

---
 README.md | 21 ++++++---------------
 1 file changed, 6 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 99d2d44506..7841129115 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
-# markdown-cv
+# md-resume
 
-A curriculum vitae maintained in plain text and rendered to HTML and PDF using CSS.
+A resume maintained in plain text and rendered to HTML and PDF using CSS.
 
-For more details, see the [project page](http://elipapa.github.io/markdown-cv), or the blog post on [why I switched to markdown for my CV](http://elipapa.github.io/blog/why-i-switched-to-markdown-for-my-cv.html).
+For more details, see the [markdown-csv project page](http://elipapa.github.io/markdown-cv), or the blog post on [why I switched to markdown for my CV](http://elipapa.github.io/blog/why-i-switched-to-markdown-for-my-cv.html).
 
 ***
 
@@ -22,24 +22,15 @@ adding your skills, jobs and education.
 
 ## Distribution
 
-To transform your plain text CV into a beautiful and shareable HTML page, you have two options:
+To transform your plain text resume into a beautiful and shareable HTML page, you have two options:
 
 ### I. Use Github Pages to publish it online
 
-1. Delete the existing `gh-pages` branch from your fork. It will only contain this webpage. You can either use git or [the Github web interface](https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/#deleting-a-branch).
-2. Create a new branch called `gh-pages`.
-3. Head to *yourusername*.github.io/markdown-cv to see your CV live.
+1. Create a new branch called `gh-pages`.
+2. Head to *yourusername*.github.io/mdresume to see your resume live.
 
 Any change you want to make to your CV from then on would have to be done on the `gh-pages` branch and will be immediately rendered by Github Pages.
 
-### II. Build it locally and print a PDF
-
-1. To [install jekyll](https://jekyllrb.com/docs/installation/), run `gem install bundler jekyll` from the command line.
-3. [Clone](https://help.github.com/en/articles/cloning-a-repository) your fork of markdown-cv to your local machine.
-3. Type `jekyll serve` to render your CV at http://localhost:4000.
-4. You can edit the `index.md` file and see the changes live in your browser.
-5. To print a PDF, press <kbd>⌘</kbd> + <kbd>p</kbd>. Print and web CSS media queries should take care of the styling.
-
 ## Styling
 
 The included CSS will render your CV in two styles:

From 1fc3014964c668e46c3dc5bfb5e17eca2f4f289f Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 08:01:34 -0600
Subject: [PATCH 03/20] put stuff into docs folder

---
 .DS_Store                                  | Bin 0 -> 6148 bytes
 docs/.DS_Store                             | Bin 0 -> 6148 bytes
 _config.yml => docs/_config.yml            |   0
 docs/_layouts/.DS_Store                    | Bin 0 -> 6148 bytes
 {_layouts => docs/_layouts}/cv.html        |   0
 docs/index.md                              |  91 +++++++++++++++++++++
 {media => docs/media}/davewhipp-print.css  |   0
 {media => docs/media}/davewhipp-screen.css |   0
 {media => docs/media}/kjhealy-print.css    |   0
 {media => docs/media}/kjhealy-screen.css   |   0
 {media => docs/media}/pagedown-resume.css  |   0
 11 files changed, 91 insertions(+)
 create mode 100644 .DS_Store
 create mode 100644 docs/.DS_Store
 rename _config.yml => docs/_config.yml (100%)
 create mode 100644 docs/_layouts/.DS_Store
 rename {_layouts => docs/_layouts}/cv.html (100%)
 create mode 100644 docs/index.md
 rename {media => docs/media}/davewhipp-print.css (100%)
 rename {media => docs/media}/davewhipp-screen.css (100%)
 rename {media => docs/media}/kjhealy-print.css (100%)
 rename {media => docs/media}/kjhealy-screen.css (100%)
 rename {media => docs/media}/pagedown-resume.css (100%)

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..f411205a9a9841e8c19799adf40055296ebc8344
GIT binary patch
literal 6148
zcmeHK%}N6?5Kh{v*^1bMV2^w8)<cW^ISEUx2XDfP9#q<0x7dZck?z(-Yh_<U-^eHM
zb(~4kVyS{B5jz8uZ!(!l$hS)-VT|$iIH)mJVvGq;#GD1q7lPxcOOi7lM2>U#X?*7o
zr4RkLrD$^eMF#NO6<EL|yJqp{@8{nQ!#Jr{-+3-ySX<u^q9}@6#VdCpQ#bLFaoqMs
z7uY-Tl7VmRQz?gY+w;%De%dYV9Lgy1!l*w|$zjlkkjwKh3S`=r<0y#LJgy!P!V*@u
zRGv)gjYh?;H=5ImJ!!S7VDC4lQ%mgb)eeq(w-1k#r|I*HW|hMasASvV3|_&QZ}8q7
zMMD|gfNvH*iz6fkhyh|?g%~hLpx9iYJ=0c+0b<~14B+`-gCaTxGmYx#fCjIRI9@<R
z0UO^Eh_*q;V5Sj9K)6l?)T!J&F}O|#zir|igPBI1&bV3`<}oXC^FrZjb@1CNoN-4Z
zwZs51u*g7OcS~6RkG_BZFD6ls7$64z6$8A`aXW3;lBumro5NabgZ4mCFfP+LPXR-f
gVu;03Tn1GFej5!y$6%%rJRo!tP&80O4E!nsAIcw4t^fc4

literal 0
HcmV?d00001

diff --git a/docs/.DS_Store b/docs/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5e793e66dadc72110e2fd64147bf2a75cc26c898
GIT binary patch
literal 6148
zcmeHK%}T>S5T0$TZYp9Af<5Nq%|k_7PeO=#@Fqm`pi&cBY#?T(NiA9{c@2FdpTO5~
zW_MdG)r$v_G6S>U?ELJqU&8(Xfba*M9e^4DNL0d-gUvTWand;{Sr4JmV<;Fv4p}tJ
z?&q@E@gEtWZzrJ*354(nU%p?Is0d^4(R~tUd86?mO6AJZ@`{vISzW7M2R$_m@-QD{
ze%QaH-f5WkB5R*1l}zn0I*+@<c5UNOrFj^q-M%i4J6%k<x`@+`8v1IGb}~IqU;<J)
z(rMS~qtRZox$W*XTjOnaw7=g#d$%<nJ92Yt=iub#?(u2#JbrmK><au5wX9p5z#AHK
z3w;RsX`<3wj7{n$`Hai}Gr$ZiFavhWldB87MqU~-zzqD30oos2R6@^UVNh=!*wFQn
z;uS&?wCOED=vwqF76vhbB1|cwDHZmKAxt^?U7P1wEDV}*5PD`D$IdM53q|PJ(eLVX
z5S~G9nE_^CmVvVA*692{{`vhsTf{wPfEidQ21Mm3IP!5x_H3P79G$f;>J2Ih<rM~}
kC1~iQ7<1_;uA^!}ze@(9XR$Dd9u&R^Xd1X-2L6<RPZFt9rvLx|

literal 0
HcmV?d00001

diff --git a/_config.yml b/docs/_config.yml
similarity index 100%
rename from _config.yml
rename to docs/_config.yml
diff --git a/docs/_layouts/.DS_Store b/docs/_layouts/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
GIT binary patch
literal 6148
zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3
zem<@ulZcFPQ@L2!n>{z**<q8>++&mCkOWA81W14cNZ<zv;LbK1Poaz?KmsK2CSc!(
z0ynLxE!0092;Krf2c+FF_Fe*7ECH>lEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ
zLs35+`xjp>T0<F0fCPF1$Cyrb|F7^5{eNG?83~ZUUlGt@xh*qZDeu<Z%US-OSsOPv
j)R!Z4KLME7ReXlK;d!wEw5GODWMKRea10D2@KpjYNUI8I

literal 0
HcmV?d00001

diff --git a/_layouts/cv.html b/docs/_layouts/cv.html
similarity index 100%
rename from _layouts/cv.html
rename to docs/_layouts/cv.html
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000000..aa6c0cb838
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,91 @@
+---
+layout: cv
+title: Isaac Newtons's CV
+---
+# Isaac Newton
+Physicist, Mathematician, Cambridge professor.
+
+<div id="webaddress">
+<a href="isaac@applesdofall.org">isaac@applesdofall.org</a>
+| <a href="http://en.wikipedia.org/wiki/Isaac_Newton">My wikipedia page</a>
+</div>
+
+
+## Currently
+
+Standing on the shoulders of giants
+
+### Specialized in
+
+Laws of motion, gravitation, minting coins, disliking [Robert Hooke](http://en.wikipedia.org/wiki/Robert_Hooke)
+
+
+### Research interests
+
+Cooling, power series, optics, alchemy, planetary motions, apples.
+
+
+## Education
+
+`1654-1660`
+__The King's School, Grantham.__
+
+`June 1661 - now`
+__Trinity College, Cambridge__
+
+- Sizar
+
+`1667 - death`
+__Trinity College, Cambridge__
+
+- Fellow
+
+
+
+## Awards
+
+`2012`
+President, *Royal Society*, London, UK
+
+Associate, *French Academy of Science*, Paris, France
+
+
+
+## Publications
+
+<!-- A list is also available [online](http://scholar.google.co.uk/citations?user=LTOTl0YAAAAJ) -->
+
+### Journals
+
+`1669`
+Newton Sir I, De analysi per æquationes numero terminorum infinitas. 
+
+`1669`
+Lectiones opticæ.
+
+etc. etc. etc.
+
+### Patents
+
+`2012`
+Infinitesimal calculus for solutions to physics problems, [SMBC](http://www.techdirt.com/articles/20121011/09312820678/if-patents-had-been-around-time-newton.shtml) patent 001
+
+
+## Occupation
+
+`1600`
+__Royal Mint__, London
+
+- Warden
+- Minted coins
+
+`1600`
+__Lucasian professor of Mathematics__, Cambridge University
+
+
+
+<!-- ### Footer
+
+Last updated: May 2013 -->
+
+
diff --git a/media/davewhipp-print.css b/docs/media/davewhipp-print.css
similarity index 100%
rename from media/davewhipp-print.css
rename to docs/media/davewhipp-print.css
diff --git a/media/davewhipp-screen.css b/docs/media/davewhipp-screen.css
similarity index 100%
rename from media/davewhipp-screen.css
rename to docs/media/davewhipp-screen.css
diff --git a/media/kjhealy-print.css b/docs/media/kjhealy-print.css
similarity index 100%
rename from media/kjhealy-print.css
rename to docs/media/kjhealy-print.css
diff --git a/media/kjhealy-screen.css b/docs/media/kjhealy-screen.css
similarity index 100%
rename from media/kjhealy-screen.css
rename to docs/media/kjhealy-screen.css
diff --git a/media/pagedown-resume.css b/docs/media/pagedown-resume.css
similarity index 100%
rename from media/pagedown-resume.css
rename to docs/media/pagedown-resume.css

From 5309f4bc1dd6ddc2bbcac77a555b483d7e957e88 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 08:14:19 -0600
Subject: [PATCH 04/20] changed name to resume

---
 docs/_layouts/{cv.html => resume.html} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename docs/_layouts/{cv.html => resume.html} (82%)

diff --git a/docs/_layouts/cv.html b/docs/_layouts/resume.html
similarity index 82%
rename from docs/_layouts/cv.html
rename to docs/_layouts/resume.html
index 991939d51b..803209ee62 100644
--- a/docs/_layouts/cv.html
+++ b/docs/_layouts/resume.html
@@ -2,7 +2,7 @@
 <html>
 <head>
   <meta charset=utf-8 />
-  <title> {% if page.title %} {{ page.title }} | {% endif %} CV</title>
+  <title> {% if page.title %} {{ page.title }} | {% endif %} Resume</title>
   <link href="media/{{ site.style }}-screen.css" type="text/css" rel="stylesheet" media="screen">
   <link href="media/{{ site.style }}-print.css" type="text/css" rel="stylesheet" media="print">
 </head>

From e88707cd68690cee5313fe05ea20df1a4aec7ecd Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 08:15:19 -0600
Subject: [PATCH 05/20] tried the other theme

---
 docs/_config.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_config.yml b/docs/_config.yml
index daba7398ab..1c4d9f3178 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -1,2 +1,2 @@
 markdown:   kramdown
-style:  kjhealy
\ No newline at end of file
+style:  davewhipp
\ No newline at end of file

From 489ab1c95eb4a2e8818cdb28d07ddaf8503923fa Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@byui.edu>
Date: Fri, 7 Aug 2020 08:17:01 -0600
Subject: [PATCH 06/20] back

---
 docs/_config.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_config.yml b/docs/_config.yml
index 1c4d9f3178..c9412b420e 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -1,2 +1,2 @@
 markdown:   kramdown
-style:  davewhipp
\ No newline at end of file
+style:  kjhealy

From 0f2733f89d3cd66dbe18bd6fe1467729df25459b Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@byui.edu>
Date: Fri, 7 Aug 2020 08:20:51 -0600
Subject: [PATCH 07/20] change to resume

---
 docs/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/index.md b/docs/index.md
index aa6c0cb838..c649285e10 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,5 +1,5 @@
 ---
-layout: cv
+layout: resume
 title: Isaac Newtons's CV
 ---
 # Isaac Newton

From 62fdb9546e93cefe7a567dec07b377bf6d41a973 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 08:21:43 -0600
Subject: [PATCH 08/20] added CV format

---
 docs/_layouts/cv.html | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 docs/_layouts/cv.html

diff --git a/docs/_layouts/cv.html b/docs/_layouts/cv.html
new file mode 100644
index 0000000000..991939d51b
--- /dev/null
+++ b/docs/_layouts/cv.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset=utf-8 />
+  <title> {% if page.title %} {{ page.title }} | {% endif %} CV</title>
+  <link href="media/{{ site.style }}-screen.css" type="text/css" rel="stylesheet" media="screen">
+  <link href="media/{{ site.style }}-print.css" type="text/css" rel="stylesheet" media="print">
+</head>
+<body>
+  <div id="main">
+    <div id="content">
+    {{ content }}
+    </div>
+  </div>
+</body>
+</html>
\ No newline at end of file

From a71188c33a86a9436e976a79fc7c3e738ab6838f Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 08:22:56 -0600
Subject: [PATCH 09/20] cv

---
 docs/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/index.md b/docs/index.md
index c649285e10..aa6c0cb838 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,5 +1,5 @@
 ---
-layout: resume
+layout: cv
 title: Isaac Newtons's CV
 ---
 # Isaac Newton

From 411c8846edd1acdc91d36cb9d846f6e97a29ad89 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 08:26:47 -0600
Subject: [PATCH 10/20] changed theme

---
 docs/_config.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_config.yml b/docs/_config.yml
index c9412b420e..823f4de072 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -1,2 +1,2 @@
 markdown:   kramdown
-style:  kjhealy
+style:  davewhipp

From c7aaf9aa02fb34b44dc7282a9c986d971225c297 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 08:34:04 -0600
Subject: [PATCH 11/20] test new style

---
 docs/_config.yml                              |   2 +-
 docs/_layouts/resume.html                     |   2 +-
 ...wn-resume.css => pagedownresume-print.css} |   0
 docs/media/pagedownresume-screen.css          | 434 ++++++++++++++++++
 4 files changed, 436 insertions(+), 2 deletions(-)
 rename docs/media/{pagedown-resume.css => pagedownresume-print.css} (100%)
 create mode 100644 docs/media/pagedownresume-screen.css

diff --git a/docs/_config.yml b/docs/_config.yml
index 823f4de072..0f1d8e1c92 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -1,2 +1,2 @@
 markdown:   kramdown
-style:  davewhipp
+style:  pagedownresume
diff --git a/docs/_layouts/resume.html b/docs/_layouts/resume.html
index 803209ee62..d72786c4eb 100644
--- a/docs/_layouts/resume.html
+++ b/docs/_layouts/resume.html
@@ -2,7 +2,7 @@
 <html>
 <head>
   <meta charset=utf-8 />
-  <title> {% if page.title %} {{ page.title }} | {% endif %} Resume</title>
+  <title> {% if page.title %} {{ page.title }} | {% endif %} RESUME</title>
   <link href="media/{{ site.style }}-screen.css" type="text/css" rel="stylesheet" media="screen">
   <link href="media/{{ site.style }}-print.css" type="text/css" rel="stylesheet" media="print">
 </head>
diff --git a/docs/media/pagedown-resume.css b/docs/media/pagedownresume-print.css
similarity index 100%
rename from docs/media/pagedown-resume.css
rename to docs/media/pagedownresume-print.css
diff --git a/docs/media/pagedownresume-screen.css b/docs/media/pagedownresume-screen.css
new file mode 100644
index 0000000000..659f959ad4
--- /dev/null
+++ b/docs/media/pagedownresume-screen.css
@@ -0,0 +1,434 @@
+@page{
+  size: letter portrait;
+  margin: 1in 0.5in 1in 0.25in;
+}
+
+*{
+  box-sizing: border-box;
+}
+
+:root{
+  --page-width: 8.5in;
+  --margin-right: 0.5in;
+  --margin-left: 0.25in;
+  --content-width: calc(var(--page-width) - var(--margin-right) - var(--margin-left));
+  --root-font-size: 12pt;
+  --sidebar-width: 15rem;
+  --sidebar-background-color: #f2f2f2;
+  --main-width: calc(var(--content-width) - var(--sidebar-width));
+  --decorator-horizontal-margin: 0.2in;
+
+  --sidebar-horizontal-padding: 0.2in;
+
+  /* XXX: using px for very good precision control */
+  --decorator-outer-offset-top: 10px;
+  --decorator-outer-offset-left: -5.5px;
+  --decorator-border-width: 1px;
+  --decorator-outer-dim: 9px;
+  --decorator-border: 1px solid #ccc;
+
+  --row-blocks-padding-top: 0.5rem;
+  --date-block-width: 0.7in;
+
+  --main-blocks-title-icon-offset-left: calc(-17pt - 0.25 * var(--root-font-size));
+
+  --viewer-background-color: #dcdcdc;
+  --viewer-pages-spacing: 12px;
+  --viewer-shadow-color: #313131;
+}
+
+.pagedjs_page {
+  --content-area-height: calc(var(--pagedjs-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
+  --sidebar-background-width: calc(var(--pagedjs-margin-right) + var(--sidebar-width));
+}
+
+@page{
+  background: linear-gradient(to left, var(--sidebar-background-color), var(--sidebar-background-color) var(--sidebar-background-width), white var(--sidebar-background-width));
+}
+
+html {
+  font-size: var(--root-font-size);
+}
+
+body{
+  width: var(--content-width);
+  font-family: "Open Sans", sans-serif;
+  font-weight: 300;
+  line-height: 1.3;
+  color: #444;
+  hyphens: auto;
+}
+
+h1, h2, h3{
+  margin: 0;
+  color: #000;
+}
+
+#main > h1, #aside > h1, #disclaimer > h2 {
+  display: none;
+}
+
+li{
+  list-style-type: none;
+}
+
+a{
+  text-decoration: none;
+}
+
+img{
+  max-width: 100%;
+}
+
+#main{
+  width: var(--main-width);
+  padding: 0 0.25in 0 0.25in;
+  font-size: 0.7rem;
+  float: left;
+}
+
+#aside{
+  position: relative; /* for disclaimer */
+  height: var(--content-area-height);
+}
+
+.aside{
+  width: var(--sidebar-width);
+  padding: 0.6in var(--sidebar-horizontal-padding);
+  font-size: 0.8rem;
+  float: right;
+  position: absolute;
+  right: 0;
+}
+
+/* main */
+
+/** big title **/
+h1, h2{
+  text-transform: uppercase;
+}
+
+#title{
+  position: relative;
+  left: 0.55in;
+  margin: auto 0.55in 0.3in auto;
+  line-height: 1.2;
+}
+
+#title h1{
+  font-weight: 300;
+  font-size: 1.8rem;
+  line-height: 1.5;
+}
+
+#title h3{
+  font-size: 0.8rem;
+}
+
+
+/*** categorial blocks ***/
+
+.main-block{
+  margin-top: 0.1in;
+}
+
+#main h2{
+  position: relative;
+  top: var(--row-blocks-padding-top);
+  /* XXX: 0.5px for aligning fx printing */
+  left: calc((var(--date-block-width) + var(--decorator-horizontal-margin)));
+  font-weight: 400;
+  font-size: 1.1rem;
+  color: #555;
+}
+
+#main h2 > i{
+  /* use absolute position to prevent icon's width from misaligning title */
+  /* assigning a fixed width here is no better due to needing to align decorator
+     line too */
+  position: absolute;
+  left: var(--main-blocks-title-icon-offset-left);
+  z-index: 1; /* over decorator line */
+  color: #444;
+}
+
+#main h2::after{ /* extends the decorator line */
+  height: calc(var(--row-blocks-padding-top) * 2);
+  position: relative;
+  top: calc(-1 * var(--row-blocks-padding-top));
+  /* XXX: 0.5px for aligning fx printing */
+  left: calc(-1 * var(--decorator-horizontal-margin));
+  display: block;
+  border-left: var(--decorator-border);
+  z-index: 0;
+  line-height: 0;
+  font-size: 0;
+  content: ' ';
+}
+
+/**** minor tweaks on the icon fonts ****/
+#main h2 > .fa-graduation-cap{
+  left: calc(var(--main-blocks-title-icon-offset-left) - 2pt);
+  top: 2pt;
+}
+
+#main h2 > .fa-suitcase{
+  top: 1pt;
+}
+
+#main h2 > .fa-folder-open{
+  top: 1.5pt;
+}
+
+/**** individual row blocks (date - decorator - details) ****/
+
+.blocks{
+  display: flex;
+  flex-flow: row nowrap;
+}
+
+.blocks > div{
+  padding-top: var(--row-blocks-padding-top);
+}
+
+.date{
+  flex: 0 0 var(--date-block-width);
+  padding-top: calc(var(--row-blocks-padding-top) + 0.25rem) !important;
+  padding-right: var(--decorator-horizontal-margin);
+  font-size: 0.7rem;
+  text-align: right;
+  line-height: 1;
+  max-width: var(--date-block-width);
+}
+
+.date span{
+  display: block;
+  text-align: center;
+}
+
+.date span:nth-child(2)::before{
+  position: relative;
+  top: 0.1rem;
+  right: 0;
+  display: block;
+  height: 1rem;
+  content: '|';
+}
+
+.decorator{
+  flex: 0 0 0;
+  position: relative;
+  width: 2pt;
+  min-height: 100%;
+  border-left: var(--decorator-border);
+}
+
+/*
+ * XXX: Use two filled circles to achieve the circle-with-white-border effect.
+ * The normal technique of only using one pseudo element and
+ * border: 1px solid white; style makes firefox erroneously either:
+ * 1) overflows the grayshade background (if no background-clip is set), or
+ * 2) shows decorator line which should've been masked by the white border
+ *
+ */
+
+.decorator::before{
+  position: absolute;
+  top: var(--decorator-outer-offset-top);
+  left: var(--decorator-outer-offset-left);
+  content: ' ';
+  display: block;
+  width: var(--decorator-outer-dim);
+  height: var(--decorator-outer-dim);
+  border-radius: calc(var(--decorator-outer-dim) / 2);
+  background-color: #fff;
+}
+
+.decorator::after{
+  position: absolute;
+  top: calc(var(--decorator-outer-offset-top) + var(--decorator-border-width));
+  left: calc(var(--decorator-outer-offset-left) + var(--decorator-border-width));
+  content: ' ';
+  display: block;
+  width: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
+  height: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
+  border-radius: calc((var(--decorator-outer-dim) - (var(--decorator-border-width) * 2)) / 2);
+  background-color: #555;
+}
+
+.blocks:last-child .decorator{ /* slightly shortens it */
+  margin-bottom: 0.25in;
+}
+
+/***** fine-tunes on the details block where the real juice is *****/
+
+.details{
+  flex: 1 0 0;
+  padding-left: var(--decorator-horizontal-margin);
+  padding-top: calc(var(--row-blocks-padding-top) - 0.05rem) !important; /* not sure why but this is needed for better alignment */
+}
+
+.details header{
+  color: #000;
+}
+
+.details h3{
+  font-size: 0.8rem;
+}
+
+.main-block:not(.concise) .details div{
+  margin: 0.18in 0 0.1in 0;
+}
+
+.main-block:not(.concise) .details div:empty {
+  margin: 0;
+}
+
+.main-block:not(.concise) .blocks:last-child .details div{
+  margin-bottom: 0;
+}
+
+.main-block.concise .details div:not(.concise){
+  /* use padding to work around the fact that margin doesn't affect floated
+     neighboring elements */
+  padding: 0.05in 0 0.07in 0;
+}
+
+.details .place{
+  float: left;
+  font-size: 0.75rem;
+}
+
+.details .location{
+  float: right;
+}
+
+.details div{
+  clear: both;
+}
+
+/***** fine-tunes on the lists... *****/
+
+#main ul{
+  padding-left: 0.07in;
+  margin: 0.08in 0;
+}
+
+#main li{
+  margin: 0 0 0.025in 0;
+}
+
+/****** customize list symbol style ******/
+#main li::before{
+  position: relative;
+  margin-left: -4.25pt;
+  content: '• ';
+}
+
+.aside li::before {
+  content: none;
+}
+
+.details .concise ul{
+  margin: 0 !important;
+  -webkit-columns: 2;
+  -moz-columns: 2;
+  columns: 2;
+}
+
+.details .concise li{
+  margin: 0 !important;
+}
+
+.details .concise li{
+  margin-left: 0 !important;
+}
+
+
+
+/* sidebar */
+
+.aside h2{
+  font-weight: 400;
+  font-size: 1.1rem;
+}
+
+.aside .level2{
+  margin-top: 0.5in;
+}
+
+#contact ul{
+  margin-top: 0.05in;
+  padding-left: 0;
+  font-weight: 400;
+  line-height: 1.75;
+}
+
+#contact li > i{
+  width: 0.9rem; /* for text alignment */
+  text-align: right;
+}
+
+#skills{
+  line-height: 1.5;
+}
+
+#skills ul{
+  margin: 0.05in 0 0.15in;
+  padding: 0;
+}
+
+#disclaimer{
+  position: absolute;
+  bottom: 0;
+  right: var(--sidebar-horizontal-padding);
+  font-size: 0.75rem;
+  font-style: italic;
+  line-height: 1.1;
+  text-align: right;
+  color: #777;
+}
+
+#disclaimer code{
+  color: #666;
+  font-family: "Source Code Pro";
+  font-weight: 400;
+  font-style: normal;
+}
+
+/* Page breaks */
+
+h2 {
+  break-after: avoid;
+}
+
+.blocks {
+  break-inside: avoid;
+}
+
+/* Paged.js viewer */
+
+@media screen {
+  body {
+    background-color: var(--viewer-background-color);
+    margin: 0; /* for mobile */
+    width: calc(var(--pagedjs-width) + 2 * var(--viewer-pages-spacing)); /* for mobile */
+  }
+   .pagedjs_pages {
+    max-width: var(--pagedjs-width);
+    margin: 0 auto;
+    display: flex;
+    flex-direction: column;
+  }
+   .pagedjs_page {
+    box-shadow: 0 0 calc(0.66667 * var(--viewer-pages-spacing)) var(--viewer-shadow-color);
+    margin: var(--viewer-pages-spacing) 0;
+  }
+}
+ @media screen and (min-width: 8.5in) {
+  /* not a mobile */
+  body {
+    margin: auto;
+    width: unset;
+  }
+}

From 2a01bf84b874d91312e175b6843bb86140401146 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 09:04:16 -0600
Subject: [PATCH 12/20] testing pagedown stuff

---
 .DS_Store               |   Bin 6148 -> 6148 bytes
 .gitignore              |     5 +-
 docs/.DS_Store          |   Bin 6148 -> 8196 bytes
 docs/html/resume.html   |   144 +
 docs/js/chrome_print.js |    68 +
 docs/js/config.js       |    81 +
 docs/js/hooks.js        |   510 +
 docs/js/paged-latest.js |    23 +
 docs/js/paged.js        | 27610 ++++++++++++++++++++++++++++++++++++++
 docs/lua/footnotes.lua  |    27 +
 docs/lua/jss.lua        |    99 +
 docs/lua/loft.lua       |   121 +
 docs/lua/uri-to-fn.lua  |    59 +
 index.md                |    10 +-
 14 files changed, 28751 insertions(+), 6 deletions(-)
 create mode 100644 docs/html/resume.html
 create mode 100644 docs/js/chrome_print.js
 create mode 100644 docs/js/config.js
 create mode 100644 docs/js/hooks.js
 create mode 100644 docs/js/paged-latest.js
 create mode 100644 docs/js/paged.js
 create mode 100644 docs/lua/footnotes.lua
 create mode 100644 docs/lua/jss.lua
 create mode 100644 docs/lua/loft.lua
 create mode 100644 docs/lua/uri-to-fn.lua

diff --git a/.DS_Store b/.DS_Store
index f411205a9a9841e8c19799adf40055296ebc8344..9e1fa1373a6b10c432317f6004fb78a753f18349 100644
GIT binary patch
delta 339
zcmZoMXfc@JFUZBfz`)4BAi$85ZWx@LpIfk5ka;y@JxG{^L60GwA(Np5CIu8@U^t_`
z0a-3L-^C><CqD@&#_?dk+Piakha6GmQ}D_cWI(J1>S18GasfoLFr)}E<TE5Q6epDz
z7eEa^F<FJFflIu)+So)#!PvlZ@_Hs&#u<~(GRfD^gy?~2L2)a?Du_Q)AaclV4O{!S
i;VjIpaCwAVvB{&jl~Dm`Ey%5#KQpPaY-Z>9%MSpR>sBWK

delta 149
zcmZoMXfc@JFUrKgz`)4BAi$7RUR;orlb;0SpWK+ZoN=;&2#Y8SLkdGaLo!1#vh3tJ
zObwnA)zv1ZraB5Hre?J|3f1Q320*s4S#2#Rhq$Vtt!F}RWmR=eZQV?uc|gDjv;z$I
Xp)`z|wfPRSHp|3<_nX-{{_+C=!}%iK

diff --git a/.gitignore b/.gitignore
index 2b8ee31c0d..8d3a04857d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,5 @@
 _site/
-.sass-cache/
\ No newline at end of file
+.sass-cache/
+.DS_Store
+*.DS_Store
+.DS_Store?
diff --git a/docs/.DS_Store b/docs/.DS_Store
index 5e793e66dadc72110e2fd64147bf2a75cc26c898..5d00259ba084c8c9251ab46407959bbb97812882 100644
GIT binary patch
literal 8196
zcmeHMzmF0@6n+DoE)e4tmmG-}n;5MqAi!NLG%I3ZXR<~MHQcUC0JH26SS06)+5bTc
zwX!wVCN?%!XQ8pPv-dBsF~&DP+}nl4Tw<aGXOfvW%=g~Ryzjy6z5xJ8bK+D1N&ui?
zWpcBKO-f-ns|zI~M^2+8Xb(VP0zQoG>3F!Htp*eWiUGxdVn8vV7+3`c@R`kuw&b}l
zP}M316a)Vy1MGazu`+2$84Agd4s3V|fHH@}ykH;m0B)m8X-F9g$xU%ikv$M;N@R*b
zggN3mQ%7k?844-Pfe3RTa%Cbj6v9_WJDsZoF@#jDVn8vl$N<aTHE4qi7VO9KciW{l
zV(;yt+aLRt%4d?v<~EKU*R+CGI8nG`_UP2~Eq^j@TBBR+(>2TQ*|L9~Qa9>b_KkjL
z+TPr{Og-P~dz}$C?mHb+xqY+mIds~j6VDm*c}xLlT3*YyH%mcKZ#2q!y|FVZ>%s1B
z1^cy~*(|SZpRHcFx;NN=5ImecdM11$@_c}kbG|-LbJXot&AW6UFDp(tX*vViYDqG*
zGjG3K{NTO2l&<F-NpIMTuW8^^ivhTAjy#uoUBs9_Iq2cF$^cw;u_E_!@UH{29R#&{
zS+7;j|28g9nS<!YvbeCgMgAq@@#G+m#p3`FKK|O}afoaO^pO8FJjwefwyDT=j_(ZI
z6PH+P$TjyZ!E^D|7IMMImvAhxRDL;@;I_!Q<>Pa_X7QMrfR$Js&b`6aC9-7w2u<CA
zL=$@uZw(vxo9Tc9eX!Q_mlN|a$?EVWvKm9<%zppz?e#}-iX}7-*-h6-GW-G;h_5gg
zYlf<_(hOw9?n*5Gzq0)Pf2Dm;n^O!Z2L6lzl53f*CeHEe9c_L(mTT)+_pq|U^g<!I
t2{ufHjq`LIW%P$3_H~IFQiehzg5~dD1gz7WbL{!8p8x#&q?)5K@Dl(&3mpIe

delta 130
zcmZp1XfcprU|?W$DortDU=RQ@Ie-{MGjUEV6q~50$jG!YU^nAr0~wadE`oxS6$D=L
zlm!>%<>cq3gEVd|{KT@Dor6P=8OQ?y0d64S3evu@@H_Klei=uQ`3#H<3@jj;31R_Q
KY;!!%9A*GIAr>D1

diff --git a/docs/html/resume.html b/docs/html/resume.html
new file mode 100644
index 0000000000..dec8192053
--- /dev/null
+++ b/docs/html/resume.html
@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta name="generator" content="pandoc" />
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    $for(author-meta)$<meta name="author" content="$author-meta$" />$endfor$
+    $if(date-meta)$<meta name="date" content="$date-meta$" />$endif$
+    <title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
+
+    $if(math)$
+    $if(mathjax)$
+    <!-- dynamically load mathjax for compatibility with self-contained -->
+    <script>
+    (function() {
+      // Retrieve previous config object if defined
+      window.PagedConfig = window.PagedConfig || {};
+      let beforePaged = PagedConfig.before;
+      window.PagedConfig.before = async () => {
+        if (beforePaged) await beforePaged();
+        return new Promise((resolve, reject) => {
+          var script = document.createElement("script");
+          script.type = "text/javascript";
+          var src = `$mathjaxurl$` + "?config=TeX-MML-AM_CHTML";
+          if (location.protocol !== "file:" && /^https?:/.test(src))
+            src = src.replace(/^https?:/, '');
+          script.src = src;
+          window.MathJax = {
+            AuthorInit: () => {
+              MathJax.Hub.Register.StartupHook("Begin", () => {
+                MathJax.Hub.Queue(resolve);
+              });
+            }
+          };
+          document.getElementsByTagName("head")[0].appendChild(script);
+        });
+      };
+    })();
+    </script>
+    $endif$
+    $endif$
+
+    $for(header-includes)$
+    $header-includes$
+    $endfor$
+
+    $for(css)$
+    <link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
+    $endfor$
+
+  </head>
+  <body>
+$for(include-before)$
+$include-before$
+$endfor$
+
+$body$
+
+<script>
+(function() {
+  var i, s, j, el, els;
+  var create_el = function(type, className, content, isHTML) {
+    var el = document.createElement(type);
+    if (className) el.className = className;
+    if (content) {
+      if (isHTML) {el.innerHTML = content;} else {el.innerText = content;}
+    }
+    return el;
+  }
+
+  // replace h2 title with h1
+  var title = document.getElementById('title').querySelector('h2');
+  title.parentNode.replaceChild(create_el('h1', false, title.innerHTML, true), title);
+
+  // add the class .aside to #aside
+  el = document.getElementById('aside');
+  if (el) el.className += ' aside';
+
+  // tweak class names of sections, and add icons
+  els = document.getElementById('main').querySelectorAll('.level2');
+  for (i = 0; i < els.length; i++) {
+    el = els[i];
+    if (i === 0 && el.id === 'title') continue;
+    el.className += ' main-block';
+    if (el.dataset['concise']) el.className += ' concise';
+    // if there is no icon, add an icon:
+    if (el.firstElementChild.firstChild && el.firstElementChild.firstChild.nodeName !== 'I') {
+      s = el.dataset['icon'] || 'bookmark';
+      el.firstElementChild.insertBefore(create_el('i', 'fa fa-' + s), el.firstElementChild.firstChild);
+    }
+  }
+
+  // tweak class names of blocks in sections
+  els = document.getElementById('main').querySelectorAll('.level3');
+  for (i = 0; i < els.length; i++) {
+    el = els[i];
+    if (el.parentNode.id === 'title') continue;
+    el.className += ' blocks';
+    el.innerHTML = '<div class="date"></div>' + '<div class="decorator"></div>' +
+      '<div class="details"><header></header><div></div></div>' + el.innerHTML;
+    var ps = el.querySelectorAll('p');
+    // move the date paragraph to the date div
+    if (ps.length >= 3) {
+      s = ps[2].innerText;
+      s = s === 'N/A' ? [] : s.split(' - ');
+      el.removeChild(ps[2]);
+      for (j = 0; j < s.length && j < 2; j++) {
+        el.children[0].appendChild(create_el('span', false, s[j]))
+      }
+    }
+    // move title, description, location to the details div
+    (function(h) {
+      h.appendChild(el.children[3]);
+      var p = el.children[3];  // description
+      if (p.innerText !== 'N/A') {
+        h.appendChild(create_el('span', 'place', p.innerHTML, true));
+      }
+      el.removeChild(p);
+      p = el.children[3];  // location
+      if (p.innerText !== 'N/A') {
+        s = create_el('span', 'location', p.innerHTML, true);
+        s.innerHTML = '<i class="fa fa-map-marker-alt"></i> ' + s.innerHTML;
+        h.appendChild(s);
+      }
+      el.removeChild(p);
+    })(el.children[2].firstElementChild);
+    // move the rest of content in a block into the last div of the details div
+    s = el.children[2];
+    while (j = s.nextSibling) {
+      if (j.className === 'aside') { s = j; continue; }
+      el.children[2].lastElementChild.append(j);
+    }
+  }
+})();
+</script>
+
+$for(include-after)$
+$include-after$
+$endfor$
+
+  </body>
+</html>
diff --git a/docs/js/chrome_print.js b/docs/js/chrome_print.js
new file mode 100644
index 0000000000..581687b80e
--- /dev/null
+++ b/docs/js/chrome_print.js
@@ -0,0 +1,68 @@
+{
+  let RevealReady = new Promise((resolve) => {
+    window.addEventListener(
+      'DOMContentLoaded',
+      () => {
+        if (window.Reveal) {
+          if (!window.location.search.match( /print-pdf/gi )) {
+            window.location.search = 'print-pdf';
+            return;
+          }
+          Reveal.addEventListener('ready', resolve);
+          if (Reveal.isReady()) resolve();
+        } else {
+          resolve();
+        }
+      },
+      {capture: true, once: true}
+    );
+  });
+
+  let HTMLWidgetsReady = new Promise((resolve) => {
+    window.addEventListener(
+      'DOMContentLoaded',
+      () => {
+        if (window.HTMLWidgets) {
+          HTMLWidgets.addPostRenderHandler(resolve);
+        } else {
+          resolve();
+        }
+      },
+      {capture: true, once: true}
+    );
+  });
+
+  let MathJaxReady = new Promise((resolve) => {
+    window.addEventListener(
+      'load',
+      () => {
+        if (window.MathJax) {
+          if (window.MathJax.Hub) {
+           window.MathJax.Hub.Register.StartupHook('Begin', () => {
+              window.MathJax.Hub.Queue(resolve);
+            });
+          } else {
+            let previousAuthorInit = window.MathJax.AuthorInit || function () {};
+            window.MathJax.AuthorInit = function() {
+              previousAuthorInit();
+              MathJax.Hub.Register.StartupHook('Begin', () => {
+                MathJax.Hub.Queue(resolve);
+              });
+            };
+          }
+        }
+        else {
+          resolve();
+        }
+      },
+      {capture: true, once: true}
+    );
+  });
+
+  window.pagedownReady = Promise.all([
+    RevealReady,
+    MathJaxReady,
+    HTMLWidgetsReady,
+    document.fonts.ready
+  ]);
+}
diff --git a/docs/js/config.js b/docs/js/config.js
new file mode 100644
index 0000000000..e926a7fdae
--- /dev/null
+++ b/docs/js/config.js
@@ -0,0 +1,81 @@
+// Configuration script for paged.js
+
+(function() {
+  // Retrieve previous config object if defined
+  window.PagedConfig = window.PagedConfig || {};
+  const {before: beforePaged, after: afterPaged} = window.PagedConfig;
+
+  // utils
+  const insertCSS = text => {
+    let style = document.createElement('style');
+		style.type = 'text/css';
+		style.appendChild(document.createTextNode(text));
+    document.head.appendChild(style);
+  };
+
+  // Util function for front and back covers images
+  const insertCSSForCover = type => {
+    const links = document.querySelectorAll('link[id^=' + type + ']');
+    if (!links.length) return;
+    const re = new RegExp(type + '-\\d+');
+    let text = ':root {--' + type + ': var(--' + type + '-1);';
+    for (const link of links) {
+      text += '--' + re.exec(link.id)[0] + ': url("' + link.href + '");';
+    }
+    text += '}';
+    insertCSS(text);
+  };
+
+  const insertPageBreaksCSS = () => {
+    insertCSS(`
+    .page-break-after {break-after: page;}
+    .page-break-before {break-before: page;}
+    `);
+  };
+
+  window.PagedConfig.before = async () => {
+    // Front and back covers support
+    let frontCover = document.querySelector('.front-cover');
+    let backCover = document.querySelector('.back-cover');
+    if (frontCover) document.body.prepend(frontCover);
+    if (backCover) document.body.append(backCover);
+    insertCSSForCover('front-cover');
+    insertCSSForCover('back-cover');
+    insertPageBreaksCSS();
+
+    if (beforePaged) await beforePaged();
+  };
+
+  window.PagedConfig.after = (flow) => {
+    // force redraw, see https://github.com/rstudio/pagedown/issues/35#issuecomment-475905361
+    // and https://stackoverflow.com/a/24753578/6500804
+    document.body.style.display = 'none';
+    document.body.offsetHeight;
+    document.body.style.display = '';
+
+    // run previous PagedConfig.after function if defined
+    if (afterPaged) afterPaged(flow);
+
+    // pagedownListener is a binding added by the chrome_print function
+    // this binding exists only when chrome_print opens the html file
+    if (window.pagedownListener) {
+      // the html file is opened for printing
+      // call the binding to signal to the R session that Paged.js has finished
+      pagedownListener(JSON.stringify({
+        pagedjs: true,
+        pages: flow.total,
+        elapsedtime: flow.performance
+      }));
+      return;
+    }
+    if (sessionStorage.getItem('pagedown-scroll')) {
+      // scroll to the last position before the page is reloaded
+      window.scrollTo(0, sessionStorage.getItem('pagedown-scroll'));
+      return;
+    }
+    if (window.location.hash) {
+      const id = window.location.hash.replace(/^#/, '');
+      document.getElementById(id).scrollIntoView({behavior: 'smooth'});
+    }
+  };
+})();
diff --git a/docs/js/hooks.js b/docs/js/hooks.js
new file mode 100644
index 0000000000..76f00f0549
--- /dev/null
+++ b/docs/js/hooks.js
@@ -0,0 +1,510 @@
+// Hooks for paged.js
+{
+  // Utils
+  let pandocMeta, pandocMetaToString;
+  {
+    let el = document.getElementById('pandoc-meta');
+    pandocMeta = el ? JSON.parse(el.firstChild.data) : {};
+  }
+
+  pandocMetaToString = meta => {
+    let el = document.createElement('div');
+    el.innerHTML = meta;
+    return el.innerText;
+  };
+
+  let isString = value => {
+    return typeof value === 'string' || value instanceof String;
+  };
+
+  let isArray = value => {
+    return value && typeof value === 'object' && value.constructor === Array;
+  };
+
+  // This hook is an attempt to fix https://github.com/rstudio/pagedown/issues/131
+  // Sometimes, the {break-after: avoid;} declaration applied on headers
+  // lead to duplicated headers. I hate this bug.
+  // This is linked to the way the HTML source is written
+  // When we have the \n character like this: <div>\n<h1>...</h1>
+  // the header may be duplicated.
+  // But, if we have <div><h1>...</h1> without any \n, the problem disappear
+  // I think this handler can fix most of cases
+  // Obviously, we cannot suppress all the \n in the HTML document
+  // because carriage returns are important in <pre> elements.
+  // Tested with Chrome 76.0.3809.100/Windows
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+      this.carriageReturn = String.fromCharCode(10);
+    }
+
+    checkNode(node) {
+      if (!node) return;
+      if (node.nodeType !== 3) return;
+      if (node.textContent === this.carriageReturn) {
+        node.remove();
+      }
+    }
+
+    afterParsed(parsed) {
+      let template = document.querySelector('template').content;
+      const breakAfterAvoidElements = template.querySelectorAll('[data-break-after="avoid"], [data-break-before="avoid"]');
+      for (let el of breakAfterAvoidElements) {
+        this.checkNode(el.previousSibling);
+        this.checkNode(el.nextSibling);
+      }
+    }
+  });
+
+  // This hook creates a list of abbreviations
+  // Note: we also could implement this feature using a Pandoc filter
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+    }
+    beforeParsed(content) {
+      const abbreviations = content.querySelectorAll('abbr');
+      if(abbreviations.length === 0) return;
+      const loaTitle = 'List of Abbreviations';
+      const loaId = 'LOA';
+      const tocList = content.querySelector('.toc ul');
+      let listOfAbbreviations = document.createElement('div');
+      let descriptionList = document.createElement('dl');
+      content.appendChild(listOfAbbreviations);
+      listOfAbbreviations.id = loaId;
+      listOfAbbreviations.classList.add('section', 'front-matter', 'level1', 'loa');
+      listOfAbbreviations.innerHTML = '<h1>' + loaTitle + '</h1>';
+      listOfAbbreviations.appendChild(descriptionList);
+      for(let abbr of abbreviations) {
+        if(!abbr.title) continue;
+        let term = document.createElement('dt');
+        let definition = document.createElement('dd');
+        descriptionList.appendChild(term);
+        descriptionList.appendChild(definition);
+        term.innerHTML = abbr.innerHTML;
+        definition.innerText = abbr.title;
+      }
+      if (tocList) {
+        const loaTOCItem = document.createElement('li');
+        loaTOCItem.innerHTML = '<a href="#' + loaId + '">' + loaTitle + '</a>';
+        tocList.appendChild(loaTOCItem);
+      }
+    }
+  });
+
+  // This hook moves the sections of class front-matter in the div.front-matter-container
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+    }
+
+    beforeParsed(content) {
+      const frontMatter = content.querySelector('.front-matter-container');
+      if (!frontMatter) return;
+
+      // move front matter sections in the front matter container
+      const frontMatterSections = content.querySelectorAll('.level1.front-matter');
+      for (const section of frontMatterSections) {
+        frontMatter.appendChild(section);
+      }
+
+      // add the class front-matter-ref to any <a></a> element
+      // referring to an entry in the front matter
+      const anchors = content.querySelectorAll('a[href^="#"]:not([href*=":"])');
+      for (const a of anchors) {
+        const ref = a.getAttribute('href').replace(/^#/, '');
+        const element = content.getElementById(ref);
+        if (frontMatter.contains(element)) a.classList.add('front-matter-ref');
+      }
+
+      // update the toc, lof and lot for front matter sections
+      const frontMatterSectionsLinks = content.querySelectorAll('.toc .front-matter-ref, .lof .front-matter-ref, .lot .front-matter-ref');
+      for (let i = frontMatterSectionsLinks.length - 1; i >= 0; i--) {
+        const listItem = frontMatterSectionsLinks[i].parentNode;
+        const list = listItem.parentNode;
+        list.insertBefore(listItem, list.firstChild);
+      }
+    }
+  });
+
+  // This hook expands the links in the lists of figures and tables
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+    }
+
+    beforeParsed(content) {
+      const items = content.querySelectorAll('.lof li, .lot li');
+      for (const item of items) {
+        const anchor = item.firstChild;
+        anchor.innerText = item.innerText;
+        item.innerText = '';
+        item.append(anchor);
+      }
+    }
+  });
+
+  // This hook adds spans for leading symbols
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+    }
+
+    beforeParsed(content) {
+      const anchors = content.querySelectorAll('.toc a, .lof a, .lot a');
+      for (const a of anchors) {
+        a.innerHTML = a.innerHTML + '<span class="leaders"></span>';
+      }
+    }
+  });
+
+  // This hook appends short titles spans
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+    }
+
+    beforeParsed(content) {
+    /* A factory returning a function that appends short titles spans.
+       The text content of these spans are reused for running titles (see default.css).
+       Argument: level - An integer between 1 and 6.
+    */
+    function appendShortTitleSpans(level) {
+      return () => {
+        const divs = Array.from(content.querySelectorAll('.level' + level));
+
+        function addSpan(div) {
+          const mainHeader = div.getElementsByTagName('h' + level)[0];
+          if (!mainHeader) return;
+          const mainTitle = mainHeader.textContent;
+          const spanSectionNumber = mainHeader.getElementsByClassName('header-section-number')[0];
+          const mainNumber = !!spanSectionNumber ? spanSectionNumber.textContent : '';
+          const runningTitle = 'shortTitle' in div.dataset ? mainNumber + ' ' + div.dataset.shortTitle : mainTitle;
+          const span = document.createElement('span');
+          span.className = 'shorttitle' + level;
+          span.innerText = runningTitle;
+          span.style.display = "none";
+          mainHeader.appendChild(span);
+          if (level == 1 && div.querySelector('.level2') === null) {
+            let span2 = document.createElement('span');
+            span2.className = 'shorttitle2';
+            span2.innerText = ' ';
+            span2.style.display = "none";
+            span.insertAdjacentElement('afterend', span2);
+          }
+        }
+
+        for (const div of divs) {
+          addSpan(div);
+        }
+      };
+    }
+
+    appendShortTitleSpans(1)();
+    appendShortTitleSpans(2)();
+    }
+  });
+
+  // Footnotes support
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+
+      this.splittedParagraphRefs = [];
+    }
+
+    beforeParsed(content) {
+      // remove footnotes in toc, lof, lot
+      // see https://github.com/rstudio/pagedown/issues/54
+      let removeThese = content.querySelectorAll('.toc .footnote, .lof .footnote, .lot .footnote');
+      for (const el of removeThese) {
+        el.remove();
+      }
+
+      let footnotes = content.querySelectorAll('.footnote');
+
+      for (let footnote of footnotes) {
+        let parentElement = footnote.parentElement;
+        let footnoteCall = document.createElement('a');
+        let footnoteNumber = footnote.dataset.pagedownFootnoteNumber;
+
+        footnoteCall.className = 'footnote-ref'; // same class as Pandoc
+        footnoteCall.setAttribute('id', 'fnref' + footnoteNumber); // same notation as Pandoc
+        footnoteCall.setAttribute('href', '#' + footnote.id);
+        footnoteCall.innerHTML = '<sup>' + footnoteNumber +'</sup>';
+        parentElement.insertBefore(footnoteCall, footnote);
+
+        // Here comes a hack. Fortunately, it works with Chrome and FF.
+        let handler = document.createElement('p');
+        handler.className = 'footnoteHandler';
+        parentElement.insertBefore(handler, footnote);
+        handler.appendChild(footnote);
+        handler.style.display = 'inline-block';
+        handler.style.width = '100%';
+        handler.style.float = 'right';
+        handler.style.pageBreakInside = 'avoid';
+      }
+    }
+
+    afterPageLayout(pageFragment, page, breakToken) {
+      function hasItemParent(node) {
+        if (node.parentElement === null) {
+          return false;
+        } else {
+          if (node.parentElement.tagName === 'LI') {
+            return true;
+          } else {
+            return hasItemParent(node.parentElement);
+          }
+        }
+      }
+      // If a li item is broken, we store the reference of the p child element
+      // see https://github.com/rstudio/pagedown/issues/23#issue-376548000
+      if (breakToken !== undefined) {
+        if (breakToken.node.nodeName === "#text" && hasItemParent(breakToken.node)) {
+          this.splittedParagraphRefs.push(breakToken.node.parentElement.dataset.ref);
+        }
+      }
+    }
+
+    afterRendered(pages) {
+      for (let page of pages) {
+        const footnotes = page.element.querySelectorAll('.footnote');
+        if (footnotes.length === 0) {
+          continue;
+        }
+
+        const pageContent = page.element.querySelector('.pagedjs_page_content');
+        let hr = document.createElement('hr');
+        let footnoteArea = document.createElement('div');
+
+        pageContent.style.display = 'flex';
+        pageContent.style.flexDirection = 'column';
+
+        hr.className = 'footnote-break';
+        hr.style.marginTop = 'auto';
+        hr.style.marginBottom = 0;
+        hr.style.marginLeft = 0;
+        hr.style.marginRight = 'auto';
+        pageContent.appendChild(hr);
+
+        footnoteArea.className = 'footnote-area';
+        pageContent.appendChild(footnoteArea);
+
+        for (let footnote of footnotes) {
+          let handler = footnote.parentElement;
+
+          footnoteArea.appendChild(footnote);
+          handler.parentNode.removeChild(handler);
+
+          footnote.innerHTML = '<sup>' + footnote.dataset.pagedownFootnoteNumber + '</sup>' + footnote.innerHTML;
+          footnote.style.fontSize = 'x-small';
+          footnote.style.marginTop = 0;
+          footnote.style.marginBottom = 0;
+          footnote.style.paddingTop = 0;
+          footnote.style.paddingBottom = 0;
+          footnote.style.display = 'block';
+        }
+      }
+
+      for (let ref of this.splittedParagraphRefs) {
+        let paragraphFirstPage = document.querySelector('[data-split-to="' + ref + '"]');
+        // We test whether the paragraph is empty
+        // see https://github.com/rstudio/pagedown/issues/23#issue-376548000
+        if (paragraphFirstPage.innerText === "") {
+          paragraphFirstPage.parentElement.style.display = "none";
+          let paragraphSecondPage = document.querySelector('[data-split-from="' + ref + '"]');
+          paragraphSecondPage.parentElement.style.setProperty('list-style', 'inherit', 'important');
+        }
+      }
+    }
+  });
+
+  // Support for "Chapter " label on section with class `.chapter`
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+
+      this.options = pandocMeta['chapter_name'];
+
+      let styles;
+      if (isString(this.options)) {
+        this.options = pandocMetaToString(this.options);
+        styles = `
+        :root {
+          --chapter-name-before: "${this.options}";
+        }
+        `;
+      }
+      if (isArray(this.options)) {
+        this.options = this.options.map(pandocMetaToString);
+        styles = `
+        :root {
+          --chapter-name-before: "${this.options[0]}";
+          --chapter-name-after: "${this.options[1]}";
+        }
+        `;
+      }
+      if (styles) polisher.insert(styles);
+    }
+
+    beforeParsed(content) {
+      const tocAnchors = content.querySelectorAll('.toc a[href^="#"]:not([href*=":"]');
+      for (const anchor of tocAnchors) {
+        const ref = anchor.getAttribute('href').replace(/^#/, '');
+        const element = content.getElementById(ref);
+        if (element.classList.contains('chapter')) {
+          anchor.classList.add('chapter-ref');
+        }
+      }
+    }
+  });
+
+  // Main text line numbering,
+  // see https://github.com/rstudio/pagedown/issues/115
+  // Original idea: Julien Taquet, thanks!
+  Paged.registerHandlers(class extends Paged.Handler {
+    constructor(chunker, polisher, caller) {
+      super(chunker, polisher, caller);
+
+      // get the number-lines option from Pandoc metavariables
+      this.options = pandocMeta['number-lines'];
+      // quit early if the "number-lines" option is false or missing
+      if (!this.options) return;
+      // retrieve the selector if provided, otherwise use the default selector
+      this.selector = this.options.selector ? pandocMetaToString(this.options.selector) : '.level1:not(.front-matter) h1, .level1 h2, .level1 h3, .level1 p';
+
+      const styles = `
+      :root {
+        --line-numbers-padding-right: 10px;
+        --line-numbers-font-size: 8pt;
+      }
+      .pagedown-linenumbers-container {
+        position: absolute;
+        margin-top: var(--pagedjs-margin-top);
+        right: calc(var(--pagedjs-width) - var(--pagedjs-margin-left));
+      }
+      .maintextlinenumbers {
+        position: absolute;
+        right: 0;
+        text-align: right;
+        padding-right: var(--line-numbers-padding-right);
+        font-size: var(--line-numbers-font-size);
+      }
+      `;
+      polisher.insert(styles);
+
+      this.resetLinesCounter();
+    }
+
+    appendLineNumbersContainer(page) {
+      const pagebox = page.element.querySelector('.pagedjs_pagebox');
+      const lineNumbersContainer = document.createElement('div');
+      lineNumbersContainer.classList.add('pagedown-linenumbers-container');
+
+      return pagebox.appendChild(lineNumbersContainer);
+    }
+
+    lineHeight(element) {
+      // If the document stylesheet does not define a value for line-height,
+      // Blink returns "normal". Therefore, parseInt may return NaN.
+      return parseInt(getComputedStyle(element).lineHeight);
+    }
+
+    innerHeight(element) {
+      let outerHeight = element.getBoundingClientRect().height;
+      let {borderTopWidth,
+           borderBottomWidth,
+           paddingTop,
+           paddingBottom} = getComputedStyle(element);
+
+      borderTopWidth = parseFloat(borderTopWidth);
+      borderBottomWidth = parseFloat(borderBottomWidth);
+      paddingTop = parseFloat(paddingTop);
+      paddingBottom = parseFloat(paddingBottom);
+
+      return Math.round(outerHeight - borderTopWidth - borderBottomWidth - paddingTop - paddingBottom);
+    }
+
+    arrayOfInt(from, length) {
+      // adapted from https://stackoverflow.com/a/50234108/6500804
+      return Array.from(Array(length).keys(), n => n + from);
+    }
+
+    incrementLinesCounter(value) {
+      this.linesCounter = this.linesCounter + value;
+    }
+
+    resetLinesCounter() {
+      this.linesCounter = 0;
+    }
+
+    isDisplayMath(element) {
+      const nodes = element.childNodes;
+      if (nodes.length != 1) return false;
+      return (nodes[0].nodeName === 'SPAN') && (nodes[0].classList.value === 'math display');
+    }
+
+    afterRendered(pages) {
+      if (!this.options) return;
+
+      for (let page of pages) {
+        const lineNumbersContainer = this.appendLineNumbersContainer(page);
+        const pageAreaY = page.area.getBoundingClientRect().y;
+        let elementsToNumber = page.area.querySelectorAll(this.selector);
+
+        for (let element of elementsToNumber) {
+          // Do not add line numbers for display math environment
+          if (this.isDisplayMath(element)) continue;
+
+          // Try to retrieve line height
+          const lineHeight = this.lineHeight(element);
+          // Test against lineHeight method returns NaN
+          if (!lineHeight) {
+            console.warn('Failed to compute line height value on "' + page.id + '".');
+            continue;
+          }
+
+          const innerHeight = this.innerHeight(element);
+
+          // Number of lines estimation
+          // There is no built-in method to detect the number of lines in a block.
+          // The main caveat is that an actual line height can differ from
+          // the line-height CSS property.
+          // Mixed fonts, subscripts, superscripts, inline math... can increase
+          // the actual line height.
+          // Here, we divide the inner height of the block by the line-height
+          // computed property and round to the floor to take into account that
+          // sometimes the actual line height is greater than its property value.
+          // This is far from perfect and can be easily broken especially by
+          // inline math.
+          const nLines = Math.floor(innerHeight / lineHeight);
+
+          // do not add line numbers for void paragraphs
+          if (nLines <= 0) continue;
+
+          const linenumbers = document.createElement('div');
+          lineNumbersContainer.appendChild(linenumbers);
+          linenumbers.classList.add('maintextlinenumbers');
+
+          const elementY = element.getBoundingClientRect().y;
+          linenumbers.style.top = (elementY - pageAreaY) + 'px';
+
+          const cs = getComputedStyle(element);
+          const paddingTop = parseFloat(cs.paddingTop) + parseFloat(cs.borderTopWidth);
+          linenumbers.style.paddingTop = paddingTop + 'px';
+
+          linenumbers.style.lineHeight = cs.lineHeight;
+
+          linenumbers.innerHTML = this.arrayOfInt(this.linesCounter + 1, nLines)
+                                      .reduce((t, v) => t + '<br />' + v);
+          this.incrementLinesCounter(nLines);
+        }
+
+        if (this.options['reset-page']) {
+          this.resetLinesCounter();
+        }
+      }
+    }
+  });
+}
diff --git a/docs/js/paged-latest.js b/docs/js/paged-latest.js
new file mode 100644
index 0000000000..731af820c0
--- /dev/null
+++ b/docs/js/paged-latest.js
@@ -0,0 +1,23 @@
+{
+  config = window.PagedConfig || {};
+  window.PagedConfig = {auto: false};
+
+  let pagedjs = document.createElement('script');
+  pagedjs.src = 'https://unpkg.com/pagedjs/dist/paged.polyfill.js';
+  let pagedjsLoaded = new Promise(_ => pagedjs.onload = _);
+
+  let hooks = document.createElement('script');
+  hooks.src = document.head
+                      .querySelector('script[src*="config.js"]')
+                      .src
+                      .replace('config', 'hooks');
+  let hooksLoaded = new Promise(_ => hooks.onload = _);
+
+  document.head.appendChild(pagedjs);
+  pagedjsLoaded.then(() => document.head.appendChild(hooks));
+  hooksLoaded.then(async () => {
+    if (config.before) await config.before();
+    await PagedPolyfill.preview();
+    if (config.after) config.after();
+  });
+}
diff --git a/docs/js/paged.js b/docs/js/paged.js
new file mode 100644
index 0000000000..b013e14d52
--- /dev/null
+++ b/docs/js/paged.js
@@ -0,0 +1,27610 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	global.PagedPolyfill = factory();
+}(typeof self !== 'undefined' ? self : this, function () { 'use strict';
+
+	function createCommonjsModule(fn, module) {
+		return module = { exports: {} }, fn(module, module.exports), module.exports;
+	}
+
+	function getCjsExportFromNamespace (n) {
+		return n && n.default || n;
+	}
+
+	var isImplemented = function () {
+		var assign = Object.assign, obj;
+		if (typeof assign !== "function") return false;
+		obj = { foo: "raz" };
+		assign(obj, { bar: "dwa" }, { trzy: "trzy" });
+		return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy";
+	};
+
+	var isImplemented$1 = function () {
+		try {
+			return true;
+		} catch (e) {
+	 return false;
+	}
+	};
+
+	// eslint-disable-next-line no-empty-function
+	var noop = function () {};
+
+	var _undefined = noop(); // Support ES3 engines
+
+	var isValue = function (val) {
+	 return (val !== _undefined) && (val !== null);
+	};
+
+	var keys = Object.keys;
+
+	var shim = function (object) {
+		return keys(isValue(object) ? Object(object) : object);
+	};
+
+	var keys$1 = isImplemented$1()
+		? Object.keys
+		: shim;
+
+	var validValue = function (value) {
+		if (!isValue(value)) throw new TypeError("Cannot use null or undefined");
+		return value;
+	};
+
+	var max   = Math.max;
+
+	var shim$1 = function (dest, src /*, …srcn*/) {
+		var error, i, length = max(arguments.length, 2), assign;
+		dest = Object(validValue(dest));
+		assign = function (key) {
+			try {
+				dest[key] = src[key];
+			} catch (e) {
+				if (!error) error = e;
+			}
+		};
+		for (i = 1; i < length; ++i) {
+			src = arguments[i];
+			keys$1(src).forEach(assign);
+		}
+		if (error !== undefined) throw error;
+		return dest;
+	};
+
+	var assign = isImplemented()
+		? Object.assign
+		: shim$1;
+
+	var forEach = Array.prototype.forEach, create = Object.create;
+
+	var process = function (src, obj) {
+		var key;
+		for (key in src) obj[key] = src[key];
+	};
+
+	// eslint-disable-next-line no-unused-vars
+	var normalizeOptions = function (opts1 /*, …options*/) {
+		var result = create(null);
+		forEach.call(arguments, function (options) {
+			if (!isValue(options)) return;
+			process(Object(options), result);
+		});
+		return result;
+	};
+
+	// Deprecated
+
+	var isCallable = function (obj) {
+	 return typeof obj === "function";
+	};
+
+	var str = "razdwatrzy";
+
+	var isImplemented$2 = function () {
+		if (typeof str.contains !== "function") return false;
+		return (str.contains("dwa") === true) && (str.contains("foo") === false);
+	};
+
+	var indexOf = String.prototype.indexOf;
+
+	var shim$2 = function (searchString/*, position*/) {
+		return indexOf.call(this, searchString, arguments[1]) > -1;
+	};
+
+	var contains = isImplemented$2()
+		? String.prototype.contains
+		: shim$2;
+
+	var d_1 = createCommonjsModule(function (module) {
+
+	var d;
+
+	d = module.exports = function (dscr, value/*, options*/) {
+		var c, e, w, options, desc;
+		if ((arguments.length < 2) || (typeof dscr !== 'string')) {
+			options = value;
+			value = dscr;
+			dscr = null;
+		} else {
+			options = arguments[2];
+		}
+		if (dscr == null) {
+			c = w = true;
+			e = false;
+		} else {
+			c = contains.call(dscr, 'c');
+			e = contains.call(dscr, 'e');
+			w = contains.call(dscr, 'w');
+		}
+
+		desc = { value: value, configurable: c, enumerable: e, writable: w };
+		return !options ? desc : assign(normalizeOptions(options), desc);
+	};
+
+	d.gs = function (dscr, get, set/*, options*/) {
+		var c, e, options, desc;
+		if (typeof dscr !== 'string') {
+			options = set;
+			set = get;
+			get = dscr;
+			dscr = null;
+		} else {
+			options = arguments[3];
+		}
+		if (get == null) {
+			get = undefined;
+		} else if (!isCallable(get)) {
+			options = get;
+			get = set = undefined;
+		} else if (set == null) {
+			set = undefined;
+		} else if (!isCallable(set)) {
+			options = set;
+			set = undefined;
+		}
+		if (dscr == null) {
+			c = true;
+			e = false;
+		} else {
+			c = contains.call(dscr, 'c');
+			e = contains.call(dscr, 'e');
+		}
+
+		desc = { get: get, set: set, configurable: c, enumerable: e };
+		return !options ? desc : assign(normalizeOptions(options), desc);
+	};
+	});
+
+	var validCallable = function (fn) {
+		if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+		return fn;
+	};
+
+	var eventEmitter = createCommonjsModule(function (module, exports) {
+
+	var apply = Function.prototype.apply, call = Function.prototype.call
+	  , create = Object.create, defineProperty = Object.defineProperty
+	  , defineProperties = Object.defineProperties
+	  , hasOwnProperty = Object.prototype.hasOwnProperty
+	  , descriptor = { configurable: true, enumerable: false, writable: true }
+
+	  , on, once, off, emit, methods, descriptors, base;
+
+	on = function (type, listener) {
+		var data;
+
+		validCallable(listener);
+
+		if (!hasOwnProperty.call(this, '__ee__')) {
+			data = descriptor.value = create(null);
+			defineProperty(this, '__ee__', descriptor);
+			descriptor.value = null;
+		} else {
+			data = this.__ee__;
+		}
+		if (!data[type]) data[type] = listener;
+		else if (typeof data[type] === 'object') data[type].push(listener);
+		else data[type] = [data[type], listener];
+
+		return this;
+	};
+
+	once = function (type, listener) {
+		var once, self;
+
+		validCallable(listener);
+		self = this;
+		on.call(this, type, once = function () {
+			off.call(self, type, once);
+			apply.call(listener, this, arguments);
+		});
+
+		once.__eeOnceListener__ = listener;
+		return this;
+	};
+
+	off = function (type, listener) {
+		var data, listeners, candidate, i;
+
+		validCallable(listener);
+
+		if (!hasOwnProperty.call(this, '__ee__')) return this;
+		data = this.__ee__;
+		if (!data[type]) return this;
+		listeners = data[type];
+
+		if (typeof listeners === 'object') {
+			for (i = 0; (candidate = listeners[i]); ++i) {
+				if ((candidate === listener) ||
+						(candidate.__eeOnceListener__ === listener)) {
+					if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
+					else listeners.splice(i, 1);
+				}
+			}
+		} else {
+			if ((listeners === listener) ||
+					(listeners.__eeOnceListener__ === listener)) {
+				delete data[type];
+			}
+		}
+
+		return this;
+	};
+
+	emit = function (type) {
+		var i, l, listener, listeners, args;
+
+		if (!hasOwnProperty.call(this, '__ee__')) return;
+		listeners = this.__ee__[type];
+		if (!listeners) return;
+
+		if (typeof listeners === 'object') {
+			l = arguments.length;
+			args = new Array(l - 1);
+			for (i = 1; i < l; ++i) args[i - 1] = arguments[i];
+
+			listeners = listeners.slice();
+			for (i = 0; (listener = listeners[i]); ++i) {
+				apply.call(listener, this, args);
+			}
+		} else {
+			switch (arguments.length) {
+			case 1:
+				call.call(listeners, this);
+				break;
+			case 2:
+				call.call(listeners, this, arguments[1]);
+				break;
+			case 3:
+				call.call(listeners, this, arguments[1], arguments[2]);
+				break;
+			default:
+				l = arguments.length;
+				args = new Array(l - 1);
+				for (i = 1; i < l; ++i) {
+					args[i - 1] = arguments[i];
+				}
+				apply.call(listeners, this, args);
+			}
+		}
+	};
+
+	methods = {
+		on: on,
+		once: once,
+		off: off,
+		emit: emit
+	};
+
+	descriptors = {
+		on: d_1(on),
+		once: d_1(once),
+		off: d_1(off),
+		emit: d_1(emit)
+	};
+
+	base = defineProperties({}, descriptors);
+
+	module.exports = exports = function (o) {
+		return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
+	};
+	exports.methods = methods;
+	});
+	var eventEmitter_1 = eventEmitter.methods;
+
+	function getBoundingClientRect(element) {
+		if (!element) {
+			return;
+		}
+		let rect;
+		if (typeof element.getBoundingClientRect !== "undefined") {
+			rect = element.getBoundingClientRect();
+		} else {
+			let range = document.createRange();
+			range.selectNode(element);
+			rect = range.getBoundingClientRect();
+		}
+		return rect;
+	}
+
+	function getClientRects(element) {
+		if (!element) {
+			return;
+		}
+		let rect;
+		if (typeof element.getClientRects !== "undefined") {
+			rect = element.getClientRects();
+		} else {
+			let range = document.createRange();
+			range.selectNode(element);
+			rect = range.getClientRects();
+		}
+		return rect;
+	}
+
+	/**
+	 * Generates a UUID
+	 * based on: http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
+	 * @returns {string} uuid
+	 */
+	function UUID() {
+		var d = new Date().getTime();
+		if (typeof performance !== "undefined" && typeof performance.now === "function"){
+			d += performance.now(); //use high-precision timer if available
+		}
+		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+			var r = (d + Math.random() * 16) % 16 | 0;
+			d = Math.floor(d / 16);
+			return (c === "x" ? r : (r & 0x3 | 0x8)).toString(16);
+		});
+	}
+
+	function attr(element, attributes) {
+		for (var i = 0; i < attributes.length; i++) {
+			if(element.hasAttribute(attributes[i])) {
+				return element.getAttribute(attributes[i]);
+			}
+		}
+	}
+
+	/* Based on by https://mths.be/cssescape v1.5.1 by @mathias | MIT license
+	 * Allows # and .
+	 */
+	function querySelectorEscape(value) {
+		if (arguments.length == 0) {
+			throw new TypeError("`CSS.escape` requires an argument.");
+		}
+		var string = String(value);
+		var length = string.length;
+		var index = -1;
+		var codeUnit;
+		var result = "";
+		var firstCodeUnit = string.charCodeAt(0);
+		while (++index < length) {
+			codeUnit = string.charCodeAt(index);
+			// Note: there’s no need to special-case astral symbols, surrogate
+			// pairs, or lone surrogates.
+
+			// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+			// (U+FFFD).
+			if (codeUnit == 0x0000) {
+				result += "\uFFFD";
+				continue;
+			}
+
+			if (
+				// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+				// U+007F, […]
+				(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
+				// If the character is the first character and is in the range [0-9]
+				// (U+0030 to U+0039), […]
+				(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+				// If the character is the second character and is in the range [0-9]
+				// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+				(
+					index == 1 &&
+					codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
+					firstCodeUnit == 0x002D
+				)
+			) {
+				// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+				result += "\\" + codeUnit.toString(16) + " ";
+				continue;
+			}
+
+			if (
+				// If the character is the first character and is a `-` (U+002D), and
+				// there is no second character, […]
+				index == 0 &&
+				length == 1 &&
+				codeUnit == 0x002D
+			) {
+				result += "\\" + string.charAt(index);
+				continue;
+			}
+
+			// If the character is not handled by one of the above rules and is
+			// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+			// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+			// U+005A), or [a-z] (U+0061 to U+007A), […]
+			if (
+				codeUnit >= 0x0080 ||
+				codeUnit == 0x002D ||
+				codeUnit == 0x005F ||
+				codeUnit == 35 || // Allow #
+				codeUnit == 46 || // Allow .
+				codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
+				codeUnit >= 0x0041 && codeUnit <= 0x005A ||
+				codeUnit >= 0x0061 && codeUnit <= 0x007A
+			) {
+				// the character itself
+				result += string.charAt(index);
+				continue;
+			}
+
+			// Otherwise, the escaped character.
+			// https://drafts.csswg.org/cssom/#escape-a-character
+			result += "\\" + string.charAt(index);
+
+		}
+		return result;
+	}
+
+	/**
+	 * Creates a new pending promise and provides methods to resolve or reject it.
+	 * From: https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred#backwards_forwards_compatible
+	 * @returns {object} defered
+	 */
+	function defer() {
+		this.resolve = null;
+
+		this.reject = null;
+
+		this.id = UUID();
+
+		this.promise = new Promise((resolve, reject) => {
+			this.resolve = resolve;
+			this.reject = reject;
+		});
+		Object.freeze(this);
+	}
+
+	const requestIdleCallback = typeof window !== "undefined" && ("requestIdleCallback" in window ? window.requestIdleCallback : window.requestAnimationFrame);
+
+	function CSSValueToString(obj) {
+		return obj.value + (obj.unit || "");
+	}
+
+	function isElement(node) {
+		return node && node.nodeType === 1;
+	}
+
+	function isText(node) {
+		return node && node.nodeType === 3;
+	}
+
+	function *walk(start, limiter) {
+		let node = start;
+
+		while (node) {
+
+			yield node;
+
+			if (node.childNodes.length) {
+				node = node.firstChild;
+			} else if (node.nextSibling) {
+				if (limiter && node === limiter) {
+					node = undefined;
+					break;
+				}
+				node = node.nextSibling;
+			} else {
+				while (node) {
+					node = node.parentNode;
+					if (limiter && node === limiter) {
+						node = undefined;
+						break;
+					}
+					if (node && node.nextSibling) {
+						node = node.nextSibling;
+						break;
+					}
+
+				}
+			}
+		}
+	}
+
+	function nodeAfter(node, limiter) {
+		let after = node;
+
+		if (after.nextSibling) {
+			if (limiter && node === limiter) {
+				return;
+			}
+			after = after.nextSibling;
+		} else {
+			while (after) {
+				after = after.parentNode;
+				if (limiter && after === limiter) {
+					after = undefined;
+					break;
+				}
+				if (after && after.nextSibling) {
+					after = after.nextSibling;
+					break;
+				}
+			}
+		}
+
+		return after;
+	}
+
+	function nodeBefore(node, limiter) {
+		let before = node;
+		if (before.previousSibling) {
+			if (limiter && node === limiter) {
+				return;
+			}
+			before = before.previousSibling;
+		} else {
+			while (before) {
+				before = before.parentNode;
+				if (limiter && before === limiter) {
+					before = undefined;
+					break;
+				}
+				if (before && before.previousSibling) {
+					before = before.previousSibling;
+					break;
+				}
+			}
+		}
+
+		return before;
+	}
+
+	function elementAfter(node, limiter) {
+		let after = nodeAfter(node);
+
+		while (after && after.nodeType !== 1) {
+			after = nodeAfter(after);
+		}
+
+		return after;
+	}
+
+	function rebuildAncestors(node) {
+		let parent, ancestor;
+		let ancestors = [];
+		let added = [];
+
+		let fragment = document.createDocumentFragment();
+
+		// Gather all ancestors
+		let element = node;
+		while(element.parentNode && element.parentNode.nodeType === 1) {
+			ancestors.unshift(element.parentNode);
+			element = element.parentNode;
+		}
+
+		for (var i = 0; i < ancestors.length; i++) {
+			ancestor = ancestors[i];
+			parent = ancestor.cloneNode(false);
+
+			parent.setAttribute("data-split-from", parent.getAttribute("data-ref"));
+			// ancestor.setAttribute("data-split-to", parent.getAttribute("data-ref"));
+
+			if (parent.hasAttribute("id")) {
+				let dataID = parent.getAttribute("id");
+				parent.setAttribute("data-id", dataID);
+				parent.removeAttribute("id");
+			}
+
+			// This is handled by css :not, but also tidied up here
+			if (parent.hasAttribute("data-break-before")) {
+				parent.removeAttribute("data-break-before");
+			}
+
+			if (parent.hasAttribute("data-previous-break-after")) {
+				parent.removeAttribute("data-previous-break-after");
+			}
+
+			if (added.length) {
+				let container = added[added.length-1];
+				container.appendChild(parent);
+			} else {
+				fragment.appendChild(parent);
+			}
+			added.push(parent);
+		}
+
+		added = undefined;
+		return fragment;
+	}
+
+	/*
+	export function split(bound, cutElement, breakAfter) {
+			let needsRemoval = [];
+			let index = indexOf(cutElement);
+
+			if (!breakAfter && index === 0) {
+				return;
+			}
+
+			if (breakAfter && index === (cutElement.parentNode.children.length - 1)) {
+				return;
+			}
+
+			// Create a fragment with rebuilt ancestors
+			let fragment = rebuildAncestors(cutElement);
+
+			// Clone cut
+			if (!breakAfter) {
+				let clone = cutElement.cloneNode(true);
+				let ref = cutElement.parentNode.getAttribute('data-ref');
+				let parent = fragment.querySelector("[data-ref='" + ref + "']");
+				parent.appendChild(clone);
+				needsRemoval.push(cutElement);
+			}
+
+			// Remove all after cut
+			let next = nodeAfter(cutElement, bound);
+			while (next) {
+				let clone = next.cloneNode(true);
+				let ref = next.parentNode.getAttribute('data-ref');
+				let parent = fragment.querySelector("[data-ref='" + ref + "']");
+				parent.appendChild(clone);
+				needsRemoval.push(next);
+				next = nodeAfter(next, bound);
+			}
+
+			// Remove originals
+			needsRemoval.forEach((node) => {
+				if (node) {
+					node.remove();
+				}
+			});
+
+			// Insert after bounds
+			bound.parentNode.insertBefore(fragment, bound.nextSibling);
+			return [bound, bound.nextSibling];
+	}
+	*/
+
+	function needsBreakBefore(node) {
+		if( typeof node !== "undefined" &&
+				typeof node.dataset !== "undefined" &&
+				typeof node.dataset.breakBefore !== "undefined" &&
+				(node.dataset.breakBefore === "always" ||
+				 node.dataset.breakBefore === "page" ||
+				 node.dataset.breakBefore === "left" ||
+				 node.dataset.breakBefore === "right" ||
+				 node.dataset.breakBefore === "recto" ||
+				 node.dataset.breakBefore === "verso")
+			 ) {
+			return true;
+		}
+
+		return false;
+	}
+
+	function needsPreviousBreakAfter(node) {
+		if( typeof node !== "undefined" &&
+				typeof node.dataset !== "undefined" &&
+				typeof node.dataset.previousBreakAfter !== "undefined" &&
+				(node.dataset.previousBreakAfter === "always" ||
+				 node.dataset.previousBreakAfter === "page" ||
+				 node.dataset.previousBreakAfter === "left" ||
+				 node.dataset.previousBreakAfter === "right" ||
+				 node.dataset.previousBreakAfter === "recto" ||
+				 node.dataset.previousBreakAfter === "verso")
+			 ) {
+			return true;
+		}
+
+		return false;
+	}
+
+	function needsPageBreak(node) {
+		if( typeof node !== "undefined" &&
+				typeof node.dataset !== "undefined" &&
+				(node.dataset.page || node.dataset.afterPage)
+			 ) {
+			return true;
+		}
+
+		return false;
+	}
+
+	function *words(node) {
+		let currentText = node.nodeValue;
+		let max = currentText.length;
+		let currentOffset = 0;
+		let currentLetter;
+
+		let range;
+
+		while(currentOffset < max) {
+			currentLetter = currentText[currentOffset];
+			if (/^[\S\u202F\u00A0]$/.test(currentLetter)) {
+				if (!range) {
+					range = document.createRange();
+					range.setStart(node, currentOffset);
+				}
+			} else {
+				if (range) {
+					range.setEnd(node, currentOffset);
+					yield range;
+					range = undefined;
+				}
+			}
+
+			currentOffset += 1;
+		}
+
+		if (range) {
+			range.setEnd(node, currentOffset);
+			yield range;
+			range = undefined;
+		}
+	}
+
+	function *letters(wordRange) {
+		let currentText = wordRange.startContainer;
+		let max = currentText.length;
+		let currentOffset = wordRange.startOffset;
+		// let currentLetter;
+
+		let range;
+
+		while(currentOffset < max) {
+			 // currentLetter = currentText[currentOffset];
+			 range = document.createRange();
+			 range.setStart(currentText, currentOffset);
+			 range.setEnd(currentText, currentOffset+1);
+
+			 yield range;
+
+			 currentOffset += 1;
+		}
+	}
+
+	function isContainer(node) {
+		let container;
+
+		if (typeof node.tagName === "undefined") {
+			return true;
+		}
+
+		if (node.style.display === "none") {
+			return false;
+		}
+
+		switch (node.tagName) {
+			// Inline
+			case "A":
+			case "ABBR":
+			case "ACRONYM":
+			case "B":
+			case "BDO":
+			case "BIG":
+			case "BR":
+			case "BUTTON":
+			case "CITE":
+			case "CODE":
+			case "DFN":
+			case "EM":
+			case "I":
+			case "IMG":
+			case "INPUT":
+			case "KBD":
+			case "LABEL":
+			case "MAP":
+			case "OBJECT":
+			case "Q":
+			case "SAMP":
+			case "SCRIPT":
+			case "SELECT":
+			case "SMALL":
+			case "SPAN":
+			case "STRONG":
+			case "SUB":
+			case "SUP":
+			case "TEXTAREA":
+			case "TIME":
+			case "TT":
+			case "VAR":
+			case "P":
+			case "H1":
+			case "H2":
+			case "H3":
+			case "H4":
+			case "H5":
+			case "H6":
+			case "FIGCAPTION":
+			case "BLOCKQUOTE":
+			case "PRE":
+			case "LI":
+			case "TR":
+			case "DT":
+			case "DD":
+			case "VIDEO":
+			case "CANVAS":
+				container = false;
+				break;
+			default:
+				container = true;
+		}
+
+		return container;
+	}
+
+	function cloneNode(n, deep=false) {
+		return n.cloneNode(deep);
+	}
+
+	function findElement(node, doc) {
+		const ref = node.getAttribute("data-ref");
+		return findRef(ref, doc);
+	}
+
+	function findRef(ref, doc) {
+		return doc.querySelector(`[data-ref='${ref}']`);
+	}
+
+	function validNode(node) {
+		if (isText(node)) {
+			return true;
+		}
+
+		if (isElement(node) && node.dataset.ref) {
+			return true;
+		}
+
+		return false;
+	}
+
+	function prevValidNode(node) {
+		while (!validNode(node)) {
+			if (node.previousSibling) {
+				node = node.previousSibling;
+			} else {
+				node = node.parentNode;
+			}
+
+			if (!node) {
+				break;
+			}
+		}
+
+		return node;
+	}
+
+
+	function indexOf$1(node) {
+		let parent = node.parentNode;
+		if (!parent) {
+			return 0;
+		}
+		return Array.prototype.indexOf.call(parent.childNodes, node);
+	}
+
+	function child(node, index) {
+		return node.childNodes[index];
+	}
+
+	function hasContent(node) {
+		if (isElement(node)) {
+			return true;
+		} else if (isText(node) &&
+				node.textContent.trim().length) {
+			return true;
+		}
+		return false;
+	}
+
+	function indexOfTextNode(node, parent) {
+		if (!isText(node)) {
+			return -1;
+		}
+		let nodeTextContent = node.textContent;
+		let child;
+		let index = -1;
+		for (var i = 0; i < parent.childNodes.length; i++) {
+			child = parent.childNodes[i];
+			if (child.nodeType === 3) {
+				let text = parent.childNodes[i].textContent;
+				if (text.includes(nodeTextContent)) {
+					index = i;
+					break;
+				}
+			}
+		}
+
+		return index;
+	}
+
+	/**
+	 * Hooks allow for injecting functions that must all complete in order before finishing
+	 * They will execute in parallel but all must finish before continuing
+	 * Functions may return a promise if they are asycn.
+	 * From epubjs/src/utils/hooks
+	 * @param {any} context scope of this
+	 * @example this.content = new Hook(this);
+	 */
+	class Hook {
+		constructor(context){
+			this.context = context || this;
+			this.hooks = [];
+		}
+
+		/**
+		 * Adds a function to be run before a hook completes
+		 * @example this.content.register(function(){...});
+		 * @return {undefined} void
+		 */
+		register(){
+			for(var i = 0; i < arguments.length; ++i) {
+				if (typeof arguments[i]  === "function") {
+					this.hooks.push(arguments[i]);
+				} else {
+					// unpack array
+					for(var j = 0; j < arguments[i].length; ++j) {
+						this.hooks.push(arguments[i][j]);
+					}
+				}
+			}
+		}
+
+		/**
+		 * Triggers a hook to run all functions
+		 * @example this.content.trigger(args).then(function(){...});
+		 * @return {Promise} results
+		 */
+		trigger(){
+			var args = arguments;
+			var context = this.context;
+			var promises = [];
+
+			this.hooks.forEach(function(task) {
+				var executing = task.apply(context, args);
+
+				if(executing && typeof executing["then"] === "function") {
+					// Task is a function that returns a promise
+					promises.push(executing);
+				}
+				// Otherwise Task resolves immediately, add resolved promise with result
+				promises.push(new Promise((resolve, reject) => {
+					resolve(executing);
+				}));
+			});
+
+
+			return Promise.all(promises);
+		}
+
+	  /**
+	   * Triggers a hook to run all functions synchronously
+	   * @example this.content.trigger(args).then(function(){...});
+	   * @return {Array} results
+	   */
+	  triggerSync(){
+	    var args = arguments;
+	    var context = this.context;
+	    var results = [];
+
+	    this.hooks.forEach(function(task) {
+	      var executing = task.apply(context, args);
+
+	      results.push(executing);
+	    });
+
+
+	    return results;
+	  }
+
+		// Adds a function to be run before a hook completes
+		list(){
+			return this.hooks;
+		}
+
+		clear(){
+			return this.hooks = [];
+		}
+	}
+
+	const MAX_CHARS_PER_BREAK = 1500;
+
+	/**
+	 * Layout
+	 * @class
+	 */
+	class Layout {
+
+		constructor(element, hooks, maxChars) {
+			this.element = element;
+
+			this.bounds = this.element.getBoundingClientRect();
+
+			if (hooks) {
+				this.hooks = hooks;
+			} else {
+				this.hooks = {};
+				this.hooks.layout = new Hook();
+				this.hooks.renderNode = new Hook();
+				this.hooks.layoutNode = new Hook();
+				this.hooks.beforeOverflow = new Hook();
+				this.hooks.onOverflow = new Hook();
+				this.hooks.onBreakToken = new Hook();
+			}
+
+			this.maxChars = maxChars || MAX_CHARS_PER_BREAK;
+		}
+
+		async renderTo(wrapper, source, breakToken, bounds=this.bounds) {
+			let start = this.getStart(source, breakToken);
+			let walker = walk(start, source);
+
+			let node;
+			let done;
+			let next;
+
+			let hasRenderedContent = false;
+			let newBreakToken;
+
+			let length = 0;
+
+			while (!done && !newBreakToken) {
+				next = walker.next();
+				node = next.value;
+				done = next.done;
+
+				if (!node) {
+					this.hooks && this.hooks.layout.trigger(wrapper, this);
+
+					let imgs = wrapper.querySelectorAll("img");
+					if (imgs.length) {
+						await this.waitForImages(imgs);
+					}
+
+					newBreakToken = this.findBreakToken(wrapper, source, bounds);
+					return newBreakToken;
+				}
+
+				this.hooks && this.hooks.layoutNode.trigger(node);
+
+				// Check if the rendered element has a break set
+				if (hasRenderedContent && this.shouldBreak(node)) {
+
+					this.hooks && this.hooks.layout.trigger(wrapper, this);
+
+					let imgs = wrapper.querySelectorAll("img");
+					if (imgs.length) {
+						await this.waitForImages(imgs);
+					}
+
+					newBreakToken = this.findBreakToken(wrapper, source, bounds);
+
+					if (!newBreakToken) {
+						newBreakToken = this.breakAt(node);
+					}
+
+					length = 0;
+
+					break;
+				}
+
+				// Should the Node be a shallow or deep clone
+				let shallow = isContainer(node);
+
+				let rendered = this.append(node, wrapper, breakToken, shallow);
+
+				length += rendered.textContent.length;
+
+				// Check if layout has content yet
+				if (!hasRenderedContent) {
+					hasRenderedContent = hasContent(node);
+				}
+
+				// Skip to the next node if a deep clone was rendered
+				if (!shallow) {
+					walker = walk(nodeAfter(node, source), source);
+				}
+
+				// Only check x characters
+				if (length >= this.maxChars) {
+
+					this.hooks && this.hooks.layout.trigger(wrapper, this);
+
+					let imgs = wrapper.querySelectorAll("img");
+					if (imgs.length) {
+						await this.waitForImages(imgs);
+					}
+
+					newBreakToken = this.findBreakToken(wrapper, source, bounds);
+
+					if (newBreakToken) {
+						length = 0;
+					}
+				}
+
+			}
+
+			return newBreakToken;
+		}
+
+		breakAt(node, offset=0) {
+			return {
+				node,
+				offset
+			};
+		}
+
+		shouldBreak(node) {
+			let previousSibling = node.previousSibling;
+			let parentNode = node.parentNode;
+			let parentBreakBefore = needsBreakBefore(node) && parentNode && !previousSibling && needsBreakBefore(parentNode);
+			let doubleBreakBefore;
+
+			if (parentBreakBefore) {
+				doubleBreakBefore = node.dataset.breakBefore === parentNode.dataset.breakBefore;
+			}
+
+			return !doubleBreakBefore && needsBreakBefore(node) || needsPreviousBreakAfter(node) || needsPageBreak(node);
+		}
+
+		getStart(source, breakToken) {
+			let start;
+			let node = breakToken && breakToken.node;
+
+			if (node) {
+				start = node;
+			} else {
+				start = source.firstChild;
+			}
+
+			return start;
+		}
+
+		append(node, dest, breakToken, shallow=true, rebuild=true) {
+
+			let clone = cloneNode(node, !shallow);
+
+			if (node.parentNode && isElement(node.parentNode)) {
+				let parent = findElement(node.parentNode, dest);
+				// Rebuild chain
+				if (parent) {
+					parent.appendChild(clone);
+				} else if (rebuild) {
+					let fragment = rebuildAncestors(node);
+					parent = findElement(node.parentNode, fragment);
+					if (!parent) {
+						dest.appendChild(clone);
+					} else if (breakToken && isText(breakToken.node) && breakToken.offset > 0) {
+						clone.textContent = clone.textContent.substring(breakToken.offset);
+						parent.appendChild(clone);
+					} else {
+						parent.appendChild(clone);
+					}
+
+					dest.appendChild(fragment);
+				} else {
+					dest.appendChild(clone);
+				}
+
+
+			} else {
+				dest.appendChild(clone);
+			}
+
+			let nodeHooks = this.hooks.renderNode.triggerSync(clone, node);
+			nodeHooks.forEach((newNode) => {
+				if (typeof newNode != "undefined") {
+					clone = newNode;
+				}
+			});
+
+			return clone;
+		}
+
+		async waitForImages(imgs) {
+			let results = Array.from(imgs).map(async (img) => {
+				return this.awaitImageLoaded(img);
+			});
+			await Promise.all(results);
+		}
+
+		async awaitImageLoaded(image) {
+			return new Promise(resolve => {
+				if (image.complete !== true) {
+					image.onload = function() {
+						let { width, height } = window.getComputedStyle(image);
+						resolve(width, height);
+					};
+					image.onerror = function(e) {
+						let { width, height } = window.getComputedStyle(image);
+						resolve(width, height, e);
+					};
+				} else {
+					let { width, height } = window.getComputedStyle(image);
+					resolve(width, height);
+				}
+			});
+		}
+
+		avoidBreakInside(node, limiter) {
+			let breakNode;
+
+			if (node === limiter) {
+				return;
+			}
+
+			while (node.parentNode) {
+				node = node.parentNode;
+
+				if (node === limiter) {
+					break;
+				}
+
+				if(window.getComputedStyle(node)["break-inside"] === "avoid") {
+					breakNode = node;
+					break;
+				}
+
+			}
+			return breakNode;
+		}
+
+		createBreakToken(overflow, rendered, source) {
+			let container = overflow.startContainer;
+			let offset = overflow.startOffset;
+			let node, renderedNode, parent, index, temp;
+
+			if (isElement(container)) {
+				temp = child(container, offset);
+
+				if (isElement(temp)) {
+					renderedNode = findElement(temp, rendered);
+
+					if (!renderedNode) {
+						// Find closest element with data-ref
+						renderedNode = findElement(prevValidNode(temp), rendered);
+						return;
+					}
+
+					node = findElement(renderedNode, source);
+					offset = 0;
+				} else {
+					renderedNode = findElement(container, rendered);
+
+					if (!renderedNode) {
+						renderedNode = findElement(prevValidNode(container), rendered);
+					}
+
+					parent = findElement(renderedNode, source);
+					index = indexOfTextNode(temp, parent);
+					node = child(parent, index);
+					offset = 0;
+				}
+			} else {
+				renderedNode = findElement(container.parentNode, rendered);
+
+				if (!renderedNode) {
+					renderedNode = findElement(prevValidNode(container.parentNode), rendered);
+				}
+
+				parent = findElement(renderedNode, source);
+				index = indexOfTextNode(container, parent);
+
+				if (index === -1) {
+					return;
+				}
+
+				node = child(parent, index);
+
+				offset += node.textContent.indexOf(container.textContent);
+			}
+
+			if (!node) {
+				return;
+			}
+
+			return {
+				node,
+				offset
+			};
+
+		}
+
+		findBreakToken(rendered, source, bounds=this.bounds, extract=true) {
+			let overflow = this.findOverflow(rendered, bounds);
+			let breakToken;
+
+			let overflowHooks = this.hooks.onOverflow.triggerSync(overflow, rendered, bounds, this);
+			overflowHooks.forEach((newOverflow) => {
+				if (typeof newOverflow != "undefined") {
+					overflow = newOverflow;
+				}
+			});
+
+			if (overflow) {
+				breakToken = this.createBreakToken(overflow, rendered, source);
+
+				let breakHooks = this.hooks.onBreakToken.triggerSync(breakToken, overflow, rendered, this);
+				breakHooks.forEach((newToken) => {
+					if (typeof newToken != "undefined") {
+						breakToken = newToken;
+					}
+				});
+
+
+				if (breakToken && breakToken.node && extract) {
+					this.removeOverflow(overflow);
+				}
+
+			}
+			return breakToken;
+		}
+
+		hasOverflow(element, bounds=this.bounds) {
+			let constrainingElement = element && element.parentNode; // this gets the element, instead of the wrapper for the width workaround
+			let { width } = element.getBoundingClientRect();
+			let scrollWidth = constrainingElement ? constrainingElement.scrollWidth : 0;
+			return Math.max(Math.floor(width), scrollWidth) > Math.round(bounds.width);
+		}
+
+		findOverflow(rendered, bounds=this.bounds) {
+			if (!this.hasOverflow(rendered, bounds)) return;
+
+			let start = Math.round(bounds.left);
+			let end =  Math.round(bounds.right);
+			let range;
+
+			let walker = walk(rendered.firstChild, rendered);
+
+			// Find Start
+			let next, done, node, offset, skip, breakAvoid, prev, br;
+			while (!done) {
+				next = walker.next();
+				done = next.done;
+				node = next.value;
+				skip = false;
+				breakAvoid = false;
+				prev = undefined;
+				br = undefined;
+
+				if (node) {
+					let pos = getBoundingClientRect(node);
+					let left = Math.floor(pos.left);
+					let right = Math.floor(pos.right);
+
+					if (!range && left >= end) {
+						// Check if it is a float
+						let isFloat = false;
+
+						if (isElement(node) ) {
+							let styles = window.getComputedStyle(node);
+							isFloat = styles.getPropertyValue("float") !== "none";
+							skip = styles.getPropertyValue("break-inside") === "avoid";
+							breakAvoid = node.dataset.breakBefore === "avoid" || node.dataset.previousBreakAfter === "avoid";
+							prev = breakAvoid && nodeBefore(node, rendered);
+							br = node.tagName === "BR" || node.tagName === "WBR";
+						}
+
+						if (prev) {
+							range = document.createRange();
+							range.setStartBefore(prev);
+							break;
+						}
+
+						if (!br && !isFloat && isElement(node)) {
+							range = document.createRange();
+							range.setStartBefore(node);
+							break;
+						}
+
+						if (isText(node) && node.textContent.trim().length) {
+							range = document.createRange();
+							range.setStartBefore(node);
+							break;
+						}
+
+					}
+
+					if (!range && isText(node) &&
+							node.textContent.trim().length &&
+							window.getComputedStyle(node.parentNode)["break-inside"] !== "avoid") {
+
+						let rects = getClientRects(node);
+						let rect;
+						left = 0;
+						for (var i = 0; i != rects.length; i++) {
+							rect = rects[i];
+							if (rect.width > 0 && (!left || rect.left > left)) {
+								left = rect.left;
+							}
+						}
+
+						if(left >= end) {
+							range = document.createRange();
+							offset = this.textBreak(node, start, end);
+							if (!offset) {
+								range = undefined;
+							} else {
+								range.setStart(node, offset);
+							}
+							break;
+						}
+					}
+
+					// Skip children
+					if (skip || right < end) {
+						next = nodeAfter(node, rendered);
+						if (next) {
+							walker = walk(next, rendered);
+						}
+
+					}
+
+				}
+			}
+
+			// Find End
+			if (range) {
+				range.setEndAfter(rendered.lastChild);
+				return range;
+			}
+
+		}
+
+		findEndToken(rendered, source, bounds=this.bounds) {
+			if (rendered.childNodes.length === 0) {
+				return;
+			}
+
+			let lastChild = rendered.lastChild;
+
+			let lastNodeIndex;
+			while (lastChild && lastChild.lastChild) {
+				if (!validNode(lastChild)) {
+					// Only get elements with refs
+					lastChild = lastChild.previousSibling;
+				} else if(!validNode(lastChild.lastChild)) {
+					// Deal with invalid dom items
+					lastChild = prevValidNode(lastChild.lastChild);
+					break;
+				} else {
+					lastChild = lastChild.lastChild;
+				}
+			}
+
+			if (isText(lastChild)) {
+
+				if (lastChild.parentNode.dataset.ref) {
+					lastNodeIndex = indexOf$1(lastChild);
+					lastChild = lastChild.parentNode;
+				} else {
+					lastChild = lastChild.previousSibling;
+				}
+			}
+
+			let original = findElement(lastChild, source);
+
+			if (lastNodeIndex) {
+				original = original.childNodes[lastNodeIndex];
+			}
+
+			let after = nodeAfter(original);
+
+			return this.breakAt(after);
+		}
+
+		textBreak(node, start, end) {
+			let wordwalker = words(node);
+			let left = 0;
+			let right = 0;
+			let word, next, done, pos;
+			let offset;
+			while (!done) {
+				next = wordwalker.next();
+				word = next.value;
+				done = next.done;
+
+				if (!word) {
+					break;
+				}
+
+				pos = getBoundingClientRect(word);
+
+				left = Math.floor(pos.left);
+				right = Math.floor(pos.right);
+
+				if (left >= end) {
+					offset = word.startOffset;
+					break;
+				}
+
+				if (right > end) {
+					let letterwalker = letters(word);
+					let letter, nextLetter, doneLetter;
+
+					while (!doneLetter) {
+						nextLetter = letterwalker.next();
+						letter = nextLetter.value;
+						doneLetter = nextLetter.done;
+
+						if (!letter) {
+							break;
+						}
+
+						pos = getBoundingClientRect(letter);
+						left = Math.floor(pos.left);
+
+						if (left >= end) {
+							offset = letter.startOffset;
+							done = true;
+
+							break;
+						}
+					}
+				}
+
+			}
+
+			return offset;
+		}
+
+		removeOverflow(overflow) {
+			let {startContainer} = overflow;
+			let extracted = overflow.extractContents();
+
+			this.hyphenateAtBreak(startContainer);
+
+			return extracted;
+		}
+
+		hyphenateAtBreak(startContainer) {
+			if (isText(startContainer)) {
+				let startText = startContainer.textContent;
+				let prevLetter = startText[startText.length-1];
+
+				// Add a hyphen if previous character is a letter or soft hyphen
+				if (/^\w|\u00AD$/.test(prevLetter)) {
+					startContainer.parentNode.classList.add("pagedjs_hyphen");
+					startContainer.textContent += "\u2011";
+				}
+			}
+		}
+	}
+
+	eventEmitter(Layout.prototype);
+
+	/**
+	 * Render a page
+	 * @class
+	 */
+	class Page {
+		constructor(pagesArea, pageTemplate, blank, hooks) {
+			this.pagesArea = pagesArea;
+			this.pageTemplate = pageTemplate;
+			this.blank = blank;
+
+			this.width = undefined;
+			this.height = undefined;
+
+			this.hooks = hooks;
+
+			// this.element = this.create(this.pageTemplate);
+		}
+
+		create(template, after) {
+			//let documentFragment = document.createRange().createContextualFragment( TEMPLATE );
+			//let page = documentFragment.children[0];
+			let clone = document.importNode(this.pageTemplate.content, true);
+
+			let page, index;
+			if (after) {
+				this.pagesArea.insertBefore(clone, after.nextElementSibling);
+				index = Array.prototype.indexOf.call(this.pagesArea.children, after.nextElementSibling);
+				page = this.pagesArea.children[index];
+			} else {
+				this.pagesArea.appendChild(clone);
+				page = this.pagesArea.lastChild;
+			}
+
+			let pagebox = page.querySelector(".pagedjs_pagebox");
+			let area = page.querySelector(".pagedjs_page_content");
+
+
+			let size = area.getBoundingClientRect();
+
+
+			area.style.columnWidth = Math.round(size.width) + "px";
+			area.style.columnGap = "calc(var(--pagedjs-margin-right) + var(--pagedjs-margin-left))";
+			// area.style.overflow = "scroll";
+
+			this.width = Math.round(size.width);
+			this.height = Math.round(size.height);
+
+			this.element = page;
+			this.pagebox = pagebox;
+			this.area = area;
+
+			return page;
+		}
+
+		createWrapper() {
+			let wrapper = document.createElement("div");
+
+			this.area.appendChild(wrapper);
+
+			this.wrapper = wrapper;
+
+			return wrapper;
+		}
+
+		index(pgnum) {
+			this.position = pgnum;
+
+			let page = this.element;
+			// let pagebox = this.pagebox;
+
+			let index = pgnum+1;
+
+			let id = `page-${index}`;
+
+			this.id = id;
+
+			// page.dataset.pageNumber = index;
+
+			page.dataset.pageNumber = index;
+			page.setAttribute('id', id);
+
+			if (this.name) {
+				page.classList.add("pagedjs_" + this.name + "_page");
+			}
+
+			if (this.blank) {
+				page.classList.add("pagedjs_blank_page");
+			}
+
+			if (pgnum === 0) {
+				page.classList.add("pagedjs_first_page");
+			}
+
+			if (pgnum % 2 !== 1) {
+				page.classList.remove("pagedjs_left_page");
+				page.classList.add("pagedjs_right_page");
+			} else {
+				page.classList.remove("pagedjs_right_page");
+				page.classList.add("pagedjs_left_page");
+			}
+		}
+
+		/*
+		size(width, height) {
+			if (width === this.width && height === this.height) {
+				return;
+			}
+			this.width = width;
+			this.height = height;
+
+			this.element.style.width = Math.round(width) + "px";
+			this.element.style.height = Math.round(height) + "px";
+			this.element.style.columnWidth = Math.round(width) + "px";
+		}
+		*/
+
+		async layout(contents, breakToken, maxChars) {
+
+			this.clear();
+
+			this.startToken = breakToken;
+
+			this.layoutMethod = new Layout(this.area, this.hooks, maxChars);
+
+			let newBreakToken = await this.layoutMethod.renderTo(this.wrapper, contents, breakToken);
+
+			this.addListeners(contents);
+
+			this.endToken = newBreakToken;
+
+			return newBreakToken;
+		}
+
+		async append(contents, breakToken) {
+
+			if (!this.layoutMethod) {
+				return this.layout(contents, breakToken);
+			}
+
+			let newBreakToken = await this.layoutMethod.renderTo(this.wrapper, contents, breakToken);
+
+			this.endToken = newBreakToken;
+
+			return newBreakToken;
+		}
+
+		getByParent(ref, entries) {
+			let e;
+			for (var i = 0; i < entries.length; i++) {
+				e = entries[i];
+				if(e.dataset.ref === ref) {
+					return e;
+				}
+			}
+		}
+
+		onOverflow(func) {
+			this._onOverflow = func;
+		}
+
+		onUnderflow(func) {
+			this._onUnderflow = func;
+		}
+
+		clear() {
+			this.removeListeners();
+			this.wrapper && this.wrapper.remove();
+			this.createWrapper();
+		}
+
+		addListeners(contents) {
+			if (typeof ResizeObserver !== "undefined") {
+				this.addResizeObserver(contents);
+			} else {
+				this._checkOverflowAfterResize = this.checkOverflowAfterResize.bind(this, contents);
+				this.element.addEventListener("overflow", this._checkOverflowAfterResize, false);
+				this.element.addEventListener("underflow", this._checkOverflowAfterResize, false);
+			}
+			// TODO: fall back to mutation observer?
+
+			this._onScroll = function() {
+				if(this.listening) {
+					this.element.scrollLeft = 0;
+				}
+			}.bind(this);
+
+			// Keep scroll left from changing
+			this.element.addEventListener("scroll", this._onScroll);
+
+			this.listening = true;
+
+			return true;
+		}
+
+		removeListeners() {
+			this.listening = false;
+
+			if (typeof ResizeObserver !== "undefined" && this.ro) {
+				this.ro.disconnect();
+			} else if (this.element) {
+				this.element.removeEventListener("overflow", this._checkOverflowAfterResize, false);
+				this.element.removeEventListener("underflow", this._checkOverflowAfterResize, false);
+			}
+
+			this.element &&this.element.removeEventListener("scroll", this._onScroll);
+
+		}
+
+		addResizeObserver(contents) {
+			let wrapper = this.wrapper;
+			let prevHeight = wrapper.getBoundingClientRect().height;
+			this.ro = new ResizeObserver( entries => {
+
+				if (!this.listening) {
+					return;
+				}
+
+				for (let entry of entries) {
+					const cr = entry.contentRect;
+
+					if (cr.height > prevHeight) {
+						this.checkOverflowAfterResize(contents);
+						prevHeight = wrapper.getBoundingClientRect().height;
+					} else if (cr.height < prevHeight ) { // TODO: calc line height && (prevHeight - cr.height) >= 22
+						this.checkUnderflowAfterResize(contents);
+						prevHeight = cr.height;
+					}
+				}
+			});
+
+			this.ro.observe(wrapper);
+		}
+
+		checkOverflowAfterResize(contents) {
+			if (!this.listening || !this.layoutMethod) {
+				return;
+			}
+
+			let newBreakToken = this.layoutMethod.findBreakToken(this.wrapper, contents);
+
+			if (newBreakToken) {
+				this.endToken = newBreakToken;
+				this._onOverflow && this._onOverflow(newBreakToken);
+			}
+		}
+
+		checkUnderflowAfterResize(contents) {
+			if (!this.listening || !this.layoutMethod) {
+				return;
+			}
+
+			let endToken = this.layoutMethod.findEndToken(this.wrapper, contents);
+
+			// let newBreakToken = this.layoutMethod.findBreakToken(this.wrapper, contents);
+
+			if (endToken) {
+				this._onUnderflow && this._onUnderflow(endToken);
+			}
+		}
+
+
+		destroy() {
+			this.removeListeners();
+
+			this.element.remove();
+
+			this.element = undefined;
+			this.wrapper = undefined;
+		}
+	}
+
+	eventEmitter(Page.prototype);
+
+	/**
+	 * Render a flow of text offscreen
+	 * @class
+	 */
+	class ContentParser {
+
+		constructor(content, cb) {
+			if (content && content.nodeType) {
+				// handle dom
+				this.dom = this.add(content);
+			} else if (typeof content === "string") {
+				this.dom = this.parse(content);
+			}
+
+			return this.dom;
+		}
+
+		parse(markup, mime) {
+			let range = document.createRange();
+			let fragment = range.createContextualFragment(markup);
+
+			this.addRefs(fragment);
+			this.removeEmpty(fragment);
+
+			return fragment;
+		}
+
+		add(contents) {
+			// let fragment = document.createDocumentFragment();
+			//
+			// let children = [...contents.childNodes];
+			// for (let child of children) {
+			// 	let clone = child.cloneNode(true);
+			// 	fragment.appendChild(clone);
+			// }
+
+			this.addRefs(contents);
+			this.removeEmpty(contents);
+
+			return contents;
+		}
+
+		addRefs(content) {
+			var treeWalker = document.createTreeWalker(
+				content,
+				NodeFilter.SHOW_ELEMENT,
+				{ acceptNode: function(node) { return NodeFilter.FILTER_ACCEPT; } },
+				false
+			);
+
+			let node = treeWalker.nextNode();
+			while(node) {
+
+				if (!node.hasAttribute("data-ref")) {
+					let uuid = UUID();
+					node.setAttribute("data-ref", uuid);
+				}
+
+				if (node.id) {
+					node.setAttribute("data-id", node.id);
+				}
+
+				// node.setAttribute("data-children", node.childNodes.length);
+
+				// node.setAttribute("data-text", node.textContent.trim().length);
+				node = treeWalker.nextNode();
+			}
+		}
+
+		removeEmpty(content) {
+			var treeWalker = document.createTreeWalker(
+				content,
+				NodeFilter.SHOW_TEXT,
+				{ acceptNode: function(node) {
+					// Only remove more than a single space
+					if (node.textContent.length > 1 && !node.textContent.trim()) {
+
+						// Don't touch whitespace if text is preformated
+						let parent = node.parentNode;
+						let pre = isElement(parent) && parent.closest("pre");
+						if (pre) {
+							return NodeFilter.FILTER_REJECT;
+						}
+
+						return NodeFilter.FILTER_ACCEPT;
+					} else {
+						return NodeFilter.FILTER_REJECT;
+					}
+				} },
+				false
+			);
+
+			let node;
+			let current;
+			node = treeWalker.nextNode();
+			while(node) {
+				current = node;
+				node = treeWalker.nextNode();
+				// if (!current.nextSibling || (current.nextSibling && current.nextSibling.nodeType === 1)) {
+				current.parentNode.removeChild(current);
+				// }
+			}
+		}
+
+		find(ref) {
+			return this.refs[ref];
+		}
+
+		// isWrapper(element) {
+		//   return wrappersRegex.test(element.nodeName);
+		// }
+
+		isText(node) {
+			return node.tagName === "TAG";
+		}
+
+		isElement(node) {
+			return node.nodeType === 1;
+		}
+
+		hasChildren(node) {
+			return node.childNodes && node.childNodes.length;
+		}
+
+
+		destroy() {
+			this.refs = undefined;
+			this.dom = undefined;
+		}
+	}
+
+	/**
+	 * Queue for handling tasks one at a time
+	 * @class
+	 * @param {scope} context what this will resolve to in the tasks
+	 */
+	class Queue {
+		constructor(context){
+			this._q = [];
+			this.context = context;
+			this.tick = requestAnimationFrame;
+			this.running = false;
+			this.paused = false;
+		}
+
+		/**
+		 * Add an item to the queue
+		 * @return {Promise} enqueued
+		 */
+		enqueue() {
+			var deferred, promise;
+			var queued;
+			var task = [].shift.call(arguments);
+			var args = arguments;
+
+			// Handle single args without context
+			// if(args && !Array.isArray(args)) {
+			//   args = [args];
+			// }
+			if(!task) {
+				throw new Error("No Task Provided");
+			}
+
+			if(typeof task === "function"){
+
+				deferred = new defer();
+				promise = deferred.promise;
+
+				queued = {
+					"task" : task,
+					"args"     : args,
+					//"context"  : context,
+					"deferred" : deferred,
+					"promise" : promise
+				};
+
+			} else {
+				// Task is a promise
+				queued = {
+					"promise" : task
+				};
+
+			}
+
+			this._q.push(queued);
+
+			// Wait to start queue flush
+			if (this.paused == false && !this.running) {
+				this.run();
+			}
+
+			return queued.promise;
+		}
+
+		/**
+		 * Run one item
+		 * @return {Promise} dequeued
+		 */
+		dequeue(){
+			var inwait, task, result;
+
+			if(this._q.length && !this.paused) {
+				inwait = this._q.shift();
+				task = inwait.task;
+				if(task){
+					// console.log(task)
+
+					result = task.apply(this.context, inwait.args);
+
+					if(result && typeof result["then"] === "function") {
+						// Task is a function that returns a promise
+						return result.then(function(){
+							inwait.deferred.resolve.apply(this.context, arguments);
+						}.bind(this), function() {
+							inwait.deferred.reject.apply(this.context, arguments);
+						}.bind(this));
+					} else {
+						// Task resolves immediately
+						inwait.deferred.resolve.apply(this.context, result);
+						return inwait.promise;
+					}
+
+
+
+				} else if(inwait.promise) {
+					// Task is a promise
+					return inwait.promise;
+				}
+
+			} else {
+				inwait = new defer();
+				inwait.deferred.resolve();
+				return inwait.promise;
+			}
+
+		}
+
+		// Run All Immediately
+		dump(){
+			while(this._q.length) {
+				this.dequeue();
+			}
+		}
+
+		/**
+		 * Run all tasks sequentially, at convince
+		 * @return {Promise} all run
+		 */
+		run(){
+
+			if(!this.running){
+				this.running = true;
+				this.defered = new defer();
+			}
+
+			this.tick.call(window, () => {
+
+				if(this._q.length) {
+
+					this.dequeue()
+						.then(function(){
+							this.run();
+						}.bind(this));
+
+				} else {
+					this.defered.resolve();
+					this.running = undefined;
+				}
+
+			});
+
+			// Unpause
+			if(this.paused == true) {
+				this.paused = false;
+			}
+
+			return this.defered.promise;
+		}
+
+		/**
+		 * Flush all, as quickly as possible
+		 * @return {Promise} ran
+		 */
+		flush(){
+
+			if(this.running){
+				return this.running;
+			}
+
+			if(this._q.length) {
+				this.running = this.dequeue()
+					.then(function(){
+						this.running = undefined;
+						return this.flush();
+					}.bind(this));
+
+				return this.running;
+			}
+
+		}
+
+		/**
+		 * Clear all items in wait
+		 * @return {void}
+		 */
+		clear(){
+			this._q = [];
+		}
+
+		/**
+		 * Get the number of tasks in the queue
+		 * @return {number} tasks
+		 */
+		length(){
+			return this._q.length;
+		}
+
+		/**
+		 * Pause a running queue
+		 * @return {void}
+		 */
+		pause(){
+			this.paused = true;
+		}
+
+		/**
+		 * End the queue
+		 * @return {void}
+		 */
+		stop(){
+			this._q = [];
+			this.running = false;
+			this.paused = true;
+		}
+	}
+
+	const TEMPLATE = `
+<div class="pagedjs_page">
+	<div class="pagedjs_sheet">
+		<div class="pagedjs_bleed pagedjs_bleed-top">
+			<div class="pagedjs_marks-crop"></div>
+			<div class="pagedjs_marks-middle">
+				<div class="pagedjs_marks-cross"></div>
+			</div>
+			<div class="pagedjs_marks-crop"></div>
+		</div>
+		<div class="pagedjs_bleed pagedjs_bleed-bottom">
+			<div class="pagedjs_marks-crop"></div>
+			<div class="pagedjs_marks-middle">
+				<div class="pagedjs_marks-cross"></div>
+			</div>		<div class="pagedjs_marks-crop"></div>
+		</div>
+		<div class="pagedjs_bleed pagedjs_bleed-left">
+			<div class="pagedjs_marks-crop"></div>
+			<div class="pagedjs_marks-middle">
+				<div class="pagedjs_marks-cross"></div>
+			</div>		<div class="pagedjs_marks-crop"></div>
+		</div>
+		<div class="pagedjs_bleed pagedjs_bleed-right">
+			<div class="pagedjs_marks-crop"></div>
+			<div class="pagedjs_marks-middle">
+				<div class="pagedjs_marks-cross"></div>
+			</div>
+			<div class="pagedjs_marks-crop"></div>
+		</div>
+		<div class="pagedjs_pagebox">
+			<div class="pagedjs_margin-top-left-corner-holder">
+				<div class="pagedjs_margin pagedjs_margin-top-left-corner"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_margin-top">
+				<div class="pagedjs_margin pagedjs_margin-top-left"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-top-center"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-top-right"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_margin-top-right-corner-holder">
+				<div class="pagedjs_margin pagedjs_margin-top-right-corner"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_margin-right">
+				<div class="pagedjs_margin pagedjs_margin-right-top"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-right-middle"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-right-bottom"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_margin-left">
+				<div class="pagedjs_margin pagedjs_margin-left-top"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-left-middle"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-left-bottom"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_margin-bottom-left-corner-holder">
+				<div class="pagedjs_margin pagedjs_margin-bottom-left-corner"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_margin-bottom">
+				<div class="pagedjs_margin pagedjs_margin-bottom-left"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-bottom-center"><div class="pagedjs_margin-content"></div></div>
+				<div class="pagedjs_margin pagedjs_margin-bottom-right"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_margin-bottom-right-corner-holder">
+				<div class="pagedjs_margin pagedjs_margin-bottom-right-corner"><div class="pagedjs_margin-content"></div></div>
+			</div>
+			<div class="pagedjs_area">
+				<div class="pagedjs_page_content"></div>
+			</div>
+		</div>
+	</div>
+</div>`;
+
+	/**
+	 * Chop up text into flows
+	 * @class
+	 */
+	class Chunker {
+		constructor(content, renderTo) {
+			// this.preview = preview;
+
+			this.hooks = {};
+			this.hooks.beforeParsed = new Hook(this);
+			this.hooks.afterParsed = new Hook(this);
+			this.hooks.beforePageLayout = new Hook(this);
+			this.hooks.layout = new Hook(this);
+			this.hooks.renderNode = new Hook(this);
+			this.hooks.layoutNode = new Hook(this);
+			this.hooks.onOverflow = new Hook(this);
+			this.hooks.onBreakToken = new Hook();
+			this.hooks.afterPageLayout = new Hook(this);
+			this.hooks.afterRendered = new Hook(this);
+
+			this.pages = [];
+			this._total = 0;
+
+			this.q = new Queue(this);
+			this.stopped = false;
+			this.rendered = false;
+
+			this.content = content;
+
+			this.charsPerBreak = [];
+			this.maxChars;
+
+			if (content) {
+				this.flow(content, renderTo);
+			}
+		}
+
+		setup(renderTo) {
+			this.pagesArea = document.createElement("div");
+			this.pagesArea.classList.add("pagedjs_pages");
+
+			if (renderTo) {
+				renderTo.appendChild(this.pagesArea);
+			} else {
+				document.querySelector("body").appendChild(this.pagesArea);
+			}
+
+			this.pageTemplate = document.createElement("template");
+			this.pageTemplate.innerHTML = TEMPLATE;
+
+		}
+
+		async flow(content, renderTo) {
+			let parsed;
+
+			await this.hooks.beforeParsed.trigger(content, this);
+
+			parsed = new ContentParser(content);
+
+			this.source = parsed;
+			this.breakToken = undefined;
+
+			if (this.pagesArea && this.pageTemplate) {
+				this.q.clear();
+				this.removePages();
+			} else {
+				this.setup(renderTo);
+			}
+
+			this.emit("rendering", content);
+
+			await this.hooks.afterParsed.trigger(parsed, this);
+
+			await this.loadFonts();
+
+			let rendered = await this.render(parsed, this.breakToken);
+			while (rendered.canceled) {
+				this.start();
+				rendered = await this.render(parsed, this.breakToken);
+			}
+
+			this.rendered = true;
+
+			await this.hooks.afterRendered.trigger(this.pages, this);
+
+			this.emit("rendered", this.pages);
+
+			return this;
+		}
+
+		// oversetPages() {
+		// 	let overset = [];
+		// 	for (let i = 0; i < this.pages.length; i++) {
+		// 		let page = this.pages[i];
+		// 		if (page.overset) {
+		// 			overset.push(page);
+		// 			// page.overset = false;
+		// 		}
+		// 	}
+		// 	return overset;
+		// }
+		//
+		// async handleOverset(parsed) {
+		// 	let overset = this.oversetPages();
+		// 	if (overset.length) {
+		// 		console.log("overset", overset);
+		// 		let index = this.pages.indexOf(overset[0]) + 1;
+		// 		console.log("INDEX", index);
+		//
+		// 		// Remove pages
+		// 		// this.removePages(index);
+		//
+		// 		// await this.render(parsed, overset[0].overset);
+		//
+		// 		// return this.handleOverset(parsed);
+		// 	}
+		// }
+
+		async render(parsed, startAt) {
+			let renderer = this.layout(parsed, startAt);
+
+			let done = false;
+			let result;
+
+			while (!done) {
+				result = await this.q.enqueue(() => { return this.renderAsync(renderer); });
+				done = result.done;
+			}
+
+			return result;
+		}
+
+		start() {
+			this.rendered = false;
+			this.stopped = false;
+		}
+
+		stop() {
+			this.stopped = true;
+			// this.q.clear();
+		}
+
+		renderOnIdle(renderer) {
+			return new Promise(resolve => {
+				requestIdleCallback(async () => {
+					if (this.stopped) {
+						return resolve({ done: true, canceled: true });
+					}
+					let result = await renderer.next();
+					if (this.stopped) {
+						resolve({ done: true, canceled: true });
+					} else {
+						resolve(result);
+					}
+				});
+			});
+		}
+
+		async renderAsync(renderer) {
+			if (this.stopped) {
+				return { done: true, canceled: true };
+			}
+			let result = await renderer.next();
+			if (this.stopped) {
+				return { done: true, canceled: true };
+			} else {
+				return result;
+			}
+		}
+
+		async handleBreaks(node) {
+			let currentPage = this.total + 1;
+			let currentPosition = currentPage % 2 === 0 ? "left" : "right";
+			// TODO: Recto and Verso should reverse for rtl languages
+			let currentSide = currentPage % 2 === 0 ? "verso" : "recto";
+			let previousBreakAfter;
+			let breakBefore;
+			let page;
+
+			if (currentPage === 1) {
+				return;
+			}
+
+			if (node &&
+					typeof node.dataset !== "undefined" &&
+					typeof node.dataset.previousBreakAfter !== "undefined") {
+				previousBreakAfter = node.dataset.previousBreakAfter;
+			}
+
+			if (node &&
+					typeof node.dataset !== "undefined" &&
+					typeof node.dataset.breakBefore !== "undefined") {
+				breakBefore = node.dataset.breakBefore;
+			}
+
+			if( previousBreakAfter &&
+					(previousBreakAfter === "left" || previousBreakAfter === "right") &&
+					previousBreakAfter !== currentPosition) {
+				page = this.addPage(true);
+			} else if( previousBreakAfter &&
+					(previousBreakAfter === "verso" || previousBreakAfter === "recto") &&
+					previousBreakAfter !== currentSide) {
+				page = this.addPage(true);
+			} else if( breakBefore &&
+					(breakBefore === "left" || breakBefore === "right") &&
+					breakBefore !== currentPosition) {
+				page = this.addPage(true);
+			} else if( breakBefore &&
+					(breakBefore === "verso" || breakBefore === "recto") &&
+					breakBefore !== currentSide) {
+				page = this.addPage(true);
+			}
+
+			if (page) {
+				await this.hooks.beforePageLayout.trigger(page, undefined, undefined, this);
+				this.emit("page", page);
+				// await this.hooks.layout.trigger(page.element, page, undefined, this);
+				await this.hooks.afterPageLayout.trigger(page.element, page, undefined, this);
+				this.emit("renderedPage", page);
+			}
+		}
+
+		async *layout(content, startAt) {
+			let breakToken = startAt || false;
+
+			while (breakToken !== undefined && (true)) {
+
+				if (breakToken && breakToken.node) {
+					await this.handleBreaks(breakToken.node);
+				} else {
+					await this.handleBreaks(content.firstChild);
+				}
+
+				let page = this.addPage();
+
+				await this.hooks.beforePageLayout.trigger(page, content, breakToken, this);
+				this.emit("page", page);
+
+				// Layout content in the page, starting from the breakToken
+				breakToken = await page.layout(content, breakToken, this.maxChars);
+
+				await this.hooks.afterPageLayout.trigger(page.element, page, breakToken, this);
+				this.emit("renderedPage", page);
+
+				this.recoredCharLength(page.wrapper.textContent.length);
+
+				yield breakToken;
+
+				// Stop if we get undefined, showing we have reached the end of the content
+			}
+		}
+
+		recoredCharLength(length) {
+			if (length === 0) {
+				return;
+			}
+
+			this.charsPerBreak.push(length);
+
+			// Keep the length of the last few breaks
+			if (this.charsPerBreak.length > 4) {
+				this.charsPerBreak.shift();
+			}
+
+			this.maxChars = this.charsPerBreak.reduce((a, b) => a + b, 0) / (this.charsPerBreak.length);
+		}
+
+		removePages(fromIndex=0) {
+
+			if (fromIndex >= this.pages.length) {
+				return;
+			}
+
+			// Remove pages
+			for (let i = fromIndex; i < this.pages.length; i++) {
+				this.pages[i].destroy();
+			}
+
+			if (fromIndex > 0) {
+				this.pages.splice(fromIndex);
+			} else {
+				this.pages = [];
+			}
+		}
+
+		addPage(blank) {
+			let lastPage = this.pages[this.pages.length - 1];
+			// Create a new page from the template
+			let page = new Page(this.pagesArea, this.pageTemplate, blank, this.hooks);
+
+			this.pages.push(page);
+
+			// Create the pages
+			page.create(undefined, lastPage && lastPage.element);
+
+			page.index(this.total);
+
+			if (!blank) {
+				// Listen for page overflow
+				page.onOverflow((overflowToken) => {
+					console.warn("overflow on", page.id, overflowToken);
+
+					// Only reflow while rendering
+					if (this.rendered) {
+						return;
+					}
+
+					let index = this.pages.indexOf(page) + 1;
+
+					// Stop the rendering
+					this.stop();
+
+					// Set the breakToken to resume at
+					this.breakToken = overflowToken;
+
+					// Remove pages
+					this.removePages(index);
+
+					if (this.rendered === true) {
+						this.rendered = false;
+
+						this.q.enqueue(async () => {
+
+							this.start();
+
+							await this.render(this.source, this.breakToken);
+
+							this.rendered = true;
+
+						});
+					}
+
+
+				});
+
+				page.onUnderflow((overflowToken) => {
+					// console.log("underflow on", page.id, overflowToken);
+
+					// page.append(this.source, overflowToken);
+
+				});
+			}
+
+			this.total = this.pages.length;
+
+			return page;
+		}
+		/*
+		insertPage(index, blank) {
+			let lastPage = this.pages[index];
+			// Create a new page from the template
+			let page = new Page(this.pagesArea, this.pageTemplate, blank, this.hooks);
+
+			let total = this.pages.splice(index, 0, page);
+
+			// Create the pages
+			page.create(undefined, lastPage && lastPage.element);
+
+			page.index(index + 1);
+
+			for (let i = index + 2; i < this.pages.length; i++) {
+				this.pages[i].index(i);
+			}
+
+			if (!blank) {
+				// Listen for page overflow
+				page.onOverflow((overflowToken) => {
+					if (total < this.pages.length) {
+						this.pages[total].layout(this.source, overflowToken);
+					} else {
+						let newPage = this.addPage();
+						newPage.layout(this.source, overflowToken);
+					}
+				});
+
+				page.onUnderflow(() => {
+					// console.log("underflow on", page.id);
+				});
+			}
+
+			this.total += 1;
+
+			return page;
+		}
+		*/
+
+		get total() {
+			return this._total;
+		}
+
+		set total(num) {
+			this.pagesArea.style.setProperty("--pagedjs-page-count", num);
+			this._total = num;
+		}
+
+		loadFonts() {
+			let fontPromises = [];
+			document.fonts.forEach((fontFace) => {
+				if (fontFace.status !== "loaded") {
+					let fontLoaded = fontFace.load().then((r) => {
+						return fontFace.family;
+					}, (r) => {
+						console.warn("Failed to preload font-family:", fontFace.family);
+						return fontFace.family;
+					});
+					fontPromises.push(fontLoaded);
+				}
+			});
+			return Promise.all(fontPromises).catch((err) => {
+				console.warn(err);
+			});
+		}
+
+		destroy() {
+			this.pagesArea.remove();
+			this.pageTemplate.remove();
+		}
+
+	}
+
+	eventEmitter(Chunker.prototype);
+
+	//
+	//            item        item        item        item
+	//          /------\    /------\    /------\    /------\
+	//          | data |    | data |    | data |    | data |
+	//  null <--+-prev |<---+-prev |<---+-prev |<---+-prev |
+	//          | next-+--->| next-+--->| next-+--->| next-+--> null
+	//          \------/    \------/    \------/    \------/
+	//             ^                                    ^
+	//             |                list                |
+	//             |              /------\              |
+	//             \--------------+-head |              |
+	//                            | tail-+--------------/
+	//                            \------/
+	//
+
+	function createItem(data) {
+	    return {
+	        prev: null,
+	        next: null,
+	        data: data
+	    };
+	}
+
+	function allocateCursor(node, prev, next) {
+	    var cursor;
+
+	    if (cursors !== null) {
+	        cursor = cursors;
+	        cursors = cursors.cursor;
+	        cursor.prev = prev;
+	        cursor.next = next;
+	        cursor.cursor = node.cursor;
+	    } else {
+	        cursor = {
+	            prev: prev,
+	            next: next,
+	            cursor: node.cursor
+	        };
+	    }
+
+	    node.cursor = cursor;
+
+	    return cursor;
+	}
+
+	function releaseCursor(node) {
+	    var cursor = node.cursor;
+
+	    node.cursor = cursor.cursor;
+	    cursor.prev = null;
+	    cursor.next = null;
+	    cursor.cursor = cursors;
+	    cursors = cursor;
+	}
+
+	var cursors = null;
+	var List = function() {
+	    this.cursor = null;
+	    this.head = null;
+	    this.tail = null;
+	};
+
+	List.createItem = createItem;
+	List.prototype.createItem = createItem;
+
+	List.prototype.updateCursors = function(prevOld, prevNew, nextOld, nextNew) {
+	    var cursor = this.cursor;
+
+	    while (cursor !== null) {
+	        if (cursor.prev === prevOld) {
+	            cursor.prev = prevNew;
+	        }
+
+	        if (cursor.next === nextOld) {
+	            cursor.next = nextNew;
+	        }
+
+	        cursor = cursor.cursor;
+	    }
+	};
+
+	List.prototype.getSize = function() {
+	    var size = 0;
+	    var cursor = this.head;
+
+	    while (cursor) {
+	        size++;
+	        cursor = cursor.next;
+	    }
+
+	    return size;
+	};
+
+	List.prototype.fromArray = function(array) {
+	    var cursor = null;
+
+	    this.head = null;
+
+	    for (var i = 0; i < array.length; i++) {
+	        var item = createItem(array[i]);
+
+	        if (cursor !== null) {
+	            cursor.next = item;
+	        } else {
+	            this.head = item;
+	        }
+
+	        item.prev = cursor;
+	        cursor = item;
+	    }
+
+	    this.tail = cursor;
+
+	    return this;
+	};
+
+	List.prototype.toArray = function() {
+	    var cursor = this.head;
+	    var result = [];
+
+	    while (cursor) {
+	        result.push(cursor.data);
+	        cursor = cursor.next;
+	    }
+
+	    return result;
+	};
+
+	List.prototype.toJSON = List.prototype.toArray;
+
+	List.prototype.isEmpty = function() {
+	    return this.head === null;
+	};
+
+	List.prototype.first = function() {
+	    return this.head && this.head.data;
+	};
+
+	List.prototype.last = function() {
+	    return this.tail && this.tail.data;
+	};
+
+	List.prototype.each = function(fn, context) {
+	    var item;
+
+	    if (context === undefined) {
+	        context = this;
+	    }
+
+	    // push cursor
+	    var cursor = allocateCursor(this, null, this.head);
+
+	    while (cursor.next !== null) {
+	        item = cursor.next;
+	        cursor.next = item.next;
+
+	        fn.call(context, item.data, item, this);
+	    }
+
+	    // pop cursor
+	    releaseCursor(this);
+	};
+
+	List.prototype.forEach = List.prototype.each;
+
+	List.prototype.eachRight = function(fn, context) {
+	    var item;
+
+	    if (context === undefined) {
+	        context = this;
+	    }
+
+	    // push cursor
+	    var cursor = allocateCursor(this, this.tail, null);
+
+	    while (cursor.prev !== null) {
+	        item = cursor.prev;
+	        cursor.prev = item.prev;
+
+	        fn.call(context, item.data, item, this);
+	    }
+
+	    // pop cursor
+	    releaseCursor(this);
+	};
+
+	List.prototype.forEachRight = List.prototype.eachRight;
+
+	List.prototype.nextUntil = function(start, fn, context) {
+	    if (start === null) {
+	        return;
+	    }
+
+	    var item;
+
+	    if (context === undefined) {
+	        context = this;
+	    }
+
+	    // push cursor
+	    var cursor = allocateCursor(this, null, start);
+
+	    while (cursor.next !== null) {
+	        item = cursor.next;
+	        cursor.next = item.next;
+
+	        if (fn.call(context, item.data, item, this)) {
+	            break;
+	        }
+	    }
+
+	    // pop cursor
+	    releaseCursor(this);
+	};
+
+	List.prototype.prevUntil = function(start, fn, context) {
+	    if (start === null) {
+	        return;
+	    }
+
+	    var item;
+
+	    if (context === undefined) {
+	        context = this;
+	    }
+
+	    // push cursor
+	    var cursor = allocateCursor(this, start, null);
+
+	    while (cursor.prev !== null) {
+	        item = cursor.prev;
+	        cursor.prev = item.prev;
+
+	        if (fn.call(context, item.data, item, this)) {
+	            break;
+	        }
+	    }
+
+	    // pop cursor
+	    releaseCursor(this);
+	};
+
+	List.prototype.some = function(fn, context) {
+	    var cursor = this.head;
+
+	    if (context === undefined) {
+	        context = this;
+	    }
+
+	    while (cursor !== null) {
+	        if (fn.call(context, cursor.data, cursor, this)) {
+	            return true;
+	        }
+
+	        cursor = cursor.next;
+	    }
+
+	    return false;
+	};
+
+	List.prototype.map = function(fn, context) {
+	    var result = new List();
+	    var cursor = this.head;
+
+	    if (context === undefined) {
+	        context = this;
+	    }
+
+	    while (cursor !== null) {
+	        result.appendData(fn.call(context, cursor.data, cursor, this));
+	        cursor = cursor.next;
+	    }
+
+	    return result;
+	};
+
+	List.prototype.filter = function(fn, context) {
+	    var result = new List();
+	    var cursor = this.head;
+
+	    if (context === undefined) {
+	        context = this;
+	    }
+
+	    while (cursor !== null) {
+	        if (fn.call(context, cursor.data, cursor, this)) {
+	            result.appendData(cursor.data);
+	        }
+	        cursor = cursor.next;
+	    }
+
+	    return result;
+	};
+
+	List.prototype.clear = function() {
+	    this.head = null;
+	    this.tail = null;
+	};
+
+	List.prototype.copy = function() {
+	    var result = new List();
+	    var cursor = this.head;
+
+	    while (cursor !== null) {
+	        result.insert(createItem(cursor.data));
+	        cursor = cursor.next;
+	    }
+
+	    return result;
+	};
+
+	List.prototype.prepend = function(item) {
+	    //      head
+	    //    ^
+	    // item
+	    this.updateCursors(null, item, this.head, item);
+
+	    // insert to the beginning of the list
+	    if (this.head !== null) {
+	        // new item <- first item
+	        this.head.prev = item;
+
+	        // new item -> first item
+	        item.next = this.head;
+	    } else {
+	        // if list has no head, then it also has no tail
+	        // in this case tail points to the new item
+	        this.tail = item;
+	    }
+
+	    // head always points to new item
+	    this.head = item;
+
+	    return this;
+	};
+
+	List.prototype.prependData = function(data) {
+	    return this.prepend(createItem(data));
+	};
+
+	List.prototype.append = function(item) {
+	    return this.insert(item);
+	};
+
+	List.prototype.appendData = function(data) {
+	    return this.insert(createItem(data));
+	};
+
+	List.prototype.insert = function(item, before) {
+	    if (before !== undefined && before !== null) {
+	        // prev   before
+	        //      ^
+	        //     item
+	        this.updateCursors(before.prev, item, before, item);
+
+	        if (before.prev === null) {
+	            // insert to the beginning of list
+	            if (this.head !== before) {
+	                throw new Error('before doesn\'t belong to list');
+	            }
+
+	            // since head points to before therefore list doesn't empty
+	            // no need to check tail
+	            this.head = item;
+	            before.prev = item;
+	            item.next = before;
+
+	            this.updateCursors(null, item);
+	        } else {
+
+	            // insert between two items
+	            before.prev.next = item;
+	            item.prev = before.prev;
+
+	            before.prev = item;
+	            item.next = before;
+	        }
+	    } else {
+	        // tail
+	        //      ^
+	        //      item
+	        this.updateCursors(this.tail, item, null, item);
+
+	        // insert to the ending of the list
+	        if (this.tail !== null) {
+	            // last item -> new item
+	            this.tail.next = item;
+
+	            // last item <- new item
+	            item.prev = this.tail;
+	        } else {
+	            // if list has no tail, then it also has no head
+	            // in this case head points to new item
+	            this.head = item;
+	        }
+
+	        // tail always points to new item
+	        this.tail = item;
+	    }
+
+	    return this;
+	};
+
+	List.prototype.insertData = function(data, before) {
+	    return this.insert(createItem(data), before);
+	};
+
+	List.prototype.remove = function(item) {
+	    //      item
+	    //       ^
+	    // prev     next
+	    this.updateCursors(item, item.prev, item, item.next);
+
+	    if (item.prev !== null) {
+	        item.prev.next = item.next;
+	    } else {
+	        if (this.head !== item) {
+	            throw new Error('item doesn\'t belong to list');
+	        }
+
+	        this.head = item.next;
+	    }
+
+	    if (item.next !== null) {
+	        item.next.prev = item.prev;
+	    } else {
+	        if (this.tail !== item) {
+	            throw new Error('item doesn\'t belong to list');
+	        }
+
+	        this.tail = item.prev;
+	    }
+
+	    item.prev = null;
+	    item.next = null;
+
+	    return item;
+	};
+
+	List.prototype.push = function(data) {
+	    this.insert(createItem(data));
+	};
+
+	List.prototype.pop = function() {
+	    if (this.tail !== null) {
+	        return this.remove(this.tail);
+	    }
+	};
+
+	List.prototype.unshift = function(data) {
+	    this.prepend(createItem(data));
+	};
+
+	List.prototype.shift = function() {
+	    if (this.head !== null) {
+	        return this.remove(this.head);
+	    }
+	};
+
+	List.prototype.prependList = function(list) {
+	    return this.insertList(list, this.head);
+	};
+
+	List.prototype.appendList = function(list) {
+	    return this.insertList(list);
+	};
+
+	List.prototype.insertList = function(list, before) {
+	    // ignore empty lists
+	    if (list.head === null) {
+	        return this;
+	    }
+
+	    if (before !== undefined && before !== null) {
+	        this.updateCursors(before.prev, list.tail, before, list.head);
+
+	        // insert in the middle of dist list
+	        if (before.prev !== null) {
+	            // before.prev <-> list.head
+	            before.prev.next = list.head;
+	            list.head.prev = before.prev;
+	        } else {
+	            this.head = list.head;
+	        }
+
+	        before.prev = list.tail;
+	        list.tail.next = before;
+	    } else {
+	        this.updateCursors(this.tail, list.tail, null, list.head);
+
+	        // insert to end of the list
+	        if (this.tail !== null) {
+	            // if destination list has a tail, then it also has a head,
+	            // but head doesn't change
+
+	            // dest tail -> source head
+	            this.tail.next = list.head;
+
+	            // dest tail <- source head
+	            list.head.prev = this.tail;
+	        } else {
+	            // if list has no a tail, then it also has no a head
+	            // in this case points head to new item
+	            this.head = list.head;
+	        }
+
+	        // tail always start point to new item
+	        this.tail = list.tail;
+	    }
+
+	    list.head = null;
+	    list.tail = null;
+
+	    return this;
+	};
+
+	List.prototype.replace = function(oldItem, newItemOrList) {
+	    if ('head' in newItemOrList) {
+	        this.insertList(newItemOrList, oldItem);
+	    } else {
+	        this.insert(newItemOrList, oldItem);
+	    }
+
+	    this.remove(oldItem);
+	};
+
+	var list = List;
+
+	var createCustomError = function createCustomError(name, message) {
+	    // use Object.create(), because some VMs prevent setting line/column otherwise
+	    // (iOS Safari 10 even throws an exception)
+	    var error = Object.create(SyntaxError.prototype);
+	    var errorStack = new Error();
+
+	    error.name = name;
+	    error.message = message;
+
+	    Object.defineProperty(error, 'stack', {
+	        get: function() {
+	            return (errorStack.stack || '').replace(/^(.+\n){1,3}/, name + ': ' + message + '\n');
+	        }
+	    });
+
+	    return error;
+	};
+
+	var MAX_LINE_LENGTH = 100;
+	var OFFSET_CORRECTION = 60;
+	var TAB_REPLACEMENT = '    ';
+
+	function sourceFragment(error, extraLines) {
+	    function processLines(start, end) {
+	        return lines.slice(start, end).map(function(line, idx) {
+	            var num = String(start + idx + 1);
+
+	            while (num.length < maxNumLength) {
+	                num = ' ' + num;
+	            }
+
+	            return num + ' |' + line;
+	        }).join('\n');
+	    }
+
+	    var lines = error.source.split(/\r\n?|\n|\f/);
+	    var line = error.line;
+	    var column = error.column;
+	    var startLine = Math.max(1, line - extraLines) - 1;
+	    var endLine = Math.min(line + extraLines, lines.length + 1);
+	    var maxNumLength = Math.max(4, String(endLine).length) + 1;
+	    var cutLeft = 0;
+
+	    // column correction according to replaced tab before column
+	    column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length;
+
+	    if (column > MAX_LINE_LENGTH) {
+	        cutLeft = column - OFFSET_CORRECTION + 3;
+	        column = OFFSET_CORRECTION - 2;
+	    }
+
+	    for (var i = startLine; i <= endLine; i++) {
+	        if (i >= 0 && i < lines.length) {
+	            lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT);
+	            lines[i] =
+	                (cutLeft > 0 && lines[i].length > cutLeft ? '\u2026' : '') +
+	                lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +
+	                (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\u2026' : '');
+	        }
+	    }
+
+	    return [
+	        processLines(startLine, line),
+	        new Array(column + maxNumLength + 2).join('-') + '^',
+	        processLines(line, endLine)
+	    ].filter(Boolean).join('\n');
+	}
+
+	var CssSyntaxError = function(message, source, offset, line, column) {
+	    var error = createCustomError('CssSyntaxError', message);
+
+	    error.source = source;
+	    error.offset = offset;
+	    error.line = line;
+	    error.column = column;
+
+	    error.sourceFragment = function(extraLines) {
+	        return sourceFragment(error, isNaN(extraLines) ? 0 : extraLines);
+	    };
+	    Object.defineProperty(error, 'formattedMessage', {
+	        get: function() {
+	            return (
+	                'Parse error: ' + error.message + '\n' +
+	                sourceFragment(error, 2)
+	            );
+	        }
+	    });
+
+	    // for backward capability
+	    error.parseError = {
+	        offset: offset,
+	        line: line,
+	        column: column
+	    };
+
+	    return error;
+	};
+
+	var error = CssSyntaxError;
+
+	// token types (note: value shouldn't intersect with used char codes)
+	var WHITESPACE = 1;
+	var IDENTIFIER = 2;
+	var NUMBER = 3;
+	var STRING = 4;
+	var COMMENT = 5;
+	var PUNCTUATOR = 6;
+	var CDO = 7;
+	var CDC = 8;
+	var ATKEYWORD = 14;
+	var FUNCTION = 15;
+	var URL$1 = 16;
+	var RAW = 17;
+
+	var TAB = 9;
+	var N = 10;
+	var F = 12;
+	var R = 13;
+	var SPACE = 32;
+
+	var TYPE = {
+	    WhiteSpace:   WHITESPACE,
+	    Identifier:   IDENTIFIER,
+	    Number:           NUMBER,
+	    String:           STRING,
+	    Comment:         COMMENT,
+	    Punctuator:   PUNCTUATOR,
+	    CDO:                 CDO,
+	    CDC:                 CDC,
+	    AtKeyword:     ATKEYWORD,
+	    Function:       FUNCTION,
+	    Url:                 URL$1,
+	    Raw:                 RAW,
+
+	    ExclamationMark:      33,  // !
+	    QuotationMark:        34,  // "
+	    NumberSign:           35,  // #
+	    DollarSign:           36,  // $
+	    PercentSign:          37,  // %
+	    Ampersand:            38,  // &
+	    Apostrophe:           39,  // '
+	    LeftParenthesis:      40,  // (
+	    RightParenthesis:     41,  // )
+	    Asterisk:             42,  // *
+	    PlusSign:             43,  // +
+	    Comma:                44,  // ,
+	    HyphenMinus:          45,  // -
+	    FullStop:             46,  // .
+	    Solidus:              47,  // /
+	    Colon:                58,  // :
+	    Semicolon:            59,  // ;
+	    LessThanSign:         60,  // <
+	    EqualsSign:           61,  // =
+	    GreaterThanSign:      62,  // >
+	    QuestionMark:         63,  // ?
+	    CommercialAt:         64,  // @
+	    LeftSquareBracket:    91,  // [
+	    Backslash:            92,  // \
+	    RightSquareBracket:   93,  // ]
+	    CircumflexAccent:     94,  // ^
+	    LowLine:              95,  // _
+	    GraveAccent:          96,  // `
+	    LeftCurlyBracket:    123,  // {
+	    VerticalLine:        124,  // |
+	    RightCurlyBracket:   125,  // }
+	    Tilde:               126   // ~
+	};
+
+	var NAME = Object.keys(TYPE).reduce(function(result, key) {
+	    result[TYPE[key]] = key;
+	    return result;
+	}, {});
+
+	// https://drafts.csswg.org/css-syntax/#tokenizer-definitions
+	// > non-ASCII code point
+	// >   A code point with a value equal to or greater than U+0080 <control>
+	// > name-start code point
+	// >   A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+	// > name code point
+	// >   A name-start code point, a digit, or U+002D HYPHEN-MINUS (-)
+	// That means only ASCII code points has a special meaning and we a maps for 0..127 codes only
+	var SafeUint32Array = typeof Uint32Array !== 'undefined' ? Uint32Array : Array; // fallback on Array when TypedArray is not supported
+	var SYMBOL_TYPE = new SafeUint32Array(0x80);
+	var PUNCTUATION = new SafeUint32Array(0x80);
+	var STOP_URL_RAW = new SafeUint32Array(0x80);
+
+	for (var i = 0; i < SYMBOL_TYPE.length; i++) {
+	    SYMBOL_TYPE[i] = IDENTIFIER;
+	}
+
+	// fill categories
+	[
+	    TYPE.ExclamationMark,    // !
+	    TYPE.QuotationMark,      // "
+	    TYPE.NumberSign,         // #
+	    TYPE.DollarSign,         // $
+	    TYPE.PercentSign,        // %
+	    TYPE.Ampersand,          // &
+	    TYPE.Apostrophe,         // '
+	    TYPE.LeftParenthesis,    // (
+	    TYPE.RightParenthesis,   // )
+	    TYPE.Asterisk,           // *
+	    TYPE.PlusSign,           // +
+	    TYPE.Comma,              // ,
+	    TYPE.HyphenMinus,        // -
+	    TYPE.FullStop,           // .
+	    TYPE.Solidus,            // /
+	    TYPE.Colon,              // :
+	    TYPE.Semicolon,          // ;
+	    TYPE.LessThanSign,       // <
+	    TYPE.EqualsSign,         // =
+	    TYPE.GreaterThanSign,    // >
+	    TYPE.QuestionMark,       // ?
+	    TYPE.CommercialAt,       // @
+	    TYPE.LeftSquareBracket,  // [
+	    // TYPE.Backslash,          // \
+	    TYPE.RightSquareBracket, // ]
+	    TYPE.CircumflexAccent,   // ^
+	    // TYPE.LowLine,            // _
+	    TYPE.GraveAccent,        // `
+	    TYPE.LeftCurlyBracket,   // {
+	    TYPE.VerticalLine,       // |
+	    TYPE.RightCurlyBracket,  // }
+	    TYPE.Tilde               // ~
+	].forEach(function(key) {
+	    SYMBOL_TYPE[Number(key)] = PUNCTUATOR;
+	    PUNCTUATION[Number(key)] = PUNCTUATOR;
+	});
+
+	for (var i = 48; i <= 57; i++) {
+	    SYMBOL_TYPE[i] = NUMBER;
+	}
+
+	SYMBOL_TYPE[SPACE] = WHITESPACE;
+	SYMBOL_TYPE[TAB] = WHITESPACE;
+	SYMBOL_TYPE[N] = WHITESPACE;
+	SYMBOL_TYPE[R] = WHITESPACE;
+	SYMBOL_TYPE[F] = WHITESPACE;
+
+	SYMBOL_TYPE[TYPE.Apostrophe] = STRING;
+	SYMBOL_TYPE[TYPE.QuotationMark] = STRING;
+
+	STOP_URL_RAW[SPACE] = 1;
+	STOP_URL_RAW[TAB] = 1;
+	STOP_URL_RAW[N] = 1;
+	STOP_URL_RAW[R] = 1;
+	STOP_URL_RAW[F] = 1;
+	STOP_URL_RAW[TYPE.Apostrophe] = 1;
+	STOP_URL_RAW[TYPE.QuotationMark] = 1;
+	STOP_URL_RAW[TYPE.LeftParenthesis] = 1;
+	STOP_URL_RAW[TYPE.RightParenthesis] = 1;
+
+	// whitespace is punctuation ...
+	PUNCTUATION[SPACE] = PUNCTUATOR;
+	PUNCTUATION[TAB] = PUNCTUATOR;
+	PUNCTUATION[N] = PUNCTUATOR;
+	PUNCTUATION[R] = PUNCTUATOR;
+	PUNCTUATION[F] = PUNCTUATOR;
+	// ... hyper minus is not
+	PUNCTUATION[TYPE.HyphenMinus] = 0;
+
+	var _const = {
+	    TYPE: TYPE,
+	    NAME: NAME,
+
+	    SYMBOL_TYPE: SYMBOL_TYPE,
+	    PUNCTUATION: PUNCTUATION,
+	    STOP_URL_RAW: STOP_URL_RAW
+	};
+
+	var PUNCTUATION$1 = _const.PUNCTUATION;
+	var STOP_URL_RAW$1 = _const.STOP_URL_RAW;
+	var TYPE$1 = _const.TYPE;
+	var FULLSTOP = TYPE$1.FullStop;
+	var PLUSSIGN = TYPE$1.PlusSign;
+	var HYPHENMINUS = TYPE$1.HyphenMinus;
+	var PUNCTUATOR$1 = TYPE$1.Punctuator;
+	var TAB$1 = 9;
+	var N$1 = 10;
+	var F$1 = 12;
+	var R$1 = 13;
+	var SPACE$1 = 32;
+	var BACK_SLASH = 92;
+	var E = 101; // 'e'.charCodeAt(0)
+
+	function firstCharOffset(source) {
+	    // detect BOM (https://en.wikipedia.org/wiki/Byte_order_mark)
+	    if (source.charCodeAt(0) === 0xFEFF ||  // UTF-16BE
+	        source.charCodeAt(0) === 0xFFFE) {  // UTF-16LE
+	        return 1;
+	    }
+
+	    return 0;
+	}
+
+	function isHex(code) {
+	    return (code >= 48 && code <= 57) || // 0 .. 9
+	           (code >= 65 && code <= 70) || // A .. F
+	           (code >= 97 && code <= 102);  // a .. f
+	}
+
+	function isNumber(code) {
+	    return code >= 48 && code <= 57;
+	}
+
+	function isWhiteSpace(code) {
+	    return code === SPACE$1 || code === TAB$1 || isNewline(code);
+	}
+
+	function isNewline(code) {
+	    return code === R$1 || code === N$1 || code === F$1;
+	}
+
+	function getNewlineLength(source, offset, code) {
+	    if (isNewline(code)) {
+	        if (code === R$1 && offset + 1 < source.length && source.charCodeAt(offset + 1) === N$1) {
+	            return 2;
+	        }
+
+	        return 1;
+	    }
+
+	    return 0;
+	}
+
+	function cmpChar(testStr, offset, referenceCode) {
+	    var code = testStr.charCodeAt(offset);
+
+	    // code.toLowerCase() for A..Z
+	    if (code >= 65 && code <= 90) {
+	        code = code | 32;
+	    }
+
+	    return code === referenceCode;
+	}
+
+	function cmpStr(testStr, start, end, referenceStr) {
+	    if (end - start !== referenceStr.length) {
+	        return false;
+	    }
+
+	    if (start < 0 || end > testStr.length) {
+	        return false;
+	    }
+
+	    for (var i = start; i < end; i++) {
+	        var testCode = testStr.charCodeAt(i);
+	        var refCode = referenceStr.charCodeAt(i - start);
+
+	        // testCode.toLowerCase() for A..Z
+	        if (testCode >= 65 && testCode <= 90) {
+	            testCode = testCode | 32;
+	        }
+
+	        if (testCode !== refCode) {
+	            return false;
+	        }
+	    }
+
+	    return true;
+	}
+
+	function findWhiteSpaceStart(source, offset) {
+	    while (offset >= 0 && isWhiteSpace(source.charCodeAt(offset))) {
+	        offset--;
+	    }
+
+	    return offset + 1;
+	}
+
+	function findWhiteSpaceEnd(source, offset) {
+	    while (offset < source.length && isWhiteSpace(source.charCodeAt(offset))) {
+	        offset++;
+	    }
+
+	    return offset;
+	}
+
+	function findCommentEnd(source, offset) {
+	    var commentEnd = source.indexOf('*/', offset);
+
+	    if (commentEnd === -1) {
+	        return source.length;
+	    }
+
+	    return commentEnd + 2;
+	}
+
+	function findStringEnd(source, offset, quote) {
+	    for (; offset < source.length; offset++) {
+	        var code = source.charCodeAt(offset);
+
+	        // TODO: bad string
+	        if (code === BACK_SLASH) {
+	            offset++;
+	        } else if (code === quote) {
+	            offset++;
+	            break;
+	        }
+	    }
+
+	    return offset;
+	}
+
+	function findDecimalNumberEnd(source, offset) {
+	    while (offset < source.length && isNumber(source.charCodeAt(offset))) {
+	        offset++;
+	    }
+
+	    return offset;
+	}
+
+	function findNumberEnd(source, offset, allowFraction) {
+	    var code;
+
+	    offset = findDecimalNumberEnd(source, offset);
+
+	    // fraction: .\d+
+	    if (allowFraction && offset + 1 < source.length && source.charCodeAt(offset) === FULLSTOP) {
+	        code = source.charCodeAt(offset + 1);
+
+	        if (isNumber(code)) {
+	            offset = findDecimalNumberEnd(source, offset + 1);
+	        }
+	    }
+
+	    // exponent: e[+-]\d+
+	    if (offset + 1 < source.length) {
+	        if ((source.charCodeAt(offset) | 32) === E) { // case insensitive check for `e`
+	            code = source.charCodeAt(offset + 1);
+
+	            if (code === PLUSSIGN || code === HYPHENMINUS) {
+	                if (offset + 2 < source.length) {
+	                    code = source.charCodeAt(offset + 2);
+	                }
+	            }
+
+	            if (isNumber(code)) {
+	                offset = findDecimalNumberEnd(source, offset + 2);
+	            }
+	        }
+	    }
+
+	    return offset;
+	}
+
+	// skip escaped unicode sequence that can ends with space
+	// [0-9a-f]{1,6}(\r\n|[ \n\r\t\f])?
+	function findEscapeEnd(source, offset) {
+	    for (var i = 0; i < 7 && offset + i < source.length; i++) {
+	        var code = source.charCodeAt(offset + i);
+
+	        if (i !== 6 && isHex(code)) {
+	            continue;
+	        }
+
+	        if (i > 0) {
+	            offset += i - 1 + getNewlineLength(source, offset + i, code);
+	            if (code === SPACE$1 || code === TAB$1) {
+	                offset++;
+	            }
+	        }
+
+	        break;
+	    }
+
+	    return offset;
+	}
+
+	function findIdentifierEnd(source, offset) {
+	    for (; offset < source.length; offset++) {
+	        var code = source.charCodeAt(offset);
+
+	        if (code === BACK_SLASH) {
+	            offset = findEscapeEnd(source, offset + 1);
+	        } else if (code < 0x80 && PUNCTUATION$1[code] === PUNCTUATOR$1) {
+	            break;
+	        }
+	    }
+
+	    return offset;
+	}
+
+	function findUrlRawEnd(source, offset) {
+	    for (; offset < source.length; offset++) {
+	        var code = source.charCodeAt(offset);
+
+	        if (code === BACK_SLASH) {
+	            offset = findEscapeEnd(source, offset + 1);
+	        } else if (code < 0x80 && STOP_URL_RAW$1[code] === 1) {
+	            break;
+	        }
+	    }
+
+	    return offset;
+	}
+
+	var utils = {
+	    firstCharOffset: firstCharOffset,
+
+	    isHex: isHex,
+	    isNumber: isNumber,
+	    isWhiteSpace: isWhiteSpace,
+	    isNewline: isNewline,
+	    getNewlineLength: getNewlineLength,
+
+	    cmpChar: cmpChar,
+	    cmpStr: cmpStr,
+
+	    findWhiteSpaceStart: findWhiteSpaceStart,
+	    findWhiteSpaceEnd: findWhiteSpaceEnd,
+	    findCommentEnd: findCommentEnd,
+	    findStringEnd: findStringEnd,
+	    findDecimalNumberEnd: findDecimalNumberEnd,
+	    findNumberEnd: findNumberEnd,
+	    findEscapeEnd: findEscapeEnd,
+	    findIdentifierEnd: findIdentifierEnd,
+	    findUrlRawEnd: findUrlRawEnd
+	};
+
+	var TYPE$2 = _const.TYPE;
+	var NAME$1 = _const.NAME;
+	var SYMBOL_TYPE$1 = _const.SYMBOL_TYPE;
+
+
+	var firstCharOffset$1 = utils.firstCharOffset;
+	var cmpStr$1 = utils.cmpStr;
+	var isNumber$1 = utils.isNumber;
+	var findWhiteSpaceStart$1 = utils.findWhiteSpaceStart;
+	var findWhiteSpaceEnd$1 = utils.findWhiteSpaceEnd;
+	var findCommentEnd$1 = utils.findCommentEnd;
+	var findStringEnd$1 = utils.findStringEnd;
+	var findNumberEnd$1 = utils.findNumberEnd;
+	var findIdentifierEnd$1 = utils.findIdentifierEnd;
+	var findUrlRawEnd$1 = utils.findUrlRawEnd;
+
+	var NULL = 0;
+	var WHITESPACE$1 = TYPE$2.WhiteSpace;
+	var IDENTIFIER$1 = TYPE$2.Identifier;
+	var NUMBER$1 = TYPE$2.Number;
+	var STRING$1 = TYPE$2.String;
+	var COMMENT$1 = TYPE$2.Comment;
+	var PUNCTUATOR$2 = TYPE$2.Punctuator;
+	var CDO$1 = TYPE$2.CDO;
+	var CDC$1 = TYPE$2.CDC;
+	var ATKEYWORD$1 = TYPE$2.AtKeyword;
+	var FUNCTION$1 = TYPE$2.Function;
+	var URL$2 = TYPE$2.Url;
+	var RAW$1 = TYPE$2.Raw;
+
+	var N$2 = 10;
+	var F$2 = 12;
+	var R$2 = 13;
+	var STAR = TYPE$2.Asterisk;
+	var SLASH = TYPE$2.Solidus;
+	var FULLSTOP$1 = TYPE$2.FullStop;
+	var PLUSSIGN$1 = TYPE$2.PlusSign;
+	var HYPHENMINUS$1 = TYPE$2.HyphenMinus;
+	var GREATERTHANSIGN = TYPE$2.GreaterThanSign;
+	var LESSTHANSIGN = TYPE$2.LessThanSign;
+	var EXCLAMATIONMARK = TYPE$2.ExclamationMark;
+	var COMMERCIALAT = TYPE$2.CommercialAt;
+	var QUOTATIONMARK = TYPE$2.QuotationMark;
+	var APOSTROPHE = TYPE$2.Apostrophe;
+	var LEFTPARENTHESIS = TYPE$2.LeftParenthesis;
+	var RIGHTPARENTHESIS = TYPE$2.RightParenthesis;
+	var LEFTCURLYBRACKET = TYPE$2.LeftCurlyBracket;
+	var RIGHTCURLYBRACKET = TYPE$2.RightCurlyBracket;
+	var LEFTSQUAREBRACKET = TYPE$2.LeftSquareBracket;
+	var RIGHTSQUAREBRACKET = TYPE$2.RightSquareBracket;
+
+	var MIN_BUFFER_SIZE = 16 * 1024;
+	var OFFSET_MASK = 0x00FFFFFF;
+	var TYPE_SHIFT = 24;
+	var SafeUint32Array$1 = typeof Uint32Array !== 'undefined' ? Uint32Array : Array; // fallback on Array when TypedArray is not supported
+
+	function computeLinesAndColumns(tokenizer, source) {
+	    var sourceLength = source.length;
+	    var start = firstCharOffset$1(source);
+	    var lines = tokenizer.lines;
+	    var line = tokenizer.startLine;
+	    var columns = tokenizer.columns;
+	    var column = tokenizer.startColumn;
+
+	    if (lines === null || lines.length < sourceLength + 1) {
+	        lines = new SafeUint32Array$1(Math.max(sourceLength + 1024, MIN_BUFFER_SIZE));
+	        columns = new SafeUint32Array$1(lines.length);
+	    }
+
+	    for (var i = start; i < sourceLength; i++) {
+	        var code = source.charCodeAt(i);
+
+	        lines[i] = line;
+	        columns[i] = column++;
+
+	        if (code === N$2 || code === R$2 || code === F$2) {
+	            if (code === R$2 && i + 1 < sourceLength && source.charCodeAt(i + 1) === N$2) {
+	                i++;
+	                lines[i] = line;
+	                columns[i] = column;
+	            }
+
+	            line++;
+	            column = 1;
+	        }
+	    }
+
+	    lines[i] = line;
+	    columns[i] = column;
+
+	    tokenizer.linesAnsColumnsComputed = true;
+	    tokenizer.lines = lines;
+	    tokenizer.columns = columns;
+	}
+
+	function tokenLayout(tokenizer, source, startPos) {
+	    var sourceLength = source.length;
+	    var offsetAndType = tokenizer.offsetAndType;
+	    var balance = tokenizer.balance;
+	    var tokenCount = 0;
+	    var prevType = 0;
+	    var offset = startPos;
+	    var anchor = 0;
+	    var balanceCloseCode = 0;
+	    var balanceStart = 0;
+	    var balancePrev = 0;
+
+	    if (offsetAndType === null || offsetAndType.length < sourceLength + 1) {
+	        offsetAndType = new SafeUint32Array$1(sourceLength + 1024);
+	        balance = new SafeUint32Array$1(sourceLength + 1024);
+	    }
+
+	    while (offset < sourceLength) {
+	        var code = source.charCodeAt(offset);
+	        var type = code < 0x80 ? SYMBOL_TYPE$1[code] : IDENTIFIER$1;
+
+	        balance[tokenCount] = sourceLength;
+
+	        switch (type) {
+	            case WHITESPACE$1:
+	                offset = findWhiteSpaceEnd$1(source, offset + 1);
+	                break;
+
+	            case PUNCTUATOR$2:
+	                switch (code) {
+	                    case balanceCloseCode:
+	                        balancePrev = balanceStart & OFFSET_MASK;
+	                        balanceStart = balance[balancePrev];
+	                        balanceCloseCode = balanceStart >> TYPE_SHIFT;
+	                        balance[tokenCount] = balancePrev;
+	                        balance[balancePrev++] = tokenCount;
+	                        for (; balancePrev < tokenCount; balancePrev++) {
+	                            if (balance[balancePrev] === sourceLength) {
+	                                balance[balancePrev] = tokenCount;
+	                            }
+	                        }
+	                        break;
+
+	                    case LEFTSQUAREBRACKET:
+	                        balance[tokenCount] = balanceStart;
+	                        balanceCloseCode = RIGHTSQUAREBRACKET;
+	                        balanceStart = (balanceCloseCode << TYPE_SHIFT) | tokenCount;
+	                        break;
+
+	                    case LEFTCURLYBRACKET:
+	                        balance[tokenCount] = balanceStart;
+	                        balanceCloseCode = RIGHTCURLYBRACKET;
+	                        balanceStart = (balanceCloseCode << TYPE_SHIFT) | tokenCount;
+	                        break;
+
+	                    case LEFTPARENTHESIS:
+	                        balance[tokenCount] = balanceStart;
+	                        balanceCloseCode = RIGHTPARENTHESIS;
+	                        balanceStart = (balanceCloseCode << TYPE_SHIFT) | tokenCount;
+	                        break;
+	                }
+
+	                // /*
+	                if (code === STAR && prevType === SLASH) {
+	                    type = COMMENT$1;
+	                    offset = findCommentEnd$1(source, offset + 1);
+	                    tokenCount--; // rewrite prev token
+	                    break;
+	                }
+
+	                // edge case for -.123 and +.123
+	                if (code === FULLSTOP$1 && (prevType === PLUSSIGN$1 || prevType === HYPHENMINUS$1)) {
+	                    if (offset + 1 < sourceLength && isNumber$1(source.charCodeAt(offset + 1))) {
+	                        type = NUMBER$1;
+	                        offset = findNumberEnd$1(source, offset + 2, false);
+	                        tokenCount--; // rewrite prev token
+	                        break;
+	                    }
+	                }
+
+	                // <!--
+	                if (code === EXCLAMATIONMARK && prevType === LESSTHANSIGN) {
+	                    if (offset + 2 < sourceLength &&
+	                        source.charCodeAt(offset + 1) === HYPHENMINUS$1 &&
+	                        source.charCodeAt(offset + 2) === HYPHENMINUS$1) {
+	                        type = CDO$1;
+	                        offset = offset + 3;
+	                        tokenCount--; // rewrite prev token
+	                        break;
+	                    }
+	                }
+
+	                // -->
+	                if (code === HYPHENMINUS$1 && prevType === HYPHENMINUS$1) {
+	                    if (offset + 1 < sourceLength && source.charCodeAt(offset + 1) === GREATERTHANSIGN) {
+	                        type = CDC$1;
+	                        offset = offset + 2;
+	                        tokenCount--; // rewrite prev token
+	                        break;
+	                    }
+	                }
+
+	                // ident(
+	                if (code === LEFTPARENTHESIS && prevType === IDENTIFIER$1) {
+	                    offset = offset + 1;
+	                    tokenCount--; // rewrite prev token
+	                    balance[tokenCount] = balance[tokenCount + 1];
+	                    balanceStart--;
+
+	                    // 4 char length identifier and equal to `url(` (case insensitive)
+	                    if (offset - anchor === 4 && cmpStr$1(source, anchor, offset, 'url(')) {
+	                        // special case for url() because it can contain any symbols sequence with few exceptions
+	                        anchor = findWhiteSpaceEnd$1(source, offset);
+	                        code = source.charCodeAt(anchor);
+	                        if (code !== LEFTPARENTHESIS &&
+	                            code !== RIGHTPARENTHESIS &&
+	                            code !== QUOTATIONMARK &&
+	                            code !== APOSTROPHE) {
+	                            // url(
+	                            offsetAndType[tokenCount++] = (URL$2 << TYPE_SHIFT) | offset;
+	                            balance[tokenCount] = sourceLength;
+
+	                            // ws*
+	                            if (anchor !== offset) {
+	                                offsetAndType[tokenCount++] = (WHITESPACE$1 << TYPE_SHIFT) | anchor;
+	                                balance[tokenCount] = sourceLength;
+	                            }
+
+	                            // raw
+	                            type = RAW$1;
+	                            offset = findUrlRawEnd$1(source, anchor);
+	                        } else {
+	                            type = URL$2;
+	                        }
+	                    } else {
+	                        type = FUNCTION$1;
+	                    }
+	                    break;
+	                }
+
+	                type = code;
+	                offset = offset + 1;
+	                break;
+
+	            case NUMBER$1:
+	                offset = findNumberEnd$1(source, offset + 1, prevType !== FULLSTOP$1);
+
+	                // merge number with a preceding dot, dash or plus
+	                if (prevType === FULLSTOP$1 ||
+	                    prevType === HYPHENMINUS$1 ||
+	                    prevType === PLUSSIGN$1) {
+	                    tokenCount--; // rewrite prev token
+	                }
+
+	                break;
+
+	            case STRING$1:
+	                offset = findStringEnd$1(source, offset + 1, code);
+	                break;
+
+	            default:
+	                anchor = offset;
+	                offset = findIdentifierEnd$1(source, offset);
+
+	                // merge identifier with a preceding dash
+	                if (prevType === HYPHENMINUS$1) {
+	                    // rewrite prev token
+	                    tokenCount--;
+	                    // restore prev prev token type
+	                    // for case @-prefix-ident
+	                    prevType = tokenCount === 0 ? 0 : offsetAndType[tokenCount - 1] >> TYPE_SHIFT;
+	                }
+
+	                if (prevType === COMMERCIALAT) {
+	                    // rewrite prev token and change type to <at-keyword-token>
+	                    tokenCount--;
+	                    type = ATKEYWORD$1;
+	                }
+	        }
+
+	        offsetAndType[tokenCount++] = (type << TYPE_SHIFT) | offset;
+	        prevType = type;
+	    }
+
+	    // finalize arrays
+	    offsetAndType[tokenCount] = offset;
+	    balance[tokenCount] = sourceLength;
+	    balance[sourceLength] = sourceLength; // prevents false positive balance match with any token
+	    while (balanceStart !== 0) {
+	        balancePrev = balanceStart & OFFSET_MASK;
+	        balanceStart = balance[balancePrev];
+	        balance[balancePrev] = sourceLength;
+	    }
+
+	    tokenizer.offsetAndType = offsetAndType;
+	    tokenizer.tokenCount = tokenCount;
+	    tokenizer.balance = balance;
+	}
+
+	//
+	// tokenizer
+	//
+
+	var Tokenizer = function(source, startOffset, startLine, startColumn) {
+	    this.offsetAndType = null;
+	    this.balance = null;
+	    this.lines = null;
+	    this.columns = null;
+
+	    this.setSource(source, startOffset, startLine, startColumn);
+	};
+
+	Tokenizer.prototype = {
+	    setSource: function(source, startOffset, startLine, startColumn) {
+	        var safeSource = String(source || '');
+	        var start = firstCharOffset$1(safeSource);
+
+	        this.source = safeSource;
+	        this.firstCharOffset = start;
+	        this.startOffset = typeof startOffset === 'undefined' ? 0 : startOffset;
+	        this.startLine = typeof startLine === 'undefined' ? 1 : startLine;
+	        this.startColumn = typeof startColumn === 'undefined' ? 1 : startColumn;
+	        this.linesAnsColumnsComputed = false;
+
+	        this.eof = false;
+	        this.currentToken = -1;
+	        this.tokenType = 0;
+	        this.tokenStart = start;
+	        this.tokenEnd = start;
+
+	        tokenLayout(this, safeSource, start);
+	        this.next();
+	    },
+
+	    lookupType: function(offset) {
+	        offset += this.currentToken;
+
+	        if (offset < this.tokenCount) {
+	            return this.offsetAndType[offset] >> TYPE_SHIFT;
+	        }
+
+	        return NULL;
+	    },
+	    lookupNonWSType: function(offset) {
+	        offset += this.currentToken;
+
+	        for (var type; offset < this.tokenCount; offset++) {
+	            type = this.offsetAndType[offset] >> TYPE_SHIFT;
+
+	            if (type !== WHITESPACE$1) {
+	                return type;
+	            }
+	        }
+
+	        return NULL;
+	    },
+	    lookupValue: function(offset, referenceStr) {
+	        offset += this.currentToken;
+
+	        if (offset < this.tokenCount) {
+	            return cmpStr$1(
+	                this.source,
+	                this.offsetAndType[offset - 1] & OFFSET_MASK,
+	                this.offsetAndType[offset] & OFFSET_MASK,
+	                referenceStr
+	            );
+	        }
+
+	        return false;
+	    },
+	    getTokenStart: function(tokenNum) {
+	        if (tokenNum === this.currentToken) {
+	            return this.tokenStart;
+	        }
+
+	        if (tokenNum > 0) {
+	            return tokenNum < this.tokenCount
+	                ? this.offsetAndType[tokenNum - 1] & OFFSET_MASK
+	                : this.offsetAndType[this.tokenCount] & OFFSET_MASK;
+	        }
+
+	        return this.firstCharOffset;
+	    },
+	    getOffsetExcludeWS: function() {
+	        if (this.currentToken > 0) {
+	            if ((this.offsetAndType[this.currentToken - 1] >> TYPE_SHIFT) === WHITESPACE$1) {
+	                return this.currentToken > 1
+	                    ? this.offsetAndType[this.currentToken - 2] & OFFSET_MASK
+	                    : this.firstCharOffset;
+	            }
+	        }
+	        return this.tokenStart;
+	    },
+	    getRawLength: function(startToken, endTokenType1, endTokenType2, includeTokenType2) {
+	        var cursor = startToken;
+	        var balanceEnd;
+
+	        loop:
+	        for (; cursor < this.tokenCount; cursor++) {
+	            balanceEnd = this.balance[cursor];
+
+	            // belance end points to offset before start
+	            if (balanceEnd < startToken) {
+	                break loop;
+	            }
+
+	            // check token is stop type
+	            switch (this.offsetAndType[cursor] >> TYPE_SHIFT) {
+	                case endTokenType1:
+	                    break loop;
+
+	                case endTokenType2:
+	                    if (includeTokenType2) {
+	                        cursor++;
+	                    }
+	                    break loop;
+
+	                default:
+	                    // fast forward to the end of balanced block
+	                    if (this.balance[balanceEnd] === cursor) {
+	                        cursor = balanceEnd;
+	                    }
+	            }
+
+	        }
+
+	        return cursor - this.currentToken;
+	    },
+	    isBalanceEdge: function(pos) {
+	        var balanceStart = this.balance[this.currentToken];
+	        return balanceStart < pos;
+	    },
+
+	    getTokenValue: function() {
+	        return this.source.substring(this.tokenStart, this.tokenEnd);
+	    },
+	    substrToCursor: function(start) {
+	        return this.source.substring(start, this.tokenStart);
+	    },
+
+	    skipWS: function() {
+	        for (var i = this.currentToken, skipTokenCount = 0; i < this.tokenCount; i++, skipTokenCount++) {
+	            if ((this.offsetAndType[i] >> TYPE_SHIFT) !== WHITESPACE$1) {
+	                break;
+	            }
+	        }
+
+	        if (skipTokenCount > 0) {
+	            this.skip(skipTokenCount);
+	        }
+	    },
+	    skipSC: function() {
+	        while (this.tokenType === WHITESPACE$1 || this.tokenType === COMMENT$1) {
+	            this.next();
+	        }
+	    },
+	    skip: function(tokenCount) {
+	        var next = this.currentToken + tokenCount;
+
+	        if (next < this.tokenCount) {
+	            this.currentToken = next;
+	            this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;
+	            next = this.offsetAndType[next];
+	            this.tokenType = next >> TYPE_SHIFT;
+	            this.tokenEnd = next & OFFSET_MASK;
+	        } else {
+	            this.currentToken = this.tokenCount;
+	            this.next();
+	        }
+	    },
+	    next: function() {
+	        var next = this.currentToken + 1;
+
+	        if (next < this.tokenCount) {
+	            this.currentToken = next;
+	            this.tokenStart = this.tokenEnd;
+	            next = this.offsetAndType[next];
+	            this.tokenType = next >> TYPE_SHIFT;
+	            this.tokenEnd = next & OFFSET_MASK;
+	        } else {
+	            this.currentToken = this.tokenCount;
+	            this.eof = true;
+	            this.tokenType = NULL;
+	            this.tokenStart = this.tokenEnd = this.source.length;
+	        }
+	    },
+
+	    eat: function(tokenType) {
+	        if (this.tokenType !== tokenType) {
+	            var offset = this.tokenStart;
+	            var message = NAME$1[tokenType] + ' is expected';
+
+	            // tweak message and offset
+	            if (tokenType === IDENTIFIER$1) {
+	                // when identifier is expected but there is a function or url
+	                if (this.tokenType === FUNCTION$1 || this.tokenType === URL$2) {
+	                    offset = this.tokenEnd - 1;
+	                    message += ' but function found';
+	                }
+	            } else {
+	                // when test type is part of another token show error for current position + 1
+	                // e.g. eat(HYPHENMINUS) will fail on "-foo", but pointing on "-" is odd
+	                if (this.source.charCodeAt(this.tokenStart) === tokenType) {
+	                    offset = offset + 1;
+	                }
+	            }
+
+	            this.error(message, offset);
+	        }
+
+	        this.next();
+	    },
+	    eatNonWS: function(tokenType) {
+	        this.skipWS();
+	        this.eat(tokenType);
+	    },
+
+	    consume: function(tokenType) {
+	        var value = this.getTokenValue();
+
+	        this.eat(tokenType);
+
+	        return value;
+	    },
+	    consumeFunctionName: function() {
+	        var name = this.source.substring(this.tokenStart, this.tokenEnd - 1);
+
+	        this.eat(FUNCTION$1);
+
+	        return name;
+	    },
+	    consumeNonWS: function(tokenType) {
+	        this.skipWS();
+
+	        return this.consume(tokenType);
+	    },
+
+	    expectIdentifier: function(name) {
+	        if (this.tokenType !== IDENTIFIER$1 || cmpStr$1(this.source, this.tokenStart, this.tokenEnd, name) === false) {
+	            this.error('Identifier `' + name + '` is expected');
+	        }
+
+	        this.next();
+	    },
+
+	    getLocation: function(offset, filename) {
+	        if (!this.linesAnsColumnsComputed) {
+	            computeLinesAndColumns(this, this.source);
+	        }
+
+	        return {
+	            source: filename,
+	            offset: this.startOffset + offset,
+	            line: this.lines[offset],
+	            column: this.columns[offset]
+	        };
+	    },
+
+	    getLocationRange: function(start, end, filename) {
+	        if (!this.linesAnsColumnsComputed) {
+	            computeLinesAndColumns(this, this.source);
+	        }
+
+	        return {
+	            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]
+	            }
+	        };
+	    },
+
+	    error: function(message, offset) {
+	        var location = typeof offset !== 'undefined' && offset < this.source.length
+	            ? this.getLocation(offset)
+	            : this.eof
+	                ? this.getLocation(findWhiteSpaceStart$1(this.source, this.source.length - 1))
+	                : this.getLocation(this.tokenStart);
+
+	        throw new error(
+	            message || 'Unexpected input',
+	            this.source,
+	            location.offset,
+	            location.line,
+	            location.column
+	        );
+	    },
+
+	    dump: function() {
+	        var offset = 0;
+
+	        return Array.prototype.slice.call(this.offsetAndType, 0, this.tokenCount).map(function(item, idx) {
+	            var start = offset;
+	            var end = item & OFFSET_MASK;
+
+	            offset = end;
+
+	            return {
+	                idx: idx,
+	                type: NAME$1[item >> TYPE_SHIFT],
+	                chunk: this.source.substring(start, end),
+	                balance: this.balance[idx]
+	            };
+	        }, this);
+	    }
+	};
+
+	// extend with error class
+	Tokenizer.CssSyntaxError = error;
+
+	// extend tokenizer with constants
+	Object.keys(_const).forEach(function(key) {
+	    Tokenizer[key] = _const[key];
+	});
+
+	// extend tokenizer with static methods from utils
+	Object.keys(utils).forEach(function(key) {
+	    Tokenizer[key] = utils[key];
+	});
+
+	// warm up tokenizer to elimitate code branches that never execute
+	// fix soft deoptimizations (insufficient type feedback)
+	new Tokenizer('\n\r\r\n\f<!---->//""\'\'/*\r\n\f*/1a;.\\31\t\+2{url(a);func();+1.2e3 -.4e-5 .6e+7}').getLocation();
+
+	var Tokenizer_1 = Tokenizer;
+
+	var tokenizer = Tokenizer_1;
+
+	function noop$1(value) {
+	    return value;
+	}
+
+	function generateMultiplier(multiplier) {
+	    if (multiplier.min === 0 && multiplier.max === 0) {
+	        return '*';
+	    }
+
+	    if (multiplier.min === 0 && multiplier.max === 1) {
+	        return '?';
+	    }
+
+	    if (multiplier.min === 1 && multiplier.max === 0) {
+	        return multiplier.comma ? '#' : '+';
+	    }
+
+	    if (multiplier.min === 1 && multiplier.max === 1) {
+	        return '';
+	    }
+
+	    return (
+	        (multiplier.comma ? '#' : '') +
+	        (multiplier.min === multiplier.max
+	            ? '{' + multiplier.min + '}'
+	            : '{' + multiplier.min + ',' + (multiplier.max !== 0 ? multiplier.max : '') + '}'
+	        )
+	    );
+	}
+
+	function generateSequence(node, forceBraces, decorate) {
+	    var result = node.terms.map(function(term) {
+	        return generate(term, forceBraces, decorate);
+	    }).join(node.combinator === ' ' ? ' ' : ' ' + node.combinator + ' ');
+
+	    if (node.explicit || forceBraces) {
+	        result = (result[0] !== ',' ? '[ ' : '[') + result + ' ]';
+	    }
+
+	    return result;
+	}
+
+	function generate(node, forceBraces, decorate) {
+	    var result;
+
+	    switch (node.type) {
+	        case 'Group':
+	            result =
+	                generateSequence(node, forceBraces, decorate) +
+	                (node.disallowEmpty ? '!' : '');
+	            break;
+
+	        case 'Multiplier':
+	            // return since node is a composition
+	            return (
+	                generate(node.term, forceBraces, decorate) +
+	                decorate(generateMultiplier(node), node)
+	            );
+
+	        case 'Type':
+	            result = '<' + node.name + '>';
+	            break;
+
+	        case 'Property':
+	            result = '<\'' + node.name + '\'>';
+	            break;
+
+	        case 'Keyword':
+	            result = node.name;
+	            break;
+
+	        case 'AtKeyword':
+	            result = '@' + node.name;
+	            break;
+
+	        case 'Function':
+	            result = node.name + '(';
+	            break;
+
+	        case 'String':
+	        case 'Token':
+	            result = node.value;
+	            break;
+
+	        case 'Comma':
+	            result = ',';
+	            break;
+
+	        default:
+	            throw new Error('Unknown node type `' + node.type + '`');
+	    }
+
+	    return decorate(result, node);
+	}
+
+	var generate_1 = function(node, options) {
+	    var decorate = noop$1;
+	    var forceBraces = false;
+
+	    if (typeof options === 'function') {
+	        decorate = options;
+	    } else if (options) {
+	        forceBraces = Boolean(options.forceBraces);
+	        if (typeof options.decorate === 'function') {
+	            decorate = options.decorate;
+	        }
+	    }
+
+	    return generate(node, forceBraces, decorate);
+	};
+
+	function fromMatchResult(matchResult) {
+	    var tokens = matchResult.tokens;
+	    var longestMatch = matchResult.longestMatch;
+	    var node = longestMatch < tokens.length ? tokens[longestMatch].node : null;
+	    var mismatchOffset = 0;
+	    var entries = 0;
+	    var css = '';
+
+	    for (var i = 0; i < tokens.length; i++) {
+	        if (i === longestMatch) {
+	            mismatchOffset = css.length;
+	        }
+
+	        if (node !== null && tokens[i].node === node) {
+	            if (i <= longestMatch) {
+	                entries++;
+	            } else {
+	                entries = 0;
+	            }
+	        }
+
+	        css += tokens[i].value;
+	    }
+
+	    if (node === null) {
+	        mismatchOffset = css.length;
+	    }
+
+	    return {
+	        node: node,
+	        css: css,
+	        mismatchOffset: mismatchOffset,
+	        last: node === null || entries > 1
+	    };
+	}
+
+	function getLocation(node, point) {
+	    var loc = node && node.loc && node.loc[point];
+
+	    if (loc) {
+	        return {
+	            offset: loc.offset,
+	            line: loc.line,
+	            column: loc.column
+	        };
+	    }
+
+	    return null;
+	}
+
+	var SyntaxReferenceError = function(type, referenceName) {
+	    var error = createCustomError(
+	        'SyntaxReferenceError',
+	        type + (referenceName ? ' `' + referenceName + '`' : '')
+	    );
+
+	    error.reference = referenceName;
+
+	    return error;
+	};
+
+	var MatchError = function(message, lexer, syntax, node, matchResult) {
+	    var error = createCustomError('SyntaxMatchError', message);
+	    var details = fromMatchResult(matchResult);
+	    var mismatchOffset = details.mismatchOffset || 0;
+	    var badNode = details.node || node;
+	    var end = getLocation(badNode, 'end');
+	    var start = details.last ? end : getLocation(badNode, 'start');
+	    var css = details.css;
+
+	    error.rawMessage = message;
+	    error.syntax = syntax ? generate_1(syntax) : '<generic>';
+	    error.css = css;
+	    error.mismatchOffset = mismatchOffset;
+	    error.loc = {
+	        source: (badNode && badNode.loc && badNode.loc.source) || '<unknown>',
+	        start: start,
+	        end: end
+	    };
+	    error.line = start ? start.line : undefined;
+	    error.column = start ? start.column : undefined;
+	    error.offset = start ? start.offset : undefined;
+	    error.message = message + '\n' +
+	        '  syntax: ' + error.syntax + '\n' +
+	        '   value: ' + (error.css || '<empty string>') + '\n' +
+	        '  --------' + new Array(error.mismatchOffset + 1).join('-') + '^';
+
+	    return error;
+	};
+
+	var error$1 = {
+	    SyntaxReferenceError: SyntaxReferenceError,
+	    MatchError: MatchError
+	};
+
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var keywords = Object.create(null);
+	var properties = Object.create(null);
+	var HYPHENMINUS$2 = 45; // '-'.charCodeAt()
+
+	function isCustomProperty(str, offset) {
+	    offset = offset || 0;
+
+	    return str.length - offset >= 2 &&
+	           str.charCodeAt(offset) === HYPHENMINUS$2 &&
+	           str.charCodeAt(offset + 1) === HYPHENMINUS$2;
+	}
+
+	function getVendorPrefix(str, offset) {
+	    offset = offset || 0;
+
+	    // verdor prefix should be at least 3 chars length
+	    if (str.length - offset >= 3) {
+	        // vendor prefix starts with hyper minus following non-hyper minus
+	        if (str.charCodeAt(offset) === HYPHENMINUS$2 &&
+	            str.charCodeAt(offset + 1) !== HYPHENMINUS$2) {
+	            // vendor prefix should contain a hyper minus at the ending
+	            var secondDashIndex = str.indexOf('-', offset + 2);
+
+	            if (secondDashIndex !== -1) {
+	                return str.substring(offset, secondDashIndex + 1);
+	            }
+	        }
+	    }
+
+	    return '';
+	}
+
+	function getKeywordDescriptor(keyword) {
+	    if (hasOwnProperty.call(keywords, keyword)) {
+	        return keywords[keyword];
+	    }
+
+	    var name = keyword.toLowerCase();
+
+	    if (hasOwnProperty.call(keywords, name)) {
+	        return keywords[keyword] = keywords[name];
+	    }
+
+	    var custom = isCustomProperty(name, 0);
+	    var vendor = !custom ? getVendorPrefix(name, 0) : '';
+
+	    return keywords[keyword] = Object.freeze({
+	        basename: name.substr(vendor.length),
+	        name: name,
+	        vendor: vendor,
+	        prefix: vendor,
+	        custom: custom
+	    });
+	}
+
+	function getPropertyDescriptor(property) {
+	    if (hasOwnProperty.call(properties, property)) {
+	        return properties[property];
+	    }
+
+	    var name = property;
+	    var hack = property[0];
+
+	    if (hack === '/') {
+	        hack = property[1] === '/' ? '//' : '/';
+	    } else if (hack !== '_' &&
+	               hack !== '*' &&
+	               hack !== '$' &&
+	               hack !== '#' &&
+	               hack !== '+') {
+	        hack = '';
+	    }
+
+	    var custom = isCustomProperty(name, hack.length);
+
+	    // re-use result when possible (the same as for lower case)
+	    if (!custom) {
+	        name = name.toLowerCase();
+	        if (hasOwnProperty.call(properties, name)) {
+	            return properties[property] = properties[name];
+	        }
+	    }
+
+	    var vendor = !custom ? getVendorPrefix(name, hack.length) : '';
+	    var prefix = name.substr(0, hack.length + vendor.length);
+
+	    return properties[property] = Object.freeze({
+	        basename: name.substr(prefix.length),
+	        name: name.substr(hack.length),
+	        hack: hack,
+	        vendor: vendor,
+	        prefix: prefix,
+	        custom: custom
+	    });
+	}
+
+	var names = {
+	    keyword: getKeywordDescriptor,
+	    property: getPropertyDescriptor,
+	    isCustomProperty: isCustomProperty,
+	    vendorPrefix: getVendorPrefix
+	};
+
+	var findIdentifierEnd$2 = utils.findIdentifierEnd;
+	var findNumberEnd$2 = utils.findNumberEnd;
+	var findDecimalNumberEnd$1 = utils.findDecimalNumberEnd;
+	var isHex$1 = utils.isHex;
+
+	var SYMBOL_TYPE$2 = _const.SYMBOL_TYPE;
+	var IDENTIFIER$2 = _const.TYPE.Identifier;
+	var PLUSSIGN$2 = _const.TYPE.PlusSign;
+	var HYPHENMINUS$3 = _const.TYPE.HyphenMinus;
+	var NUMBERSIGN = _const.TYPE.NumberSign;
+
+	var PERCENTAGE = {
+	    '%': true
+	};
+
+	// https://www.w3.org/TR/css-values-3/#lengths
+	var LENGTH = {
+	    // absolute length units
+	    'px': true,
+	    'mm': true,
+	    'cm': true,
+	    'in': true,
+	    'pt': true,
+	    'pc': true,
+	    'q': true,
+
+	    // relative length units
+	    'em': true,
+	    'ex': true,
+	    'ch': true,
+	    'rem': true,
+
+	    // viewport-percentage lengths
+	    'vh': true,
+	    'vw': true,
+	    'vmin': true,
+	    'vmax': true,
+	    'vm': true
+	};
+
+	var ANGLE = {
+	    'deg': true,
+	    'grad': true,
+	    'rad': true,
+	    'turn': true
+	};
+
+	var TIME = {
+	    's': true,
+	    'ms': true
+	};
+
+	var FREQUENCY = {
+	    'hz': true,
+	    'khz': true
+	};
+
+	// https://www.w3.org/TR/css-values-3/#resolution (https://drafts.csswg.org/css-values/#resolution)
+	var RESOLUTION = {
+	    'dpi': true,
+	    'dpcm': true,
+	    'dppx': true,
+	    'x': true      // https://github.com/w3c/csswg-drafts/issues/461
+	};
+
+	// https://drafts.csswg.org/css-grid/#fr-unit
+	var FLEX = {
+	    'fr': true
+	};
+
+	// https://www.w3.org/TR/css3-speech/#mixing-props-voice-volume
+	var DECIBEL = {
+	    'db': true
+	};
+
+	// https://www.w3.org/TR/css3-speech/#voice-props-voice-pitch
+	var SEMITONES = {
+	    'st': true
+	};
+
+	function consumeFunction(token, addTokenToMatch, getNextToken) {
+	    var length = 1;
+	    var cursor;
+
+	    do {
+	        cursor = getNextToken(length++);
+	    } while (cursor !== null && cursor.node !== token.node);
+
+	    if (cursor === null) {
+	        return false;
+	    }
+
+	    while (true) {
+	        // consume tokens until cursor
+	        if (addTokenToMatch() === cursor) {
+	            break;
+	        }
+	    }
+
+	    return true;
+	}
+
+	// TODO: implement
+	// can be used wherever <length>, <frequency>, <angle>, <time>, <percentage>, <number>, or <integer> values are allowed
+	// https://drafts.csswg.org/css-values/#calc-notation
+	function calc(token, addTokenToMatch, getNextToken) {
+	    if (token === null) {
+	        return false;
+	    }
+
+	    var name = token.value.toLowerCase();
+	    if (name !== 'calc(' &&
+	        name !== '-moz-calc(' &&
+	        name !== '-webkit-calc(') {
+	        return false;
+	    }
+
+	    return consumeFunction(token, addTokenToMatch, getNextToken);
+	}
+
+	function attr$1(token, addTokenToMatch, getNextToken) {
+	    if (token === null || token.value.toLowerCase() !== 'attr(') {
+	        return false;
+	    }
+
+	    return consumeFunction(token, addTokenToMatch, getNextToken);
+	}
+
+	function expression(token, addTokenToMatch, getNextToken) {
+	    if (token === null || token.value.toLowerCase() !== 'expression(') {
+	        return false;
+	    }
+
+	    return consumeFunction(token, addTokenToMatch, getNextToken);
+	}
+
+	function url(token, addTokenToMatch, getNextToken) {
+	    if (token === null || token.value.toLowerCase() !== 'url(') {
+	        return false;
+	    }
+
+	    return consumeFunction(token, addTokenToMatch, getNextToken);
+	}
+
+	function idSelector(token, addTokenToMatch) {
+	    if (token === null) {
+	        return false;
+	    }
+
+	    if (token.value.charCodeAt(0) !== NUMBERSIGN) {
+	        return false;
+	    }
+
+	    if (consumeIdentifier(token.value, 1) !== token.value.length) {
+	        return false;
+	    }
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	function isNumber$2(str) {
+	    return /^[-+]?(\d+|\d*\.\d+)([eE][-+]?\d+)?$/.test(str);
+	}
+
+	function consumeNumber(str, allowFraction) {
+	    var code = str.charCodeAt(0);
+
+	    return findNumberEnd$2(str, code === PLUSSIGN$2 || code === HYPHENMINUS$3 ? 1 : 0, allowFraction);
+	}
+
+	function consumeIdentifier(str, offset) {
+	    var code = str.charCodeAt(offset);
+
+	    if (code < 0x80 && SYMBOL_TYPE$2[code] !== IDENTIFIER$2 && code !== HYPHENMINUS$3) {
+	        return offset;
+	    }
+
+	    return findIdentifierEnd$2(str, offset + 1);
+	}
+
+	function astNode(type) {
+	    return function(token, addTokenToMatch) {
+	        if (token === null || token.node.type !== type) {
+	            return false;
+	        }
+
+	        addTokenToMatch();
+	        return true;
+	    };
+	}
+
+	function dimension(type) {
+	    return function(token, addTokenToMatch, getNextToken) {
+	        if (calc(token, addTokenToMatch, getNextToken)) {
+	            return true;
+	        }
+
+	        if (token === null) {
+	            return false;
+	        }
+
+	        var numberEnd = consumeNumber(token.value, true);
+	        if (numberEnd === 0) {
+	            return false;
+	        }
+
+	        if (type) {
+	            if (!type.hasOwnProperty(token.value.substr(numberEnd).toLowerCase())) {
+	                return false;
+	            }
+	        } else {
+	            var unitEnd = consumeIdentifier(token.value, numberEnd);
+	            if (unitEnd === numberEnd || unitEnd !== token.value.length) {
+	                return false;
+	            }
+	        }
+
+	        addTokenToMatch();
+	        return true;
+	    };
+	}
+
+	function zeroUnitlessDimension(type) {
+	    var isDimension = dimension(type);
+
+	    return function(token, addTokenToMatch, getNextToken) {
+	        if (isDimension(token, addTokenToMatch, getNextToken)) {
+	            return true;
+	        }
+
+	        if (token === null || Number(token.value) !== 0) {
+	            return false;
+	        }
+
+	        addTokenToMatch();
+	        return true;
+	    };
+	}
+
+	function number(token, addTokenToMatch, getNextToken) {
+	    if (calc(token, addTokenToMatch, getNextToken)) {
+	        return true;
+	    }
+
+	    if (token === null) {
+	        return false;
+	    }
+
+	    var numberEnd = consumeNumber(token.value, true);
+	    if (numberEnd !== token.value.length) {
+	        return false;
+	    }
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	function numberZeroOne(token, addTokenToMatch, getNextToken) {
+	    if (calc(token, addTokenToMatch, getNextToken)) {
+	        return true;
+	    }
+
+	    if (token === null || !isNumber$2(token.value)) {
+	        return false;
+	    }
+
+	    var value = Number(token.value);
+	    if (value < 0 || value > 1) {
+	        return false;
+	    }
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	function numberOneOrGreater(token, addTokenToMatch, getNextToken) {
+	    if (calc(token, addTokenToMatch, getNextToken)) {
+	        return true;
+	    }
+
+	    if (token === null || !isNumber$2(token.value)) {
+	        return false;
+	    }
+
+	    var value = Number(token.value);
+	    if (value < 1) {
+	        return false;
+	    }
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	// TODO: fail on 10e-2
+	function integer(token, addTokenToMatch, getNextToken) {
+	    if (calc(token, addTokenToMatch, getNextToken)) {
+	        return true;
+	    }
+
+	    if (token === null) {
+	        return false;
+	    }
+
+	    var numberEnd = consumeNumber(token.value, false);
+	    if (numberEnd !== token.value.length) {
+	        return false;
+	    }
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	// TODO: fail on 10e-2
+	function positiveInteger(token, addTokenToMatch, getNextToken) {
+	    if (calc(token, addTokenToMatch, getNextToken)) {
+	        return true;
+	    }
+
+	    if (token === null) {
+	        return false;
+	    }
+
+	    var numberEnd = findDecimalNumberEnd$1(token.value, 0);
+	    if (numberEnd !== token.value.length || token.value.charCodeAt(0) === HYPHENMINUS$3) {
+	        return false;
+	    }
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	function hexColor(token, addTokenToMatch) {
+	    if (token === null || token.value.charCodeAt(0) !== NUMBERSIGN) {
+	        return false;
+	    }
+
+	    var length = token.value.length - 1;
+
+	    // valid length is 3, 4, 6 and 8 (+1 for #)
+	    if (length !== 3 && length !== 4 && length !== 6 && length !== 8) {
+	        return false;
+	    }
+
+	    for (var i = 1; i < length; i++) {
+	        if (!isHex$1(token.value.charCodeAt(i))) {
+	            return false;
+	        }
+	    }
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	// https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident
+	// https://drafts.csswg.org/css-values-4/#identifier-value
+	function customIdent(token, addTokenToMatch) {
+	    if (token === null) {
+	        return false;
+	    }
+
+	    var identEnd = consumeIdentifier(token.value, 0);
+	    if (identEnd !== token.value.length) {
+	        return false;
+	    }
+
+	    var name = token.value.toLowerCase();
+
+	    // § 3.2. Author-defined Identifiers: the <custom-ident> type
+	    // The CSS-wide keywords are not valid <custom-ident>s
+	    if (name === 'unset' || name === 'initial' || name === 'inherit') {
+	        return false;
+	    }
+
+	    // The default keyword is reserved and is also not a valid <custom-ident>
+	    if (name === 'default') {
+	        return false;
+	    }
+
+	    // TODO: ignore property specific keywords (as described https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident)
+
+	    addTokenToMatch();
+	    return true;
+	}
+
+	var generic = {
+	    'angle': zeroUnitlessDimension(ANGLE),
+	    'attr()': attr$1,
+	    'custom-ident': customIdent,
+	    'decibel': dimension(DECIBEL),
+	    'dimension': dimension(),
+	    'frequency': dimension(FREQUENCY),
+	    'flex': dimension(FLEX),
+	    'hex-color': hexColor,
+	    'id-selector': idSelector, // element( <id-selector> )
+	    'ident': astNode('Identifier'),
+	    'integer': integer,
+	    'length': zeroUnitlessDimension(LENGTH),
+	    'number': number,
+	    'number-zero-one': numberZeroOne,
+	    'number-one-or-greater': numberOneOrGreater,
+	    'percentage': dimension(PERCENTAGE),
+	    'positive-integer': positiveInteger,
+	    'resolution': dimension(RESOLUTION),
+	    'semitones': dimension(SEMITONES),
+	    'string': astNode('String'),
+	    'time': dimension(TIME),
+	    'unicode-range': astNode('UnicodeRange'),
+	    'url': url,
+
+	    // old IE stuff
+	    'progid': astNode('Raw'),
+	    'expression': expression
+	};
+
+	var SyntaxParseError = function(message, input, offset) {
+	    var error = createCustomError('SyntaxParseError', message);
+
+	    error.input = input;
+	    error.offset = offset;
+	    error.rawMessage = message;
+	    error.message = error.rawMessage + '\n' +
+	        '  ' + error.input + '\n' +
+	        '--' + new Array((error.offset || error.input.length) + 1).join('-') + '^';
+
+	    return error;
+	};
+
+	var error$2 = {
+	    SyntaxParseError: SyntaxParseError
+	};
+
+	var SyntaxParseError$1 = error$2.SyntaxParseError;
+
+	var TAB$2 = 9;
+	var N$3 = 10;
+	var F$3 = 12;
+	var R$3 = 13;
+	var SPACE$2 = 32;
+
+	var Tokenizer$1 = function(str) {
+	    this.str = str;
+	    this.pos = 0;
+	};
+
+	Tokenizer$1.prototype = {
+	    charCodeAt: function(pos) {
+	        return pos < this.str.length ? this.str.charCodeAt(pos) : 0;
+	    },
+	    charCode: function() {
+	        return this.charCodeAt(this.pos);
+	    },
+	    nextCharCode: function() {
+	        return this.charCodeAt(this.pos + 1);
+	    },
+	    nextNonWsCode: function(pos) {
+	        return this.charCodeAt(this.findWsEnd(pos));
+	    },
+	    findWsEnd: function(pos) {
+	        for (; pos < this.str.length; pos++) {
+	            var code = this.str.charCodeAt(pos);
+	            if (code !== R$3 && code !== N$3 && code !== F$3 && code !== SPACE$2 && code !== TAB$2) {
+	                break;
+	            }
+	        }
+
+	        return pos;
+	    },
+	    substringToPos: function(end) {
+	        return this.str.substring(this.pos, this.pos = end);
+	    },
+	    eat: function(code) {
+	        if (this.charCode() !== code) {
+	            this.error('Expect `' + String.fromCharCode(code) + '`');
+	        }
+
+	        this.pos++;
+	    },
+	    peek: function() {
+	        return this.pos < this.str.length ? this.str.charAt(this.pos++) : '';
+	    },
+	    error: function(message) {
+	        throw new SyntaxParseError$1(message, this.str, this.pos);
+	    }
+	};
+
+	var tokenizer$1 = Tokenizer$1;
+
+	var TAB$3 = 9;
+	var N$4 = 10;
+	var F$4 = 12;
+	var R$4 = 13;
+	var SPACE$3 = 32;
+	var EXCLAMATIONMARK$1 = 33;    // !
+	var NUMBERSIGN$1 = 35;         // #
+	var AMPERSAND = 38;          // &
+	var APOSTROPHE$1 = 39;         // '
+	var LEFTPARENTHESIS$1 = 40;    // (
+	var RIGHTPARENTHESIS$1 = 41;   // )
+	var ASTERISK = 42;           // *
+	var PLUSSIGN$3 = 43;           // +
+	var COMMA = 44;              // ,
+	var LESSTHANSIGN$1 = 60;       // <
+	var GREATERTHANSIGN$1 = 62;    // >
+	var QUESTIONMARK = 63;       // ?
+	var COMMERCIALAT$1 = 64;       // @
+	var LEFTSQUAREBRACKET$1 = 91;  // [
+	var RIGHTSQUAREBRACKET$1 = 93; // ]
+	var LEFTCURLYBRACKET$1 = 123;  // {
+	var VERTICALLINE = 124;      // |
+	var RIGHTCURLYBRACKET$1 = 125; // }
+	var NAME_CHAR = createCharMap(function(ch) {
+	    return /[a-zA-Z0-9\-]/.test(ch);
+	});
+	var COMBINATOR_PRECEDENCE = {
+	    ' ': 1,
+	    '&&': 2,
+	    '||': 3,
+	    '|': 4
+	};
+
+	function createCharMap(fn) {
+	    var array = typeof Uint32Array === 'function' ? new Uint32Array(128) : new Array(128);
+	    for (var i = 0; i < 128; i++) {
+	        array[i] = fn(String.fromCharCode(i)) ? 1 : 0;
+	    }
+	    return array;
+	}
+
+	function scanSpaces(tokenizer) {
+	    return tokenizer.substringToPos(
+	        tokenizer.findWsEnd(tokenizer.pos + 1)
+	    );
+	}
+
+	function scanWord(tokenizer) {
+	    var end = tokenizer.pos;
+
+	    for (; end < tokenizer.str.length; end++) {
+	        var code = tokenizer.str.charCodeAt(end);
+	        if (code >= 128 || NAME_CHAR[code] === 0) {
+	            break;
+	        }
+	    }
+
+	    if (tokenizer.pos === end) {
+	        tokenizer.error('Expect a keyword');
+	    }
+
+	    return tokenizer.substringToPos(end);
+	}
+
+	function scanNumber(tokenizer) {
+	    var end = tokenizer.pos;
+
+	    for (; end < tokenizer.str.length; end++) {
+	        var code = tokenizer.str.charCodeAt(end);
+	        if (code < 48 || code > 57) {
+	            break;
+	        }
+	    }
+
+	    if (tokenizer.pos === end) {
+	        tokenizer.error('Expect a number');
+	    }
+
+	    return tokenizer.substringToPos(end);
+	}
+
+	function scanString(tokenizer) {
+	    var end = tokenizer.str.indexOf('\'', tokenizer.pos + 1);
+
+	    if (end === -1) {
+	        tokenizer.pos = tokenizer.str.length;
+	        tokenizer.error('Expect an apostrophe');
+	    }
+
+	    return tokenizer.substringToPos(end + 1);
+	}
+
+	function readMultiplierRange(tokenizer) {
+	    var min = null;
+	    var max = null;
+
+	    tokenizer.eat(LEFTCURLYBRACKET$1);
+
+	    min = scanNumber(tokenizer);
+
+	    if (tokenizer.charCode() === COMMA) {
+	        tokenizer.pos++;
+	        if (tokenizer.charCode() !== RIGHTCURLYBRACKET$1) {
+	            max = scanNumber(tokenizer);
+	        }
+	    } else {
+	        max = min;
+	    }
+
+	    tokenizer.eat(RIGHTCURLYBRACKET$1);
+
+	    return {
+	        min: Number(min),
+	        max: max ? Number(max) : 0
+	    };
+	}
+
+	function readMultiplier(tokenizer) {
+	    var range = null;
+	    var comma = false;
+
+	    switch (tokenizer.charCode()) {
+	        case ASTERISK:
+	            tokenizer.pos++;
+
+	            range = {
+	                min: 0,
+	                max: 0
+	            };
+
+	            break;
+
+	        case PLUSSIGN$3:
+	            tokenizer.pos++;
+
+	            range = {
+	                min: 1,
+	                max: 0
+	            };
+
+	            break;
+
+	        case QUESTIONMARK:
+	            tokenizer.pos++;
+
+	            range = {
+	                min: 0,
+	                max: 1
+	            };
+
+	            break;
+
+	        case NUMBERSIGN$1:
+	            tokenizer.pos++;
+
+	            comma = true;
+
+	            if (tokenizer.charCode() === LEFTCURLYBRACKET$1) {
+	                range = readMultiplierRange(tokenizer);
+	            } else {
+	                range = {
+	                    min: 1,
+	                    max: 0
+	                };
+	            }
+
+	            break;
+
+	        case LEFTCURLYBRACKET$1:
+	            range = readMultiplierRange(tokenizer);
+	            break;
+
+	        default:
+	            return null;
+	    }
+
+	    return {
+	        type: 'Multiplier',
+	        comma: comma,
+	        min: range.min,
+	        max: range.max,
+	        term: null
+	    };
+	}
+
+	function maybeMultiplied(tokenizer, node) {
+	    var multiplier = readMultiplier(tokenizer);
+
+	    if (multiplier !== null) {
+	        multiplier.term = node;
+	        return multiplier;
+	    }
+
+	    return node;
+	}
+
+	function maybeToken(tokenizer) {
+	    var ch = tokenizer.peek();
+
+	    if (ch === '') {
+	        return null;
+	    }
+
+	    return {
+	        type: 'Token',
+	        value: ch
+	    };
+	}
+
+	function readProperty(tokenizer) {
+	    var name;
+
+	    tokenizer.eat(LESSTHANSIGN$1);
+	    tokenizer.eat(APOSTROPHE$1);
+
+	    name = scanWord(tokenizer);
+
+	    tokenizer.eat(APOSTROPHE$1);
+	    tokenizer.eat(GREATERTHANSIGN$1);
+
+	    return maybeMultiplied(tokenizer, {
+	        type: 'Property',
+	        name: name
+	    });
+	}
+
+	function readType(tokenizer) {
+	    var name;
+
+	    tokenizer.eat(LESSTHANSIGN$1);
+	    name = scanWord(tokenizer);
+
+	    if (tokenizer.charCode() === LEFTPARENTHESIS$1 &&
+	        tokenizer.nextCharCode() === RIGHTPARENTHESIS$1) {
+	        tokenizer.pos += 2;
+	        name += '()';
+	    }
+
+	    tokenizer.eat(GREATERTHANSIGN$1);
+
+	    return maybeMultiplied(tokenizer, {
+	        type: 'Type',
+	        name: name
+	    });
+	}
+
+	function readKeywordOrFunction(tokenizer) {
+	    var name;
+
+	    name = scanWord(tokenizer);
+
+	    if (tokenizer.charCode() === LEFTPARENTHESIS$1) {
+	        tokenizer.pos++;
+
+	        return {
+	            type: 'Function',
+	            name: name
+	        };
+	    }
+
+	    return maybeMultiplied(tokenizer, {
+	        type: 'Keyword',
+	        name: name
+	    });
+	}
+
+	function regroupTerms(terms, combinators) {
+	    function createGroup(terms, combinator) {
+	        return {
+	            type: 'Group',
+	            terms: terms,
+	            combinator: combinator,
+	            disallowEmpty: false,
+	            explicit: false
+	        };
+	    }
+
+	    combinators = Object.keys(combinators).sort(function(a, b) {
+	        return COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b];
+	    });
+
+	    while (combinators.length > 0) {
+	        var combinator = combinators.shift();
+	        for (var i = 0, subgroupStart = 0; i < terms.length; i++) {
+	            var term = terms[i];
+	            if (term.type === 'Combinator') {
+	                if (term.value === combinator) {
+	                    if (subgroupStart === -1) {
+	                        subgroupStart = i - 1;
+	                    }
+	                    terms.splice(i, 1);
+	                    i--;
+	                } else {
+	                    if (subgroupStart !== -1 && i - subgroupStart > 1) {
+	                        terms.splice(
+	                            subgroupStart,
+	                            i - subgroupStart,
+	                            createGroup(terms.slice(subgroupStart, i), combinator)
+	                        );
+	                        i = subgroupStart + 1;
+	                    }
+	                    subgroupStart = -1;
+	                }
+	            }
+	        }
+
+	        if (subgroupStart !== -1 && combinators.length) {
+	            terms.splice(
+	                subgroupStart,
+	                i - subgroupStart,
+	                createGroup(terms.slice(subgroupStart, i), combinator)
+	            );
+	        }
+	    }
+
+	    return combinator;
+	}
+
+	function readImplicitGroup(tokenizer) {
+	    var terms = [];
+	    var combinators = {};
+	    var token;
+	    var prevToken = null;
+	    var prevTokenPos = tokenizer.pos;
+
+	    while (token = peek(tokenizer)) {
+	        if (token.type !== 'Spaces') {
+	            if (token.type === 'Combinator') {
+	                // check for combinator in group beginning and double combinator sequence
+	                if (prevToken === null || prevToken.type === 'Combinator') {
+	                    tokenizer.pos = prevTokenPos;
+	                    tokenizer.error('Unexpected combinator');
+	                }
+
+	                combinators[token.value] = true;
+	            } else if (prevToken !== null && prevToken.type !== 'Combinator') {
+	                combinators[' '] = true;  // a b
+	                terms.push({
+	                    type: 'Combinator',
+	                    value: ' '
+	                });
+	            }
+
+	            terms.push(token);
+	            prevToken = token;
+	            prevTokenPos = tokenizer.pos;
+	        }
+	    }
+
+	    // check for combinator in group ending
+	    if (prevToken !== null && prevToken.type === 'Combinator') {
+	        tokenizer.pos -= prevTokenPos;
+	        tokenizer.error('Unexpected combinator');
+	    }
+
+	    return {
+	        type: 'Group',
+	        terms: terms,
+	        combinator: regroupTerms(terms, combinators) || ' ',
+	        disallowEmpty: false,
+	        explicit: false
+	    };
+	}
+
+	function readGroup(tokenizer) {
+	    var result;
+
+	    tokenizer.eat(LEFTSQUAREBRACKET$1);
+	    result = readImplicitGroup(tokenizer);
+	    tokenizer.eat(RIGHTSQUAREBRACKET$1);
+
+	    result.explicit = true;
+
+	    if (tokenizer.charCode() === EXCLAMATIONMARK$1) {
+	        tokenizer.pos++;
+	        result.disallowEmpty = true;
+	    }
+
+	    return result;
+	}
+
+	function peek(tokenizer) {
+	    var code = tokenizer.charCode();
+
+	    if (code < 128 && NAME_CHAR[code] === 1) {
+	        return readKeywordOrFunction(tokenizer);
+	    }
+
+	    switch (code) {
+	        case RIGHTSQUAREBRACKET$1:
+	            // don't eat, stop scan a group
+	            break;
+
+	        case LEFTSQUAREBRACKET$1:
+	            return maybeMultiplied(tokenizer, readGroup(tokenizer));
+
+	        case LESSTHANSIGN$1:
+	            return tokenizer.nextCharCode() === APOSTROPHE$1
+	                ? readProperty(tokenizer)
+	                : readType(tokenizer);
+
+	        case VERTICALLINE:
+	            return {
+	                type: 'Combinator',
+	                value: tokenizer.substringToPos(
+	                    tokenizer.nextCharCode() === VERTICALLINE
+	                        ? tokenizer.pos + 2
+	                        : tokenizer.pos + 1
+	                )
+	            };
+
+	        case AMPERSAND:
+	            tokenizer.pos++;
+	            tokenizer.eat(AMPERSAND);
+
+	            return {
+	                type: 'Combinator',
+	                value: '&&'
+	            };
+
+	        case COMMA:
+	            tokenizer.pos++;
+	            return {
+	                type: 'Comma'
+	            };
+
+	        case APOSTROPHE$1:
+	            return maybeMultiplied(tokenizer, {
+	                type: 'String',
+	                value: scanString(tokenizer)
+	            });
+
+	        case SPACE$3:
+	        case TAB$3:
+	        case N$4:
+	        case R$4:
+	        case F$4:
+	            return {
+	                type: 'Spaces',
+	                value: scanSpaces(tokenizer)
+	            };
+
+	        case COMMERCIALAT$1:
+	            code = tokenizer.nextCharCode();
+
+	            if (code < 128 && NAME_CHAR[code] === 1) {
+	                tokenizer.pos++;
+	                return {
+	                    type: 'AtKeyword',
+	                    name: scanWord(tokenizer)
+	                };
+	            }
+
+	            return maybeToken(tokenizer);
+
+	        case ASTERISK:
+	        case PLUSSIGN$3:
+	        case QUESTIONMARK:
+	        case NUMBERSIGN$1:
+	        case EXCLAMATIONMARK$1:
+	            // prohibited tokens (used as a multiplier start)
+	            break;
+
+	        case LEFTCURLYBRACKET$1:
+	            // LEFTCURLYBRACKET is allowed since mdn/data uses it w/o quoting
+	            // check next char isn't a number, because it's likely a disjoined multiplier
+	            code = tokenizer.nextCharCode();
+
+	            if (code < 48 || code > 57) {
+	                return maybeToken(tokenizer);
+	            }
+
+	            break;
+
+	        default:
+	            return maybeToken(tokenizer);
+	    }
+	}
+
+	function parse(str) {
+	    var tokenizer = new tokenizer$1(str);
+	    var result = readImplicitGroup(tokenizer);
+
+	    if (tokenizer.pos !== str.length) {
+	        tokenizer.error('Unexpected input');
+	    }
+
+	    // reduce redundant groups with single group term
+	    if (result.terms.length === 1 && result.terms[0].type === 'Group') {
+	        result = result.terms[0];
+	    }
+
+	    return result;
+	}
+
+	// warm up parse to elimitate code branches that never execute
+	// fix soft deoptimizations (insufficient type feedback)
+	parse('[a&&<b>#|<\'c\'>*||e() f{2} /,(% g#{1,2} h{2,})]!');
+
+	var parse_1 = parse;
+
+	var noop$2 = function() {};
+
+	function ensureFunction(value) {
+	    return typeof value === 'function' ? value : noop$2;
+	}
+
+	var walk$1 = function(node, options, context) {
+	    function walk(node) {
+	        enter.call(context, node);
+
+	        switch (node.type) {
+	            case 'Group':
+	                node.terms.forEach(walk);
+	                break;
+
+	            case 'Multiplier':
+	                walk(node.term);
+	                break;
+
+	            case 'Type':
+	            case 'Property':
+	            case 'Keyword':
+	            case 'AtKeyword':
+	            case 'Function':
+	            case 'String':
+	            case 'Token':
+	            case 'Comma':
+	                break;
+
+	            default:
+	                throw new Error('Unknown type: ' + node.type);
+	        }
+
+	        leave.call(context, node);
+	    }
+
+	    var enter = noop$2;
+	    var leave = noop$2;
+
+	    if (typeof options === 'function') {
+	        enter = options;
+	    } else if (options) {
+	        enter = ensureFunction(options.enter);
+	        leave = ensureFunction(options.leave);
+	    }
+
+	    if (enter === noop$2 && leave === noop$2) {
+	        throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+	    }
+
+	    walk(node, context);
+	};
+
+	var astToTokens = {
+	    decorator: function(handlers) {
+	        var curNode = null;
+	        var prev = null;
+	        var tokens = [];
+
+	        return {
+	            children: handlers.children,
+	            node: function(node) {
+	                var tmp = curNode;
+	                curNode = node;
+	                handlers.node.call(this, node);
+	                curNode = tmp;
+	            },
+	            chunk: function(chunk) {
+	                if (tokens.length > 0) {
+	                    switch (curNode.type) {
+	                        case 'Dimension':
+	                        case 'HexColor':
+	                        case 'IdSelector':
+	                        case 'Percentage':
+	                            if (prev.node === curNode) {
+	                                prev.value += chunk;
+	                                return;
+	                            }
+	                            break;
+
+	                        case 'Function':
+	                        case 'PseudoClassSelector':
+	                        case 'PseudoElementSelector':
+	                        case 'Url':
+	                            if (chunk === '(') {
+	                                prev.value += chunk;
+	                                return;
+	                            }
+	                            break;
+
+	                        case 'Atrule':
+	                            if (prev.node === curNode && prev.value === '@') {
+	                                prev.value += chunk;
+	                                return;
+	                            }
+	                            break;
+	                    }
+	                }
+
+	                tokens.push(prev = {
+	                    value: chunk,
+	                    node: curNode
+	                });
+	            },
+	            result: function() {
+	                return tokens;
+	            }
+	        };
+	    }
+	};
+
+	var MATCH = { type: 'Match' };
+	var MISMATCH = { type: 'Mismatch' };
+	var DISALLOW_EMPTY = { type: 'DisallowEmpty' };
+	var LEFTPARENTHESIS$2 = 40;  // (
+	var RIGHTPARENTHESIS$2 = 41; // )
+
+	function createCondition(match, thenBranch, elseBranch) {
+	    // reduce node count
+	    if (thenBranch === MATCH && elseBranch === MISMATCH) {
+	        return match;
+	    }
+
+	    if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) {
+	        return match;
+	    }
+
+	    if (match.type === 'If' && match.else === MISMATCH && thenBranch === MATCH) {
+	        thenBranch = match.then;
+	        match = match.match;
+	    }
+
+	    return {
+	        type: 'If',
+	        match: match,
+	        then: thenBranch,
+	        else: elseBranch
+	    };
+	}
+
+	function isFunctionType(name) {
+	    return (
+	        name.length > 2 &&
+	        name.charCodeAt(name.length - 2) === LEFTPARENTHESIS$2 &&
+	        name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS$2
+	    );
+	}
+
+	function isEnumCapatible(term) {
+	    return (
+	        term.type === 'Keyword' ||
+	        term.type === 'AtKeyword' ||
+	        term.type === 'Function' ||
+	        term.type === 'Type' && isFunctionType(term.name)
+	    );
+	}
+
+	function buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) {
+	    switch (combinator) {
+	        case ' ':
+	            // Juxtaposing components means that all of them must occur, in the given order.
+	            //
+	            // a b c
+	            // =
+	            // match a
+	            //   then match b
+	            //     then match c
+	            //       then MATCH
+	            //       else MISMATCH
+	            //     else MISMATCH
+	            //   else MISMATCH
+	            var result = MATCH;
+
+	            for (var i = terms.length - 1; i >= 0; i--) {
+	                var term = terms[i];
+
+	                result = createCondition(
+	                    term,
+	                    result,
+	                    MISMATCH
+	                );
+	            }
+	            return result;
+
+	        case '|':
+	            // A bar (|) separates two or more alternatives: exactly one of them must occur.
+	            //
+	            // a | b | c
+	            // =
+	            // match a
+	            //   then MATCH
+	            //   else match b
+	            //     then MATCH
+	            //     else match c
+	            //       then MATCH
+	            //       else MISMATCH
+
+	            var result = MISMATCH;
+	            var map = null;
+
+	            for (var i = terms.length - 1; i >= 0; i--) {
+	                var term = terms[i];
+
+	                // reduce sequence of keywords into a Enum
+	                if (isEnumCapatible(term)) {
+	                    if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) {
+	                        map = Object.create(null);
+	                        result = createCondition(
+	                            {
+	                                type: 'Enum',
+	                                map: map
+	                            },
+	                            MATCH,
+	                            result
+	                        );
+	                    }
+
+	                    if (map !== null) {
+	                        var key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase();
+	                        if (key in map === false) {
+	                            map[key] = term;
+	                            continue;
+	                        }
+	                    }
+	                }
+
+	                map = null;
+
+	                // create a new conditonal node
+	                result = createCondition(
+	                    term,
+	                    MATCH,
+	                    result
+	                );
+	            }
+	            return result;
+
+	        case '&&':
+	            // A double ampersand (&&) separates two or more components,
+	            // all of which must occur, in any order.
+
+	            // Use MatchOnce for groups with a large number of terms,
+	            // since &&-groups produces at least N!-node trees
+	            if (terms.length > 5) {
+	                return {
+	                    type: 'MatchOnce',
+	                    terms: terms,
+	                    all: true
+	                };
+	            }
+
+	            // Use a combination tree for groups with small number of terms
+	            //
+	            // a && b && c
+	            // =
+	            // match a
+	            //   then [b && c]
+	            //   else match b
+	            //     then [a && c]
+	            //     else match c
+	            //       then [a && b]
+	            //       else MISMATCH
+	            //
+	            // a && b
+	            // =
+	            // match a
+	            //   then match b
+	            //     then MATCH
+	            //     else MISMATCH
+	            //   else match b
+	            //     then match a
+	            //       then MATCH
+	            //       else MISMATCH
+	            //     else MISMATCH
+	            var result = MISMATCH;
+
+	            for (var i = terms.length - 1; i >= 0; i--) {
+	                var term = terms[i];
+	                var thenClause;
+
+	                if (terms.length > 1) {
+	                    thenClause = buildGroupMatchGraph(
+	                        combinator,
+	                        terms.filter(function(newGroupTerm) {
+	                            return newGroupTerm !== term;
+	                        }),
+	                        false
+	                    );
+	                } else {
+	                    thenClause = MATCH;
+	                }
+
+	                result = createCondition(
+	                    term,
+	                    thenClause,
+	                    result
+	                );
+	            }
+	            return result;
+
+	        case '||':
+	            // A double bar (||) separates two or more options:
+	            // one or more of them must occur, in any order.
+
+	            // Use MatchOnce for groups with a large number of terms,
+	            // since ||-groups produces at least N!-node trees
+	            if (terms.length > 5) {
+	                return {
+	                    type: 'MatchOnce',
+	                    terms: terms,
+	                    all: false
+	                };            }
+
+	            // Use a combination tree for groups with small number of terms
+	            //
+	            // a || b || c
+	            // =
+	            // match a
+	            //   then [b || c]
+	            //   else match b
+	            //     then [a || c]
+	            //     else match c
+	            //       then [a || b]
+	            //       else MISMATCH
+	            //
+	            // a || b
+	            // =
+	            // match a
+	            //   then match b
+	            //     then MATCH
+	            //     else MATCH
+	            //   else match b
+	            //     then match a
+	            //       then MATCH
+	            //       else MATCH
+	            //     else MISMATCH
+	            var result = atLeastOneTermMatched ? MATCH : MISMATCH;
+
+	            for (var i = terms.length - 1; i >= 0; i--) {
+	                var term = terms[i];
+	                var thenClause;
+
+	                if (terms.length > 1) {
+	                    thenClause = buildGroupMatchGraph(
+	                        combinator,
+	                        terms.filter(function(newGroupTerm) {
+	                            return newGroupTerm !== term;
+	                        }),
+	                        true
+	                    );
+	                } else {
+	                    thenClause = MATCH;
+	                }
+
+	                result = createCondition(
+	                    term,
+	                    thenClause,
+	                    result
+	                );
+	            }
+	            return result;
+	    }
+	}
+
+	function buildMultiplierMatchGraph(node) {
+	    var result = MATCH;
+	    var matchTerm = buildMatchGraph(node.term);
+
+	    if (node.max === 0) {
+	        // disable repeating of empty match to prevent infinite loop
+	        matchTerm = createCondition(
+	            matchTerm,
+	            DISALLOW_EMPTY,
+	            MISMATCH
+	        );
+
+	        // an occurrence count is not limited, make a cycle;
+	        // to collect more terms on each following matching mismatch
+	        result = createCondition(
+	            matchTerm,
+	            null, // will be a loop
+	            MISMATCH
+	        );
+
+	        result.then = createCondition(
+	            MATCH,
+	            MATCH,
+	            result // make a loop
+	        );
+
+	        if (node.comma) {
+	            result.then.else = createCondition(
+	                { type: 'Comma', syntax: node },
+	                result,
+	                MISMATCH
+	            );
+	        }
+	    } else {
+	        // create a match node chain for [min .. max] interval with optional matches
+	        for (var i = node.min || 1; i <= node.max; i++) {
+	            if (node.comma && result !== MATCH) {
+	                result = createCondition(
+	                    { type: 'Comma', syntax: node },
+	                    result,
+	                    MISMATCH
+	                );
+	            }
+
+	            result = createCondition(
+	                matchTerm,
+	                createCondition(
+	                    MATCH,
+	                    MATCH,
+	                    result
+	                ),
+	                MISMATCH
+	            );
+	        }
+	    }
+
+	    if (node.min === 0) {
+	        // allow zero match
+	        result = createCondition(
+	            MATCH,
+	            MATCH,
+	            result
+	        );
+	    } else {
+	        // create a match node chain to collect [0 ... min - 1] required matches
+	        for (var i = 0; i < node.min - 1; i++) {
+	            if (node.comma && result !== MATCH) {
+	                result = createCondition(
+	                    { type: 'Comma', syntax: node },
+	                    result,
+	                    MISMATCH
+	                );
+	            }
+
+	            result = createCondition(
+	                matchTerm,
+	                result,
+	                MISMATCH
+	            );
+	        }
+	    }
+
+	    return result;
+	}
+
+	function buildMatchGraph(node) {
+	    if (typeof node === 'function') {
+	        return {
+	            type: 'Generic',
+	            fn: node
+	        };
+	    }
+
+	    switch (node.type) {
+	        case 'Group':
+	            var result = buildGroupMatchGraph(
+	                node.combinator,
+	                node.terms.map(buildMatchGraph),
+	                false
+	            );
+
+	            if (node.disallowEmpty) {
+	                result = createCondition(
+	                    result,
+	                    DISALLOW_EMPTY,
+	                    MISMATCH
+	                );
+	            }
+
+	            return result;
+
+	        case 'Multiplier':
+	            return buildMultiplierMatchGraph(node);
+
+	        case 'Type':
+	        case 'Property':
+	            return {
+	                type: node.type,
+	                name: node.name,
+	                syntax: node
+	            };
+
+	        case 'Keyword':
+	            return {
+	                type: node.type,
+	                name: node.name.toLowerCase(),
+	                syntax: node
+	            };
+
+	        case 'AtKeyword':
+	            return {
+	                type: node.type,
+	                name: '@' + node.name.toLowerCase(),
+	                syntax: node
+	            };
+
+	        case 'Function':
+	            return {
+	                type: node.type,
+	                name: node.name.toLowerCase() + '(',
+	                syntax: node
+	            };
+
+	        case 'String':
+	            // convert a one char length String to a Token
+	            if (node.value.length === 3) {
+	                return {
+	                    type: 'Token',
+	                    value: node.value.charAt(1),
+	                    syntax: node
+	                };
+	            }
+
+	            // otherwise use it as is
+	            return {
+	                type: node.type,
+	                value: node.value,
+	                syntax: node
+	            };
+
+	        case 'Token':
+	            return {
+	                type: node.type,
+	                value: node.value,
+	                syntax: node
+	            };
+
+	        case 'Comma':
+	            return {
+	                type: node.type,
+	                syntax: node
+	            };
+
+	        default:
+	            throw new Error('Unknown node type:', node.type);
+	    }
+	}
+
+	var matchGraph = {
+	    MATCH: MATCH,
+	    MISMATCH: MISMATCH,
+	    DISALLOW_EMPTY: DISALLOW_EMPTY,
+	    buildMatchGraph: function(syntaxTree, ref) {
+	        if (typeof syntaxTree === 'string') {
+	            syntaxTree = parse_1(syntaxTree);
+	        }
+
+	        return {
+	            type: 'MatchGraph',
+	            match: buildMatchGraph(syntaxTree),
+	            syntax: ref || null,
+	            source: syntaxTree
+	        };
+	    }
+	};
+
+	var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+
+	var MATCH$1 = matchGraph.MATCH;
+	var MISMATCH$1 = matchGraph.MISMATCH;
+	var DISALLOW_EMPTY$1 = matchGraph.DISALLOW_EMPTY;
+
+	var TOKEN = 1;
+	var OPEN_SYNTAX = 2;
+	var CLOSE_SYNTAX = 3;
+
+	var EXIT_REASON_MATCH = 'Match';
+	var EXIT_REASON_MISMATCH = 'Mismatch';
+	var EXIT_REASON_ITERATION_LIMIT = 'Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)';
+
+	var ITERATION_LIMIT = 10000;
+	var totalIterationCount = 0;
+
+	function mapList(list, fn) {
+	    var result = [];
+
+	    while (list) {
+	        result.unshift(fn(list));
+	        list = list.prev;
+	    }
+
+	    return result;
+	}
+
+	function isCommaContextStart(token) {
+	    if (token === null) {
+	        return true;
+	    }
+
+	    token = token.value.charAt(token.value.length - 1);
+
+	    return (
+	        token === ',' ||
+	        token === '(' ||
+	        token === '[' ||
+	        token === '/'
+	    );
+	}
+
+	function isCommaContextEnd(token) {
+	    if (token === null) {
+	        return true;
+	    }
+
+	    token = token.value.charAt(0);
+
+	    return (
+	        token === ')' ||
+	        token === ']' ||
+	        token === '/'
+	    );
+	}
+
+	function internalMatch(tokens, syntax, syntaxes) {
+	    function moveToNextToken() {
+	        do {
+	            tokenCursor++;
+	            token = tokenCursor < tokens.length ? tokens[tokenCursor] : null;
+	        } while (token !== null && !/\S/.test(token.value));
+	    }
+
+	    function getNextToken(offset) {
+	        var nextIndex = tokenCursor + offset;
+
+	        return nextIndex < tokens.length ? tokens[nextIndex] : null;
+	    }
+
+	    function pushThenStack(nextSyntax) {
+	        thenStack = {
+	            nextSyntax: nextSyntax,
+	            matchStack: matchStack,
+	            syntaxStack: syntaxStack,
+	            prev: thenStack
+	        };
+	    }
+
+	    function pushElseStack(nextSyntax) {
+	        elseStack = {
+	            nextSyntax: nextSyntax,
+	            matchStack: matchStack,
+	            syntaxStack: syntaxStack,
+	            thenStack: thenStack,
+	            tokenCursor: tokenCursor,
+	            token: token,
+	            prev: elseStack
+	        };
+	    }
+
+	    function addTokenToMatch() {
+	        matchStack = {
+	            type: TOKEN,
+	            syntax: syntax.syntax,
+	            token: token,
+	            prev: matchStack
+	        };
+
+	        moveToNextToken();
+
+	        if (tokenCursor > longestMatch) {
+	            longestMatch = tokenCursor;
+	        }
+
+	        return matchStack.token;
+	    }
+
+	    function openSyntax() {
+	        syntaxStack = {
+	            syntax: syntax,
+	            prev: syntaxStack
+	        };
+
+	        matchStack = {
+	            type: OPEN_SYNTAX,
+	            syntax: syntax.syntax,
+	            token: matchStack.token,
+	            prev: matchStack
+	        };
+	    }
+
+	    function closeSyntax() {
+	        if (matchStack.type === OPEN_SYNTAX) {
+	            matchStack = matchStack.prev;
+	        } else {
+	            matchStack = {
+	                type: CLOSE_SYNTAX,
+	                syntax: syntaxStack.syntax,
+	                token: matchStack.token,
+	                prev: matchStack
+	            };
+	        }
+
+	        syntaxStack = syntaxStack.prev;
+	    }
+
+	    var syntaxStack = null;
+	    var thenStack = null;
+	    var elseStack = null;
+
+	    var iterationCount = 0;
+	    var exitReason = EXIT_REASON_MATCH;
+
+	    var matchStack = { type: 'Stub', syntax: null, token: null, tokenCursor: -1, prev: null };
+	    var longestMatch = 0;
+	    var tokenCursor = -1;
+	    var token = null;
+
+	    moveToNextToken();
+
+	    while (true) {
+	        // console.log('--\n',
+	        //     '#' + iterationCount,
+	        //     require('util').inspect({
+	        //         match: mapList(matchStack, x => x.type === TOKEN ? x.token && x.token.value : x.syntax ? x.type + '!' + x.syntax.name : null),
+	        //         elseStack: mapList(elseStack, x => x.id),
+	        //         thenStack: mapList(thenStack, x => x.id),
+	        //         token: token && token.value,
+	        //         tokenCursor,
+	        //         syntax
+	        //     }, { depth: null })
+	        // );
+
+	        // prevent infinite loop
+	        if (++iterationCount === ITERATION_LIMIT) {
+	            console.warn('[csstree-match] BREAK after ' + ITERATION_LIMIT + ' iterations');
+	            exitReason = EXIT_REASON_ITERATION_LIMIT;
+	            break;
+	        }
+
+	        if (syntax === MATCH$1) {
+	            if (thenStack === null) {
+	                // turn to MISMATCH when some tokens left unmatched
+	                if (token !== null) {
+	                    // doesn't mismatch if just one token left and it's an IE hack
+	                    if (tokenCursor !== tokens.length - 1 || (token.value !== '\\0' && token.value !== '\\9')) {
+	                        syntax = MISMATCH$1;
+	                        continue;
+	                    }
+	                }
+
+	                // break the main loop, return a result - MATCH
+	                exitReason = EXIT_REASON_MATCH;
+	                break;
+	            }
+
+	            // go to next syntax (`then` branch)
+	            syntax = thenStack.nextSyntax;
+
+	            // check match is not empty
+	            if (syntax === DISALLOW_EMPTY$1) {
+	                if (thenStack.matchStack.token === matchStack.token) {
+	                    syntax = MISMATCH$1;
+	                    continue;
+	                } else {
+	                    syntax = MATCH$1;
+	                }
+	            }
+
+	            // close syntax if needed
+	            while (syntaxStack !== null && thenStack.syntaxStack !== syntaxStack) {
+	                closeSyntax();
+	            }
+
+	            // pop stack
+	            thenStack = thenStack.prev;
+	            continue;
+	        }
+
+	        if (syntax === MISMATCH$1) {
+	            if (elseStack === null) {
+	                // break the main loop, return a result - MISMATCH
+	                exitReason = EXIT_REASON_MISMATCH;
+	                break;
+	            }
+
+	            // go to next syntax (`else` branch)
+	            syntax = elseStack.nextSyntax;
+
+	            // restore all the rest stack states
+	            thenStack = elseStack.thenStack;
+	            syntaxStack = elseStack.syntaxStack;
+	            matchStack = elseStack.matchStack;
+	            tokenCursor = elseStack.tokenCursor;
+	            token = elseStack.token;
+
+	            // pop stack
+	            elseStack = elseStack.prev;
+	            continue;
+	        }
+
+	        switch (syntax.type) {
+	            case 'MatchGraph':
+	                syntax = syntax.match;
+	                break;
+
+	            case 'If':
+	                // IMPORTANT: else stack push must go first,
+	                // since it stores the state of thenStack before changes
+	                if (syntax.else !== MISMATCH$1) {
+	                    pushElseStack(syntax.else);
+	                }
+
+	                if (syntax.then !== MATCH$1) {
+	                    pushThenStack(syntax.then);
+	                }
+
+	                syntax = syntax.match;
+	                break;
+
+	            case 'MatchOnce':
+	                syntax = {
+	                    type: 'MatchOnceBuffer',
+	                    terms: syntax.terms,
+	                    all: syntax.all,
+	                    matchStack: matchStack,
+	                    index: 0,
+	                    mask: 0
+	                };
+	                break;
+
+	            case 'MatchOnceBuffer':
+	                if (syntax.index === syntax.terms.length) {
+	                    // if no matches during a cycle
+	                    if (syntax.matchStack === matchStack) {
+	                        // no matches at all or it's required all terms to be matched
+	                        if (syntax.mask === 0 || syntax.all) {
+	                            syntax = MISMATCH$1;
+	                            break;
+	                        }
+
+	                        // a partial match is ok
+	                        syntax = MATCH$1;
+	                        break;
+	                    } else {
+	                        // start trying to match from the start
+	                        syntax.index = 0;
+	                        syntax.matchStack = matchStack;
+	                    }
+	                }
+
+	                for (; syntax.index < syntax.terms.length; syntax.index++) {
+	                    if ((syntax.mask & (1 << syntax.index)) === 0) {
+	                        // IMPORTANT: else stack push must go first,
+	                        // since it stores the state of thenStack before changes
+	                        pushElseStack(syntax);
+	                        pushThenStack({
+	                            type: 'AddMatchOnce',
+	                            buffer: syntax
+	                        });
+
+	                        // match
+	                        syntax = syntax.terms[syntax.index++];
+	                        break;
+	                    }
+	                }
+	                break;
+
+	            case 'AddMatchOnce':
+	                syntax = syntax.buffer;
+
+	                var newMask = syntax.mask | (1 << (syntax.index - 1));
+
+	                // all terms are matched
+	                if (newMask === (1 << syntax.terms.length) - 1) {
+	                    syntax = MATCH$1;
+	                    continue;
+	                }
+
+	                syntax = {
+	                    type: 'MatchOnceBuffer',
+	                    terms: syntax.terms,
+	                    all: syntax.all,
+	                    matchStack: syntax.matchStack,
+	                    index: syntax.index,
+	                    mask: newMask
+	                };
+
+	                break;
+
+	            case 'Enum':
+	                var name = token !== null ? token.value.toLowerCase() : '';
+
+	                // drop \0 and \9 hack from keyword name
+	                if (name.indexOf('\\') !== -1) {
+	                    name = name.replace(/\\[09].*$/, '');
+	                }
+
+	                if (hasOwnProperty$1.call(syntax.map, name)) {
+	                    syntax = syntax.map[name];
+	                } else {
+	                    syntax = MISMATCH$1;
+	                }
+
+	                break;
+
+	            case 'Generic':
+	                syntax = syntax.fn(token, addTokenToMatch, getNextToken) ? MATCH$1 : MISMATCH$1;
+	                break;
+
+	            case 'Type':
+	            case 'Property':
+	                openSyntax();
+
+	                var syntaxDict = syntax.type === 'Type' ? 'types' : 'properties';
+
+	                if (hasOwnProperty$1.call(syntaxes, syntaxDict) && syntaxes[syntaxDict][syntax.name]) {
+	                    syntax = syntaxes[syntaxDict][syntax.name].match;
+	                } else {
+	                    syntax = undefined;
+	                }
+
+	                if (!syntax) {
+	                    throw new Error(
+	                        'Bad syntax reference: ' +
+	                        (syntaxStack.syntax.type === 'Type'
+	                            ? '<' + syntaxStack.syntax.name + '>'
+	                            : '<\'' + syntaxStack.syntax.name + '\'>')
+	                    );
+	                }
+
+	                break;
+
+	            case 'Keyword':
+	                var name = syntax.name;
+
+	                if (token !== null) {
+	                    var keywordName = token.value;
+
+	                    // drop \0 and \9 hack from keyword name
+	                    if (keywordName.indexOf('\\') !== -1) {
+	                        keywordName = keywordName.replace(/\\[09].*$/, '');
+	                    }
+
+	                    if (keywordName.toLowerCase() === name) {
+	                        addTokenToMatch();
+
+	                        syntax = MATCH$1;
+	                        break;
+	                    }
+	                }
+
+	                syntax = MISMATCH$1;
+	                break;
+
+	            case 'AtKeyword':
+	            case 'Function':
+	                if (token !== null && token.value.toLowerCase() === syntax.name) {
+	                    addTokenToMatch();
+
+	                    syntax = MATCH$1;
+	                    break;
+	                }
+
+	                syntax = MISMATCH$1;
+	                break;
+
+	            case 'Token':
+	                if (token !== null && token.value === syntax.value) {
+	                    addTokenToMatch();
+
+	                    syntax = MATCH$1;
+	                    break;
+	                }
+
+	                syntax = MISMATCH$1;
+	                break;
+
+	            case 'Comma':
+	                if (token !== null && token.value === ',') {
+	                    if (isCommaContextStart(matchStack.token)) {
+	                        syntax = MISMATCH$1;
+	                    } else {
+	                        addTokenToMatch();
+	                        syntax = isCommaContextEnd(token) ? MISMATCH$1 : MATCH$1;
+	                    }
+	                } else {
+	                    syntax = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH$1 : MISMATCH$1;
+	                }
+
+	                break;
+
+	            // case 'String':
+	            // TODO: strings with length other than 1 char
+
+	            default:
+	                throw new Error('Unknown node type: ' + syntax.type);
+	        }
+	    }
+
+	    totalIterationCount += iterationCount;
+
+	    if (exitReason === EXIT_REASON_MATCH) {
+	        while (syntaxStack !== null) {
+	            closeSyntax();
+	        }
+	    } else {
+	        matchStack = null;
+	    }
+
+	    return {
+	        tokens: tokens,
+	        reason: exitReason,
+	        iterations: iterationCount,
+	        match: matchStack,
+	        longestMatch: longestMatch
+	    };
+	}
+
+	function matchAsList(tokens, matchGraph$$1, syntaxes) {
+	    var matchResult = internalMatch(tokens, matchGraph$$1, syntaxes || {});
+
+	    if (matchResult.match !== null) {
+	        matchResult.match = mapList(matchResult.match, function(item) {
+	            if (item.type === OPEN_SYNTAX || item.type === CLOSE_SYNTAX) {
+	                return { type: item.type, syntax: item.syntax };
+	            }
+
+	            return {
+	                syntax: item.syntax,
+	                token: item.token && item.token.value,
+	                node: item.token && item.token.node
+	            };
+	        }).slice(1);
+	    }
+
+	    return matchResult;
+	}
+
+	function matchAsTree(tokens, matchGraph$$1, syntaxes) {
+	    var matchResult = internalMatch(tokens, matchGraph$$1, syntaxes || {});
+
+	    if (matchResult.match === null) {
+	        return matchResult;
+	    }
+
+	    var cursor = matchResult.match;
+	    var host = matchResult.match = {
+	        syntax: matchGraph$$1.syntax || null,
+	        match: []
+	    };
+	    var stack = [host];
+
+	    // revert a list
+	    var prev = null;
+	    var next = null;
+	    while (cursor !== null) {
+	        next = cursor.prev;
+	        cursor.prev = prev;
+	        prev = cursor;
+	        cursor = next;
+	    }
+
+	    // init the cursor to start with 2nd item since 1st is a stub item
+	    cursor = prev.prev;
+
+	    // build a tree
+	    while (cursor !== null && cursor.syntax !== null) {
+	        var entry = cursor;
+
+	        switch (entry.type) {
+	            case OPEN_SYNTAX:
+	                host.match.push(host = {
+	                    syntax: entry.syntax,
+	                    match: []
+	                });
+	                stack.push(host);
+	                break;
+
+	            case CLOSE_SYNTAX:
+	                stack.pop();
+	                host = stack[stack.length - 1];
+	                break;
+
+	            default:
+	                host.match.push({
+	                    syntax: entry.syntax || null,
+	                    token: entry.token.value,
+	                    node: entry.token.node
+	                });
+	        }
+
+	        cursor = cursor.prev;
+	    }
+
+	    return matchResult;
+	}
+
+	var match = {
+	    matchAsList: matchAsList,
+	    matchAsTree: matchAsTree,
+	    getTotalIterationCount: function() {
+	        return totalIterationCount;
+	    }
+	};
+
+	function getTrace(node) {
+	    function shouldPutToTrace(syntax) {
+	        if (syntax === null) {
+	            return false;
+	        }
+
+	        return (
+	            syntax.type === 'Type' ||
+	            syntax.type === 'Property' ||
+	            syntax.type === 'Keyword'
+	        );
+	    }
+
+	    function hasMatch(matchNode) {
+	        if (Array.isArray(matchNode.match)) {
+	            // use for-loop for better perfomance
+	            for (var i = 0; i < matchNode.match.length; i++) {
+	                if (hasMatch(matchNode.match[i])) {
+	                    if (shouldPutToTrace(matchNode.syntax)) {
+	                        result.unshift(matchNode.syntax);
+	                    }
+
+	                    return true;
+	                }
+	            }
+	        } else if (matchNode.node === node) {
+	            result = shouldPutToTrace(matchNode.syntax)
+	                ? [matchNode.syntax]
+	                : [];
+
+	            return true;
+	        }
+
+	        return false;
+	    }
+
+	    var result = null;
+
+	    if (this.matched !== null) {
+	        hasMatch(this.matched);
+	    }
+
+	    return result;
+	}
+
+	function testNode(match, node, fn) {
+	    var trace = getTrace.call(match, node);
+
+	    if (trace === null) {
+	        return false;
+	    }
+
+	    return trace.some(fn);
+	}
+
+	function isType(node, type) {
+	    return testNode(this, node, function(matchNode) {
+	        return matchNode.type === 'Type' && matchNode.name === type;
+	    });
+	}
+
+	function isProperty(node, property) {
+	    return testNode(this, node, function(matchNode) {
+	        return matchNode.type === 'Property' && matchNode.name === property;
+	    });
+	}
+
+	function isKeyword(node) {
+	    return testNode(this, node, function(matchNode) {
+	        return matchNode.type === 'Keyword';
+	    });
+	}
+
+	var trace = {
+	    getTrace: getTrace,
+	    isType: isType,
+	    isProperty: isProperty,
+	    isKeyword: isKeyword
+	};
+
+	function getFirstMatchNode(matchNode) {
+	    if ('node' in matchNode) {
+	        return matchNode.node;
+	    }
+
+	    return getFirstMatchNode(matchNode.match[0]);
+	}
+
+	function getLastMatchNode(matchNode) {
+	    if ('node' in matchNode) {
+	        return matchNode.node;
+	    }
+
+	    return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);
+	}
+
+	function matchFragments(lexer, ast, match, type, name) {
+	    function findFragments(matchNode) {
+	        if (matchNode.syntax !== null &&
+	            matchNode.syntax.type === type &&
+	            matchNode.syntax.name === name) {
+	            var start = getFirstMatchNode(matchNode);
+	            var end = getLastMatchNode(matchNode);
+
+	            lexer.syntax.walk(ast, function(node, item, list$$1) {
+	                if (node === start) {
+	                    var nodes = new list();
+
+	                    do {
+	                        nodes.appendData(item.data);
+
+	                        if (item.data === end) {
+	                            break;
+	                        }
+
+	                        item = item.next;
+	                    } while (item !== null);
+
+	                    fragments.push({
+	                        parent: list$$1,
+	                        nodes: nodes
+	                    });
+	                }
+	            });
+	        }
+
+	        if (Array.isArray(matchNode.match)) {
+	            matchNode.match.forEach(findFragments);
+	        }
+	    }
+
+	    var fragments = [];
+
+	    if (match.matched !== null) {
+	        findFragments(match.matched);
+	    }
+
+	    return fragments;
+	}
+
+	var search = {
+	    matchFragments: matchFragments
+	};
+
+	var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+
+	function isValidNumber(value) {
+	    // Number.isInteger(value) && value >= 0
+	    return (
+	        typeof value === 'number' &&
+	        isFinite(value) &&
+	        Math.floor(value) === value &&
+	        value >= 0
+	    );
+	}
+
+	function isValidLocation(loc) {
+	    return (
+	        Boolean(loc) &&
+	        isValidNumber(loc.offset) &&
+	        isValidNumber(loc.line) &&
+	        isValidNumber(loc.column)
+	    );
+	}
+
+	function createNodeStructureChecker(type, fields) {
+	    return function checkNode(node, warn) {
+	        if (!node || node.constructor !== Object) {
+	            return warn(node, 'Type of node should be an Object');
+	        }
+
+	        for (var key in node) {
+	            var valid = true;
+
+	            if (hasOwnProperty$2.call(node, key) === false) {
+	                continue;
+	            }
+
+	            if (key === 'type') {
+	                if (node.type !== type) {
+	                    warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');
+	                }
+	            } else if (key === 'loc') {
+	                if (node.loc === null) {
+	                    continue;
+	                } else if (node.loc && node.loc.constructor === Object) {
+	                    if (typeof node.loc.source !== 'string') {
+	                        key += '.source';
+	                    } else if (!isValidLocation(node.loc.start)) {
+	                        key += '.start';
+	                    } else if (!isValidLocation(node.loc.end)) {
+	                        key += '.end';
+	                    } else {
+	                        continue;
+	                    }
+	                }
+
+	                valid = false;
+	            } else if (fields.hasOwnProperty(key)) {
+	                for (var i = 0, valid = false; !valid && i < fields[key].length; i++) {
+	                    var fieldType = fields[key][i];
+
+	                    switch (fieldType) {
+	                        case String:
+	                            valid = typeof node[key] === 'string';
+	                            break;
+
+	                        case Boolean:
+	                            valid = typeof node[key] === 'boolean';
+	                            break;
+
+	                        case null:
+	                            valid = node[key] === null;
+	                            break;
+
+	                        default:
+	                            if (typeof fieldType === 'string') {
+	                                valid = node[key] && node[key].type === fieldType;
+	                            } else if (Array.isArray(fieldType)) {
+	                                valid = node[key] instanceof list;
+	                            }
+	                    }
+	                }
+	            } else {
+	                warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');
+	            }
+
+	            if (!valid) {
+	                warn(node, 'Bad value for `' + type + '.' + key + '`');
+	            }
+	        }
+
+	        for (var key in fields) {
+	            if (hasOwnProperty$2.call(fields, key) &&
+	                hasOwnProperty$2.call(node, key) === false) {
+	                warn(node, 'Field `' + type + '.' + key + '` is missed');
+	            }
+	        }
+	    };
+	}
+
+	function processStructure(name, nodeType) {
+	    var structure = nodeType.structure;
+	    var fields = {
+	        type: String,
+	        loc: true
+	    };
+	    var docs = {
+	        type: '"' + name + '"'
+	    };
+
+	    for (var key in structure) {
+	        if (hasOwnProperty$2.call(structure, key) === false) {
+	            continue;
+	        }
+
+	        var docsTypes = [];
+	        var fieldTypes = fields[key] = Array.isArray(structure[key])
+	            ? structure[key].slice()
+	            : [structure[key]];
+
+	        for (var i = 0; i < fieldTypes.length; i++) {
+	            var fieldType = fieldTypes[i];
+	            if (fieldType === String || fieldType === Boolean) {
+	                docsTypes.push(fieldType.name);
+	            } else if (fieldType === null) {
+	                docsTypes.push('null');
+	            } else if (typeof fieldType === 'string') {
+	                docsTypes.push('<' + fieldType + '>');
+	            } else if (Array.isArray(fieldType)) {
+	                docsTypes.push('List'); // TODO: use type enum
+	            } else {
+	                throw new Error('Wrong value `' + fieldType + '` in `' + name + '.' + key + '` structure definition');
+	            }
+	        }
+
+	        docs[key] = docsTypes.join(' | ');
+	    }
+
+	    return {
+	        docs: docs,
+	        check: createNodeStructureChecker(name, fields)
+	    };
+	}
+
+	var structure = {
+	    getStructureFromConfig: function(config) {
+	        var structure = {};
+
+	        if (config.node) {
+	            for (var name in config.node) {
+	                if (hasOwnProperty$2.call(config.node, name)) {
+	                    var nodeType = config.node[name];
+
+	                    if (nodeType.structure) {
+	                        structure[name] = processStructure(name, nodeType);
+	                    } else {
+	                        throw new Error('Missed `structure` field in `' + name + '` node type definition');
+	                    }
+	                }
+	            }
+	        }
+
+	        return structure;
+	    }
+	};
+
+	var SyntaxReferenceError$1 = error$1.SyntaxReferenceError;
+	var MatchError$1 = error$1.MatchError;
+
+
+
+
+
+
+	var buildMatchGraph$1 = matchGraph.buildMatchGraph;
+	var matchAsTree$1 = match.matchAsTree;
+
+
+	var getStructureFromConfig = structure.getStructureFromConfig;
+	var cssWideKeywords = buildMatchGraph$1(parse_1('inherit | initial | unset'));
+	var cssWideKeywordsWithExpression = buildMatchGraph$1(parse_1('inherit | initial | unset | <expression>'));
+
+	function dumpMapSyntax(map, syntaxAsAst) {
+	    var result = {};
+
+	    for (var name in map) {
+	        if (map[name].syntax) {
+	            result[name] = syntaxAsAst ? map[name].syntax : generate_1(map[name].syntax);
+	        }
+	    }
+
+	    return result;
+	}
+
+	function valueHasVar(value) {
+	    var hasVar = false;
+
+	    this.syntax.walk(value, function(node) {
+	        if (node.type === 'Function' && node.name.toLowerCase() === 'var') {
+	            hasVar = true;
+	        }
+	    });
+
+	    return hasVar;
+	}
+
+	function buildMatchResult(match$$1, error, iterations) {
+	    return {
+	        matched: match$$1,
+	        iterations: iterations,
+	        error: error,
+	        getTrace: trace.getTrace,
+	        isType: trace.isType,
+	        isProperty: trace.isProperty,
+	        isKeyword: trace.isKeyword
+	    };
+	}
+
+	function matchSyntax(lexer, syntax, node, useCommon) {
+	    if (!node) {
+	        return buildMatchResult(null, new Error('Node is undefined'));
+	    }
+
+	    if (valueHasVar.call(lexer, node)) {
+	        return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));
+	    }
+
+	    var tokens = lexer.syntax.generate(node, astToTokens);
+	    var result;
+
+	    if (useCommon) {
+	        result = matchAsTree$1(tokens, lexer.valueCommonSyntax, lexer);
+	    }
+
+	    if (!useCommon || !result.match) {
+	        result = matchAsTree$1(tokens, syntax.match, lexer);
+	        if (!result.match) {
+	            return buildMatchResult(
+	                null,
+	                new MatchError$1(result.reason, lexer, syntax.syntax, node, result),
+	                result.iterations
+	            );
+	        }
+	    }
+
+	    return buildMatchResult(result.match, null, result.iterations);
+	}
+
+	var Lexer = function(config, syntax, structure$$1) {
+	    this.valueCommonSyntax = cssWideKeywords;
+	    this.syntax = syntax;
+	    this.generic = false;
+	    this.properties = {};
+	    this.types = {};
+	    this.structure = structure$$1 || getStructureFromConfig(config);
+
+	    if (config) {
+	        if (config.generic) {
+	            this.generic = true;
+	            for (var name in generic) {
+	                this.addType_(name, generic[name]);
+	            }
+	        }
+
+	        if (config.types) {
+	            for (var name in config.types) {
+	                this.addType_(name, config.types[name]);
+	            }
+	        }
+
+	        if (config.properties) {
+	            for (var name in config.properties) {
+	                this.addProperty_(name, config.properties[name]);
+	            }
+	        }
+	    }
+	};
+
+	Lexer.prototype = {
+	    structure: {},
+	    checkStructure: function(ast) {
+	        function collectWarning(node, message) {
+	            warns.push({
+	                node: node,
+	                message: message
+	            });
+	        }
+
+	        var structure$$1 = this.structure;
+	        var warns = [];
+
+	        this.syntax.walk(ast, function(node) {
+	            if (structure$$1.hasOwnProperty(node.type)) {
+	                structure$$1[node.type].check(node, collectWarning);
+	            } else {
+	                collectWarning(node, 'Unknown node type `' + node.type + '`');
+	            }
+	        });
+
+	        return warns.length ? warns : false;
+	    },
+
+	    createDescriptor: function(syntax, type, name) {
+	        var ref = {
+	            type: type,
+	            name: name
+	        };
+	        var descriptor = {
+	            type: type,
+	            name: name,
+	            syntax: null,
+	            match: null
+	        };
+
+	        if (typeof syntax === 'function') {
+	            descriptor.match = buildMatchGraph$1(syntax, ref);
+	        } else {
+	            if (typeof syntax === 'string') {
+	                // lazy parsing on first access
+	                Object.defineProperty(descriptor, 'syntax', {
+	                    get: function() {
+	                        Object.defineProperty(descriptor, 'syntax', {
+	                            value: parse_1(syntax)
+	                        });
+
+	                        return descriptor.syntax;
+	                    }
+	                });
+	            } else {
+	                descriptor.syntax = syntax;
+	            }
+
+	            Object.defineProperty(descriptor, 'match', {
+	                get: function() {
+	                    Object.defineProperty(descriptor, 'match', {
+	                        value: buildMatchGraph$1(descriptor.syntax, ref)
+	                    });
+
+	                    return descriptor.match;
+	                }
+	            });
+	        }
+
+	        return descriptor;
+	    },
+	    addProperty_: function(name, syntax) {
+	        this.properties[name] = this.createDescriptor(syntax, 'Property', name);
+	    },
+	    addType_: function(name, syntax) {
+	        this.types[name] = this.createDescriptor(syntax, 'Type', name);
+
+	        if (syntax === generic.expression) {
+	            this.valueCommonSyntax = cssWideKeywordsWithExpression;
+	        }
+	    },
+
+	    matchDeclaration: function(node) {
+	        if (node.type !== 'Declaration') {
+	            return buildMatchResult(null, new Error('Not a Declaration node'));
+	        }
+
+	        return this.matchProperty(node.property, node.value);
+	    },
+	    matchProperty: function(propertyName, value) {
+	        var property = names.property(propertyName);
+
+	        // don't match syntax for a custom property
+	        if (property.custom) {
+	            return buildMatchResult(null, new Error('Lexer matching doesn\'t applicable for custom properties'));
+	        }
+
+	        var propertySyntax = property.vendor
+	            ? this.getProperty(property.name) || this.getProperty(property.basename)
+	            : this.getProperty(property.name);
+
+	        if (!propertySyntax) {
+	            return buildMatchResult(null, new SyntaxReferenceError$1('Unknown property', propertyName));
+	        }
+
+	        return matchSyntax(this, propertySyntax, value, true);
+	    },
+	    matchType: function(typeName, value) {
+	        var typeSyntax = this.getType(typeName);
+
+	        if (!typeSyntax) {
+	            return buildMatchResult(null, new SyntaxReferenceError$1('Unknown type', typeName));
+	        }
+
+	        return matchSyntax(this, typeSyntax, value, false);
+	    },
+	    match: function(syntax, value) {
+	        if (!syntax || !syntax.type) {
+	            return buildMatchResult(null, new SyntaxReferenceError$1('Bad syntax'));
+	        }
+
+	        if (!syntax.match) {
+	            syntax = this.createDescriptor(syntax);
+	        }
+
+	        return matchSyntax(this, syntax, value, false);
+	    },
+
+	    findValueFragments: function(propertyName, value, type, name) {
+	        return search.matchFragments(this, value, this.matchProperty(propertyName, value), type, name);
+	    },
+	    findDeclarationValueFragments: function(declaration, type, name) {
+	        return search.matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);
+	    },
+	    findAllFragments: function(ast, type, name) {
+	        var result = [];
+
+	        this.syntax.walk(ast, {
+	            visit: 'Declaration',
+	            enter: function(declaration) {
+	                result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));
+	            }.bind(this)
+	        });
+
+	        return result;
+	    },
+
+	    getProperty: function(name) {
+	        return this.properties.hasOwnProperty(name) ? this.properties[name] : null;
+	    },
+	    getType: function(name) {
+	        return this.types.hasOwnProperty(name) ? this.types[name] : null;
+	    },
+
+	    validate: function() {
+	        function validate(syntax, name, broken, descriptor) {
+	            if (broken.hasOwnProperty(name)) {
+	                return broken[name];
+	            }
+
+	            broken[name] = false;
+	            if (descriptor.syntax !== null) {
+	                walk$1(descriptor.syntax, function(node) {
+	                    if (node.type !== 'Type' && node.type !== 'Property') {
+	                        return;
+	                    }
+
+	                    var map = node.type === 'Type' ? syntax.types : syntax.properties;
+	                    var brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;
+
+	                    if (!map.hasOwnProperty(node.name) || validate(syntax, node.name, brokenMap, map[node.name])) {
+	                        broken[name] = true;
+	                    }
+	                }, this);
+	            }
+	        }
+
+	        var brokenTypes = {};
+	        var brokenProperties = {};
+
+	        for (var key in this.types) {
+	            validate(this, key, brokenTypes, this.types[key]);
+	        }
+
+	        for (var key in this.properties) {
+	            validate(this, key, brokenProperties, this.properties[key]);
+	        }
+
+	        brokenTypes = Object.keys(brokenTypes).filter(function(name) {
+	            return brokenTypes[name];
+	        });
+	        brokenProperties = Object.keys(brokenProperties).filter(function(name) {
+	            return brokenProperties[name];
+	        });
+
+	        if (brokenTypes.length || brokenProperties.length) {
+	            return {
+	                types: brokenTypes,
+	                properties: brokenProperties
+	            };
+	        }
+
+	        return null;
+	    },
+	    dump: function(syntaxAsAst) {
+	        return {
+	            generic: this.generic,
+	            types: dumpMapSyntax(this.types, syntaxAsAst),
+	            properties: dumpMapSyntax(this.properties, syntaxAsAst)
+	        };
+	    },
+	    toString: function() {
+	        return JSON.stringify(this.dump());
+	    }
+	};
+
+	var Lexer_1 = Lexer;
+
+	var grammar = {
+	    SyntaxParseError: error$2.SyntaxParseError,
+	    parse: parse_1,
+	    generate: generate_1,
+	    walk: walk$1
+	};
+
+	var TYPE$3 = tokenizer.TYPE;
+	var WHITESPACE$2 = TYPE$3.WhiteSpace;
+	var COMMENT$2 = TYPE$3.Comment;
+
+	var sequence = function readSequence(recognizer) {
+	    var children = this.createList();
+	    var child = null;
+	    var context = {
+	        recognizer: recognizer,
+	        space: null,
+	        ignoreWS: false,
+	        ignoreWSAfter: false
+	    };
+
+	    this.scanner.skipSC();
+
+	    while (!this.scanner.eof) {
+	        switch (this.scanner.tokenType) {
+	            case COMMENT$2:
+	                this.scanner.next();
+	                continue;
+
+	            case WHITESPACE$2:
+	                if (context.ignoreWS) {
+	                    this.scanner.next();
+	                } else {
+	                    context.space = this.WhiteSpace();
+	                }
+	                continue;
+	        }
+
+	        child = recognizer.getNode.call(this, context);
+
+	        if (child === undefined) {
+	            break;
+	        }
+
+	        if (context.space !== null) {
+	            children.push(context.space);
+	            context.space = null;
+	        }
+
+	        children.push(child);
+
+	        if (context.ignoreWSAfter) {
+	            context.ignoreWSAfter = false;
+	            context.ignoreWS = true;
+	        } else {
+	            context.ignoreWS = false;
+	        }
+	    }
+
+	    return children;
+	};
+
+	var noop$3 = function() {};
+
+	function createParseContext(name) {
+	    return function() {
+	        return this[name]();
+	    };
+	}
+
+	function processConfig(config) {
+	    var parserConfig = {
+	        context: {},
+	        scope: {},
+	        atrule: {},
+	        pseudo: {}
+	    };
+
+	    if (config.parseContext) {
+	        for (var name in config.parseContext) {
+	            switch (typeof config.parseContext[name]) {
+	                case 'function':
+	                    parserConfig.context[name] = config.parseContext[name];
+	                    break;
+
+	                case 'string':
+	                    parserConfig.context[name] = createParseContext(config.parseContext[name]);
+	                    break;
+	            }
+	        }
+	    }
+
+	    if (config.scope) {
+	        for (var name in config.scope) {
+	            parserConfig.scope[name] = config.scope[name];
+	        }
+	    }
+
+	    if (config.atrule) {
+	        for (var name in config.atrule) {
+	            var atrule = config.atrule[name];
+
+	            if (atrule.parse) {
+	                parserConfig.atrule[name] = atrule.parse;
+	            }
+	        }
+	    }
+
+	    if (config.pseudo) {
+	        for (var name in config.pseudo) {
+	            var pseudo = config.pseudo[name];
+
+	            if (pseudo.parse) {
+	                parserConfig.pseudo[name] = pseudo.parse;
+	            }
+	        }
+	    }
+
+	    if (config.node) {
+	        for (var name in config.node) {
+	            parserConfig[name] = config.node[name].parse;
+	        }
+	    }
+
+	    return parserConfig;
+	}
+
+	var create$1 = function createParser(config) {
+	    var parser = {
+	        scanner: new tokenizer(),
+	        filename: '<unknown>',
+	        needPositions: false,
+	        onParseError: noop$3,
+	        onParseErrorThrow: false,
+	        parseAtrulePrelude: true,
+	        parseRulePrelude: true,
+	        parseValue: true,
+	        parseCustomProperty: false,
+
+	        readSequence: sequence,
+
+	        createList: function() {
+	            return new list();
+	        },
+	        createSingleNodeList: function(node) {
+	            return new list().appendData(node);
+	        },
+	        getFirstListNode: function(list$$1) {
+	            return list$$1 && list$$1.first();
+	        },
+	        getLastListNode: function(list$$1) {
+	            return list$$1.last();
+	        },
+
+	        parseWithFallback: function(consumer, fallback) {
+	            var startToken = this.scanner.currentToken;
+
+	            try {
+	                return consumer.call(this);
+	            } catch (e) {
+	                if (this.onParseErrorThrow) {
+	                    throw e;
+	                }
+
+	                var fallbackNode = fallback.call(this, startToken);
+
+	                this.onParseErrorThrow = true;
+	                this.onParseError(e, fallbackNode);
+	                this.onParseErrorThrow = false;
+
+	                return fallbackNode;
+	            }
+	        },
+
+	        getLocation: function(start, end) {
+	            if (this.needPositions) {
+	                return this.scanner.getLocationRange(
+	                    start,
+	                    end,
+	                    this.filename
+	                );
+	            }
+
+	            return null;
+	        },
+	        getLocationFromList: function(list$$1) {
+	            if (this.needPositions) {
+	                var head = this.getFirstListNode(list$$1);
+	                var tail = this.getLastListNode(list$$1);
+	                return this.scanner.getLocationRange(
+	                    head !== null ? head.loc.start.offset - this.scanner.startOffset : this.scanner.tokenStart,
+	                    tail !== null ? tail.loc.end.offset - this.scanner.startOffset : this.scanner.tokenStart,
+	                    this.filename
+	                );
+	            }
+
+	            return null;
+	        }
+	    };
+
+	    config = processConfig(config || {});
+	    for (var key in config) {
+	        parser[key] = config[key];
+	    }
+
+	    return function(source, options) {
+	        options = options || {};
+
+	        var context = options.context || 'default';
+	        var ast;
+
+	        parser.scanner.setSource(source, options.offset, options.line, options.column);
+	        parser.filename = options.filename || '<unknown>';
+	        parser.needPositions = Boolean(options.positions);
+	        parser.onParseError = typeof options.onParseError === 'function' ? options.onParseError : noop$3;
+	        parser.onParseErrorThrow = false;
+	        parser.parseAtrulePrelude = 'parseAtrulePrelude' in options ? Boolean(options.parseAtrulePrelude) : true;
+	        parser.parseRulePrelude = 'parseRulePrelude' in options ? Boolean(options.parseRulePrelude) : true;
+	        parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;
+	        parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;
+
+	        if (!parser.context.hasOwnProperty(context)) {
+	            throw new Error('Unknown context `' + context + '`');
+	        }
+
+	        ast = parser.context[context].call(parser, options);
+
+	        if (!parser.scanner.eof) {
+	            parser.scanner.error();
+	        }
+
+	        return ast;
+	    };
+	};
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+
+	/**
+	 * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+	 */
+	var encode = function (number) {
+	  if (0 <= number && number < intToCharMap.length) {
+	    return intToCharMap[number];
+	  }
+	  throw new TypeError("Must be between 0 and 63: " + number);
+	};
+
+	/**
+	 * Decode a single base 64 character code digit to an integer. Returns -1 on
+	 * failure.
+	 */
+	var decode = function (charCode) {
+	  var bigA = 65;     // 'A'
+	  var bigZ = 90;     // 'Z'
+
+	  var littleA = 97;  // 'a'
+	  var littleZ = 122; // 'z'
+
+	  var zero = 48;     // '0'
+	  var nine = 57;     // '9'
+
+	  var plus = 43;     // '+'
+	  var slash = 47;    // '/'
+
+	  var littleOffset = 26;
+	  var numberOffset = 52;
+
+	  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
+	  if (bigA <= charCode && charCode <= bigZ) {
+	    return (charCode - bigA);
+	  }
+
+	  // 26 - 51: abcdefghijklmnopqrstuvwxyz
+	  if (littleA <= charCode && charCode <= littleZ) {
+	    return (charCode - littleA + littleOffset);
+	  }
+
+	  // 52 - 61: 0123456789
+	  if (zero <= charCode && charCode <= nine) {
+	    return (charCode - zero + numberOffset);
+	  }
+
+	  // 62: +
+	  if (charCode == plus) {
+	    return 62;
+	  }
+
+	  // 63: /
+	  if (charCode == slash) {
+	    return 63;
+	  }
+
+	  // Invalid base64 digit.
+	  return -1;
+	};
+
+	var base64 = {
+		encode: encode,
+		decode: decode
+	};
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 *
+	 * Based on the Base 64 VLQ implementation in Closure Compiler:
+	 * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+	 *
+	 * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+	 * Redistribution and use in source and binary forms, with or without
+	 * modification, are permitted provided that the following conditions are
+	 * met:
+	 *
+	 *  * Redistributions of source code must retain the above copyright
+	 *    notice, this list of conditions and the following disclaimer.
+	 *  * Redistributions in binary form must reproduce the above
+	 *    copyright notice, this list of conditions and the following
+	 *    disclaimer in the documentation and/or other materials provided
+	 *    with the distribution.
+	 *  * Neither the name of Google Inc. nor the names of its
+	 *    contributors may be used to endorse or promote products derived
+	 *    from this software without specific prior written permission.
+	 *
+	 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+	 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+	 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+	 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+	 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+	 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	 */
+
+
+
+	// A single base 64 digit can contain 6 bits of data. For the base 64 variable
+	// length quantities we use in the source map spec, the first bit is the sign,
+	// the next four bits are the actual value, and the 6th bit is the
+	// continuation bit. The continuation bit tells us whether there are more
+	// digits in this value following this digit.
+	//
+	//   Continuation
+	//   |    Sign
+	//   |    |
+	//   V    V
+	//   101011
+
+	var VLQ_BASE_SHIFT = 5;
+
+	// binary: 100000
+	var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+	// binary: 011111
+	var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+	// binary: 100000
+	var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+	/**
+	 * Converts from a two-complement value to a value where the sign bit is
+	 * placed in the least significant bit.  For example, as decimals:
+	 *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+	 *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+	 */
+	function toVLQSigned(aValue) {
+	  return aValue < 0
+	    ? ((-aValue) << 1) + 1
+	    : (aValue << 1) + 0;
+	}
+
+	/**
+	 * Converts to a two-complement value from a value where the sign bit is
+	 * placed in the least significant bit.  For example, as decimals:
+	 *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+	 *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+	 */
+	function fromVLQSigned(aValue) {
+	  var isNegative = (aValue & 1) === 1;
+	  var shifted = aValue >> 1;
+	  return isNegative
+	    ? -shifted
+	    : shifted;
+	}
+
+	/**
+	 * Returns the base 64 VLQ encoded value.
+	 */
+	var encode$1 = function base64VLQ_encode(aValue) {
+	  var encoded = "";
+	  var digit;
+
+	  var vlq = toVLQSigned(aValue);
+
+	  do {
+	    digit = vlq & VLQ_BASE_MASK;
+	    vlq >>>= VLQ_BASE_SHIFT;
+	    if (vlq > 0) {
+	      // There are still more digits in this value, so we must make sure the
+	      // continuation bit is marked.
+	      digit |= VLQ_CONTINUATION_BIT;
+	    }
+	    encoded += base64.encode(digit);
+	  } while (vlq > 0);
+
+	  return encoded;
+	};
+
+	/**
+	 * Decodes the next base 64 VLQ value from the given string and returns the
+	 * value and the rest of the string via the out parameter.
+	 */
+	var decode$1 = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+	  var strLen = aStr.length;
+	  var result = 0;
+	  var shift = 0;
+	  var continuation, digit;
+
+	  do {
+	    if (aIndex >= strLen) {
+	      throw new Error("Expected more digits in base 64 VLQ value.");
+	    }
+
+	    digit = base64.decode(aStr.charCodeAt(aIndex++));
+	    if (digit === -1) {
+	      throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+	    }
+
+	    continuation = !!(digit & VLQ_CONTINUATION_BIT);
+	    digit &= VLQ_BASE_MASK;
+	    result = result + (digit << shift);
+	    shift += VLQ_BASE_SHIFT;
+	  } while (continuation);
+
+	  aOutParam.value = fromVLQSigned(result);
+	  aOutParam.rest = aIndex;
+	};
+
+	var base64Vlq = {
+		encode: encode$1,
+		decode: decode$1
+	};
+
+	var util = createCommonjsModule(function (module, exports) {
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	/**
+	 * This is a helper function for getting values from parameter/options
+	 * objects.
+	 *
+	 * @param args The object we are extracting values from
+	 * @param name The name of the property we are getting.
+	 * @param defaultValue An optional value to return if the property is missing
+	 * from the object. If this is not specified and the property is missing, an
+	 * error will be thrown.
+	 */
+	function getArg(aArgs, aName, aDefaultValue) {
+	  if (aName in aArgs) {
+	    return aArgs[aName];
+	  } else if (arguments.length === 3) {
+	    return aDefaultValue;
+	  } else {
+	    throw new Error('"' + aName + '" is a required argument.');
+	  }
+	}
+	exports.getArg = getArg;
+
+	var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
+	var dataUrlRegexp = /^data:.+\,.+$/;
+
+	function urlParse(aUrl) {
+	  var match = aUrl.match(urlRegexp);
+	  if (!match) {
+	    return null;
+	  }
+	  return {
+	    scheme: match[1],
+	    auth: match[2],
+	    host: match[3],
+	    port: match[4],
+	    path: match[5]
+	  };
+	}
+	exports.urlParse = urlParse;
+
+	function urlGenerate(aParsedUrl) {
+	  var url = '';
+	  if (aParsedUrl.scheme) {
+	    url += aParsedUrl.scheme + ':';
+	  }
+	  url += '//';
+	  if (aParsedUrl.auth) {
+	    url += aParsedUrl.auth + '@';
+	  }
+	  if (aParsedUrl.host) {
+	    url += aParsedUrl.host;
+	  }
+	  if (aParsedUrl.port) {
+	    url += ":" + aParsedUrl.port;
+	  }
+	  if (aParsedUrl.path) {
+	    url += aParsedUrl.path;
+	  }
+	  return url;
+	}
+	exports.urlGenerate = urlGenerate;
+
+	/**
+	 * Normalizes a path, or the path portion of a URL:
+	 *
+	 * - Replaces consecutive slashes with one slash.
+	 * - Removes unnecessary '.' parts.
+	 * - Removes unnecessary '<dir>/..' parts.
+	 *
+	 * Based on code in the Node.js 'path' core module.
+	 *
+	 * @param aPath The path or url to normalize.
+	 */
+	function normalize(aPath) {
+	  var path = aPath;
+	  var url = urlParse(aPath);
+	  if (url) {
+	    if (!url.path) {
+	      return aPath;
+	    }
+	    path = url.path;
+	  }
+	  var isAbsolute = exports.isAbsolute(path);
+
+	  var parts = path.split(/\/+/);
+	  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+	    part = parts[i];
+	    if (part === '.') {
+	      parts.splice(i, 1);
+	    } else if (part === '..') {
+	      up++;
+	    } else if (up > 0) {
+	      if (part === '') {
+	        // The first part is blank if the path is absolute. Trying to go
+	        // above the root is a no-op. Therefore we can remove all '..' parts
+	        // directly after the root.
+	        parts.splice(i + 1, up);
+	        up = 0;
+	      } else {
+	        parts.splice(i, 2);
+	        up--;
+	      }
+	    }
+	  }
+	  path = parts.join('/');
+
+	  if (path === '') {
+	    path = isAbsolute ? '/' : '.';
+	  }
+
+	  if (url) {
+	    url.path = path;
+	    return urlGenerate(url);
+	  }
+	  return path;
+	}
+	exports.normalize = normalize;
+
+	/**
+	 * Joins two paths/URLs.
+	 *
+	 * @param aRoot The root path or URL.
+	 * @param aPath The path or URL to be joined with the root.
+	 *
+	 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+	 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+	 *   first.
+	 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+	 *   is updated with the result and aRoot is returned. Otherwise the result
+	 *   is returned.
+	 *   - If aPath is absolute, the result is aPath.
+	 *   - Otherwise the two paths are joined with a slash.
+	 * - Joining for example 'http://' and 'www.example.com' is also supported.
+	 */
+	function join(aRoot, aPath) {
+	  if (aRoot === "") {
+	    aRoot = ".";
+	  }
+	  if (aPath === "") {
+	    aPath = ".";
+	  }
+	  var aPathUrl = urlParse(aPath);
+	  var aRootUrl = urlParse(aRoot);
+	  if (aRootUrl) {
+	    aRoot = aRootUrl.path || '/';
+	  }
+
+	  // `join(foo, '//www.example.org')`
+	  if (aPathUrl && !aPathUrl.scheme) {
+	    if (aRootUrl) {
+	      aPathUrl.scheme = aRootUrl.scheme;
+	    }
+	    return urlGenerate(aPathUrl);
+	  }
+
+	  if (aPathUrl || aPath.match(dataUrlRegexp)) {
+	    return aPath;
+	  }
+
+	  // `join('http://', 'www.example.com')`
+	  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+	    aRootUrl.host = aPath;
+	    return urlGenerate(aRootUrl);
+	  }
+
+	  var joined = aPath.charAt(0) === '/'
+	    ? aPath
+	    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+	  if (aRootUrl) {
+	    aRootUrl.path = joined;
+	    return urlGenerate(aRootUrl);
+	  }
+	  return joined;
+	}
+	exports.join = join;
+
+	exports.isAbsolute = function (aPath) {
+	  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);
+	};
+
+	/**
+	 * Make a path relative to a URL or another path.
+	 *
+	 * @param aRoot The root path or URL.
+	 * @param aPath The path or URL to be made relative to aRoot.
+	 */
+	function relative(aRoot, aPath) {
+	  if (aRoot === "") {
+	    aRoot = ".";
+	  }
+
+	  aRoot = aRoot.replace(/\/$/, '');
+
+	  // It is possible for the path to be above the root. In this case, simply
+	  // checking whether the root is a prefix of the path won't work. Instead, we
+	  // need to remove components from the root one by one, until either we find
+	  // a prefix that fits, or we run out of components to remove.
+	  var level = 0;
+	  while (aPath.indexOf(aRoot + '/') !== 0) {
+	    var index = aRoot.lastIndexOf("/");
+	    if (index < 0) {
+	      return aPath;
+	    }
+
+	    // If the only part of the root that is left is the scheme (i.e. http://,
+	    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+	    // have exhausted all components, so the path is not relative to the root.
+	    aRoot = aRoot.slice(0, index);
+	    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+	      return aPath;
+	    }
+
+	    ++level;
+	  }
+
+	  // Make sure we add a "../" for each component we removed from the root.
+	  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+	}
+	exports.relative = relative;
+
+	var supportsNullProto = (function () {
+	  var obj = Object.create(null);
+	  return !('__proto__' in obj);
+	}());
+
+	function identity (s) {
+	  return s;
+	}
+
+	/**
+	 * Because behavior goes wacky when you set `__proto__` on objects, we
+	 * have to prefix all the strings in our set with an arbitrary character.
+	 *
+	 * See https://github.com/mozilla/source-map/pull/31 and
+	 * https://github.com/mozilla/source-map/issues/30
+	 *
+	 * @param String aStr
+	 */
+	function toSetString(aStr) {
+	  if (isProtoString(aStr)) {
+	    return '$' + aStr;
+	  }
+
+	  return aStr;
+	}
+	exports.toSetString = supportsNullProto ? identity : toSetString;
+
+	function fromSetString(aStr) {
+	  if (isProtoString(aStr)) {
+	    return aStr.slice(1);
+	  }
+
+	  return aStr;
+	}
+	exports.fromSetString = supportsNullProto ? identity : fromSetString;
+
+	function isProtoString(s) {
+	  if (!s) {
+	    return false;
+	  }
+
+	  var length = s.length;
+
+	  if (length < 9 /* "__proto__".length */) {
+	    return false;
+	  }
+
+	  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
+	      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
+	      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+	      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+	      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+	      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+	      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+	      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
+	      s.charCodeAt(length - 9) !== 95  /* '_' */) {
+	    return false;
+	  }
+
+	  for (var i = length - 10; i >= 0; i--) {
+	    if (s.charCodeAt(i) !== 36 /* '$' */) {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	}
+
+	/**
+	 * Comparator between two mappings where the original positions are compared.
+	 *
+	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+	 * mappings with the same original source/line/column, but different generated
+	 * line and column the same. Useful when searching for a mapping with a
+	 * stubbed out mapping.
+	 */
+	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+	  var cmp = mappingA.source - mappingB.source;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0 || onlyCompareOriginal) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  return mappingA.name - mappingB.name;
+	}
+	exports.compareByOriginalPositions = compareByOriginalPositions;
+
+	/**
+	 * Comparator between two mappings with deflated source and name indices where
+	 * the generated positions are compared.
+	 *
+	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+	 * mappings with the same generated line and column, but different
+	 * source/name/original line and column the same. Useful when searching for a
+	 * mapping with a stubbed out mapping.
+	 */
+	function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0 || onlyCompareGenerated) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.source - mappingB.source;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  return mappingA.name - mappingB.name;
+	}
+	exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+
+	function strcmp(aStr1, aStr2) {
+	  if (aStr1 === aStr2) {
+	    return 0;
+	  }
+
+	  if (aStr1 > aStr2) {
+	    return 1;
+	  }
+
+	  return -1;
+	}
+
+	/**
+	 * Comparator between two mappings with inflated source and name strings where
+	 * the generated positions are compared.
+	 */
+	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = strcmp(mappingA.source, mappingB.source);
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0) {
+	    return cmp;
+	  }
+
+	  return strcmp(mappingA.name, mappingB.name);
+	}
+	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+	});
+	var util_1 = util.getArg;
+	var util_2 = util.urlParse;
+	var util_3 = util.urlGenerate;
+	var util_4 = util.normalize;
+	var util_5 = util.join;
+	var util_6 = util.isAbsolute;
+	var util_7 = util.relative;
+	var util_8 = util.toSetString;
+	var util_9 = util.fromSetString;
+	var util_10 = util.compareByOriginalPositions;
+	var util_11 = util.compareByGeneratedPositionsDeflated;
+	var util_12 = util.compareByGeneratedPositionsInflated;
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+
+	var has = Object.prototype.hasOwnProperty;
+	var hasNativeMap = typeof Map !== "undefined";
+
+	/**
+	 * A data structure which is a combination of an array and a set. Adding a new
+	 * member is O(1), testing for membership is O(1), and finding the index of an
+	 * element is O(1). Removing elements from the set is not supported. Only
+	 * strings are supported for membership.
+	 */
+	function ArraySet() {
+	  this._array = [];
+	  this._set = hasNativeMap ? new Map() : Object.create(null);
+	}
+
+	/**
+	 * Static method for creating ArraySet instances from an existing array.
+	 */
+	ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+	  var set = new ArraySet();
+	  for (var i = 0, len = aArray.length; i < len; i++) {
+	    set.add(aArray[i], aAllowDuplicates);
+	  }
+	  return set;
+	};
+
+	/**
+	 * Return how many unique items are in this ArraySet. If duplicates have been
+	 * added, than those do not count towards the size.
+	 *
+	 * @returns Number
+	 */
+	ArraySet.prototype.size = function ArraySet_size() {
+	  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+	};
+
+	/**
+	 * Add the given string to this set.
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+	  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
+	  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+	  var idx = this._array.length;
+	  if (!isDuplicate || aAllowDuplicates) {
+	    this._array.push(aStr);
+	  }
+	  if (!isDuplicate) {
+	    if (hasNativeMap) {
+	      this._set.set(aStr, idx);
+	    } else {
+	      this._set[sStr] = idx;
+	    }
+	  }
+	};
+
+	/**
+	 * Is the given string a member of this set?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.has = function ArraySet_has(aStr) {
+	  if (hasNativeMap) {
+	    return this._set.has(aStr);
+	  } else {
+	    var sStr = util.toSetString(aStr);
+	    return has.call(this._set, sStr);
+	  }
+	};
+
+	/**
+	 * What is the index of the given string in the array?
+	 *
+	 * @param String aStr
+	 */
+	ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+	  if (hasNativeMap) {
+	    var idx = this._set.get(aStr);
+	    if (idx >= 0) {
+	        return idx;
+	    }
+	  } else {
+	    var sStr = util.toSetString(aStr);
+	    if (has.call(this._set, sStr)) {
+	      return this._set[sStr];
+	    }
+	  }
+
+	  throw new Error('"' + aStr + '" is not in the set.');
+	};
+
+	/**
+	 * What is the element at the given index?
+	 *
+	 * @param Number aIdx
+	 */
+	ArraySet.prototype.at = function ArraySet_at(aIdx) {
+	  if (aIdx >= 0 && aIdx < this._array.length) {
+	    return this._array[aIdx];
+	  }
+	  throw new Error('No element indexed by ' + aIdx);
+	};
+
+	/**
+	 * Returns the array representation of this set (which has the proper indices
+	 * indicated by indexOf). Note that this is a copy of the internal array used
+	 * for storing the members so that no one can mess with internal state.
+	 */
+	ArraySet.prototype.toArray = function ArraySet_toArray() {
+	  return this._array.slice();
+	};
+
+	var ArraySet_1 = ArraySet;
+
+	var arraySet = {
+		ArraySet: ArraySet_1
+	};
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2014 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+
+
+	/**
+	 * Determine whether mappingB is after mappingA with respect to generated
+	 * position.
+	 */
+	function generatedPositionAfter(mappingA, mappingB) {
+	  // Optimized for most common case
+	  var lineA = mappingA.generatedLine;
+	  var lineB = mappingB.generatedLine;
+	  var columnA = mappingA.generatedColumn;
+	  var columnB = mappingB.generatedColumn;
+	  return lineB > lineA || lineB == lineA && columnB >= columnA ||
+	         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+	}
+
+	/**
+	 * A data structure to provide a sorted view of accumulated mappings in a
+	 * performance conscious manner. It trades a neglibable overhead in general
+	 * case for a large speedup in case of mappings being added in order.
+	 */
+	function MappingList() {
+	  this._array = [];
+	  this._sorted = true;
+	  // Serves as infimum
+	  this._last = {generatedLine: -1, generatedColumn: 0};
+	}
+
+	/**
+	 * Iterate through internal items. This method takes the same arguments that
+	 * `Array.prototype.forEach` takes.
+	 *
+	 * NOTE: The order of the mappings is NOT guaranteed.
+	 */
+	MappingList.prototype.unsortedForEach =
+	  function MappingList_forEach(aCallback, aThisArg) {
+	    this._array.forEach(aCallback, aThisArg);
+	  };
+
+	/**
+	 * Add the given source mapping.
+	 *
+	 * @param Object aMapping
+	 */
+	MappingList.prototype.add = function MappingList_add(aMapping) {
+	  if (generatedPositionAfter(this._last, aMapping)) {
+	    this._last = aMapping;
+	    this._array.push(aMapping);
+	  } else {
+	    this._sorted = false;
+	    this._array.push(aMapping);
+	  }
+	};
+
+	/**
+	 * Returns the flat, sorted array of mappings. The mappings are sorted by
+	 * generated position.
+	 *
+	 * WARNING: This method returns internal data without copying, for
+	 * performance. The return value must NOT be mutated, and should be treated as
+	 * an immutable borrow. If you want to take ownership, you must make your own
+	 * copy.
+	 */
+	MappingList.prototype.toArray = function MappingList_toArray() {
+	  if (!this._sorted) {
+	    this._array.sort(util.compareByGeneratedPositionsInflated);
+	    this._sorted = true;
+	  }
+	  return this._array;
+	};
+
+	var MappingList_1 = MappingList;
+
+	var mappingList = {
+		MappingList: MappingList_1
+	};
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+
+
+	var ArraySet$1 = arraySet.ArraySet;
+	var MappingList$1 = mappingList.MappingList;
+
+	/**
+	 * An instance of the SourceMapGenerator represents a source map which is
+	 * being built incrementally. You may pass an object with the following
+	 * properties:
+	 *
+	 *   - file: The filename of the generated source.
+	 *   - sourceRoot: A root for all relative URLs in this source map.
+	 */
+	function SourceMapGenerator(aArgs) {
+	  if (!aArgs) {
+	    aArgs = {};
+	  }
+	  this._file = util.getArg(aArgs, 'file', null);
+	  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+	  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
+	  this._sources = new ArraySet$1();
+	  this._names = new ArraySet$1();
+	  this._mappings = new MappingList$1();
+	  this._sourcesContents = null;
+	}
+
+	SourceMapGenerator.prototype._version = 3;
+
+	/**
+	 * Creates a new SourceMapGenerator based on a SourceMapConsumer
+	 *
+	 * @param aSourceMapConsumer The SourceMap.
+	 */
+	SourceMapGenerator.fromSourceMap =
+	  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
+	    var sourceRoot = aSourceMapConsumer.sourceRoot;
+	    var generator = new SourceMapGenerator({
+	      file: aSourceMapConsumer.file,
+	      sourceRoot: sourceRoot
+	    });
+	    aSourceMapConsumer.eachMapping(function (mapping) {
+	      var newMapping = {
+	        generated: {
+	          line: mapping.generatedLine,
+	          column: mapping.generatedColumn
+	        }
+	      };
+
+	      if (mapping.source != null) {
+	        newMapping.source = mapping.source;
+	        if (sourceRoot != null) {
+	          newMapping.source = util.relative(sourceRoot, newMapping.source);
+	        }
+
+	        newMapping.original = {
+	          line: mapping.originalLine,
+	          column: mapping.originalColumn
+	        };
+
+	        if (mapping.name != null) {
+	          newMapping.name = mapping.name;
+	        }
+	      }
+
+	      generator.addMapping(newMapping);
+	    });
+	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+	      if (content != null) {
+	        generator.setSourceContent(sourceFile, content);
+	      }
+	    });
+	    return generator;
+	  };
+
+	/**
+	 * Add a single mapping from original source line and column to the generated
+	 * source's line and column for this source map being created. The mapping
+	 * object should have the following properties:
+	 *
+	 *   - generated: An object with the generated line and column positions.
+	 *   - original: An object with the original line and column positions.
+	 *   - source: The original source file (relative to the sourceRoot).
+	 *   - name: An optional original token name for this mapping.
+	 */
+	SourceMapGenerator.prototype.addMapping =
+	  function SourceMapGenerator_addMapping(aArgs) {
+	    var generated = util.getArg(aArgs, 'generated');
+	    var original = util.getArg(aArgs, 'original', null);
+	    var source = util.getArg(aArgs, 'source', null);
+	    var name = util.getArg(aArgs, 'name', null);
+
+	    if (!this._skipValidation) {
+	      this._validateMapping(generated, original, source, name);
+	    }
+
+	    if (source != null) {
+	      source = String(source);
+	      if (!this._sources.has(source)) {
+	        this._sources.add(source);
+	      }
+	    }
+
+	    if (name != null) {
+	      name = String(name);
+	      if (!this._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
+	    });
+	  };
+
+	/**
+	 * Set the source content for a source file.
+	 */
+	SourceMapGenerator.prototype.setSourceContent =
+	  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+	    var source = aSourceFile;
+	    if (this._sourceRoot != null) {
+	      source = util.relative(this._sourceRoot, source);
+	    }
+
+	    if (aSourceContent != null) {
+	      // Add the source content to the _sourcesContents map.
+	      // Create a new _sourcesContents map if the property is null.
+	      if (!this._sourcesContents) {
+	        this._sourcesContents = Object.create(null);
+	      }
+	      this._sourcesContents[util.toSetString(source)] = aSourceContent;
+	    } else if (this._sourcesContents) {
+	      // Remove the source file from the _sourcesContents map.
+	      // If the _sourcesContents map is empty, set the property to null.
+	      delete this._sourcesContents[util.toSetString(source)];
+	      if (Object.keys(this._sourcesContents).length === 0) {
+	        this._sourcesContents = null;
+	      }
+	    }
+	  };
+
+	/**
+	 * Applies the mappings of a sub-source-map for a specific source file to the
+	 * source map being generated. Each mapping to the supplied source file is
+	 * rewritten using the supplied source map. Note: The resolution for the
+	 * resulting mappings is the minimium of this map and the supplied map.
+	 *
+	 * @param aSourceMapConsumer The source map to be applied.
+	 * @param aSourceFile Optional. The filename of the source file.
+	 *        If omitted, SourceMapConsumer's file property will be used.
+	 * @param aSourceMapPath Optional. The dirname of the path to the source map
+	 *        to be applied. If relative, it is relative to the SourceMapConsumer.
+	 *        This parameter is needed when the two source maps aren't in the same
+	 *        directory, and the source map to be applied contains relative source
+	 *        paths. If so, those relative source paths need to be rewritten
+	 *        relative to the SourceMapGenerator.
+	 */
+	SourceMapGenerator.prototype.applySourceMap =
+	  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+	    var sourceFile = aSourceFile;
+	    // If aSourceFile is omitted, we will use the file property of the SourceMap
+	    if (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.'
+	        );
+	      }
+	      sourceFile = aSourceMapConsumer.file;
+	    }
+	    var sourceRoot = this._sourceRoot;
+	    // Make "sourceFile" relative if an absolute Url is passed.
+	    if (sourceRoot != null) {
+	      sourceFile = util.relative(sourceRoot, sourceFile);
+	    }
+	    // Applying the SourceMap can add and remove items from the sources and
+	    // the names array.
+	    var newSources = new ArraySet$1();
+	    var newNames = new ArraySet$1();
+
+	    // Find mappings for the "sourceFile"
+	    this._mappings.unsortedForEach(function (mapping) {
+	      if (mapping.source === sourceFile && mapping.originalLine != null) {
+	        // Check if it can be mapped by the source map, then update the mapping.
+	        var original = aSourceMapConsumer.originalPositionFor({
+	          line: mapping.originalLine,
+	          column: mapping.originalColumn
+	        });
+	        if (original.source != null) {
+	          // Copy mapping
+	          mapping.source = original.source;
+	          if (aSourceMapPath != null) {
+	            mapping.source = util.join(aSourceMapPath, mapping.source);
+	          }
+	          if (sourceRoot != null) {
+	            mapping.source = util.relative(sourceRoot, mapping.source);
+	          }
+	          mapping.originalLine = original.line;
+	          mapping.originalColumn = original.column;
+	          if (original.name != null) {
+	            mapping.name = original.name;
+	          }
+	        }
+	      }
+
+	      var source = mapping.source;
+	      if (source != null && !newSources.has(source)) {
+	        newSources.add(source);
+	      }
+
+	      var name = mapping.name;
+	      if (name != null && !newNames.has(name)) {
+	        newNames.add(name);
+	      }
+
+	    }, this);
+	    this._sources = newSources;
+	    this._names = newNames;
+
+	    // Copy sourcesContents of applied map.
+	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+	      if (content != null) {
+	        if (aSourceMapPath != null) {
+	          sourceFile = util.join(aSourceMapPath, sourceFile);
+	        }
+	        if (sourceRoot != null) {
+	          sourceFile = util.relative(sourceRoot, sourceFile);
+	        }
+	        this.setSourceContent(sourceFile, content);
+	      }
+	    }, this);
+	  };
+
+	/**
+	 * A mapping can have one of the three levels of data:
+	 *
+	 *   1. Just the generated position.
+	 *   2. The Generated position, original position, and original source.
+	 *   3. Generated and original position, original source, as well as a name
+	 *      token.
+	 *
+	 * To maintain consistency, we validate that any new mapping being added falls
+	 * in to one of these categories.
+	 */
+	SourceMapGenerator.prototype._validateMapping =
+	  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+	                                              aName) {
+	    // When aOriginal is truthy but has empty values for .line and .column,
+	    // it is most likely a programmer error. In this case we throw a very
+	    // specific error message to try to guide them the right way.
+	    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+	    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+	        throw new Error(
+	            '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.'
+	        );
+	    }
+
+	    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+	        && aGenerated.line > 0 && aGenerated.column >= 0
+	        && !aOriginal && !aSource && !aName) {
+	      // Case 1.
+	      return;
+	    }
+	    else if (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) {
+	      // Cases 2 and 3.
+	      return;
+	    }
+	    else {
+	      throw new Error('Invalid mapping: ' + JSON.stringify({
+	        generated: aGenerated,
+	        source: aSource,
+	        original: aOriginal,
+	        name: aName
+	      }));
+	    }
+	  };
+
+	/**
+	 * Serialize the accumulated mappings in to the stream of base 64 VLQs
+	 * specified by the source map format.
+	 */
+	SourceMapGenerator.prototype._serializeMappings =
+	  function SourceMapGenerator_serializeMappings() {
+	    var previousGeneratedColumn = 0;
+	    var previousGeneratedLine = 1;
+	    var previousOriginalColumn = 0;
+	    var previousOriginalLine = 0;
+	    var previousName = 0;
+	    var previousSource = 0;
+	    var result = '';
+	    var next;
+	    var mapping;
+	    var nameIdx;
+	    var sourceIdx;
+
+	    var mappings = this._mappings.toArray();
+	    for (var i = 0, len = mappings.length; i < len; i++) {
+	      mapping = mappings[i];
+	      next = '';
+
+	      if (mapping.generatedLine !== previousGeneratedLine) {
+	        previousGeneratedColumn = 0;
+	        while (mapping.generatedLine !== previousGeneratedLine) {
+	          next += ';';
+	          previousGeneratedLine++;
+	        }
+	      }
+	      else {
+	        if (i > 0) {
+	          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+	            continue;
+	          }
+	          next += ',';
+	        }
+	      }
+
+	      next += base64Vlq.encode(mapping.generatedColumn
+	                                 - previousGeneratedColumn);
+	      previousGeneratedColumn = mapping.generatedColumn;
+
+	      if (mapping.source != null) {
+	        sourceIdx = this._sources.indexOf(mapping.source);
+	        next += base64Vlq.encode(sourceIdx - previousSource);
+	        previousSource = sourceIdx;
+
+	        // lines are stored 0-based in SourceMap spec version 3
+	        next += base64Vlq.encode(mapping.originalLine - 1
+	                                   - previousOriginalLine);
+	        previousOriginalLine = mapping.originalLine - 1;
+
+	        next += base64Vlq.encode(mapping.originalColumn
+	                                   - previousOriginalColumn);
+	        previousOriginalColumn = mapping.originalColumn;
+
+	        if (mapping.name != null) {
+	          nameIdx = this._names.indexOf(mapping.name);
+	          next += base64Vlq.encode(nameIdx - previousName);
+	          previousName = nameIdx;
+	        }
+	      }
+
+	      result += next;
+	    }
+
+	    return result;
+	  };
+
+	SourceMapGenerator.prototype._generateSourcesContent =
+	  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+	    return aSources.map(function (source) {
+	      if (!this._sourcesContents) {
+	        return null;
+	      }
+	      if (aSourceRoot != null) {
+	        source = util.relative(aSourceRoot, source);
+	      }
+	      var key = util.toSetString(source);
+	      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
+	        ? this._sourcesContents[key]
+	        : null;
+	    }, this);
+	  };
+
+	/**
+	 * Externalize the source map.
+	 */
+	SourceMapGenerator.prototype.toJSON =
+	  function SourceMapGenerator_toJSON() {
+	    var map = {
+	      version: this._version,
+	      sources: this._sources.toArray(),
+	      names: this._names.toArray(),
+	      mappings: this._serializeMappings()
+	    };
+	    if (this._file != null) {
+	      map.file = this._file;
+	    }
+	    if (this._sourceRoot != null) {
+	      map.sourceRoot = this._sourceRoot;
+	    }
+	    if (this._sourcesContents) {
+	      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+	    }
+
+	    return map;
+	  };
+
+	/**
+	 * Render the source map being generated to a string.
+	 */
+	SourceMapGenerator.prototype.toString =
+	  function SourceMapGenerator_toString() {
+	    return JSON.stringify(this.toJSON());
+	  };
+
+	var SourceMapGenerator_1 = SourceMapGenerator;
+
+	var sourceMapGenerator = {
+		SourceMapGenerator: SourceMapGenerator_1
+	};
+
+	var binarySearch = createCommonjsModule(function (module, exports) {
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	exports.GREATEST_LOWER_BOUND = 1;
+	exports.LEAST_UPPER_BOUND = 2;
+
+	/**
+	 * Recursive implementation of binary search.
+	 *
+	 * @param aLow Indices here and lower do not contain the needle.
+	 * @param aHigh Indices here and higher do not contain the needle.
+	 * @param aNeedle The element being searched for.
+	 * @param aHaystack The non-empty array being searched.
+	 * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 */
+	function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+	  // This function terminates when one of the following is true:
+	  //
+	  //   1. We find the exact element we are looking for.
+	  //
+	  //   2. We did not find the exact element, but we can return the index of
+	  //      the next-closest element.
+	  //
+	  //   3. We did not find the exact element, and there is no next-closest
+	  //      element than the one we are searching for, so we return -1.
+	  var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+	  var cmp = aCompare(aNeedle, aHaystack[mid], true);
+	  if (cmp === 0) {
+	    // Found the element we are looking for.
+	    return mid;
+	  }
+	  else if (cmp > 0) {
+	    // Our needle is greater than aHaystack[mid].
+	    if (aHigh - mid > 1) {
+	      // The element is in the upper half.
+	      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+	    }
+
+	    // The exact needle element was not found in this haystack. Determine if
+	    // we are in termination case (3) or (2) and return the appropriate thing.
+	    if (aBias == exports.LEAST_UPPER_BOUND) {
+	      return aHigh < aHaystack.length ? aHigh : -1;
+	    } else {
+	      return mid;
+	    }
+	  }
+	  else {
+	    // Our needle is less than aHaystack[mid].
+	    if (mid - aLow > 1) {
+	      // The element is in the lower half.
+	      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+	    }
+
+	    // we are in termination case (3) or (2) and return the appropriate thing.
+	    if (aBias == exports.LEAST_UPPER_BOUND) {
+	      return mid;
+	    } else {
+	      return aLow < 0 ? -1 : aLow;
+	    }
+	  }
+	}
+
+	/**
+	 * This is an implementation of binary search which will always try and return
+	 * the index of the closest element if there is no exact hit. This is because
+	 * mappings between original and generated line/col pairs are single points,
+	 * and there is an implicit region between each of them, so a miss just means
+	 * that you aren't on the very start of a region.
+	 *
+	 * @param aNeedle The element you are looking for.
+	 * @param aHaystack The array that is being searched.
+	 * @param aCompare A function which takes the needle and an element in the
+	 *     array and returns -1, 0, or 1 depending on whether the needle is less
+	 *     than, equal to, or greater than the element, respectively.
+	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
+	 */
+	exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+	  if (aHaystack.length === 0) {
+	    return -1;
+	  }
+
+	  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
+	                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
+	  if (index < 0) {
+	    return -1;
+	  }
+
+	  // We have found either the exact element, or the next-closest element than
+	  // the one we are searching for. However, there may be more than one such
+	  // element. Make sure we always return the smallest of these.
+	  while (index - 1 >= 0) {
+	    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+	      break;
+	    }
+	    --index;
+	  }
+
+	  return index;
+	};
+	});
+	var binarySearch_1 = binarySearch.GREATEST_LOWER_BOUND;
+	var binarySearch_2 = binarySearch.LEAST_UPPER_BOUND;
+	var binarySearch_3 = binarySearch.search;
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	// It turns out that some (most?) JavaScript engines don't self-host
+	// `Array.prototype.sort`. This makes sense because C++ will likely remain
+	// faster than JS when doing raw CPU-intensive sorting. However, when using a
+	// custom comparator function, calling back and forth between the VM's C++ and
+	// JIT'd JS is rather slow *and* loses JIT type information, resulting in
+	// worse generated code for the comparator function than would be optimal. In
+	// fact, when sorting with a comparator, these costs outweigh the benefits of
+	// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
+	// a ~3500ms mean speed-up in `bench/bench.html`.
+
+	/**
+	 * Swap the elements indexed by `x` and `y` in the array `ary`.
+	 *
+	 * @param {Array} ary
+	 *        The array.
+	 * @param {Number} x
+	 *        The index of the first item.
+	 * @param {Number} y
+	 *        The index of the second item.
+	 */
+	function swap(ary, x, y) {
+	  var temp = ary[x];
+	  ary[x] = ary[y];
+	  ary[y] = temp;
+	}
+
+	/**
+	 * Returns a random integer within the range `low .. high` inclusive.
+	 *
+	 * @param {Number} low
+	 *        The lower bound on the range.
+	 * @param {Number} high
+	 *        The upper bound on the range.
+	 */
+	function randomIntInRange(low, high) {
+	  return Math.round(low + (Math.random() * (high - low)));
+	}
+
+	/**
+	 * The Quick Sort algorithm.
+	 *
+	 * @param {Array} ary
+	 *        An array to sort.
+	 * @param {function} comparator
+	 *        Function to use to compare two items.
+	 * @param {Number} p
+	 *        Start index of the array
+	 * @param {Number} r
+	 *        End index of the array
+	 */
+	function doQuickSort(ary, comparator, p, r) {
+	  // If our lower bound is less than our upper bound, we (1) partition the
+	  // array into two pieces and (2) recurse on each half. If it is not, this is
+	  // the empty array and our base case.
+
+	  if (p < r) {
+	    // (1) Partitioning.
+	    //
+	    // The partitioning chooses a pivot between `p` and `r` and moves all
+	    // elements that are less than or equal to the pivot to the before it, and
+	    // all the elements that are greater than it after it. The effect is that
+	    // once partition is done, the pivot is in the exact place it will be when
+	    // the array is put in sorted order, and it will not need to be moved
+	    // again. This runs in O(n) time.
+
+	    // Always choose a random pivot so that an input array which is reverse
+	    // sorted does not cause O(n^2) running time.
+	    var pivotIndex = randomIntInRange(p, r);
+	    var i = p - 1;
+
+	    swap(ary, pivotIndex, r);
+	    var pivot = ary[r];
+
+	    // Immediately after `j` is incremented in this loop, the following hold
+	    // true:
+	    //
+	    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
+	    //
+	    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
+	    for (var j = p; j < r; j++) {
+	      if (comparator(ary[j], pivot) <= 0) {
+	        i += 1;
+	        swap(ary, i, j);
+	      }
+	    }
+
+	    swap(ary, i + 1, j);
+	    var q = i + 1;
+
+	    // (2) Recurse on each half.
+
+	    doQuickSort(ary, comparator, p, q - 1);
+	    doQuickSort(ary, comparator, q + 1, r);
+	  }
+	}
+
+	/**
+	 * Sort the given array in-place with the given comparator function.
+	 *
+	 * @param {Array} ary
+	 *        An array to sort.
+	 * @param {function} comparator
+	 *        Function to use to compare two items.
+	 */
+	var quickSort_1 = function (ary, comparator) {
+	  doQuickSort(ary, comparator, 0, ary.length - 1);
+	};
+
+	var quickSort = {
+		quickSort: quickSort_1
+	};
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+
+
+	var ArraySet$2 = arraySet.ArraySet;
+
+	var quickSort$1 = quickSort.quickSort;
+
+	function SourceMapConsumer(aSourceMap) {
+	  var sourceMap = aSourceMap;
+	  if (typeof aSourceMap === 'string') {
+	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+	  }
+
+	  return sourceMap.sections != null
+	    ? new IndexedSourceMapConsumer(sourceMap)
+	    : new BasicSourceMapConsumer(sourceMap);
+	}
+
+	SourceMapConsumer.fromSourceMap = function(aSourceMap) {
+	  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);
+	};
+
+	/**
+	 * The version of the source mapping spec that we are consuming.
+	 */
+	SourceMapConsumer.prototype._version = 3;
+
+	// `__generatedMappings` and `__originalMappings` are arrays that hold the
+	// parsed mapping coordinates from the source map's "mappings" attribute. They
+	// are lazily instantiated, accessed via the `_generatedMappings` and
+	// `_originalMappings` getters respectively, and we only parse the mappings
+	// and create these arrays once queried for a source location. We jump through
+	// these hoops because there can be many thousands of mappings, and parsing
+	// them is expensive, so we only want to do it if we must.
+	//
+	// Each object in the arrays is of the form:
+	//
+	//     {
+	//       generatedLine: The line number in the generated code,
+	//       generatedColumn: The column number in the generated code,
+	//       source: The path to the original source file that generated this
+	//               chunk of code,
+	//       originalLine: The line number in the original source that
+	//                     corresponds to this chunk of generated code,
+	//       originalColumn: The column number in the original source that
+	//                       corresponds to this chunk of generated code,
+	//       name: The name of the original symbol which generated this chunk of
+	//             code.
+	//     }
+	//
+	// All properties except for `generatedLine` and `generatedColumn` can be
+	// `null`.
+	//
+	// `_generatedMappings` is ordered by the generated positions.
+	//
+	// `_originalMappings` is ordered by the original positions.
+
+	SourceMapConsumer.prototype.__generatedMappings = null;
+	Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
+	  get: function () {
+	    if (!this.__generatedMappings) {
+	      this._parseMappings(this._mappings, this.sourceRoot);
+	    }
+
+	    return this.__generatedMappings;
+	  }
+	});
+
+	SourceMapConsumer.prototype.__originalMappings = null;
+	Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
+	  get: function () {
+	    if (!this.__originalMappings) {
+	      this._parseMappings(this._mappings, this.sourceRoot);
+	    }
+
+	    return this.__originalMappings;
+	  }
+	});
+
+	SourceMapConsumer.prototype._charIsMappingSeparator =
+	  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+	    var c = aStr.charAt(index);
+	    return c === ";" || c === ",";
+	  };
+
+	/**
+	 * Parse the mappings in a string in to a data structure which we can easily
+	 * query (the ordered arrays in the `this.__generatedMappings` and
+	 * `this.__originalMappings` properties).
+	 */
+	SourceMapConsumer.prototype._parseMappings =
+	  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+	    throw new Error("Subclasses must implement _parseMappings");
+	  };
+
+	SourceMapConsumer.GENERATED_ORDER = 1;
+	SourceMapConsumer.ORIGINAL_ORDER = 2;
+
+	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+
+	/**
+	 * Iterate over each mapping between an original source/line/column and a
+	 * generated line/column in this source map.
+	 *
+	 * @param Function aCallback
+	 *        The function that is called with each mapping.
+	 * @param Object aContext
+	 *        Optional. If specified, this object will be the value of `this` every
+	 *        time that `aCallback` is called.
+	 * @param aOrder
+	 *        Either `SourceMapConsumer.GENERATED_ORDER` or
+	 *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+	 *        iterate over the mappings sorted by the generated file's line/column
+	 *        order or the original's source/line/column order, respectively. Defaults to
+	 *        `SourceMapConsumer.GENERATED_ORDER`.
+	 */
+	SourceMapConsumer.prototype.eachMapping =
+	  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+	    var context = aContext || null;
+	    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+
+	    var mappings;
+	    switch (order) {
+	    case SourceMapConsumer.GENERATED_ORDER:
+	      mappings = this._generatedMappings;
+	      break;
+	    case SourceMapConsumer.ORIGINAL_ORDER:
+	      mappings = this._originalMappings;
+	      break;
+	    default:
+	      throw new Error("Unknown order of iteration.");
+	    }
+
+	    var sourceRoot = this.sourceRoot;
+	    mappings.map(function (mapping) {
+	      var source = mapping.source === null ? null : this._sources.at(mapping.source);
+	      if (source != null && sourceRoot != null) {
+	        source = util.join(sourceRoot, source);
+	      }
+	      return {
+	        source: source,
+	        generatedLine: mapping.generatedLine,
+	        generatedColumn: mapping.generatedColumn,
+	        originalLine: mapping.originalLine,
+	        originalColumn: mapping.originalColumn,
+	        name: mapping.name === null ? null : this._names.at(mapping.name)
+	      };
+	    }, this).forEach(aCallback, context);
+	  };
+
+	/**
+	 * Returns all generated line and column information for the original source,
+	 * line, and column provided. If no column is provided, returns all mappings
+	 * corresponding to a either the line we are searching for or the next
+	 * closest line that has any mappings. Otherwise, returns all mappings
+	 * corresponding to the given line and either the column we are searching for
+	 * or the next closest column that has any offsets.
+	 *
+	 * The only argument is an object with the following properties:
+	 *
+	 *   - source: The filename of the original source.
+	 *   - line: The line number in the original source.
+	 *   - column: Optional. the column number in the original source.
+	 *
+	 * and an array of objects is returned, each with the following properties:
+	 *
+	 *   - line: The line number in the generated source, or null.
+	 *   - column: The column number in the generated source, or null.
+	 */
+	SourceMapConsumer.prototype.allGeneratedPositionsFor =
+	  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+	    var line = util.getArg(aArgs, 'line');
+
+	    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
+	    // returns the index of the closest mapping less than the needle. By
+	    // setting needle.originalColumn to 0, we thus find the last mapping for
+	    // the given line, provided such a mapping exists.
+	    var needle = {
+	      source: util.getArg(aArgs, 'source'),
+	      originalLine: line,
+	      originalColumn: util.getArg(aArgs, 'column', 0)
+	    };
+
+	    if (this.sourceRoot != null) {
+	      needle.source = util.relative(this.sourceRoot, needle.source);
+	    }
+	    if (!this._sources.has(needle.source)) {
+	      return [];
+	    }
+	    needle.source = this._sources.indexOf(needle.source);
+
+	    var mappings = [];
+
+	    var index = this._findMapping(needle,
+	                                  this._originalMappings,
+	                                  "originalLine",
+	                                  "originalColumn",
+	                                  util.compareByOriginalPositions,
+	                                  binarySearch.LEAST_UPPER_BOUND);
+	    if (index >= 0) {
+	      var mapping = this._originalMappings[index];
+
+	      if (aArgs.column === undefined) {
+	        var originalLine = mapping.originalLine;
+
+	        // Iterate until either we run out of mappings, or we run into
+	        // a mapping for a different line than the one we found. Since
+	        // mappings are sorted, this is guaranteed to find all mappings for
+	        // the line we found.
+	        while (mapping && mapping.originalLine === originalLine) {
+	          mappings.push({
+	            line: util.getArg(mapping, 'generatedLine', null),
+	            column: util.getArg(mapping, 'generatedColumn', null),
+	            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+	          });
+
+	          mapping = this._originalMappings[++index];
+	        }
+	      } else {
+	        var originalColumn = mapping.originalColumn;
+
+	        // Iterate until either we run out of mappings, or we run into
+	        // a mapping for a different line than the one we were searching for.
+	        // Since mappings are sorted, this is guaranteed to find all mappings for
+	        // the line we are searching for.
+	        while (mapping &&
+	               mapping.originalLine === line &&
+	               mapping.originalColumn == originalColumn) {
+	          mappings.push({
+	            line: util.getArg(mapping, 'generatedLine', null),
+	            column: util.getArg(mapping, 'generatedColumn', null),
+	            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+	          });
+
+	          mapping = this._originalMappings[++index];
+	        }
+	      }
+	    }
+
+	    return mappings;
+	  };
+
+	var SourceMapConsumer_1 = SourceMapConsumer;
+
+	/**
+	 * A BasicSourceMapConsumer instance represents a parsed source map which we can
+	 * query for information about the original file positions by giving it a file
+	 * position in the generated source.
+	 *
+	 * The only parameter is the raw source map (either as a JSON string, or
+	 * already parsed to an object). According to the spec, source maps have the
+	 * following attributes:
+	 *
+	 *   - version: Which version of the source map spec this map is following.
+	 *   - sources: An array of URLs to the original source files.
+	 *   - names: An array of identifiers which can be referrenced by individual mappings.
+	 *   - sourceRoot: Optional. The URL root from which all sources are relative.
+	 *   - sourcesContent: Optional. An array of contents of the original source files.
+	 *   - mappings: A string of base64 VLQs which contain the actual mappings.
+	 *   - file: Optional. The generated file this source map is associated with.
+	 *
+	 * Here is an example source map, taken from the source map spec[0]:
+	 *
+	 *     {
+	 *       version : 3,
+	 *       file: "out.js",
+	 *       sourceRoot : "",
+	 *       sources: ["foo.js", "bar.js"],
+	 *       names: ["src", "maps", "are", "fun"],
+	 *       mappings: "AA,AB;;ABCDE;"
+	 *     }
+	 *
+	 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+	 */
+	function BasicSourceMapConsumer(aSourceMap) {
+	  var sourceMap = aSourceMap;
+	  if (typeof aSourceMap === 'string') {
+	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+	  }
+
+	  var version = util.getArg(sourceMap, 'version');
+	  var sources = util.getArg(sourceMap, 'sources');
+	  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
+	  // requires the array) to play nice here.
+	  var names = util.getArg(sourceMap, 'names', []);
+	  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+	  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+	  var mappings = util.getArg(sourceMap, 'mappings');
+	  var file = util.getArg(sourceMap, 'file', null);
+
+	  // Once again, Sass deviates from the spec and supplies the version as a
+	  // string rather than a number, so we use loose equality checking here.
+	  if (version != this._version) {
+	    throw new Error('Unsupported version: ' + version);
+	  }
+
+	  sources = sources
+	    .map(String)
+	    // Some source maps produce relative source paths like "./foo.js" instead of
+	    // "foo.js".  Normalize these first so that future comparisons will succeed.
+	    // See bugzil.la/1090768.
+	    .map(util.normalize)
+	    // Always ensure that absolute sources are internally stored relative to
+	    // the source root, if the source root is absolute. Not doing this would
+	    // be particularly problematic when the source root is a prefix of the
+	    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
+	    .map(function (source) {
+	      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
+	        ? util.relative(sourceRoot, source)
+	        : source;
+	    });
+
+	  // Pass `true` below to allow duplicate names and sources. While source maps
+	  // are intended to be compressed and deduplicated, the TypeScript compiler
+	  // sometimes generates source maps with duplicates in them. See Github issue
+	  // #72 and bugzil.la/889492.
+	  this._names = ArraySet$2.fromArray(names.map(String), true);
+	  this._sources = ArraySet$2.fromArray(sources, true);
+
+	  this.sourceRoot = sourceRoot;
+	  this.sourcesContent = sourcesContent;
+	  this._mappings = mappings;
+	  this.file = file;
+	}
+
+	BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+
+	/**
+	 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+	 *
+	 * @param SourceMapGenerator aSourceMap
+	 *        The source map that will be consumed.
+	 * @returns BasicSourceMapConsumer
+	 */
+	BasicSourceMapConsumer.fromSourceMap =
+	  function SourceMapConsumer_fromSourceMap(aSourceMap) {
+	    var smc = Object.create(BasicSourceMapConsumer.prototype);
+
+	    var names = smc._names = ArraySet$2.fromArray(aSourceMap._names.toArray(), true);
+	    var sources = smc._sources = ArraySet$2.fromArray(aSourceMap._sources.toArray(), true);
+	    smc.sourceRoot = aSourceMap._sourceRoot;
+	    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
+	                                                            smc.sourceRoot);
+	    smc.file = aSourceMap._file;
+
+	    // Because we are modifying the entries (by converting string sources and
+	    // names to indices into the sources and names ArraySets), we have to make
+	    // a copy of the entry or else bad things happen. Shared mutable state
+	    // strikes again! See github issue #191.
+
+	    var generatedMappings = aSourceMap._mappings.toArray().slice();
+	    var destGeneratedMappings = smc.__generatedMappings = [];
+	    var destOriginalMappings = smc.__originalMappings = [];
+
+	    for (var i = 0, length = generatedMappings.length; i < length; i++) {
+	      var srcMapping = generatedMappings[i];
+	      var destMapping = new Mapping;
+	      destMapping.generatedLine = srcMapping.generatedLine;
+	      destMapping.generatedColumn = srcMapping.generatedColumn;
+
+	      if (srcMapping.source) {
+	        destMapping.source = sources.indexOf(srcMapping.source);
+	        destMapping.originalLine = srcMapping.originalLine;
+	        destMapping.originalColumn = srcMapping.originalColumn;
+
+	        if (srcMapping.name) {
+	          destMapping.name = names.indexOf(srcMapping.name);
+	        }
+
+	        destOriginalMappings.push(destMapping);
+	      }
+
+	      destGeneratedMappings.push(destMapping);
+	    }
+
+	    quickSort$1(smc.__originalMappings, util.compareByOriginalPositions);
+
+	    return smc;
+	  };
+
+	/**
+	 * The version of the source mapping spec that we are consuming.
+	 */
+	BasicSourceMapConsumer.prototype._version = 3;
+
+	/**
+	 * The list of original sources.
+	 */
+	Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
+	  get: function () {
+	    return this._sources.toArray().map(function (s) {
+	      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
+	    }, this);
+	  }
+	});
+
+	/**
+	 * Provide the JIT with a nice shape / hidden class.
+	 */
+	function Mapping() {
+	  this.generatedLine = 0;
+	  this.generatedColumn = 0;
+	  this.source = null;
+	  this.originalLine = null;
+	  this.originalColumn = null;
+	  this.name = null;
+	}
+
+	/**
+	 * Parse the mappings in a string in to a data structure which we can easily
+	 * query (the ordered arrays in the `this.__generatedMappings` and
+	 * `this.__originalMappings` properties).
+	 */
+	BasicSourceMapConsumer.prototype._parseMappings =
+	  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+	    var generatedLine = 1;
+	    var previousGeneratedColumn = 0;
+	    var previousOriginalLine = 0;
+	    var previousOriginalColumn = 0;
+	    var previousSource = 0;
+	    var previousName = 0;
+	    var length = aStr.length;
+	    var index = 0;
+	    var cachedSegments = {};
+	    var temp = {};
+	    var originalMappings = [];
+	    var generatedMappings = [];
+	    var mapping, str, segment, end, value;
+
+	    while (index < length) {
+	      if (aStr.charAt(index) === ';') {
+	        generatedLine++;
+	        index++;
+	        previousGeneratedColumn = 0;
+	      }
+	      else if (aStr.charAt(index) === ',') {
+	        index++;
+	      }
+	      else {
+	        mapping = new Mapping();
+	        mapping.generatedLine = generatedLine;
+
+	        // Because each offset is encoded relative to the previous one,
+	        // many segments often have the same encoding. We can exploit this
+	        // fact by caching the parsed variable length fields of each segment,
+	        // allowing us to avoid a second parse if we encounter the same
+	        // segment again.
+	        for (end = index; end < length; end++) {
+	          if (this._charIsMappingSeparator(aStr, end)) {
+	            break;
+	          }
+	        }
+	        str = aStr.slice(index, end);
+
+	        segment = cachedSegments[str];
+	        if (segment) {
+	          index += str.length;
+	        } else {
+	          segment = [];
+	          while (index < end) {
+	            base64Vlq.decode(aStr, index, temp);
+	            value = temp.value;
+	            index = temp.rest;
+	            segment.push(value);
+	          }
+
+	          if (segment.length === 2) {
+	            throw new Error('Found a source, but no line and column');
+	          }
+
+	          if (segment.length === 3) {
+	            throw new Error('Found a source and line, but no column');
+	          }
+
+	          cachedSegments[str] = segment;
+	        }
+
+	        // Generated column.
+	        mapping.generatedColumn = previousGeneratedColumn + segment[0];
+	        previousGeneratedColumn = mapping.generatedColumn;
+
+	        if (segment.length > 1) {
+	          // Original source.
+	          mapping.source = previousSource + segment[1];
+	          previousSource += segment[1];
+
+	          // Original line.
+	          mapping.originalLine = previousOriginalLine + segment[2];
+	          previousOriginalLine = mapping.originalLine;
+	          // Lines are stored 0-based
+	          mapping.originalLine += 1;
+
+	          // Original column.
+	          mapping.originalColumn = previousOriginalColumn + segment[3];
+	          previousOriginalColumn = mapping.originalColumn;
+
+	          if (segment.length > 4) {
+	            // Original name.
+	            mapping.name = previousName + segment[4];
+	            previousName += segment[4];
+	          }
+	        }
+
+	        generatedMappings.push(mapping);
+	        if (typeof mapping.originalLine === 'number') {
+	          originalMappings.push(mapping);
+	        }
+	      }
+	    }
+
+	    quickSort$1(generatedMappings, util.compareByGeneratedPositionsDeflated);
+	    this.__generatedMappings = generatedMappings;
+
+	    quickSort$1(originalMappings, util.compareByOriginalPositions);
+	    this.__originalMappings = originalMappings;
+	  };
+
+	/**
+	 * Find the mapping that best matches the hypothetical "needle" mapping that
+	 * we are searching for in the given "haystack" of mappings.
+	 */
+	BasicSourceMapConsumer.prototype._findMapping =
+	  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
+	                                         aColumnName, aComparator, aBias) {
+	    // To return the position we are searching for, we must first find the
+	    // mapping for the given position and then return the opposite position it
+	    // points to. Because the mappings are sorted, we can use binary search to
+	    // find the best mapping.
+
+	    if (aNeedle[aLineName] <= 0) {
+	      throw new TypeError('Line must be greater than or equal to 1, got '
+	                          + aNeedle[aLineName]);
+	    }
+	    if (aNeedle[aColumnName] < 0) {
+	      throw new TypeError('Column must be greater than or equal to 0, got '
+	                          + aNeedle[aColumnName]);
+	    }
+
+	    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+	  };
+
+	/**
+	 * Compute the last column for each generated mapping. The last column is
+	 * inclusive.
+	 */
+	BasicSourceMapConsumer.prototype.computeColumnSpans =
+	  function SourceMapConsumer_computeColumnSpans() {
+	    for (var index = 0; index < this._generatedMappings.length; ++index) {
+	      var mapping = this._generatedMappings[index];
+
+	      // Mappings do not contain a field for the last generated columnt. We
+	      // can come up with an optimistic estimate, however, by assuming that
+	      // mappings are contiguous (i.e. given two consecutive mappings, the
+	      // first mapping ends where the second one starts).
+	      if (index + 1 < this._generatedMappings.length) {
+	        var nextMapping = this._generatedMappings[index + 1];
+
+	        if (mapping.generatedLine === nextMapping.generatedLine) {
+	          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+	          continue;
+	        }
+	      }
+
+	      // The last mapping for each line spans the entire line.
+	      mapping.lastGeneratedColumn = Infinity;
+	    }
+	  };
+
+	/**
+	 * Returns the original source, line, and column information for the generated
+	 * source's line and column positions provided. The only argument is an object
+	 * with the following properties:
+	 *
+	 *   - line: The line number in the generated source.
+	 *   - column: The column number in the generated source.
+	 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+	 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - source: The original source file, or null.
+	 *   - line: The line number in the original source, or null.
+	 *   - column: The column number in the original source, or null.
+	 *   - name: The original identifier, or null.
+	 */
+	BasicSourceMapConsumer.prototype.originalPositionFor =
+	  function SourceMapConsumer_originalPositionFor(aArgs) {
+	    var needle = {
+	      generatedLine: util.getArg(aArgs, 'line'),
+	      generatedColumn: util.getArg(aArgs, 'column')
+	    };
+
+	    var index = this._findMapping(
+	      needle,
+	      this._generatedMappings,
+	      "generatedLine",
+	      "generatedColumn",
+	      util.compareByGeneratedPositionsDeflated,
+	      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+	    );
+
+	    if (index >= 0) {
+	      var mapping = this._generatedMappings[index];
+
+	      if (mapping.generatedLine === needle.generatedLine) {
+	        var source = util.getArg(mapping, 'source', null);
+	        if (source !== null) {
+	          source = this._sources.at(source);
+	          if (this.sourceRoot != null) {
+	            source = util.join(this.sourceRoot, source);
+	          }
+	        }
+	        var name = util.getArg(mapping, 'name', null);
+	        if (name !== null) {
+	          name = this._names.at(name);
+	        }
+	        return {
+	          source: source,
+	          line: util.getArg(mapping, 'originalLine', null),
+	          column: util.getArg(mapping, 'originalColumn', null),
+	          name: name
+	        };
+	      }
+	    }
+
+	    return {
+	      source: null,
+	      line: null,
+	      column: null,
+	      name: null
+	    };
+	  };
+
+	/**
+	 * Return true if we have the source content for every source in the source
+	 * map, false otherwise.
+	 */
+	BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
+	  function BasicSourceMapConsumer_hasContentsOfAllSources() {
+	    if (!this.sourcesContent) {
+	      return false;
+	    }
+	    return this.sourcesContent.length >= this._sources.size() &&
+	      !this.sourcesContent.some(function (sc) { return sc == null; });
+	  };
+
+	/**
+	 * Returns the original source content. The only argument is the url of the
+	 * original source file. Returns null if no original source content is
+	 * available.
+	 */
+	BasicSourceMapConsumer.prototype.sourceContentFor =
+	  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+	    if (!this.sourcesContent) {
+	      return null;
+	    }
+
+	    if (this.sourceRoot != null) {
+	      aSource = util.relative(this.sourceRoot, aSource);
+	    }
+
+	    if (this._sources.has(aSource)) {
+	      return this.sourcesContent[this._sources.indexOf(aSource)];
+	    }
+
+	    var url;
+	    if (this.sourceRoot != null
+	        && (url = util.urlParse(this.sourceRoot))) {
+	      // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+	      // many users. We can help them out when they expect file:// URIs to
+	      // behave like it would if they were running a local HTTP server. See
+	      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+	      var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
+	      if (url.scheme == "file"
+	          && this._sources.has(fileUriAbsPath)) {
+	        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+	      }
+
+	      if ((!url.path || url.path == "/")
+	          && this._sources.has("/" + aSource)) {
+	        return this.sourcesContent[this._sources.indexOf("/" + aSource)];
+	      }
+	    }
+
+	    // This function is used recursively from
+	    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
+	    // don't want to throw if we can't find the source - we just want to
+	    // return null, so we provide a flag to exit gracefully.
+	    if (nullOnMissing) {
+	      return null;
+	    }
+	    else {
+	      throw new Error('"' + aSource + '" is not in the SourceMap.');
+	    }
+	  };
+
+	/**
+	 * Returns the generated line and column information for the original source,
+	 * line, and column positions provided. The only argument is an object with
+	 * the following properties:
+	 *
+	 *   - source: The filename of the original source.
+	 *   - line: The line number in the original source.
+	 *   - column: The column number in the original source.
+	 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+	 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - line: The line number in the generated source, or null.
+	 *   - column: The column number in the generated source, or null.
+	 */
+	BasicSourceMapConsumer.prototype.generatedPositionFor =
+	  function SourceMapConsumer_generatedPositionFor(aArgs) {
+	    var source = util.getArg(aArgs, 'source');
+	    if (this.sourceRoot != null) {
+	      source = util.relative(this.sourceRoot, source);
+	    }
+	    if (!this._sources.has(source)) {
+	      return {
+	        line: null,
+	        column: null,
+	        lastColumn: null
+	      };
+	    }
+	    source = this._sources.indexOf(source);
+
+	    var needle = {
+	      source: source,
+	      originalLine: util.getArg(aArgs, 'line'),
+	      originalColumn: util.getArg(aArgs, 'column')
+	    };
+
+	    var index = this._findMapping(
+	      needle,
+	      this._originalMappings,
+	      "originalLine",
+	      "originalColumn",
+	      util.compareByOriginalPositions,
+	      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+	    );
+
+	    if (index >= 0) {
+	      var mapping = this._originalMappings[index];
+
+	      if (mapping.source === needle.source) {
+	        return {
+	          line: util.getArg(mapping, 'generatedLine', null),
+	          column: util.getArg(mapping, 'generatedColumn', null),
+	          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+	        };
+	      }
+	    }
+
+	    return {
+	      line: null,
+	      column: null,
+	      lastColumn: null
+	    };
+	  };
+
+	var BasicSourceMapConsumer_1 = BasicSourceMapConsumer;
+
+	/**
+	 * An IndexedSourceMapConsumer instance represents a parsed source map which
+	 * we can query for information. It differs from BasicSourceMapConsumer in
+	 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
+	 * input.
+	 *
+	 * The only parameter is a raw source map (either as a JSON string, or already
+	 * parsed to an object). According to the spec for indexed source maps, they
+	 * have the following attributes:
+	 *
+	 *   - version: Which version of the source map spec this map is following.
+	 *   - file: Optional. The generated file this source map is associated with.
+	 *   - sections: A list of section definitions.
+	 *
+	 * Each value under the "sections" field has two fields:
+	 *   - offset: The offset into the original specified at which this section
+	 *       begins to apply, defined as an object with a "line" and "column"
+	 *       field.
+	 *   - map: A source map definition. This source map could also be indexed,
+	 *       but doesn't have to be.
+	 *
+	 * Instead of the "map" field, it's also possible to have a "url" field
+	 * specifying a URL to retrieve a source map from, but that's currently
+	 * unsupported.
+	 *
+	 * Here's an example source map, taken from the source map spec[0], but
+	 * modified to omit a section which uses the "url" field.
+	 *
+	 *  {
+	 *    version : 3,
+	 *    file: "app.js",
+	 *    sections: [{
+	 *      offset: {line:100, column:10},
+	 *      map: {
+	 *        version : 3,
+	 *        file: "section.js",
+	 *        sources: ["foo.js", "bar.js"],
+	 *        names: ["src", "maps", "are", "fun"],
+	 *        mappings: "AAAA,E;;ABCDE;"
+	 *      }
+	 *    }],
+	 *  }
+	 *
+	 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
+	 */
+	function IndexedSourceMapConsumer(aSourceMap) {
+	  var sourceMap = aSourceMap;
+	  if (typeof aSourceMap === 'string') {
+	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+	  }
+
+	  var version = util.getArg(sourceMap, 'version');
+	  var sections = util.getArg(sourceMap, 'sections');
+
+	  if (version != this._version) {
+	    throw new Error('Unsupported version: ' + version);
+	  }
+
+	  this._sources = new ArraySet$2();
+	  this._names = new ArraySet$2();
+
+	  var lastOffset = {
+	    line: -1,
+	    column: 0
+	  };
+	  this._sections = sections.map(function (s) {
+	    if (s.url) {
+	      // The url field will require support for asynchronicity.
+	      // See https://github.com/mozilla/source-map/issues/16
+	      throw new Error('Support for url field in sections not implemented.');
+	    }
+	    var offset = util.getArg(s, 'offset');
+	    var offsetLine = util.getArg(offset, 'line');
+	    var offsetColumn = util.getArg(offset, 'column');
+
+	    if (offsetLine < lastOffset.line ||
+	        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
+	      throw new Error('Section offsets must be ordered and non-overlapping.');
+	    }
+	    lastOffset = offset;
+
+	    return {
+	      generatedOffset: {
+	        // The offset fields are 0-based, but we use 1-based indices when
+	        // encoding/decoding from VLQ.
+	        generatedLine: offsetLine + 1,
+	        generatedColumn: offsetColumn + 1
+	      },
+	      consumer: new SourceMapConsumer(util.getArg(s, 'map'))
+	    }
+	  });
+	}
+
+	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+	IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+
+	/**
+	 * The version of the source mapping spec that we are consuming.
+	 */
+	IndexedSourceMapConsumer.prototype._version = 3;
+
+	/**
+	 * The list of original sources.
+	 */
+	Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
+	  get: function () {
+	    var sources = [];
+	    for (var i = 0; i < this._sections.length; i++) {
+	      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
+	        sources.push(this._sections[i].consumer.sources[j]);
+	      }
+	    }
+	    return sources;
+	  }
+	});
+
+	/**
+	 * Returns the original source, line, and column information for the generated
+	 * source's line and column positions provided. The only argument is an object
+	 * with the following properties:
+	 *
+	 *   - line: The line number in the generated source.
+	 *   - column: The column number in the generated source.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - source: The original source file, or null.
+	 *   - line: The line number in the original source, or null.
+	 *   - column: The column number in the original source, or null.
+	 *   - name: The original identifier, or null.
+	 */
+	IndexedSourceMapConsumer.prototype.originalPositionFor =
+	  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+	    var needle = {
+	      generatedLine: util.getArg(aArgs, 'line'),
+	      generatedColumn: util.getArg(aArgs, 'column')
+	    };
+
+	    // Find the section containing the generated position we're trying to map
+	    // to an original position.
+	    var sectionIndex = binarySearch.search(needle, this._sections,
+	      function(needle, section) {
+	        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
+	        if (cmp) {
+	          return cmp;
+	        }
+
+	        return (needle.generatedColumn -
+	                section.generatedOffset.generatedColumn);
+	      });
+	    var section = this._sections[sectionIndex];
+
+	    if (!section) {
+	      return {
+	        source: null,
+	        line: null,
+	        column: null,
+	        name: null
+	      };
+	    }
+
+	    return section.consumer.originalPositionFor({
+	      line: needle.generatedLine -
+	        (section.generatedOffset.generatedLine - 1),
+	      column: needle.generatedColumn -
+	        (section.generatedOffset.generatedLine === needle.generatedLine
+	         ? section.generatedOffset.generatedColumn - 1
+	         : 0),
+	      bias: aArgs.bias
+	    });
+	  };
+
+	/**
+	 * Return true if we have the source content for every source in the source
+	 * map, false otherwise.
+	 */
+	IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
+	  function IndexedSourceMapConsumer_hasContentsOfAllSources() {
+	    return this._sections.every(function (s) {
+	      return s.consumer.hasContentsOfAllSources();
+	    });
+	  };
+
+	/**
+	 * Returns the original source content. The only argument is the url of the
+	 * original source file. Returns null if no original source content is
+	 * available.
+	 */
+	IndexedSourceMapConsumer.prototype.sourceContentFor =
+	  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+	    for (var i = 0; i < this._sections.length; i++) {
+	      var section = this._sections[i];
+
+	      var content = section.consumer.sourceContentFor(aSource, true);
+	      if (content) {
+	        return content;
+	      }
+	    }
+	    if (nullOnMissing) {
+	      return null;
+	    }
+	    else {
+	      throw new Error('"' + aSource + '" is not in the SourceMap.');
+	    }
+	  };
+
+	/**
+	 * Returns the generated line and column information for the original source,
+	 * line, and column positions provided. The only argument is an object with
+	 * the following properties:
+	 *
+	 *   - source: The filename of the original source.
+	 *   - line: The line number in the original source.
+	 *   - column: The column number in the original source.
+	 *
+	 * and an object is returned with the following properties:
+	 *
+	 *   - line: The line number in the generated source, or null.
+	 *   - column: The column number in the generated source, or null.
+	 */
+	IndexedSourceMapConsumer.prototype.generatedPositionFor =
+	  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+	    for (var i = 0; i < this._sections.length; i++) {
+	      var section = this._sections[i];
+
+	      // Only consider this section if the requested source is in the list of
+	      // sources of the consumer.
+	      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {
+	        continue;
+	      }
+	      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+	      if (generatedPosition) {
+	        var ret = {
+	          line: generatedPosition.line +
+	            (section.generatedOffset.generatedLine - 1),
+	          column: generatedPosition.column +
+	            (section.generatedOffset.generatedLine === generatedPosition.line
+	             ? section.generatedOffset.generatedColumn - 1
+	             : 0)
+	        };
+	        return ret;
+	      }
+	    }
+
+	    return {
+	      line: null,
+	      column: null
+	    };
+	  };
+
+	/**
+	 * Parse the mappings in a string in to a data structure which we can easily
+	 * query (the ordered arrays in the `this.__generatedMappings` and
+	 * `this.__originalMappings` properties).
+	 */
+	IndexedSourceMapConsumer.prototype._parseMappings =
+	  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+	    this.__generatedMappings = [];
+	    this.__originalMappings = [];
+	    for (var i = 0; i < this._sections.length; i++) {
+	      var section = this._sections[i];
+	      var sectionMappings = section.consumer._generatedMappings;
+	      for (var j = 0; j < sectionMappings.length; j++) {
+	        var mapping = sectionMappings[j];
+
+	        var source = section.consumer._sources.at(mapping.source);
+	        if (section.consumer.sourceRoot !== null) {
+	          source = util.join(section.consumer.sourceRoot, source);
+	        }
+	        this._sources.add(source);
+	        source = this._sources.indexOf(source);
+
+	        var name = section.consumer._names.at(mapping.name);
+	        this._names.add(name);
+	        name = this._names.indexOf(name);
+
+	        // The mappings coming from the consumer for the section have
+	        // generated positions relative to the start of the section, so we
+	        // need to offset them to be relative to the start of the concatenated
+	        // generated file.
+	        var adjustedMapping = {
+	          source: source,
+	          generatedLine: mapping.generatedLine +
+	            (section.generatedOffset.generatedLine - 1),
+	          generatedColumn: mapping.generatedColumn +
+	            (section.generatedOffset.generatedLine === mapping.generatedLine
+	            ? section.generatedOffset.generatedColumn - 1
+	            : 0),
+	          originalLine: mapping.originalLine,
+	          originalColumn: mapping.originalColumn,
+	          name: name
+	        };
+
+	        this.__generatedMappings.push(adjustedMapping);
+	        if (typeof adjustedMapping.originalLine === 'number') {
+	          this.__originalMappings.push(adjustedMapping);
+	        }
+	      }
+	    }
+
+	    quickSort$1(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+	    quickSort$1(this.__originalMappings, util.compareByOriginalPositions);
+	  };
+
+	var IndexedSourceMapConsumer_1 = IndexedSourceMapConsumer;
+
+	var sourceMapConsumer = {
+		SourceMapConsumer: SourceMapConsumer_1,
+		BasicSourceMapConsumer: BasicSourceMapConsumer_1,
+		IndexedSourceMapConsumer: IndexedSourceMapConsumer_1
+	};
+
+	/* -*- Mode: js; js-indent-level: 2; -*- */
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	var SourceMapGenerator$1 = sourceMapGenerator.SourceMapGenerator;
+
+
+	// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
+	// operating systems these days (capturing the result).
+	var REGEX_NEWLINE = /(\r?\n)/;
+
+	// Newline character code for charCodeAt() comparisons
+	var NEWLINE_CODE = 10;
+
+	// Private symbol for identifying `SourceNode`s when multiple versions of
+	// the source-map library are loaded. This MUST NOT CHANGE across
+	// versions!
+	var isSourceNode = "$$$isSourceNode$$$";
+
+	/**
+	 * SourceNodes provide a way to abstract over interpolating/concatenating
+	 * snippets of generated JavaScript source code while maintaining the line and
+	 * column information associated with the original source code.
+	 *
+	 * @param aLine The original line number.
+	 * @param aColumn The original column number.
+	 * @param aSource The original source's filename.
+	 * @param aChunks Optional. An array of strings which are snippets of
+	 *        generated JS, or other SourceNodes.
+	 * @param aName The original identifier.
+	 */
+	function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+	  this.children = [];
+	  this.sourceContents = {};
+	  this.line = aLine == null ? null : aLine;
+	  this.column = aColumn == null ? null : aColumn;
+	  this.source = aSource == null ? null : aSource;
+	  this.name = aName == null ? null : aName;
+	  this[isSourceNode] = true;
+	  if (aChunks != null) this.add(aChunks);
+	}
+
+	/**
+	 * Creates a SourceNode from generated code and a SourceMapConsumer.
+	 *
+	 * @param aGeneratedCode The generated code
+	 * @param aSourceMapConsumer The SourceMap for the generated code
+	 * @param aRelativePath Optional. The path that relative sources in the
+	 *        SourceMapConsumer should be relative to.
+	 */
+	SourceNode.fromStringWithSourceMap =
+	  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+	    // The SourceNode we want to fill with the generated code
+	    // and the SourceMap
+	    var node = new SourceNode();
+
+	    // All even indices of this array are one line of the generated code,
+	    // while all odd indices are the newlines between two adjacent lines
+	    // (since `REGEX_NEWLINE` captures its match).
+	    // Processed fragments are accessed by calling `shiftNextLine`.
+	    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+	    var remainingLinesIndex = 0;
+	    var shiftNextLine = function() {
+	      var lineContents = getNextLine();
+	      // The last line of a file might not have a newline.
+	      var newLine = getNextLine() || "";
+	      return lineContents + newLine;
+
+	      function getNextLine() {
+	        return remainingLinesIndex < remainingLines.length ?
+	            remainingLines[remainingLinesIndex++] : undefined;
+	      }
+	    };
+
+	    // We need to remember the position of "remainingLines"
+	    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+	    // The generate SourceNodes we need a code range.
+	    // To extract it current and last mapping is used.
+	    // Here we store the last mapping.
+	    var lastMapping = null;
+
+	    aSourceMapConsumer.eachMapping(function (mapping) {
+	      if (lastMapping !== null) {
+	        // We add the code from "lastMapping" to "mapping":
+	        // First check if there is a new line in between.
+	        if (lastGeneratedLine < mapping.generatedLine) {
+	          // Associate first line with "lastMapping"
+	          addMappingWithCode(lastMapping, shiftNextLine());
+	          lastGeneratedLine++;
+	          lastGeneratedColumn = 0;
+	          // The remaining code is added without mapping
+	        } else {
+	          // There is no new line in between.
+	          // Associate the code between "lastGeneratedColumn" and
+	          // "mapping.generatedColumn" with "lastMapping"
+	          var nextLine = remainingLines[remainingLinesIndex];
+	          var code = nextLine.substr(0, mapping.generatedColumn -
+	                                        lastGeneratedColumn);
+	          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
+	                                              lastGeneratedColumn);
+	          lastGeneratedColumn = mapping.generatedColumn;
+	          addMappingWithCode(lastMapping, code);
+	          // No more remaining code, continue
+	          lastMapping = mapping;
+	          return;
+	        }
+	      }
+	      // We add the generated code until the first mapping
+	      // to the SourceNode without any mapping.
+	      // Each line is added as separate string.
+	      while (lastGeneratedLine < mapping.generatedLine) {
+	        node.add(shiftNextLine());
+	        lastGeneratedLine++;
+	      }
+	      if (lastGeneratedColumn < mapping.generatedColumn) {
+	        var nextLine = remainingLines[remainingLinesIndex];
+	        node.add(nextLine.substr(0, mapping.generatedColumn));
+	        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+	        lastGeneratedColumn = mapping.generatedColumn;
+	      }
+	      lastMapping = mapping;
+	    }, this);
+	    // We have processed all mappings.
+	    if (remainingLinesIndex < remainingLines.length) {
+	      if (lastMapping) {
+	        // Associate the remaining code in the current line with "lastMapping"
+	        addMappingWithCode(lastMapping, shiftNextLine());
+	      }
+	      // and add the remaining lines without any mapping
+	      node.add(remainingLines.splice(remainingLinesIndex).join(""));
+	    }
+
+	    // Copy sourcesContent into SourceNode
+	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+	      if (content != null) {
+	        if (aRelativePath != null) {
+	          sourceFile = util.join(aRelativePath, sourceFile);
+	        }
+	        node.setSourceContent(sourceFile, content);
+	      }
+	    });
+
+	    return node;
+
+	    function addMappingWithCode(mapping, code) {
+	      if (mapping === null || mapping.source === undefined) {
+	        node.add(code);
+	      } else {
+	        var source = aRelativePath
+	          ? util.join(aRelativePath, mapping.source)
+	          : mapping.source;
+	        node.add(new SourceNode(mapping.originalLine,
+	                                mapping.originalColumn,
+	                                source,
+	                                code,
+	                                mapping.name));
+	      }
+	    }
+	  };
+
+	/**
+	 * Add a chunk of generated JS to this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.add = function SourceNode_add(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    aChunk.forEach(function (chunk) {
+	      this.add(chunk);
+	    }, this);
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    if (aChunk) {
+	      this.children.push(aChunk);
+	    }
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+
+	/**
+	 * Add a chunk of generated JS to the beginning of this source node.
+	 *
+	 * @param aChunk A string snippet of generated JS code, another instance of
+	 *        SourceNode, or an array where each member is one of those things.
+	 */
+	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+	  if (Array.isArray(aChunk)) {
+	    for (var i = aChunk.length-1; i >= 0; i--) {
+	      this.prepend(aChunk[i]);
+	    }
+	  }
+	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+	    this.children.unshift(aChunk);
+	  }
+	  else {
+	    throw new TypeError(
+	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+	    );
+	  }
+	  return this;
+	};
+
+	/**
+	 * Walk over the tree of JS snippets in this node and its children. The
+	 * walking function is called once for each snippet of JS and is passed that
+	 * snippet and the its original associated source's line/column location.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+	  var chunk;
+	  for (var i = 0, len = this.children.length; i < len; i++) {
+	    chunk = this.children[i];
+	    if (chunk[isSourceNode]) {
+	      chunk.walk(aFn);
+	    }
+	    else {
+	      if (chunk !== '') {
+	        aFn(chunk, { source: this.source,
+	                     line: this.line,
+	                     column: this.column,
+	                     name: this.name });
+	      }
+	    }
+	  }
+	};
+
+	/**
+	 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+	 * each of `this.children`.
+	 *
+	 * @param aSep The separator.
+	 */
+	SourceNode.prototype.join = function SourceNode_join(aSep) {
+	  var newChildren;
+	  var i;
+	  var len = this.children.length;
+	  if (len > 0) {
+	    newChildren = [];
+	    for (i = 0; i < len-1; i++) {
+	      newChildren.push(this.children[i]);
+	      newChildren.push(aSep);
+	    }
+	    newChildren.push(this.children[i]);
+	    this.children = newChildren;
+	  }
+	  return this;
+	};
+
+	/**
+	 * Call String.prototype.replace on the very right-most source snippet. Useful
+	 * for trimming whitespace from the end of a source node, etc.
+	 *
+	 * @param aPattern The pattern to replace.
+	 * @param aReplacement The thing to replace the pattern with.
+	 */
+	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+	  var lastChild = this.children[this.children.length - 1];
+	  if (lastChild[isSourceNode]) {
+	    lastChild.replaceRight(aPattern, aReplacement);
+	  }
+	  else if (typeof lastChild === 'string') {
+	    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+	  }
+	  else {
+	    this.children.push(''.replace(aPattern, aReplacement));
+	  }
+	  return this;
+	};
+
+	/**
+	 * Set the source content for a source file. This will be added to the SourceMapGenerator
+	 * in the sourcesContent field.
+	 *
+	 * @param aSourceFile The filename of the source file
+	 * @param aSourceContent The content of the source file
+	 */
+	SourceNode.prototype.setSourceContent =
+	  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+	    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+	  };
+
+	/**
+	 * Walk over the tree of SourceNodes. The walking function is called for each
+	 * source file content and is passed the filename and source content.
+	 *
+	 * @param aFn The traversal function.
+	 */
+	SourceNode.prototype.walkSourceContents =
+	  function SourceNode_walkSourceContents(aFn) {
+	    for (var i = 0, len = this.children.length; i < len; i++) {
+	      if (this.children[i][isSourceNode]) {
+	        this.children[i].walkSourceContents(aFn);
+	      }
+	    }
+
+	    var sources = Object.keys(this.sourceContents);
+	    for (var i = 0, len = sources.length; i < len; i++) {
+	      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+	    }
+	  };
+
+	/**
+	 * Return the string representation of this source node. Walks over the tree
+	 * and concatenates all the various snippets together to one string.
+	 */
+	SourceNode.prototype.toString = function SourceNode_toString() {
+	  var str = "";
+	  this.walk(function (chunk) {
+	    str += chunk;
+	  });
+	  return str;
+	};
+
+	/**
+	 * Returns the string representation of this source node along with a source
+	 * map.
+	 */
+	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+	  var generated = {
+	    code: "",
+	    line: 1,
+	    column: 0
+	  };
+	  var map = new SourceMapGenerator$1(aArgs);
+	  var sourceMappingActive = false;
+	  var lastOriginalSource = null;
+	  var lastOriginalLine = null;
+	  var lastOriginalColumn = null;
+	  var lastOriginalName = null;
+	  this.walk(function (chunk, original) {
+	    generated.code += chunk;
+	    if (original.source !== null
+	        && original.line !== null
+	        && original.column !== null) {
+	      if(lastOriginalSource !== original.source
+	         || lastOriginalLine !== original.line
+	         || lastOriginalColumn !== original.column
+	         || lastOriginalName !== original.name) {
+	        map.addMapping({
+	          source: original.source,
+	          original: {
+	            line: original.line,
+	            column: original.column
+	          },
+	          generated: {
+	            line: generated.line,
+	            column: generated.column
+	          },
+	          name: original.name
+	        });
+	      }
+	      lastOriginalSource = original.source;
+	      lastOriginalLine = original.line;
+	      lastOriginalColumn = original.column;
+	      lastOriginalName = original.name;
+	      sourceMappingActive = true;
+	    } else if (sourceMappingActive) {
+	      map.addMapping({
+	        generated: {
+	          line: generated.line,
+	          column: generated.column
+	        }
+	      });
+	      lastOriginalSource = null;
+	      sourceMappingActive = false;
+	    }
+	    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+	      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+	        generated.line++;
+	        generated.column = 0;
+	        // Mappings end at eol
+	        if (idx + 1 === length) {
+	          lastOriginalSource = null;
+	          sourceMappingActive = false;
+	        } else if (sourceMappingActive) {
+	          map.addMapping({
+	            source: original.source,
+	            original: {
+	              line: original.line,
+	              column: original.column
+	            },
+	            generated: {
+	              line: generated.line,
+	              column: generated.column
+	            },
+	            name: original.name
+	          });
+	        }
+	      } else {
+	        generated.column++;
+	      }
+	    }
+	  });
+	  this.walkSourceContents(function (sourceFile, sourceContent) {
+	    map.setSourceContent(sourceFile, sourceContent);
+	  });
+
+	  return { code: generated.code, map: map };
+	};
+
+	var SourceNode_1 = SourceNode;
+
+	var sourceNode = {
+		SourceNode: SourceNode_1
+	};
+
+	/*
+	 * Copyright 2009-2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE.txt or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+	var SourceMapGenerator$2 = sourceMapGenerator.SourceMapGenerator;
+	var SourceMapConsumer$1 = sourceMapConsumer.SourceMapConsumer;
+	var SourceNode$1 = sourceNode.SourceNode;
+
+	var sourceMap = {
+		SourceMapGenerator: SourceMapGenerator$2,
+		SourceMapConsumer: SourceMapConsumer$1,
+		SourceNode: SourceNode$1
+	};
+
+	var SourceMapGenerator$3 = sourceMap.SourceMapGenerator;
+	var trackNodes = {
+	    Atrule: true,
+	    Selector: true,
+	    Declaration: true
+	};
+
+	var sourceMap$1 = function generateSourceMap(handlers) {
+	    var map = new SourceMapGenerator$3();
+	    var line = 1;
+	    var column = 0;
+	    var generated = {
+	        line: 1,
+	        column: 0
+	    };
+	    var original = {
+	        line: 0, // should be zero to add first mapping
+	        column: 0
+	    };
+	    var sourceMappingActive = false;
+	    var activatedGenerated = {
+	        line: 1,
+	        column: 0
+	    };
+	    var activatedMapping = {
+	        generated: activatedGenerated
+	    };
+
+	    var handlersNode = handlers.node;
+	    handlers.node = function(node) {
+	        if (node.loc && node.loc.start && trackNodes.hasOwnProperty(node.type)) {
+	            var nodeLine = node.loc.start.line;
+	            var nodeColumn = node.loc.start.column - 1;
+
+	            if (original.line !== nodeLine ||
+	                original.column !== nodeColumn) {
+	                original.line = nodeLine;
+	                original.column = nodeColumn;
+
+	                generated.line = line;
+	                generated.column = column;
+
+	                if (sourceMappingActive) {
+	                    sourceMappingActive = false;
+	                    if (generated.line !== activatedGenerated.line ||
+	                        generated.column !== activatedGenerated.column) {
+	                        map.addMapping(activatedMapping);
+	                    }
+	                }
+
+	                sourceMappingActive = true;
+	                map.addMapping({
+	                    source: node.loc.source,
+	                    original: original,
+	                    generated: generated
+	                });
+	            }
+	        }
+
+	        handlersNode.call(this, node);
+
+	        if (sourceMappingActive && trackNodes.hasOwnProperty(node.type)) {
+	            activatedGenerated.line = line;
+	            activatedGenerated.column = column;
+	        }
+	    };
+
+	    var handlersChunk = handlers.chunk;
+	    handlers.chunk = function(chunk) {
+	        for (var i = 0; i < chunk.length; i++) {
+	            if (chunk.charCodeAt(i) === 10) { // \n
+	                line++;
+	                column = 0;
+	            } else {
+	                column++;
+	            }
+	        }
+
+	        handlersChunk(chunk);
+	    };
+
+	    var handlersResult = handlers.result;
+	    handlers.result = function() {
+	        if (sourceMappingActive) {
+	            map.addMapping(activatedMapping);
+	        }
+
+	        return {
+	            css: handlersResult(),
+	            map: map
+	        };
+	    };
+
+	    return handlers;
+	};
+
+	var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+
+	function processChildren(node, delimeter) {
+	    var list = node.children;
+	    var prev = null;
+
+	    if (typeof delimeter !== 'function') {
+	        list.forEach(this.node, this);
+	    } else {
+	        list.forEach(function(node) {
+	            if (prev !== null) {
+	                delimeter.call(this, prev);
+	            }
+
+	            this.node(node);
+	            prev = node;
+	        }, this);
+	    }
+	}
+
+	var create$2 = function createGenerator(config) {
+	    function processNode(node) {
+	        if (hasOwnProperty$3.call(types, node.type)) {
+	            types[node.type].call(this, node);
+	        } else {
+	            throw new Error('Unknown node type: ' + node.type);
+	        }
+	    }
+
+	    var types = {};
+
+	    if (config.node) {
+	        for (var name in config.node) {
+	            types[name] = config.node[name].generate;
+	        }
+	    }
+
+	    return function(node, options) {
+	        var buffer = '';
+	        var handlers = {
+	            children: processChildren,
+	            node: processNode,
+	            chunk: function(chunk) {
+	                buffer += chunk;
+	            },
+	            result: function() {
+	                return buffer;
+	            }
+	        };
+
+	        if (options) {
+	            if (typeof options.decorator === 'function') {
+	                handlers = options.decorator(handlers);
+	            }
+
+	            if (options.sourceMap) {
+	                handlers = sourceMap$1(handlers);
+	            }
+	        }
+
+	        handlers.node(node);
+
+	        return handlers.result();
+	    };
+	};
+
+	var create$3 = function createConvertors(walk) {
+	    return {
+	        fromPlainObject: function(ast) {
+	            walk(ast, {
+	                enter: function(node) {
+	                    if (node.children && node.children instanceof list === false) {
+	                        node.children = new list().fromArray(node.children);
+	                    }
+	                }
+	            });
+
+	            return ast;
+	        },
+	        toPlainObject: function(ast) {
+	            walk(ast, {
+	                leave: function(node) {
+	                    if (node.children && node.children instanceof list) {
+	                        node.children = node.children.toArray();
+	                    }
+	                }
+	            });
+
+	            return ast;
+	        }
+	    };
+	};
+
+	var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
+	var noop$4 = function() {};
+
+	function ensureFunction$1(value) {
+	    return typeof value === 'function' ? value : noop$4;
+	}
+
+	function invokeForType(fn, type) {
+	    return function(node, item, list) {
+	        if (node.type === type) {
+	            fn.call(this, node, item, list);
+	        }
+	    };
+	}
+
+	function getWalkersFromStructure(name, nodeType) {
+	    var structure = nodeType.structure;
+	    var walkers = [];
+
+	    for (var key in structure) {
+	        if (hasOwnProperty$4.call(structure, key) === false) {
+	            continue;
+	        }
+
+	        var fieldTypes = structure[key];
+	        var walker = {
+	            name: key,
+	            type: false,
+	            nullable: false
+	        };
+
+	        if (!Array.isArray(structure[key])) {
+	            fieldTypes = [structure[key]];
+	        }
+
+	        for (var i = 0; i < fieldTypes.length; i++) {
+	            var fieldType = fieldTypes[i];
+	            if (fieldType === null) {
+	                walker.nullable = true;
+	            } else if (typeof fieldType === 'string') {
+	                walker.type = 'node';
+	            } else if (Array.isArray(fieldType)) {
+	                walker.type = 'list';
+	            }
+	        }
+
+	        if (walker.type) {
+	            walkers.push(walker);
+	        }
+	    }
+
+	    if (walkers.length) {
+	        return {
+	            context: nodeType.walkContext,
+	            fields: walkers
+	        };
+	    }
+
+	    return null;
+	}
+
+	function getTypesFromConfig(config) {
+	    var types = {};
+
+	    for (var name in config.node) {
+	        if (hasOwnProperty$4.call(config.node, name)) {
+	            var nodeType = config.node[name];
+
+	            if (!nodeType.structure) {
+	                throw new Error('Missed `structure` field in `' + name + '` node type definition');
+	            }
+
+	            types[name] = getWalkersFromStructure(name, nodeType);
+	        }
+	    }
+
+	    return types;
+	}
+
+	function createTypeIterator(config, reverse) {
+	    var fields = reverse ? config.fields.slice().reverse() : config.fields;
+	    var body = fields.map(function(field) {
+	        var ref = 'node.' + field.name;
+	        var line;
+
+	        if (field.type === 'list') {
+	            line = reverse
+	                ? ref + '.forEachRight(walk);'
+	                : ref + '.forEach(walk);';
+	        } else {
+	            line = 'walk(' + ref + ');';
+	        }
+
+	        if (field.nullable) {
+	            line = 'if (' + ref + ') {\n    ' + line + '}';
+	        }
+
+	        return line;
+	    });
+
+	    if (config.context) {
+	        body = [].concat(
+	            'var old = context.' + config.context + ';',
+	            'context.' + config.context + ' = node;',
+	            body,
+	            'context.' + config.context + ' = old;'
+	        );
+	    }
+
+	    return new Function('node', 'context', 'walk', body.join('\n'));
+	}
+
+	function createFastTraveralMap(iterators) {
+	    return {
+	        Atrule: {
+	            StyleSheet: iterators.StyleSheet,
+	            Atrule: iterators.Atrule,
+	            Rule: iterators.Rule,
+	            Block: iterators.Block
+	        },
+	        Rule: {
+	            StyleSheet: iterators.StyleSheet,
+	            Atrule: iterators.Atrule,
+	            Rule: iterators.Rule,
+	            Block: iterators.Block
+	        },
+	        Declaration: {
+	            StyleSheet: iterators.StyleSheet,
+	            Atrule: iterators.Atrule,
+	            Rule: iterators.Rule,
+	            Block: iterators.Block
+	        }
+	    };
+	}
+
+	var create$4 = function createWalker(config) {
+	    var types = getTypesFromConfig(config);
+	    var iteratorsNatural = {};
+	    var iteratorsReverse = {};
+
+	    for (var name in types) {
+	        if (hasOwnProperty$4.call(types, name) && types[name] !== null) {
+	            iteratorsNatural[name] = createTypeIterator(types[name], false);
+	            iteratorsReverse[name] = createTypeIterator(types[name], true);
+	        }
+	    }
+
+	    var fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);
+	    var fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);
+
+	    return function walk(root, options) {
+	        function walkNode(node, item, list) {
+	            enter.call(context, node, item, list);
+
+	            if (iterators.hasOwnProperty(node.type)) {
+	                iterators[node.type](node, context, walkNode);
+	            }
+
+	            leave.call(context, node, item, list);
+	        }
+
+	        var enter = noop$4;
+	        var leave = noop$4;
+	        var iterators = iteratorsNatural;
+	        var context = {
+	            root: root,
+	            stylesheet: null,
+	            atrule: null,
+	            atrulePrelude: null,
+	            rule: null,
+	            selector: null,
+	            block: null,
+	            declaration: null,
+	            function: null
+	        };
+
+	        if (typeof options === 'function') {
+	            enter = options;
+	        } else if (options) {
+	            enter = ensureFunction$1(options.enter);
+	            leave = ensureFunction$1(options.leave);
+
+	            if (options.reverse) {
+	                iterators = iteratorsReverse;
+	            }
+
+	            if (options.visit) {
+	                if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {
+	                    iterators = options.reverse
+	                        ? fastTraversalIteratorsReverse[options.visit]
+	                        : fastTraversalIteratorsNatural[options.visit];
+	                } else if (!types.hasOwnProperty(options.visit)) {
+	                    throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).join(', ') + ')');
+	                }
+
+	                enter = invokeForType(enter, options.visit);
+	                leave = invokeForType(leave, options.visit);
+	            }
+	        }
+
+	        if (enter === noop$4 && leave === noop$4) {
+	            throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+	        }
+
+	        // swap handlers in reverse mode to invert visit order
+	        if (options.reverse) {
+	            var tmp = enter;
+	            enter = leave;
+	            leave = tmp;
+	        }
+
+	        walkNode(root);
+	    };
+	};
+
+	var clone = function clone(node) {
+	    var result = {};
+
+	    for (var key in node) {
+	        var value = node[key];
+
+	        if (value) {
+	            if (Array.isArray(value) || value instanceof list) {
+	                value = value.map(clone);
+	            } else if (value.constructor === Object) {
+	                value = clone(value);
+	            }
+	        }
+
+	        result[key] = value;
+	    }
+
+	    return result;
+	};
+
+	var hasOwnProperty$5 = Object.prototype.hasOwnProperty;
+	var shape = {
+	    generic: true,
+	    types: {},
+	    properties: {},
+	    parseContext: {},
+	    scope: {},
+	    atrule: ['parse'],
+	    pseudo: ['parse'],
+	    node: ['name', 'structure', 'parse', 'generate', 'walkContext']
+	};
+
+	function isObject(value) {
+	    return value && value.constructor === Object;
+	}
+
+	function copy(value) {
+	    if (isObject(value)) {
+	        var res = {};
+	        for (var key in value) {
+	            if (hasOwnProperty$5.call(value, key)) {
+	                res[key] = value[key];
+	            }
+	        }
+	        return res;
+	    } else {
+	        return value;
+	    }
+	}
+
+	function extend(dest, src) {
+	    for (var key in src) {
+	        if (hasOwnProperty$5.call(src, key)) {
+	            if (isObject(dest[key])) {
+	                extend(dest[key], copy(src[key]));
+	            } else {
+	                dest[key] = copy(src[key]);
+	            }
+	        }
+	    }
+	}
+
+	function mix(dest, src, shape) {
+	    for (var key in shape) {
+	        if (hasOwnProperty$5.call(shape, key) === false) {
+	            continue;
+	        }
+
+	        if (shape[key] === true) {
+	            if (key in src) {
+	                if (hasOwnProperty$5.call(src, key)) {
+	                    dest[key] = copy(src[key]);
+	                }
+	            }
+	        } else if (shape[key]) {
+	            if (isObject(shape[key])) {
+	                var res = {};
+	                extend(res, dest[key]);
+	                extend(res, src[key]);
+	                dest[key] = res;
+	            } else if (Array.isArray(shape[key])) {
+	                var res = {};
+	                var innerShape = shape[key].reduce(function(s, k) {
+	                    s[k] = true;
+	                    return s;
+	                }, {});
+	                for (var name in dest[key]) {
+	                    if (hasOwnProperty$5.call(dest[key], name)) {
+	                        res[name] = {};
+	                        if (dest[key] && dest[key][name]) {
+	                            mix(res[name], dest[key][name], innerShape);
+	                        }
+	                    }
+	                }
+	                for (var name in src[key]) {
+	                    if (hasOwnProperty$5.call(src[key], name)) {
+	                        if (!res[name]) {
+	                            res[name] = {};
+	                        }
+	                        if (src[key] && src[key][name]) {
+	                            mix(res[name], src[key][name], innerShape);
+	                        }
+	                    }
+	                }
+	                dest[key] = res;
+	            }
+	        }
+	    }
+	    return dest;
+	}
+
+	var mix_1 = function(dest, src) {
+	    return mix(dest, src, shape);
+	};
+
+	function assign$1(dest, src) {
+	    for (var key in src) {
+	        dest[key] = src[key];
+	    }
+
+	    return dest;
+	}
+
+	function createSyntax(config) {
+	    var parse = create$1(config);
+	    var walk = create$4(config);
+	    var generate = create$2(config);
+	    var convert = create$3(walk);
+
+	    var syntax = {
+	        List: list,
+	        Tokenizer: tokenizer,
+	        Lexer: Lexer_1,
+
+	        vendorPrefix: names.vendorPrefix,
+	        keyword: names.keyword,
+	        property: names.property,
+	        isCustomProperty: names.isCustomProperty,
+
+	        grammar: grammar,
+	        lexer: null,
+	        createLexer: function(config) {
+	            return new Lexer_1(config, syntax, syntax.lexer.structure);
+	        },
+
+	        parse: parse,
+	        walk: walk,
+	        generate: generate,
+
+	        clone: clone,
+	        fromPlainObject: convert.fromPlainObject,
+	        toPlainObject: convert.toPlainObject,
+
+	        createSyntax: function(config) {
+	            return createSyntax(mix_1({}, config));
+	        },
+	        fork: function(extension) {
+	            var base = mix_1({}, config); // copy of config
+	            return createSyntax(
+	                typeof extension === 'function'
+	                    ? extension(base, assign$1)
+	                    : mix_1(base, extension)
+	            );
+	        }
+	    };
+
+	    syntax.lexer = new Lexer_1({
+	        generic: true,
+	        types: config.types,
+	        properties: config.properties,
+	        node: config.node
+	    }, syntax);
+
+	    return syntax;
+	}
+	var create_1 = function(config) {
+	    return createSyntax(mix_1({}, config));
+	};
+
+	var create$5 = {
+		create: create_1
+	};
+
+	var all = {
+		syntax: "initial | inherit | unset | revert",
+		media: "noPracticalMedia",
+		inherited: false,
+		animationType: "eachOfShorthandPropertiesExceptUnicodeBiDiAndDirection",
+		percentages: "no",
+		groups: [
+			"CSS Miscellaneous"
+		],
+		initial: "noPracticalInitialValue",
+		appliesto: "allElements",
+		computed: "asSpecifiedAppliesToEachProperty",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var animation = {
+		syntax: "<single-animation>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: [
+			"animation-name",
+			"animation-duration",
+			"animation-timing-function",
+			"animation-delay",
+			"animation-iteration-count",
+			"animation-direction",
+			"animation-fill-mode",
+			"animation-play-state"
+		],
+		appliesto: "allElementsAndPseudos",
+		computed: [
+			"animation-name",
+			"animation-duration",
+			"animation-timing-function",
+			"animation-delay",
+			"animation-direction",
+			"animation-iteration-count",
+			"animation-fill-mode",
+			"animation-play-state"
+		],
+		order: "orderOfAppearance",
+		status: "standard"
+	};
+	var appearance = {
+		syntax: "auto | none",
+		media: "all",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	};
+	var azimuth = {
+		syntax: "<angle> | [ [ left-side | far-left | left | center-left | center | center-right | right | far-right | right-side ] || behind ] | leftwards | rightwards",
+		media: "aural",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Speech"
+		],
+		initial: "center",
+		appliesto: "allElements",
+		computed: "normalizedAngle",
+		order: "orderOfAppearance",
+		status: "obsolete"
+	};
+	var background = {
+		syntax: "[ <bg-layer> , ]* <final-bg-layer>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"background-color",
+			"background-image",
+			"background-clip",
+			"background-position",
+			"background-size",
+			"background-repeat",
+			"background-attachment"
+		],
+		percentages: [
+			"background-position",
+			"background-size"
+		],
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"background-image",
+			"background-position",
+			"background-size",
+			"background-repeat",
+			"background-origin",
+			"background-clip",
+			"background-attachment",
+			"background-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"background-image",
+			"background-position",
+			"background-size",
+			"background-repeat",
+			"background-origin",
+			"background-clip",
+			"background-attachment",
+			"background-color"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	};
+	var border = {
+		syntax: "<br-width> || <br-style> || <color>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-color",
+			"border-style",
+			"border-width"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-width",
+			"border-style",
+			"border-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-width",
+			"border-style",
+			"border-color"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	};
+	var bottom = {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToContainingBlockHeight",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var clear = {
+		syntax: "none | left | right | both | inline-start | inline-end",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "none",
+		appliesto: "blockLevelElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var clip = {
+		syntax: "<shape> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "rectangle",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "auto",
+		appliesto: "absolutelyPositionedElements",
+		computed: "autoOrRectangle",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var color = {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Color"
+		],
+		initial: "variesFromBrowserToBrowser",
+		appliesto: "allElements",
+		computed: "translucentValuesRGBAOtherwiseRGB",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	};
+	var columns = {
+		syntax: "<'column-width'> || <'column-count'>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"column-width",
+			"column-count"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: [
+			"column-width",
+			"column-count"
+		],
+		appliesto: "blockContainersExceptTableWrappers",
+		computed: [
+			"column-width",
+			"column-count"
+		],
+		order: "perGrammar",
+		status: "standard"
+	};
+	var contain = {
+		syntax: "none | strict | content | [ size || layout || style || paint ]",
+		media: "all",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Containment"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	};
+	var content = {
+		syntax: "normal | none | [ <content-replacement> | <content-list> ] [/ <string> ]?",
+		media: "all",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Generated Content"
+		],
+		initial: "normal",
+		appliesto: "beforeAndAfterPseudos",
+		computed: "normalOnElementsForPseudosNoneAbsoluteURIStringOrAsSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var cursor = {
+		syntax: "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing ] ]",
+		media: [
+			"visual",
+			"interactive"
+		],
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecifiedURLsAbsolute",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var direction = {
+		syntax: "ltr | rtl",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Writing Modes"
+		],
+		initial: "ltr",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var display = {
+		syntax: "[ <display-outside> || <display-inside> ] | <display-listitem> | <display-internal> | <display-box> | <display-legacy>",
+		media: "all",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Display"
+		],
+		initial: "inline",
+		appliesto: "allElements",
+		computed: "asSpecifiedExceptPositionedFloatingAndRootElementsKeywordMaybeDifferent",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var filter = {
+		syntax: "none | <filter-function-list>",
+		media: "visual",
+		inherited: false,
+		animationType: "filterList",
+		percentages: "no",
+		groups: [
+			"Filter Effects"
+		],
+		initial: "none",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var flex = {
+		syntax: "none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"flex-grow",
+			"flex-shrink",
+			"flex-basis"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: [
+			"flex-grow",
+			"flex-shrink",
+			"flex-basis"
+		],
+		appliesto: "flexItemsAndInFlowPseudos",
+		computed: [
+			"flex-grow",
+			"flex-shrink",
+			"flex-basis"
+		],
+		order: "orderOfAppearance",
+		status: "standard"
+	};
+	var float = {
+		syntax: "left | right | none | inline-start | inline-end",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "none",
+		appliesto: "allElementsNoEffectIfDisplayNone",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var font = {
+		syntax: "[ [ <'font-style'> || <font-variant-css21> || <'font-weight'> || <'font-stretch'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ] | caption | icon | menu | message-box | small-caption | status-bar",
+		media: "visual",
+		inherited: true,
+		animationType: [
+			"font-style",
+			"font-variant",
+			"font-weight",
+			"font-stretch",
+			"font-size",
+			"line-height",
+			"font-family"
+		],
+		percentages: [
+			"font-size",
+			"line-height"
+		],
+		groups: [
+			"CSS Fonts"
+		],
+		initial: [
+			"font-style",
+			"font-variant",
+			"font-weight",
+			"font-stretch",
+			"font-size",
+			"line-height",
+			"font-family"
+		],
+		appliesto: "allElements",
+		computed: [
+			"font-style",
+			"font-variant",
+			"font-weight",
+			"font-stretch",
+			"font-size",
+			"line-height",
+			"font-family"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	};
+	var gap = {
+		syntax: "<'row-gap'> <'column-gap'>?",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"row-gap",
+			"column-gap"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Box Alignment"
+		],
+		initial: [
+			"row-gap",
+			"column-gap"
+		],
+		appliesto: "gridContainers",
+		computed: [
+			"row-gap",
+			"column-gap"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var grid = {
+		syntax: "<'grid-template'> | <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? | [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: [
+			"grid-template-rows",
+			"grid-template-columns",
+			"grid-auto-rows",
+			"grid-auto-columns"
+		],
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: [
+			"grid-template-rows",
+			"grid-template-columns",
+			"grid-template-areas",
+			"grid-auto-rows",
+			"grid-auto-columns",
+			"grid-auto-flow",
+			"grid-column-gap",
+			"grid-row-gap",
+			"column-gap",
+			"row-gap"
+		],
+		appliesto: "gridContainers",
+		computed: [
+			"grid-template-rows",
+			"grid-template-columns",
+			"grid-template-areas",
+			"grid-auto-rows",
+			"grid-auto-columns",
+			"grid-auto-flow",
+			"grid-column-gap",
+			"grid-row-gap",
+			"column-gap",
+			"row-gap"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var height = {
+		syntax: "[ <length> | <percentage> ] && [ border-box | content-box ]? | available | min-content | max-content | fit-content | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentagesRelativeToContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "auto",
+		appliesto: "allElementsButNonReplacedAndTableColumns",
+		computed: "percentageAutoOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var hyphens = {
+		syntax: "none | manual | auto",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "manual",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var isolation = {
+		syntax: "auto | isolate",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Compositing and Blending"
+		],
+		initial: "auto",
+		appliesto: "allElementsSVGContainerGraphicsAndGraphicsReferencingElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var left = {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var margin = {
+		syntax: "[ <length> | <percentage> | auto ]{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: [
+			"margin-bottom",
+			"margin-left",
+			"margin-right",
+			"margin-top"
+		],
+		appliesto: "allElementsExceptTableDisplayTypes",
+		computed: [
+			"margin-bottom",
+			"margin-left",
+			"margin-right",
+			"margin-top"
+		],
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	};
+	var mask = {
+		syntax: "<mask-layer>#",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"mask-image",
+			"mask-mode",
+			"mask-repeat",
+			"mask-position",
+			"mask-clip",
+			"mask-origin",
+			"mask-size",
+			"mask-composite"
+		],
+		percentages: [
+			"mask-position"
+		],
+		groups: [
+			"CSS Masking"
+		],
+		initial: [
+			"mask-image",
+			"mask-mode",
+			"mask-repeat",
+			"mask-position",
+			"mask-clip",
+			"mask-origin",
+			"mask-size",
+			"mask-composite"
+		],
+		appliesto: "allElementsSVGContainerElements",
+		computed: [
+			"mask-image",
+			"mask-mode",
+			"mask-repeat",
+			"mask-position",
+			"mask-clip",
+			"mask-origin",
+			"mask-size",
+			"mask-composite"
+		],
+		order: "perGrammar",
+		stacking: true,
+		status: "standard"
+	};
+	var offset = {
+		syntax: "[ <'offset-position'>? [ <'offset-path'> [ <'offset-distance'> || <'offset-rotate'> ]? ]? ]! [ / <'offset-anchor'> ]?",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"offset-position",
+			"offset-path",
+			"offset-distance",
+			"offset-anchor",
+			"offset-rotate"
+		],
+		percentages: [
+			"offset-position",
+			"offset-distance",
+			"offset-anchor"
+		],
+		groups: [
+			"CSS Motion"
+		],
+		initial: [
+			"offset-position",
+			"offset-path",
+			"offset-distance",
+			"offset-anchor",
+			"offset-rotate"
+		],
+		appliesto: "transformableElements",
+		computed: [
+			"offset-position",
+			"offset-path",
+			"offset-distance",
+			"offset-anchor",
+			"offset-rotate"
+		],
+		order: "perGrammar",
+		stacking: true,
+		status: "experimental"
+	};
+	var opacity = {
+		syntax: "<number>",
+		media: "visual",
+		inherited: false,
+		animationType: "number",
+		percentages: "no",
+		groups: [
+			"CSS Color"
+		],
+		initial: "1.0",
+		appliesto: "allElements",
+		computed: "specifiedValueClipped0To1",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::placeholder"
+		],
+		status: "standard"
+	};
+	var order = {
+		syntax: "<integer>",
+		media: "visual",
+		inherited: false,
+		animationType: "integer",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "0",
+		appliesto: "flexItemsAndAbsolutelyPositionedFlexContainerChildren",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var orphans = {
+		syntax: "<integer>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fragmentation"
+		],
+		initial: "2",
+		appliesto: "blockContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	};
+	var outline = {
+		syntax: "[ <'outline-color'> || <'outline-style'> || <'outline-width'> ]",
+		media: [
+			"visual",
+			"interactive"
+		],
+		inherited: false,
+		animationType: [
+			"outline-color",
+			"outline-width",
+			"outline-style"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: [
+			"outline-color",
+			"outline-style",
+			"outline-width"
+		],
+		appliesto: "allElements",
+		computed: [
+			"outline-color",
+			"outline-width",
+			"outline-style"
+		],
+		order: "orderOfAppearance",
+		status: "standard"
+	};
+	var overflow = {
+		syntax: "[ visible | hidden | clip | scroll | auto ]{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "visible",
+		appliesto: "blockContainersFlexContainersGridContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var padding = {
+		syntax: "[ <length> | <percentage> ]{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: [
+			"padding-bottom",
+			"padding-left",
+			"padding-right",
+			"padding-top"
+		],
+		appliesto: "allElementsExceptInternalTableDisplayTypes",
+		computed: [
+			"padding-bottom",
+			"padding-left",
+			"padding-right",
+			"padding-top"
+		],
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	};
+	var perspective = {
+		syntax: "none | <length>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "none",
+		appliesto: "transformableElements",
+		computed: "absoluteLengthOrNone",
+		order: "uniqueOrder",
+		stacking: true,
+		status: "standard"
+	};
+	var position = {
+		syntax: "static | relative | absolute | sticky | fixed",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "static",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		stacking: true,
+		status: "standard"
+	};
+	var quotes = {
+		syntax: "none | [ <string> <string> ]+",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Generated Content"
+		],
+		initial: "dependsOnUserAgent",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var resize = {
+		syntax: "none | both | horizontal | vertical",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "none",
+		appliesto: "elementsWithOverflowNotVisibleAndReplacedElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var right = {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var rotate = {
+		syntax: "none | [ x | y | z | <number>{3} ]? && <angle>",
+		media: "visual",
+		inherited: false,
+		animationType: "transform",
+		percentages: "no",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "none",
+		appliesto: "transformableElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		stacking: true,
+		status: "standard"
+	};
+	var scale = {
+		syntax: "none | <number>{1,3}",
+		media: "visual",
+		inherited: false,
+		animationType: "transform",
+		percentages: "no",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "none",
+		appliesto: "transformableElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		stacking: true,
+		status: "standard"
+	};
+	var top = {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToContainingBlockHeight",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var transform = {
+		syntax: "none | <transform-list>",
+		media: "visual",
+		inherited: false,
+		animationType: "transform",
+		percentages: "referToSizeOfBoundingBox",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "none",
+		appliesto: "transformableElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		stacking: true,
+		status: "standard"
+	};
+	var transition = {
+		syntax: "<single-transition>#",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transitions"
+		],
+		initial: [
+			"transition-delay",
+			"transition-duration",
+			"transition-property",
+			"transition-timing-function"
+		],
+		appliesto: "allElementsAndPseudos",
+		computed: [
+			"transition-delay",
+			"transition-duration",
+			"transition-property",
+			"transition-timing-function"
+		],
+		order: "orderOfAppearance",
+		status: "standard"
+	};
+	var translate = {
+		syntax: "none | <length-percentage> [ <length-percentage> <length>? ]?",
+		media: "visual",
+		inherited: false,
+		animationType: "transform",
+		percentages: "referToSizeOfBoundingBox",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "none",
+		appliesto: "transformableElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "perGrammar",
+		stacking: true,
+		status: "standard"
+	};
+	var visibility = {
+		syntax: "visible | hidden | collapse",
+		media: "visual",
+		inherited: true,
+		animationType: "visibility",
+		percentages: "no",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "visible",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	};
+	var widows = {
+		syntax: "<integer>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fragmentation"
+		],
+		initial: "2",
+		appliesto: "blockContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	};
+	var width = {
+		syntax: "[ <length> | <percentage> ] && [ border-box | content-box ]? | available | min-content | max-content | fit-content | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "auto",
+		appliesto: "allElementsButNonReplacedAndTableRows",
+		computed: "percentageAutoOrAbsoluteLength",
+		order: "lengthOrPercentageBeforeKeywordIfBothPresent",
+		status: "standard"
+	};
+	var zoom = {
+		syntax: "normal | reset | <number> | <percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "integer",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	};
+	var properties$1 = {
+		"--*": {
+		syntax: "<declaration-value>",
+		media: "all",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Variables"
+		],
+		initial: "seeProse",
+		appliesto: "allElements",
+		computed: "asSpecifiedWithVarsSubstituted",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"-ms-accelerator": {
+		syntax: "false | true",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "false",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-block-progression": {
+		syntax: "tb | rl | bt | lr",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "tb",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zoom-chaining": {
+		syntax: "none | chained",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "none",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zooming": {
+		syntax: "none | zoom",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "zoomForTheTopLevelNoneForTheRest",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zoom-limit": {
+		syntax: "<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: [
+			"-ms-content-zoom-limit-max",
+			"-ms-content-zoom-limit-min"
+		],
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: [
+			"-ms-content-zoom-limit-max",
+			"-ms-content-zoom-limit-min"
+		],
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: [
+			"-ms-content-zoom-limit-max",
+			"-ms-content-zoom-limit-min"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zoom-limit-max": {
+		syntax: "<percentage>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "maxZoomFactor",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "400%",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zoom-limit-min": {
+		syntax: "<percentage>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "minZoomFactor",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "100%",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zoom-snap": {
+		syntax: "<'-ms-content-zoom-snap-type'> || <'-ms-content-zoom-snap-points'>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: [
+			"-ms-content-zoom-snap-type",
+			"-ms-content-zoom-snap-points"
+		],
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: [
+			"-ms-content-zoom-snap-type",
+			"-ms-content-zoom-snap-points"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zoom-snap-points": {
+		syntax: "snapInterval( <percentage>, <percentage> ) | snapList( <percentage># )",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "snapInterval(0%, 100%)",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-content-zoom-snap-type": {
+		syntax: "none | proximity | mandatory",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "none",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-filter": {
+		syntax: "<string>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "\"\"",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-flow-from": {
+		syntax: "[ none | <custom-ident> ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "none",
+		appliesto: "nonReplacedElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-flow-into": {
+		syntax: "[ none | <custom-ident> ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "none",
+		appliesto: "iframeElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-high-contrast-adjust": {
+		syntax: "auto | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-hyphenate-limit-chars": {
+		syntax: "auto | <integer>{1,3}",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-hyphenate-limit-lines": {
+		syntax: "no-limit | <integer>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "no-limit",
+		appliesto: "blockContainerElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-hyphenate-limit-zone": {
+		syntax: "<percentage> | <length>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "referToLineBoxWidth",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "0",
+		appliesto: "blockContainerElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-ime-align": {
+		syntax: "auto | after",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-overflow-style": {
+		syntax: "auto | none | scrollbar | -ms-autohiding-scrollbar",
+		media: "interactive",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "auto",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-3dlight-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "dependsOnUserAgent",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-arrow-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "ButtonText",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-base-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "dependsOnUserAgent",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-darkshadow-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "ThreeDDarkShadow",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-face-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "ThreeDFace",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-highlight-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "ThreeDHighlight",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-shadow-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "ThreeDDarkShadow",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scrollbar-track-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "Scrollbar",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-chaining": {
+		syntax: "chained | none",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "chained",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-limit": {
+		syntax: "<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: [
+			"-ms-scroll-limit-x-min",
+			"-ms-scroll-limit-y-min",
+			"-ms-scroll-limit-x-max",
+			"-ms-scroll-limit-y-max"
+		],
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: [
+			"-ms-scroll-limit-x-min",
+			"-ms-scroll-limit-y-min",
+			"-ms-scroll-limit-x-max",
+			"-ms-scroll-limit-y-max"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-limit-x-max": {
+		syntax: "auto | <length>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "auto",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-limit-x-min": {
+		syntax: "<length>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "0",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-limit-y-max": {
+		syntax: "auto | <length>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "auto",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-limit-y-min": {
+		syntax: "<length>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "0",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-rails": {
+		syntax: "none | railed",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "railed",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-snap-points-x": {
+		syntax: "snapInterval( <length-percentage>, <length-percentage> ) | snapList( <length-percentage># )",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "snapInterval(0px, 100%)",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-snap-points-y": {
+		syntax: "snapInterval( <length-percentage>, <length-percentage> ) | snapList( <length-percentage># )",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "snapInterval(0px, 100%)",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-snap-type": {
+		syntax: "none | proximity | mandatory",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "none",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-snap-x": {
+		syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: [
+			"-ms-scroll-snap-type",
+			"-ms-scroll-snap-points-x"
+		],
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: [
+			"-ms-scroll-snap-type",
+			"-ms-scroll-snap-points-x"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-snap-y": {
+		syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: [
+			"-ms-scroll-snap-type",
+			"-ms-scroll-snap-points-y"
+		],
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: [
+			"-ms-scroll-snap-type",
+			"-ms-scroll-snap-points-y"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-scroll-translation": {
+		syntax: "none | vertical-to-horizontal",
+		media: "interactive",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-text-autospace": {
+		syntax: "none | ideograph-alpha | ideograph-numeric | ideograph-parenthesis | ideograph-space",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-touch-select": {
+		syntax: "grippers | none",
+		media: "interactive",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "grippers",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-user-select": {
+		syntax: "none | element | text",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "text",
+		appliesto: "nonReplacedElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-wrap-flow": {
+		syntax: "auto | both | start | end | maximum | clear",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "auto",
+		appliesto: "blockLevelElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-wrap-margin": {
+		syntax: "<length>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "0",
+		appliesto: "exclusionElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-ms-wrap-through": {
+		syntax: "wrap | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Microsoft Extensions"
+		],
+		initial: "wrap",
+		appliesto: "blockLevelElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-appearance": {
+		syntax: "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",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "noneButOverriddenInUserAgentCSS",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-binding": {
+		syntax: "<url> | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElementsExceptGeneratedContentOrPseudoElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-border-bottom-colors": {
+		syntax: "<color>+ | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-border-left-colors": {
+		syntax: "<color>+ | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-border-right-colors": {
+		syntax: "<color>+ | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-border-top-colors": {
+		syntax: "<color>+ | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-context-properties": {
+		syntax: "none | [ fill | fill-opacity | stroke | stroke-opacity ]#",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElementsThatCanReferenceImages",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-float-edge": {
+		syntax: "border-box | content-box | margin-box | padding-box",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "content-box",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-force-broken-image-icon": {
+		syntax: "<integer>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "0",
+		appliesto: "images",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-image-region": {
+		syntax: "<shape> | auto",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "auto",
+		appliesto: "xulImageElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-orient": {
+		syntax: "inline | block | horizontal | vertical",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "inline",
+		appliesto: "anyElementEffectOnProgressAndMeter",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-outline-radius": {
+		syntax: "<outline-radius>{1,4} [ / <outline-radius>{1,4} ]?",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"-moz-outline-radius-topleft",
+			"-moz-outline-radius-topright",
+			"-moz-outline-radius-bottomright",
+			"-moz-outline-radius-bottomleft"
+		],
+		percentages: [
+			"-moz-outline-radius-topleft",
+			"-moz-outline-radius-topright",
+			"-moz-outline-radius-bottomright",
+			"-moz-outline-radius-bottomleft"
+		],
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: [
+			"-moz-outline-radius-topleft",
+			"-moz-outline-radius-topright",
+			"-moz-outline-radius-bottomright",
+			"-moz-outline-radius-bottomleft"
+		],
+		appliesto: "allElements",
+		computed: [
+			"-moz-outline-radius-topleft",
+			"-moz-outline-radius-topright",
+			"-moz-outline-radius-bottomright",
+			"-moz-outline-radius-bottomleft"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-outline-radius-bottomleft": {
+		syntax: "<outline-radius>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-outline-radius-bottomright": {
+		syntax: "<outline-radius>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-outline-radius-topleft": {
+		syntax: "<outline-radius>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-outline-radius-topright": {
+		syntax: "<outline-radius>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-stack-sizing": {
+		syntax: "ignore | stretch-to-fit",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "stretch-to-fit",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-text-blink": {
+		syntax: "none | blink",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-user-focus": {
+		syntax: "ignore | normal | select-after | select-before | select-menu | select-same | select-all | none",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-user-input": {
+		syntax: "auto | none | enabled | disabled",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-user-modify": {
+		syntax: "read-only | read-write | write-only",
+		media: "interactive",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "read-only",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-window-dragging": {
+		syntax: "drag | no-drag",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "drag",
+		appliesto: "allElementsCreatingNativeWindows",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-moz-window-shadow": {
+		syntax: "default | menu | tooltip | sheet | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "default",
+		appliesto: "allElementsCreatingNativeWindows",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-appearance": {
+		syntax: "none | button | button-bevel | 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 | searchfield | searchfield-cancel-button | searchfield-decoration | searchfield-results-button | searchfield-results-decoration | slider-horizontal | slider-vertical | sliderthumb-horizontal | sliderthumb-vertical | square-button | textarea | textfield",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "noneButOverriddenInUserAgentCSS",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-border-before": {
+		syntax: "<'border-width'> || <'border-style'> || <'color'>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: [
+			"-webkit-border-before-width"
+		],
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: [
+			"border-width",
+			"border-style",
+			"color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-width",
+			"border-style",
+			"color"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-border-before-color": {
+		syntax: "<'color'>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-border-before-style": {
+		syntax: "<'border-style'>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-border-before-width": {
+		syntax: "<'border-width'>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-box-reflect": {
+		syntax: "[ above | below | right | left ]? <length>? <image>?",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-mask": {
+		syntax: "[ <mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || [ <box> | border | padding | content | text ] || [ <box> | border | padding | content ] ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: [
+			"-webkit-mask-image",
+			"-webkit-mask-repeat",
+			"-webkit-mask-attachment",
+			"-webkit-mask-position",
+			"-webkit-mask-origin",
+			"-webkit-mask-clip"
+		],
+		appliesto: "allElements",
+		computed: [
+			"-webkit-mask-image",
+			"-webkit-mask-repeat",
+			"-webkit-mask-attachment",
+			"-webkit-mask-position",
+			"-webkit-mask-origin",
+			"-webkit-mask-clip"
+		],
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-mask-attachment": {
+		syntax: "<attachment>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "scroll",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-clip": {
+		syntax: "[ <box> | border | padding | content | text ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "border",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-composite": {
+		syntax: "<composite-style>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "source-over",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-image": {
+		syntax: "<mask-reference>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "absoluteURIOrNone",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-origin": {
+		syntax: "[ <box> | border | padding | content ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "padding",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-position": {
+		syntax: "<position>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToSizeOfElement",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "0% 0%",
+		appliesto: "allElements",
+		computed: "absoluteLengthOrPercentage",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-position-x": {
+		syntax: "[ <length-percentage> | left | center | right ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToSizeOfElement",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "0%",
+		appliesto: "allElements",
+		computed: "absoluteLengthOrPercentage",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-position-y": {
+		syntax: "[ <length-percentage> | top | center | bottom ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToSizeOfElement",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "0%",
+		appliesto: "allElements",
+		computed: "absoluteLengthOrPercentage",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-repeat": {
+		syntax: "<repeat-style>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "repeat",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-repeat-x": {
+		syntax: "repeat | no-repeat | space | round",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "repeat",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-repeat-y": {
+		syntax: "repeat | no-repeat | space | round",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "repeat",
+		appliesto: "allElements",
+		computed: "absoluteLengthOrPercentage",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-mask-size": {
+		syntax: "<bg-size>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "relativeToBackgroundPositioningArea",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "auto auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-overflow-scrolling": {
+		syntax: "auto | touch",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "auto",
+		appliesto: "scrollingBoxes",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "nonstandard"
+	},
+		"-webkit-tap-highlight-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "black",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-text-fill-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-text-stroke": {
+		syntax: "<length> || <color>",
+		media: "visual",
+		inherited: true,
+		animationType: [
+			"-webkit-text-stroke-width",
+			"-webkit-text-stroke-color"
+		],
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: [
+			"-webkit-text-stroke-width",
+			"-webkit-text-stroke-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"-webkit-text-stroke-width",
+			"-webkit-text-stroke-color"
+		],
+		order: "canonicalOrder",
+		status: "nonstandard"
+	},
+		"-webkit-text-stroke-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: true,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-text-stroke-width": {
+		syntax: "<length>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "absoluteLength",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-touch-callout": {
+		syntax: "default | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "default",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"-webkit-user-modify": {
+		syntax: "read-only | read-write | read-write-plaintext-only",
+		media: "interactive",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"WebKit Extensions"
+		],
+		initial: "read-only",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"align-content": {
+		syntax: "normal | <baseline-position> | <content-distribution> | <overflow-position>? <content-position>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "normal",
+		appliesto: "multilineFlexContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"align-items": {
+		syntax: "normal | stretch | <baseline-position> | [ <overflow-position>? <self-position> ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"align-self": {
+		syntax: "auto | normal | stretch | <baseline-position> | <overflow-position>? <self-position>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "auto",
+		appliesto: "flexItemsGridItemsAndAbsolutelyPositionedBoxes",
+		computed: "autoOnAbsolutelyPositionedElementsValueOfAlignItemsOnParent",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		all: all,
+		animation: animation,
+		"animation-delay": {
+		syntax: "<time>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "0s",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"animation-direction": {
+		syntax: "<single-animation-direction>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "normal",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"animation-duration": {
+		syntax: "<time>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "0s",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"animation-fill-mode": {
+		syntax: "<single-animation-fill-mode>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "none",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"animation-iteration-count": {
+		syntax: "<single-animation-iteration-count>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "1",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"animation-name": {
+		syntax: "[ none | <keyframes-name> ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "none",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"animation-play-state": {
+		syntax: "<single-animation-play-state>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "running",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"animation-timing-function": {
+		syntax: "<single-timing-function>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Animations"
+		],
+		initial: "ease",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		appearance: appearance,
+		azimuth: azimuth,
+		"backdrop-filter": {
+		syntax: "none | <filter-function-list>",
+		media: "visual",
+		inherited: false,
+		animationType: "filterList",
+		percentages: "no",
+		groups: [
+			"Filter Effects"
+		],
+		initial: "none",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"backface-visibility": {
+		syntax: "visible | hidden",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "visible",
+		appliesto: "transformableElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		background: background,
+		"background-attachment": {
+		syntax: "<attachment>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "scroll",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-blend-mode": {
+		syntax: "<blend-mode>#",
+		media: "none",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Compositing and Blending"
+		],
+		initial: "normal",
+		appliesto: "allElementsSVGContainerGraphicsAndGraphicsReferencingElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-clip": {
+		syntax: "<box>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "border-box",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "transparent",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-image": {
+		syntax: "<bg-image>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecifiedURLsAbsolute",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-origin": {
+		syntax: "<box>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "padding-box",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-position": {
+		syntax: "<bg-position>#",
+		media: "visual",
+		inherited: false,
+		animationType: "repeatableListOfSimpleListOfLpc",
+		percentages: "referToSizeOfBackgroundPositioningAreaMinusBackgroundImageSize",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "0% 0%",
+		appliesto: "allElements",
+		computed: "listEachItemTwoKeywordsOriginOffsets",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-position-x": {
+		syntax: "[ center | [ left | right | x-start | x-end ]? <length-percentage>? ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToWidthOfBackgroundPositioningAreaMinusBackgroundImageHeight",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "left",
+		appliesto: "allElements",
+		computed: "listEachItemConsistingOfAbsoluteLengthPercentageAndOrigin",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"background-position-y": {
+		syntax: "[ center | [ top | bottom | y-start | y-end ]? <length-percentage>? ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToHeightOfBackgroundPositioningAreaMinusBackgroundImageHeight",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "top",
+		appliesto: "allElements",
+		computed: "listEachItemConsistingOfAbsoluteLengthPercentageAndOrigin",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"background-repeat": {
+		syntax: "<repeat-style>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "repeat",
+		appliesto: "allElements",
+		computed: "listEachItemHasTwoKeywordsOnePerDimension",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"background-size": {
+		syntax: "<bg-size>#",
+		media: "visual",
+		inherited: false,
+		animationType: "repeatableListOfSimpleListOfLpc",
+		percentages: "relativeToBackgroundPositioningArea",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "auto auto",
+		appliesto: "allElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"block-overflow": {
+		syntax: "clip | ellipsis | <string>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "clip",
+		appliesto: "blockContainers",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"block-size": {
+		syntax: "<'width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "blockSizeOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "auto",
+		appliesto: "sameAsWidthAndHeight",
+		computed: "sameAsWidthAndHeight",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		border: border,
+		"border-block-end": {
+		syntax: "<'border-width'> || <'border-style'> || <'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: [
+			"border-width",
+			"border-style",
+			"color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-width",
+			"border-style",
+			"border-block-end-color"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-block-end-color": {
+		syntax: "<'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-block-end-style": {
+		syntax: "<'border-style'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-block-end-width": {
+		syntax: "<'border-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-block-start": {
+		syntax: "<'border-width'> || <'border-style'> || <'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: [
+			"border-width",
+			"border-style",
+			"color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-width",
+			"border-style",
+			"border-block-start-color"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-block-start-color": {
+		syntax: "<'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-block-start-style": {
+		syntax: "<'border-style'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-block-start-width": {
+		syntax: "<'border-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-bottom": {
+		syntax: "<br-width> || <br-style> || <color>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-bottom-color",
+			"border-bottom-style",
+			"border-bottom-width"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-bottom-width",
+			"border-bottom-style",
+			"border-bottom-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-bottom-width",
+			"border-bottom-style",
+			"border-bottom-color"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-bottom-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-bottom-left-radius": {
+		syntax: "<length-percentage>{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "0",
+		appliesto: "allElementsUAsNotRequiredWhenCollapse",
+		computed: "twoAbsoluteLengthOrPercentages",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-bottom-right-radius": {
+		syntax: "<length-percentage>{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "0",
+		appliesto: "allElementsUAsNotRequiredWhenCollapse",
+		computed: "twoAbsoluteLengthOrPercentages",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-bottom-style": {
+		syntax: "<br-style>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-bottom-width": {
+		syntax: "<br-width>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthOr0IfBorderBottomStyleNoneOrHidden",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-collapse": {
+		syntax: "collapse | separate",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Table"
+		],
+		initial: "separate",
+		appliesto: "tableElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-color": {
+		syntax: "<color>{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-bottom-color",
+			"border-left-color",
+			"border-right-color",
+			"border-top-color"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-top-color",
+			"border-right-color",
+			"border-bottom-color",
+			"border-left-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-bottom-color",
+			"border-left-color",
+			"border-right-color",
+			"border-top-color"
+		],
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-image": {
+		syntax: "<'border-image-source'> || <'border-image-slice'> [ / <'border-image-width'> | / <'border-image-width'>? / <'border-image-outset'> ]? || <'border-image-repeat'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: [
+			"border-image-slice",
+			"border-image-width"
+		],
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-image-source",
+			"border-image-slice",
+			"border-image-width",
+			"border-image-outset",
+			"border-image-repeat"
+		],
+		appliesto: "allElementsExceptTableElementsWhenCollapse",
+		computed: [
+			"border-image-outset",
+			"border-image-repeat",
+			"border-image-slice",
+			"border-image-source",
+			"border-image-width"
+		],
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-image-outset": {
+		syntax: "[ <length> | <number> ]{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptTableElementsWhenCollapse",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-image-repeat": {
+		syntax: "[ stretch | repeat | round | space ]{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "stretch",
+		appliesto: "allElementsExceptTableElementsWhenCollapse",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-image-slice": {
+		syntax: "<number-percentage>{1,4} && fill?",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToSizeOfBorderImage",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "100%",
+		appliesto: "allElementsExceptTableElementsWhenCollapse",
+		computed: "oneToFourPercentagesOrAbsoluteLengthsPlusFill",
+		order: "percentagesOrLengthsFollowedByFill",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-image-source": {
+		syntax: "none | <image>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "none",
+		appliesto: "allElementsExceptTableElementsWhenCollapse",
+		computed: "noneOrImageWithAbsoluteURI",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-image-width": {
+		syntax: "[ <length-percentage> | <number> | auto ]{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToWidthOrHeightOfBorderImageArea",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "1",
+		appliesto: "allElementsExceptTableElementsWhenCollapse",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-inline-end": {
+		syntax: "<'border-width'> || <'border-style'> || <'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: [
+			"border-width",
+			"border-style",
+			"color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-width",
+			"border-style",
+			"border-inline-end-color"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-inline-end-color": {
+		syntax: "<'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-inline-end-style": {
+		syntax: "<'border-style'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-inline-end-width": {
+		syntax: "<'border-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-inline-start": {
+		syntax: "<'border-width'> || <'border-style'> || <'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: [
+			"border-width",
+			"border-style",
+			"color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-width",
+			"border-style",
+			"border-inline-start-color"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-inline-start-color": {
+		syntax: "<'color'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-inline-start-style": {
+		syntax: "<'border-style'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-inline-start-width": {
+		syntax: "<'border-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-left": {
+		syntax: "<br-width> || <br-style> || <color>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-left-color",
+			"border-left-style",
+			"border-left-width"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-left-width",
+			"border-left-style",
+			"border-left-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-left-width",
+			"border-left-style",
+			"border-left-color"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-left-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-left-style": {
+		syntax: "<br-style>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-left-width": {
+		syntax: "<br-width>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthOr0IfBorderLeftStyleNoneOrHidden",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-radius": {
+		syntax: "<length-percentage>{1,4} [ / <length-percentage>{1,4} ]?",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-top-left-radius",
+			"border-top-right-radius",
+			"border-bottom-right-radius",
+			"border-bottom-left-radius"
+		],
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-top-left-radius",
+			"border-top-right-radius",
+			"border-bottom-right-radius",
+			"border-bottom-left-radius"
+		],
+		appliesto: "allElementsUAsNotRequiredWhenCollapse",
+		computed: [
+			"border-bottom-left-radius",
+			"border-bottom-right-radius",
+			"border-top-left-radius",
+			"border-top-right-radius"
+		],
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-right": {
+		syntax: "<br-width> || <br-style> || <color>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-right-color",
+			"border-right-style",
+			"border-right-width"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-right-width",
+			"border-right-style",
+			"border-right-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-right-width",
+			"border-right-style",
+			"border-right-color"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-right-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-right-style": {
+		syntax: "<br-style>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-right-width": {
+		syntax: "<br-width>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthOr0IfBorderRightStyleNoneOrHidden",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-spacing": {
+		syntax: "<length> <length>?",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Table"
+		],
+		initial: "0",
+		appliesto: "tableElements",
+		computed: "twoAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"border-style": {
+		syntax: "<br-style>{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-top-style",
+			"border-right-style",
+			"border-bottom-style",
+			"border-left-style"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-bottom-style",
+			"border-left-style",
+			"border-right-style",
+			"border-top-style"
+		],
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-top": {
+		syntax: "<br-width> || <br-style> || <color>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-top-color",
+			"border-top-style",
+			"border-top-width"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-top-width",
+			"border-top-style",
+			"border-top-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-top-width",
+			"border-top-style",
+			"border-top-color"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-top-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-top-left-radius": {
+		syntax: "<length-percentage>{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "0",
+		appliesto: "allElementsUAsNotRequiredWhenCollapse",
+		computed: "twoAbsoluteLengthOrPercentages",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-top-right-radius": {
+		syntax: "<length-percentage>{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfBorderBox",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "0",
+		appliesto: "allElementsUAsNotRequiredWhenCollapse",
+		computed: "twoAbsoluteLengthOrPercentages",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-top-style": {
+		syntax: "<br-style>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-top-width": {
+		syntax: "<br-width>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLengthOr0IfBorderTopStyleNoneOrHidden",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"border-width": {
+		syntax: "<br-width>{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"border-bottom-width",
+			"border-left-width",
+			"border-right-width",
+			"border-top-width"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: [
+			"border-top-width",
+			"border-right-width",
+			"border-bottom-width",
+			"border-left-width"
+		],
+		appliesto: "allElements",
+		computed: [
+			"border-bottom-width",
+			"border-left-width",
+			"border-right-width",
+			"border-top-width"
+		],
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		bottom: bottom,
+		"box-align": {
+		syntax: "start | center | end | baseline | stretch",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "stretch",
+		appliesto: "elementsWithDisplayBoxOrInlineBox",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-decoration-break": {
+		syntax: "slice | clone",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fragmentation"
+		],
+		initial: "slice",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"box-direction": {
+		syntax: "normal | reverse | inherit",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "normal",
+		appliesto: "elementsWithDisplayBoxOrInlineBox",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-flex": {
+		syntax: "<number>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "0",
+		appliesto: "directChildrenOfElementsWithDisplayMozBoxMozInlineBox",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-flex-group": {
+		syntax: "<integer>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "1",
+		appliesto: "inFlowChildrenOfBoxElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-lines": {
+		syntax: "single | multiple",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "single",
+		appliesto: "boxElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-ordinal-group": {
+		syntax: "<integer>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "1",
+		appliesto: "childrenOfBoxElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-orient": {
+		syntax: "horizontal | vertical | inline-axis | block-axis | inherit",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "inlineAxisHorizontalInXUL",
+		appliesto: "elementsWithDisplayBoxOrInlineBox",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-pack": {
+		syntax: "start | center | end | justify",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions",
+			"WebKit Extensions"
+		],
+		initial: "start",
+		appliesto: "elementsWithDisplayMozBoxMozInlineBox",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"box-shadow": {
+		syntax: "none | <shadow>#",
+		media: "visual",
+		inherited: false,
+		animationType: "shadowList",
+		percentages: "no",
+		groups: [
+			"CSS Backgrounds and Borders"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "absoluteLengthsSpecifiedColorAsSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"box-sizing": {
+		syntax: "content-box | border-box",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "content-box",
+		appliesto: "allElementsAcceptingWidthOrHeight",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"break-after": {
+		syntax: "auto | avoid | avoid-page | page | left | right | recto | verso | avoid-column | column | avoid-region | region",
+		media: "paged",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fragmentation"
+		],
+		initial: "auto",
+		appliesto: "blockLevelElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"break-before": {
+		syntax: "auto | avoid | avoid-page | page | left | right | recto | verso | avoid-column | column | avoid-region | region",
+		media: "paged",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fragmentation"
+		],
+		initial: "auto",
+		appliesto: "blockLevelElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"break-inside": {
+		syntax: "auto | avoid | avoid-page | avoid-column | avoid-region",
+		media: "paged",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fragmentation"
+		],
+		initial: "auto",
+		appliesto: "blockLevelElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"caption-side": {
+		syntax: "top | bottom | block-start | block-end | inline-start | inline-end",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Table"
+		],
+		initial: "top",
+		appliesto: "tableCaptionElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"caret-color": {
+		syntax: "auto | <color>",
+		media: "interactive",
+		inherited: true,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asAutoOrColor",
+		order: "perGrammar",
+		status: "standard"
+	},
+		clear: clear,
+		clip: clip,
+		"clip-path": {
+		syntax: "<clip-source> | [ <basic-shape> || <geometry-box> ] | none",
+		media: "visual",
+		inherited: false,
+		animationType: "basicShapeOtherwiseNo",
+		percentages: "referToReferenceBoxWhenSpecifiedOtherwiseBorderBox",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "none",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecifiedURLsAbsolute",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		color: color,
+		"color-adjust": {
+		syntax: "economy | exact",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Color"
+		],
+		initial: "economy",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-count": {
+		syntax: "<integer> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "integer",
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: "auto",
+		appliesto: "blockContainersExceptTableWrappers",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-fill": {
+		syntax: "auto | balance | balance-all",
+		media: "visualInContinuousMediaNoEffectInOverflowColumns",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: "balance",
+		appliesto: "multicolElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-gap": {
+		syntax: "normal | <length-percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Box Alignment"
+		],
+		initial: "normal",
+		appliesto: "multiColumnElementsFlexContainersGridContainers",
+		computed: "asSpecifiedWithLengthsAbsoluteAndNormalComputingToZeroExceptMultiColumn",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-rule": {
+		syntax: "<'column-rule-width'> || <'column-rule-style'> || <'column-rule-color'>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"column-rule-color",
+			"column-rule-style",
+			"column-rule-width"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: [
+			"column-rule-width",
+			"column-rule-style",
+			"column-rule-color"
+		],
+		appliesto: "multicolElements",
+		computed: [
+			"column-rule-color",
+			"column-rule-style",
+			"column-rule-width"
+		],
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-rule-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: "currentcolor",
+		appliesto: "multicolElements",
+		computed: "computedColor",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-rule-style": {
+		syntax: "<'border-style'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: "none",
+		appliesto: "multicolElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-rule-width": {
+		syntax: "<'border-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: "medium",
+		appliesto: "multicolElements",
+		computed: "absoluteLength0IfColumnRuleStyleNoneOrHidden",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-span": {
+		syntax: "none | all",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: "none",
+		appliesto: "inFlowBlockLevelElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"column-width": {
+		syntax: "<length> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Columns"
+		],
+		initial: "auto",
+		appliesto: "blockContainersExceptTableWrappers",
+		computed: "absoluteLengthZeroOrLarger",
+		order: "perGrammar",
+		status: "standard"
+	},
+		columns: columns,
+		contain: contain,
+		content: content,
+		"counter-increment": {
+		syntax: "[ <custom-ident> <integer>? ]+ | none",
+		media: "all",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Counter Styles"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"counter-reset": {
+		syntax: "[ <custom-ident> <integer>? ]+ | none",
+		media: "all",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Counter Styles"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		cursor: cursor,
+		direction: direction,
+		display: display,
+		"empty-cells": {
+		syntax: "show | hide",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Table"
+		],
+		initial: "show",
+		appliesto: "tableCellElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		filter: filter,
+		flex: flex,
+		"flex-basis": {
+		syntax: "content | <'width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToFlexContainersInnerMainSize",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "auto",
+		appliesto: "flexItemsAndInFlowPseudos",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "lengthOrPercentageBeforeKeywordIfBothPresent",
+		status: "standard"
+	},
+		"flex-direction": {
+		syntax: "row | row-reverse | column | column-reverse",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "row",
+		appliesto: "flexContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"flex-flow": {
+		syntax: "<'flex-direction'> || <'flex-wrap'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: [
+			"flex-direction",
+			"flex-wrap"
+		],
+		appliesto: "flexContainers",
+		computed: [
+			"flex-direction",
+			"flex-wrap"
+		],
+		order: "orderOfAppearance",
+		status: "standard"
+	},
+		"flex-grow": {
+		syntax: "<number>",
+		media: "visual",
+		inherited: false,
+		animationType: "number",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "0",
+		appliesto: "flexItemsAndInFlowPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"flex-shrink": {
+		syntax: "<number>",
+		media: "visual",
+		inherited: false,
+		animationType: "number",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "1",
+		appliesto: "flexItemsAndInFlowPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"flex-wrap": {
+		syntax: "nowrap | wrap | wrap-reverse",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "nowrap",
+		appliesto: "flexContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		float: float,
+		font: font,
+		"font-family": {
+		syntax: "[ <family-name> | <generic-family> ]#",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "dependsOnUserAgent",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-feature-settings": {
+		syntax: "normal | <feature-tag-value>#",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-kerning": {
+		syntax: "auto | normal | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-language-override": {
+		syntax: "normal | <string>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-optical-sizing": {
+		syntax: "auto | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variation-settings": {
+		syntax: "normal | [ <string> <number> ]#",
+		media: "visual",
+		inherited: true,
+		animationType: "transform",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "experimental"
+	},
+		"font-size": {
+		syntax: "<absolute-size> | <relative-size> | <length-percentage>",
+		media: "visual",
+		inherited: true,
+		animationType: "length",
+		percentages: "referToParentElementsFontSize",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-size-adjust": {
+		syntax: "none | <number>",
+		media: "visual",
+		inherited: true,
+		animationType: "number",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-stretch": {
+		syntax: "<font-stretch-absolute>",
+		media: "visual",
+		inherited: true,
+		animationType: "fontStretch",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-style": {
+		syntax: "normal | italic | oblique <angle>?",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-synthesis": {
+		syntax: "none | [ weight || style ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "weight style",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variant": {
+		syntax: "normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> || stylistic( <feature-value-name> ) || historical-forms || styleset( <feature-value-name># ) || character-variant( <feature-value-name># ) || swash( <feature-value-name> ) || ornaments( <feature-value-name> ) || annotation( <feature-value-name> ) || [ small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps ] || <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero || <east-asian-variant-values> || <east-asian-width-values> || ruby ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variant-alternates": {
+		syntax: "normal | [ stylistic( <feature-value-name> ) || historical-forms || styleset( <feature-value-name># ) || character-variant( <feature-value-name># ) || swash( <feature-value-name> ) || ornaments( <feature-value-name> ) || annotation( <feature-value-name> ) ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variant-caps": {
+		syntax: "normal | small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variant-east-asian": {
+		syntax: "normal | [ <east-asian-variant-values> || <east-asian-width-values> || ruby ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variant-ligatures": {
+		syntax: "normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variant-numeric": {
+		syntax: "normal | [ <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-variant-position": {
+		syntax: "normal | sub | super",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"font-weight": {
+		syntax: "<font-weight-absolute> | bolder | lighter",
+		media: "visual",
+		inherited: true,
+		animationType: "fontWeight",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "keywordOrNumericalValueBolderLighterTransformedToRealValue",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		gap: gap,
+		grid: grid,
+		"grid-area": {
+		syntax: "<grid-line> [ / <grid-line> ]{0,3}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: [
+			"grid-row-start",
+			"grid-column-start",
+			"grid-row-end",
+			"grid-column-end"
+		],
+		appliesto: "gridItemsAndBoxesWithinGridContainer",
+		computed: [
+			"grid-row-start",
+			"grid-column-start",
+			"grid-row-end",
+			"grid-column-end"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-auto-columns": {
+		syntax: "<track-size>+",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "auto",
+		appliesto: "gridContainers",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-auto-flow": {
+		syntax: "[ row | column ] || dense",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "row",
+		appliesto: "gridContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-auto-rows": {
+		syntax: "<track-size>+",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "auto",
+		appliesto: "gridContainers",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-column": {
+		syntax: "<grid-line> [ / <grid-line> ]?",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: [
+			"grid-column-start",
+			"grid-column-end"
+		],
+		appliesto: "gridItemsAndBoxesWithinGridContainer",
+		computed: [
+			"grid-column-start",
+			"grid-column-end"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-column-end": {
+		syntax: "<grid-line>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "auto",
+		appliesto: "gridItemsAndBoxesWithinGridContainer",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-column-gap": {
+		syntax: "<length-percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "0",
+		appliesto: "gridContainers",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "obsolete"
+	},
+		"grid-column-start": {
+		syntax: "<grid-line>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "auto",
+		appliesto: "gridItemsAndBoxesWithinGridContainer",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-gap": {
+		syntax: "<'grid-row-gap'> <'grid-column-gap'>?",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"grid-row-gap",
+			"grid-column-gap"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: [
+			"grid-row-gap",
+			"grid-column-gap"
+		],
+		appliesto: "gridContainers",
+		computed: [
+			"grid-row-gap",
+			"grid-column-gap"
+		],
+		order: "uniqueOrder",
+		status: "obsolete"
+	},
+		"grid-row": {
+		syntax: "<grid-line> [ / <grid-line> ]?",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: [
+			"grid-row-start",
+			"grid-row-end"
+		],
+		appliesto: "gridItemsAndBoxesWithinGridContainer",
+		computed: [
+			"grid-row-start",
+			"grid-row-end"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-row-end": {
+		syntax: "<grid-line>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "auto",
+		appliesto: "gridItemsAndBoxesWithinGridContainer",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-row-gap": {
+		syntax: "<length-percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "0",
+		appliesto: "gridContainers",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "obsolete"
+	},
+		"grid-row-start": {
+		syntax: "<grid-line>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "auto",
+		appliesto: "gridItemsAndBoxesWithinGridContainer",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-template": {
+		syntax: "none | [ <'grid-template-rows'> / <'grid-template-columns'> ] | [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: [
+			"grid-template-columns",
+			"grid-template-rows"
+		],
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: [
+			"grid-template-columns",
+			"grid-template-rows",
+			"grid-template-areas"
+		],
+		appliesto: "gridContainers",
+		computed: [
+			"grid-template-columns",
+			"grid-template-rows",
+			"grid-template-areas"
+		],
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-template-areas": {
+		syntax: "none | <string>+",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "none",
+		appliesto: "gridContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-template-columns": {
+		syntax: "none | <track-list> | <auto-track-list>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "none",
+		appliesto: "gridContainers",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"grid-template-rows": {
+		syntax: "none | <track-list> | <auto-track-list>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Grid Layout"
+		],
+		initial: "none",
+		appliesto: "gridContainers",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"hanging-punctuation": {
+		syntax: "none | [ first || [ force-end | allow-end ] || last ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		height: height,
+		hyphens: hyphens,
+		"image-orientation": {
+		syntax: "from-image | <angle> | [ <angle>? flip ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Images"
+		],
+		initial: "0deg",
+		appliesto: "allElements",
+		computed: "angleRoundedToNextQuarter",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"image-rendering": {
+		syntax: "auto | crisp-edges | pixelated",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Images"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"image-resolution": {
+		syntax: "[ from-image || <resolution> ] && snap?",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Images"
+		],
+		initial: "1dppx",
+		appliesto: "allElements",
+		computed: "asSpecifiedWithExceptionOfResolution",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"ime-mode": {
+		syntax: "auto | normal | active | inactive | disabled",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "auto",
+		appliesto: "textFields",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "obsolete"
+	},
+		"initial-letter": {
+		syntax: "normal | [ <number> <integer>? ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Inline"
+		],
+		initial: "normal",
+		appliesto: "firstLetterPseudoElementsAndInlineLevelFirstChildren",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"initial-letter-align": {
+		syntax: "[ auto | alphabetic | hanging | ideographic ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Inline"
+		],
+		initial: "auto",
+		appliesto: "firstLetterPseudoElementsAndInlineLevelFirstChildren",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"inline-size": {
+		syntax: "<'width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "inlineSizeOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "auto",
+		appliesto: "sameAsWidthAndHeight",
+		computed: "sameAsWidthAndHeight",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		isolation: isolation,
+		"justify-content": {
+		syntax: "normal | <content-distribution> | <overflow-position>? [ <content-position> | left | right ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "normal",
+		appliesto: "flexContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"justify-items": {
+		syntax: "normal | stretch | <baseline-position> | <overflow-position>? [ <self-position> | left | right ] | legacy | legacy && [ left | right | center ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Box Alignment"
+		],
+		initial: "legacy",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"justify-self": {
+		syntax: "auto | normal | stretch | <baseline-position> | <overflow-position>? [ <self-position> | left | right ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Box Alignment"
+		],
+		initial: "auto",
+		appliesto: "blockLevelBoxesAndAbsolutelyPositionedBoxesAndGridItems",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		left: left,
+		"letter-spacing": {
+		syntax: "normal | <length>",
+		media: "visual",
+		inherited: true,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "optimumValueOfAbsoluteLengthOrNormal",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line"
+		],
+		status: "standard"
+	},
+		"line-break": {
+		syntax: "auto | loose | normal | strict",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"line-clamp": {
+		syntax: "none | <integer>",
+		media: "visual",
+		inherited: false,
+		animationType: "integer",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "none",
+		appliesto: "blockContainersExceptMultiColumnContainers",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"line-height": {
+		syntax: "normal | <number> | <length> | <percentage>",
+		media: "visual",
+		inherited: true,
+		animationType: "numberOrLength",
+		percentages: "referToElementFontSize",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "absoluteLengthOrAsSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"line-height-step": {
+		syntax: "<length>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Fonts"
+		],
+		initial: "0",
+		appliesto: "blockContainerElements",
+		computed: "absoluteLength",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"list-style": {
+		syntax: "<'list-style-type'> || <'list-style-position'> || <'list-style-image'>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Lists and Counters"
+		],
+		initial: [
+			"list-style-type",
+			"list-style-position",
+			"list-style-image"
+		],
+		appliesto: "listItems",
+		computed: [
+			"list-style-image",
+			"list-style-position",
+			"list-style-type"
+		],
+		order: "orderOfAppearance",
+		status: "standard"
+	},
+		"list-style-image": {
+		syntax: "<url> | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Lists and Counters"
+		],
+		initial: "none",
+		appliesto: "listItems",
+		computed: "noneOrImageWithAbsoluteURI",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"list-style-position": {
+		syntax: "inside | outside",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Lists and Counters"
+		],
+		initial: "outside",
+		appliesto: "listItems",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"list-style-type": {
+		syntax: "<counter-style> | <string> | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Lists and Counters"
+		],
+		initial: "disc",
+		appliesto: "listItems",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		margin: margin,
+		"margin-block-end": {
+		syntax: "<'margin-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "dependsOnLayoutModel",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsMargin",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"margin-block-start": {
+		syntax: "<'margin-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "dependsOnLayoutModel",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsMargin",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"margin-bottom": {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"margin-inline-end": {
+		syntax: "<'margin-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "dependsOnLayoutModel",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsMargin",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"margin-inline-start": {
+		syntax: "<'margin-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "dependsOnLayoutModel",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsMargin",
+		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"margin-left": {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"margin-right": {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"margin-top": {
+		syntax: "<length> | <percentage> | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		mask: mask,
+		"mask-border": {
+		syntax: "<'mask-border-source'> || <'mask-border-slice'> [ / <'mask-border-width'>? [ / <'mask-border-outset'> ]? ]? || <'mask-border-repeat'> || <'mask-border-mode'>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"mask-border-mode",
+			"mask-border-outset",
+			"mask-border-repeat",
+			"mask-border-slice",
+			"mask-border-source",
+			"mask-border-width"
+		],
+		percentages: [
+			"mask-border-slice",
+			"mask-border-width"
+		],
+		groups: [
+			"CSS Masking"
+		],
+		initial: [
+			"mask-border-mode",
+			"mask-border-outset",
+			"mask-border-repeat",
+			"mask-border-slice",
+			"mask-border-source",
+			"mask-border-width"
+		],
+		appliesto: "allElementsSVGContainerElements",
+		computed: [
+			"mask-border-mode",
+			"mask-border-outset",
+			"mask-border-repeat",
+			"mask-border-slice",
+			"mask-border-source",
+			"mask-border-width"
+		],
+		order: "perGrammar",
+		stacking: true,
+		status: "experimental"
+	},
+		"mask-border-mode": {
+		syntax: "luminance | alpha",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "alpha",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"mask-border-outset": {
+		syntax: "[ <length> | <number> ]{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "0",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"mask-border-repeat": {
+		syntax: "[ stretch | repeat | round | space ]{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "stretch",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"mask-border-slice": {
+		syntax: "<number-percentage>{1,4} fill?",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "referToSizeOfMaskBorderImage",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "0",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"mask-border-source": {
+		syntax: "none | <image>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "none",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecifiedURLsAbsolute",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"mask-border-width": {
+		syntax: "[ <length-percentage> | <number> | auto ]{1,4}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "relativeToMaskBorderImageArea",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "auto",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"mask-clip": {
+		syntax: "[ <geometry-box> | no-clip ]#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "border-box",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-composite": {
+		syntax: "<compositing-operator>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "add",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-image": {
+		syntax: "<mask-reference>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "none",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecifiedURLsAbsolute",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-mode": {
+		syntax: "<masking-mode>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "match-source",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-origin": {
+		syntax: "<geometry-box>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "border-box",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-position": {
+		syntax: "<position>#",
+		media: "visual",
+		inherited: false,
+		animationType: "repeatableListOfSimpleListOfLpc",
+		percentages: "referToSizeOfMaskPaintingArea",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "center",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "consistsOfTwoKeywordsForOriginAndOffsets",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-repeat": {
+		syntax: "<repeat-style>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "no-repeat",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "consistsOfTwoDimensionKeywords",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-size": {
+		syntax: "<bg-size>#",
+		media: "visual",
+		inherited: false,
+		animationType: "repeatableListOfSimpleListOfLpc",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "auto",
+		appliesto: "allElementsSVGContainerElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"mask-type": {
+		syntax: "luminance | alpha",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Masking"
+		],
+		initial: "luminance",
+		appliesto: "maskElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"max-block-size": {
+		syntax: "<'max-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "blockSizeOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsWidthAndHeight",
+		computed: "sameAsMaxWidthAndMaxHeight",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"max-height": {
+		syntax: "<length> | <percentage> | none | max-content | min-content | fit-content | fill-available",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentagesNone",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "none",
+		appliesto: "allElementsButNonReplacedAndTableColumns",
+		computed: "percentageAsSpecifiedAbsoluteLengthOrNone",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"max-inline-size": {
+		syntax: "<'max-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "inlineSizeOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsWidthAndHeight",
+		computed: "sameAsMaxWidthAndMaxHeight",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"max-lines": {
+		syntax: "none | <integer>",
+		media: "visual",
+		inherited: false,
+		animationType: "integer",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "none",
+		appliesto: "blockContainersExceptMultiColumnContainers",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"max-width": {
+		syntax: "<length> | <percentage> | none | max-content | min-content | fit-content | fill-available",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "none",
+		appliesto: "allElementsButNonReplacedAndTableRows",
+		computed: "percentageAsSpecifiedAbsoluteLengthOrNone",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"min-block-size": {
+		syntax: "<'min-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "blockSizeOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsWidthAndHeight",
+		computed: "sameAsMinWidthAndMinHeight",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"min-height": {
+		syntax: "<length> | <percentage> | auto | max-content | min-content | fit-content | fill-available",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentages0",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsButNonReplacedAndTableColumns",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"min-inline-size": {
+		syntax: "<'min-width'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "inlineSizeOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "sameAsWidthAndHeight",
+		computed: "sameAsMinWidthAndMinHeight",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"min-width": {
+		syntax: "<length> | <percentage> | auto | max-content | min-content | fit-content | fill-available",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsButNonReplacedAndTableRows",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"mix-blend-mode": {
+		syntax: "<blend-mode>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Compositing and Blending"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		stacking: true,
+		status: "standard"
+	},
+		"object-fit": {
+		syntax: "fill | contain | cover | none | scale-down",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Images"
+		],
+		initial: "fill",
+		appliesto: "replacedElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"object-position": {
+		syntax: "<position>",
+		media: "visual",
+		inherited: true,
+		animationType: "repeatableListOfSimpleListOfLpc",
+		percentages: "referToWidthAndHeightOfElement",
+		groups: [
+			"CSS Images"
+		],
+		initial: "50% 50%",
+		appliesto: "replacedElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		offset: offset,
+		"offset-anchor": {
+		syntax: "auto | <position>",
+		media: "visual",
+		inherited: false,
+		animationType: "position",
+		percentages: "relativeToWidthAndHeight",
+		groups: [
+			"CSS Motion"
+		],
+		initial: "auto",
+		appliesto: "transformableElements",
+		computed: "forLengthAbsoluteValueOtherwisePercentage",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"offset-block-end": {
+		syntax: "<'left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalHeightOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "sameAsBoxOffsets",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"offset-block-start": {
+		syntax: "<'left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalHeightOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "sameAsBoxOffsets",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"offset-inline-end": {
+		syntax: "<'left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "sameAsBoxOffsets",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"offset-inline-start": {
+		syntax: "<'left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "sameAsBoxOffsets",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"offset-distance": {
+		syntax: "<length-percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToTotalPathLength",
+		groups: [
+			"CSS Motion"
+		],
+		initial: "0",
+		appliesto: "transformableElements",
+		computed: "forLengthAbsoluteValueOtherwisePercentage",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"offset-path": {
+		syntax: "none | ray( [ <angle> && <size>? && contain? ] ) | <path()> | <url> | [ <basic-shape> || <geometry-box> ]",
+		media: "visual",
+		inherited: false,
+		animationType: "angleOrBasicShapeOrPath",
+		percentages: "no",
+		groups: [
+			"CSS Motion"
+		],
+		initial: "none",
+		appliesto: "transformableElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		stacking: true,
+		status: "experimental"
+	},
+		"offset-position": {
+		syntax: "auto | <position>",
+		media: "visual",
+		inherited: false,
+		animationType: "position",
+		percentages: "referToSizeOfContainingBlock",
+		groups: [
+			"CSS Motion"
+		],
+		initial: "auto",
+		appliesto: "transformableElements",
+		computed: "forLengthAbsoluteValueOtherwisePercentage",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"offset-rotate": {
+		syntax: "[ auto | reverse ] || <angle>",
+		media: "visual",
+		inherited: false,
+		animationType: "angle",
+		percentages: "no",
+		groups: [
+			"CSS Motion"
+		],
+		initial: "auto",
+		appliesto: "transformableElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		opacity: opacity,
+		order: order,
+		orphans: orphans,
+		outline: outline,
+		"outline-color": {
+		syntax: "<color> | invert",
+		media: [
+			"visual",
+			"interactive"
+		],
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "invertOrCurrentColor",
+		appliesto: "allElements",
+		computed: "invertForTranslucentColorRGBAOtherwiseRGB",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"outline-offset": {
+		syntax: "<length>",
+		media: [
+			"visual",
+			"interactive"
+		],
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"outline-style": {
+		syntax: "auto | <br-style>",
+		media: [
+			"visual",
+			"interactive"
+		],
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"outline-width": {
+		syntax: "<br-width>",
+		media: [
+			"visual",
+			"interactive"
+		],
+		inherited: false,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "medium",
+		appliesto: "allElements",
+		computed: "absoluteLength0ForNone",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		overflow: overflow,
+		"overflow-anchor": {
+		syntax: "auto | none",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Scroll Anchoring"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"overflow-block": {
+		syntax: "<'overflow'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "auto",
+		appliesto: "blockContainersFlexContainersGridContainers",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"overflow-clip-box": {
+		syntax: "padding-box | content-box",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Mozilla Extensions"
+		],
+		initial: "padding-box",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"overflow-inline": {
+		syntax: "<'overflow'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "auto",
+		appliesto: "blockContainersFlexContainersGridContainers",
+		computed: "asSpecified",
+		order: "perGrammar",
+		status: "experimental"
+	},
+		"overflow-wrap": {
+		syntax: "normal | break-word",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"overflow-x": {
+		syntax: "visible | hidden | clip | scroll | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "visible",
+		appliesto: "blockContainersFlexContainersGridContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"overflow-y": {
+		syntax: "visible | hidden | clip | scroll | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Overflow"
+		],
+		initial: "visible",
+		appliesto: "blockContainersFlexContainersGridContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"overscroll-behavior": {
+		syntax: "[ contain | none | auto ]{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "auto",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"overscroll-behavior-x": {
+		syntax: "contain | none | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "auto",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"overscroll-behavior-y": {
+		syntax: "contain | none | auto",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "auto",
+		appliesto: "nonReplacedBlockAndInlineBlockElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		padding: padding,
+		"padding-block-end": {
+		syntax: "<'padding-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"padding-block-start": {
+		syntax: "<'padding-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"padding-bottom": {
+		syntax: "<length> | <percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptInternalTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"padding-inline-end": {
+		syntax: "<'padding-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"padding-inline-start": {
+		syntax: "<'padding-left'>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "logicalWidthOfContainingBlock",
+		groups: [
+			"CSS Logical Properties"
+		],
+		initial: "0",
+		appliesto: "allElements",
+		computed: "asLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"padding-left": {
+		syntax: "<length> | <percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptInternalTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"padding-right": {
+		syntax: "<length> | <percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptInternalTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"padding-top": {
+		syntax: "<length> | <percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Box Model"
+		],
+		initial: "0",
+		appliesto: "allElementsExceptInternalTableDisplayTypes",
+		computed: "percentageAsSpecifiedOrAbsoluteLength",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter"
+		],
+		status: "standard"
+	},
+		"page-break-after": {
+		syntax: "auto | always | avoid | left | right | recto | verso",
+		media: [
+			"visual",
+			"paged"
+		],
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Pages"
+		],
+		initial: "auto",
+		appliesto: "blockElementsInNormalFlow",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"page-break-before": {
+		syntax: "auto | always | avoid | left | right | recto | verso",
+		media: [
+			"visual",
+			"paged"
+		],
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Pages"
+		],
+		initial: "auto",
+		appliesto: "blockElementsInNormalFlow",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"page-break-inside": {
+		syntax: "auto | avoid",
+		media: [
+			"visual",
+			"paged"
+		],
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Pages"
+		],
+		initial: "auto",
+		appliesto: "blockElementsInNormalFlow",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"paint-order": {
+		syntax: "normal | [ fill || stroke || markers ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "normal",
+		appliesto: "textElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		perspective: perspective,
+		"perspective-origin": {
+		syntax: "<position>",
+		media: "visual",
+		inherited: false,
+		animationType: "simpleListOfLpc",
+		percentages: "referToSizeOfBoundingBox",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "50% 50%",
+		appliesto: "transformableElements",
+		computed: "forLengthAbsoluteValueOtherwisePercentage",
+		order: "oneOrTwoValuesLengthAbsoluteKeywordsPercentages",
+		status: "standard"
+	},
+		"place-content": {
+		syntax: "<'align-content'> <'justify-content'>?",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Flexible Box Layout"
+		],
+		initial: "normal",
+		appliesto: "multilineFlexContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"pointer-events": {
+		syntax: "auto | none | visiblePainted | visibleFill | visibleStroke | visible | painted | fill | stroke | all | inherit",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Pointer Events"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		position: position,
+		quotes: quotes,
+		resize: resize,
+		right: right,
+		rotate: rotate,
+		"row-gap": {
+		syntax: "normal | <length-percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToDimensionOfContentArea",
+		groups: [
+			"CSS Box Alignment"
+		],
+		initial: "normal",
+		appliesto: "multiColumnElementsFlexContainersGridContainers",
+		computed: "asSpecifiedWithLengthsAbsoluteAndNormalComputingToZeroExceptMultiColumn",
+		order: "perGrammar",
+		status: "standard"
+	},
+		"ruby-align": {
+		syntax: "start | center | space-between | space-around",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Ruby"
+		],
+		initial: "space-around",
+		appliesto: "rubyBasesAnnotationsBaseAnnotationContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"ruby-merge": {
+		syntax: "separate | collapse | auto",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Ruby"
+		],
+		initial: "separate",
+		appliesto: "rubyAnnotationsContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"ruby-position": {
+		syntax: "over | under | inter-character",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Ruby"
+		],
+		initial: "over",
+		appliesto: "rubyAnnotationsContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		scale: scale,
+		"scroll-behavior": {
+		syntax: "auto | smooth",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSSOM View"
+		],
+		initial: "auto",
+		appliesto: "scrollingBoxes",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"scroll-snap-coordinate": {
+		syntax: "none | <position>#",
+		media: "interactive",
+		inherited: false,
+		animationType: "position",
+		percentages: "referToBorderBox",
+		groups: [
+			"CSS Scroll Snap"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"scroll-snap-destination": {
+		syntax: "<position>",
+		media: "interactive",
+		inherited: false,
+		animationType: "position",
+		percentages: "relativeToScrollContainerPaddingBoxAxis",
+		groups: [
+			"CSS Scroll Snap"
+		],
+		initial: "0px 0px",
+		appliesto: "scrollContainers",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"scroll-snap-points-x": {
+		syntax: "none | repeat( <length-percentage> )",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "relativeToScrollContainerPaddingBoxAxis",
+		groups: [
+			"CSS Scroll Snap"
+		],
+		initial: "none",
+		appliesto: "scrollContainers",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "obsolete"
+	},
+		"scroll-snap-points-y": {
+		syntax: "none | repeat( <length-percentage> )",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "relativeToScrollContainerPaddingBoxAxis",
+		groups: [
+			"CSS Scroll Snap"
+		],
+		initial: "none",
+		appliesto: "scrollContainers",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "obsolete"
+	},
+		"scroll-snap-type": {
+		syntax: "none | mandatory | proximity",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Scroll Snap"
+		],
+		initial: "none",
+		appliesto: "scrollContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"scroll-snap-type-x": {
+		syntax: "none | mandatory | proximity",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Scroll Snap"
+		],
+		initial: "none",
+		appliesto: "scrollContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"scroll-snap-type-y": {
+		syntax: "none | mandatory | proximity",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Scroll Snap"
+		],
+		initial: "none",
+		appliesto: "scrollContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"shape-image-threshold": {
+		syntax: "<number>",
+		media: "visual",
+		inherited: false,
+		animationType: "number",
+		percentages: "no",
+		groups: [
+			"CSS Shapes"
+		],
+		initial: "0.0",
+		appliesto: "floats",
+		computed: "specifiedValueNumberClipped0To1",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"shape-margin": {
+		syntax: "<length-percentage>",
+		media: "visual",
+		inherited: false,
+		animationType: "lpc",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Shapes"
+		],
+		initial: "0",
+		appliesto: "floats",
+		computed: "asSpecifiedRelativeToAbsoluteLengths",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"shape-outside": {
+		syntax: "none | <shape-box> || <basic-shape> | <image>",
+		media: "visual",
+		inherited: false,
+		animationType: "basicShapeOtherwiseNo",
+		percentages: "no",
+		groups: [
+			"CSS Shapes"
+		],
+		initial: "none",
+		appliesto: "floats",
+		computed: "asDefinedForBasicShapeWithAbsoluteURIOtherwiseAsSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"tab-size": {
+		syntax: "<integer> | <length>",
+		media: "visual",
+		inherited: true,
+		animationType: "length",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "8",
+		appliesto: "blockContainers",
+		computed: "specifiedIntegerOrAbsoluteLength",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"table-layout": {
+		syntax: "auto | fixed",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Table"
+		],
+		initial: "auto",
+		appliesto: "tableElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-align": {
+		syntax: "start | end | left | right | center | justify | match-parent",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "startOrNamelessValueIfLTRRightIfRTL",
+		appliesto: "blockContainers",
+		computed: "asSpecifiedExceptMatchParent",
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-align-last": {
+		syntax: "auto | start | end | left | right | center | justify",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "auto",
+		appliesto: "blockContainers",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-combine-upright": {
+		syntax: "none | all | [ digits <integer>? ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Writing Modes"
+		],
+		initial: "none",
+		appliesto: "nonReplacedInlineElements",
+		computed: "keywordPlusIntegerIfDigits",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-decoration": {
+		syntax: "<'text-decoration-line'> || <'text-decoration-style'> || <'text-decoration-color'>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"text-decoration-color",
+			"text-decoration-style",
+			"text-decoration-line"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: [
+			"text-decoration-color",
+			"text-decoration-style",
+			"text-decoration-line"
+		],
+		appliesto: "allElements",
+		computed: [
+			"text-decoration-line",
+			"text-decoration-style",
+			"text-decoration-color"
+		],
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-decoration-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-decoration-line": {
+		syntax: "none | [ underline || overline || line-through || blink ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-decoration-skip": {
+		syntax: "none | [ objects || [ spaces | [ leading-spaces || trailing-spaces ] ] || edges || box-decoration ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "objects",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "experimental"
+	},
+		"text-decoration-skip-ink": {
+		syntax: "auto | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "experimental"
+	},
+		"text-decoration-style": {
+		syntax: "solid | double | dotted | dashed | wavy",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "solid",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-emphasis": {
+		syntax: "<'text-emphasis-style'> || <'text-emphasis-color'>",
+		media: "visual",
+		inherited: false,
+		animationType: [
+			"text-emphasis-color",
+			"text-emphasis-style"
+		],
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: [
+			"text-emphasis-style",
+			"text-emphasis-color"
+		],
+		appliesto: "allElements",
+		computed: [
+			"text-emphasis-style",
+			"text-emphasis-color"
+		],
+		order: "orderOfAppearance",
+		status: "standard"
+	},
+		"text-emphasis-color": {
+		syntax: "<color>",
+		media: "visual",
+		inherited: false,
+		animationType: "color",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "currentcolor",
+		appliesto: "allElements",
+		computed: "computedColor",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-emphasis-position": {
+		syntax: "[ over | under ] && [ right | left ]",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "over right",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-emphasis-style": {
+		syntax: "none | [ [ filled | open ] || [ dot | circle | double-circle | triangle | sesame ] ] | <string>",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-indent": {
+		syntax: "<length-percentage> && hanging? && each-line?",
+		media: "visual",
+		inherited: true,
+		animationType: "lpc",
+		percentages: "referToWidthOfContainingBlock",
+		groups: [
+			"CSS Text"
+		],
+		initial: "0",
+		appliesto: "blockContainers",
+		computed: "percentageOrAbsoluteLengthPlusKeywords",
+		order: "lengthOrPercentageBeforeKeywords",
+		status: "standard"
+	},
+		"text-justify": {
+		syntax: "auto | inter-character | inter-word | none",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "auto",
+		appliesto: "inlineLevelAndTableCellElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-orientation": {
+		syntax: "mixed | upright | sideways",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Writing Modes"
+		],
+		initial: "mixed",
+		appliesto: "allElementsExceptTableRowGroupsRowsColumnGroupsAndColumns",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-overflow": {
+		syntax: "[ clip | ellipsis | <string> ]{1,2}",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "clip",
+		appliesto: "blockContainerElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-rendering": {
+		syntax: "auto | optimizeSpeed | optimizeLegibility | geometricPrecision",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Miscellaneous"
+		],
+		initial: "auto",
+		appliesto: "textElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"text-shadow": {
+		syntax: "none | <shadow-t>#",
+		media: "visual",
+		inherited: true,
+		animationType: "shadowList",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "colorPlusThreeAbsoluteLengths",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-size-adjust": {
+		syntax: "none | auto | <percentage>",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "referToSizeOfFont",
+		groups: [
+			"CSS Text"
+		],
+		initial: "autoForSmartphoneBrowsersSupportingInflation",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "experimental"
+	},
+		"text-transform": {
+		syntax: "none | capitalize | uppercase | lowercase | full-width",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "none",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"text-underline-position": {
+		syntax: "auto | [ under || [ left | right ] ]",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text Decoration"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "orderOfAppearance",
+		status: "standard"
+	},
+		top: top,
+		"touch-action": {
+		syntax: "auto | none | [ [ pan-x | pan-left | pan-right ] || [ pan-y | pan-up | pan-down ] || pinch-zoom ] | manipulation",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"Pointer Events"
+		],
+		initial: "auto",
+		appliesto: "allElementsExceptNonReplacedInlineElementsTableRowsColumnsRowColumnGroups",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		transform: transform,
+		"transform-box": {
+		syntax: "border-box | fill-box | view-box",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "border-box ",
+		appliesto: "transformableElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"transform-origin": {
+		syntax: "[ <length-percentage> | left | center | right | top | bottom ] | [ [ <length-percentage> | left | center | right ] && [ <length-percentage> | top | center | bottom ] ] <length>?",
+		media: "visual",
+		inherited: false,
+		animationType: "simpleListOfLpc",
+		percentages: "referToSizeOfBoundingBox",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "50% 50% 0",
+		appliesto: "transformableElements",
+		computed: "forLengthAbsoluteValueOtherwisePercentage",
+		order: "oneOrTwoValuesLengthAbsoluteKeywordsPercentages",
+		status: "standard"
+	},
+		"transform-style": {
+		syntax: "flat | preserve-3d",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transforms"
+		],
+		initial: "flat",
+		appliesto: "transformableElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		stacking: true,
+		status: "standard"
+	},
+		transition: transition,
+		"transition-delay": {
+		syntax: "<time>#",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transitions"
+		],
+		initial: "0s",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"transition-duration": {
+		syntax: "<time>#",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transitions"
+		],
+		initial: "0s",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"transition-property": {
+		syntax: "none | <single-transition-property>#",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transitions"
+		],
+		initial: "all",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"transition-timing-function": {
+		syntax: "<single-transition-timing-function>#",
+		media: "interactive",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Transitions"
+		],
+		initial: "ease",
+		appliesto: "allElementsAndPseudos",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		translate: translate,
+		"unicode-bidi": {
+		syntax: "normal | embed | isolate | bidi-override | isolate-override | plaintext",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Writing Modes"
+		],
+		initial: "normal",
+		appliesto: "allElementsSomeValuesNoEffectOnNonInlineElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"user-select": {
+		syntax: "auto | text | none | contain | all",
+		media: "visual",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Basic User Interface"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "nonstandard"
+	},
+		"vertical-align": {
+		syntax: "baseline | sub | super | text-top | text-bottom | middle | top | bottom | <percentage> | <length>",
+		media: "visual",
+		inherited: false,
+		animationType: "length",
+		percentages: "referToLineHeight",
+		groups: [
+			"CSS Table"
+		],
+		initial: "baseline",
+		appliesto: "inlineLevelAndTableCellElements",
+		computed: "absoluteLengthOrKeyword",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		visibility: visibility,
+		"white-space": {
+		syntax: "normal | pre | nowrap | pre-wrap | pre-line",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		widows: widows,
+		width: width,
+		"will-change": {
+		syntax: "auto | <animateable-feature>#",
+		media: "all",
+		inherited: false,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Will Change"
+		],
+		initial: "auto",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"word-break": {
+		syntax: "normal | break-all | keep-all | break-word",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"word-spacing": {
+		syntax: "normal | <length-percentage>",
+		media: "visual",
+		inherited: true,
+		animationType: "length",
+		percentages: "referToWidthOfAffectedGlyph",
+		groups: [
+			"CSS Text"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "optimumMinAndMaxValueOfAbsoluteLengthPercentageOrNormal",
+		order: "uniqueOrder",
+		alsoAppliesTo: [
+			"::first-letter",
+			"::first-line",
+			"::placeholder"
+		],
+		status: "standard"
+	},
+		"word-wrap": {
+		syntax: "normal | break-word",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Text"
+		],
+		initial: "normal",
+		appliesto: "allElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"writing-mode": {
+		syntax: "horizontal-tb | vertical-rl | vertical-lr | sideways-rl | sideways-lr",
+		media: "visual",
+		inherited: true,
+		animationType: "discrete",
+		percentages: "no",
+		groups: [
+			"CSS Writing Modes"
+		],
+		initial: "horizontal-tb",
+		appliesto: "allElementsExceptTableRowColumnGroupsTableRowsColumns",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		status: "standard"
+	},
+		"z-index": {
+		syntax: "auto | <integer>",
+		media: "visual",
+		inherited: false,
+		animationType: "integer",
+		percentages: "no",
+		groups: [
+			"CSS Positioning"
+		],
+		initial: "auto",
+		appliesto: "positionedElements",
+		computed: "asSpecified",
+		order: "uniqueOrder",
+		stacking: true,
+		status: "standard"
+	},
+		zoom: zoom
+	};
+
+	var properties$2 = /*#__PURE__*/Object.freeze({
+		all: all,
+		animation: animation,
+		appearance: appearance,
+		azimuth: azimuth,
+		background: background,
+		border: border,
+		bottom: bottom,
+		clear: clear,
+		clip: clip,
+		color: color,
+		columns: columns,
+		contain: contain,
+		content: content,
+		cursor: cursor,
+		direction: direction,
+		display: display,
+		filter: filter,
+		flex: flex,
+		float: float,
+		font: font,
+		gap: gap,
+		grid: grid,
+		height: height,
+		hyphens: hyphens,
+		isolation: isolation,
+		left: left,
+		margin: margin,
+		mask: mask,
+		offset: offset,
+		opacity: opacity,
+		order: order,
+		orphans: orphans,
+		outline: outline,
+		overflow: overflow,
+		padding: padding,
+		perspective: perspective,
+		position: position,
+		quotes: quotes,
+		resize: resize,
+		right: right,
+		rotate: rotate,
+		scale: scale,
+		top: top,
+		transform: transform,
+		transition: transition,
+		translate: translate,
+		visibility: visibility,
+		widows: widows,
+		width: width,
+		zoom: zoom,
+		default: properties$1
+	});
+
+	var attachment = {
+		syntax: "scroll | fixed | local"
+	};
+	var box = {
+		syntax: "border-box | padding-box | content-box"
+	};
+	var color$1 = {
+		syntax: "<rgb()> | <rgba()> | <hsl()> | <hsla()> | <hex-color> | <named-color> | currentcolor | <deprecated-system-color>"
+	};
+	var gradient = {
+		syntax: "<linear-gradient()> | <repeating-linear-gradient()> | <radial-gradient()> | <repeating-radial-gradient()>"
+	};
+	var hue = {
+		syntax: "<number> | <angle>"
+	};
+	var image = {
+		syntax: "<url> | <image()> | <image-set()> | <element()> | <cross-fade()> | <gradient>"
+	};
+	var nth = {
+		syntax: "<an-plus-b> | even | odd"
+	};
+	var position$1 = {
+		syntax: "[ [ left | center | right ] || [ top | center | bottom ] | [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]? | [ [ left | right ] <length-percentage> ] && [ [ top | bottom ] <length-percentage> ] ]"
+	};
+	var quote = {
+		syntax: "open-quote | close-quote | no-open-quote | no-close-quote"
+	};
+	var shadow = {
+		syntax: "inset? && <length>{2,4} && <color>?"
+	};
+	var shape$1 = {
+		syntax: "rect(<top>, <right>, <bottom>, <left>)"
+	};
+	var size = {
+		syntax: "closest-side | farthest-side | closest-corner | farthest-corner | <length> | <length-percentage>{2}"
+	};
+	var symbol = {
+		syntax: "<string> | <image> | <custom-ident>"
+	};
+	var target = {
+		syntax: "<target-counter()> | <target-counters()> | <target-text()>"
+	};
+	var syntaxes = {
+		"absolute-size": {
+		syntax: "xx-small | x-small | small | medium | large | x-large | xx-large"
+	},
+		"alpha-value": {
+		syntax: "<number> | <percentage>"
+	},
+		"angle-percentage": {
+		syntax: "<angle> | <percentage>"
+	},
+		"animateable-feature": {
+		syntax: "scroll-position | contents | <custom-ident>"
+	},
+		attachment: attachment,
+		"attr()": {
+		syntax: "attr( <attr-name> <type-or-unit>? [, <attr-fallback> ]? )"
+	},
+		"attr-matcher": {
+		syntax: "[ '~' | '|' | '^' | '$' | '*' ]? '='"
+	},
+		"attr-modifier": {
+		syntax: "i"
+	},
+		"attribute-selector": {
+		syntax: "'[' <wq-name> ']' | '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'"
+	},
+		"auto-repeat": {
+		syntax: "repeat( [ auto-fill | auto-fit ] , [ <line-names>? <fixed-size> ]+ <line-names>? )"
+	},
+		"auto-track-list": {
+		syntax: "[ <line-names>? [ <fixed-size> | <fixed-repeat> ] ]* <line-names>? <auto-repeat>\n[ <line-names>? [ <fixed-size> | <fixed-repeat> ] ]* <line-names>?"
+	},
+		"baseline-position": {
+		syntax: "[ first | last ]? baseline"
+	},
+		"basic-shape": {
+		syntax: "<inset()> | <circle()> | <ellipse()> | <polygon()>"
+	},
+		"bg-image": {
+		syntax: "none | <image>"
+	},
+		"bg-layer": {
+		syntax: "<bg-image> || <bg-position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box>"
+	},
+		"bg-position": {
+		syntax: "[ [ left | center | right | top | bottom | <length-percentage> ] | [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ] | [ center | [ left | right ] <length-percentage>? ] && [ center | [ top | bottom ] <length-percentage>? ] ]"
+	},
+		"bg-size": {
+		syntax: "[ <length-percentage> | auto ]{1,2} | cover | contain"
+	},
+		"blur()": {
+		syntax: "blur( <length> )"
+	},
+		"blend-mode": {
+		syntax: "normal | multiply | screen | overlay | darken | lighten | color-dodge | color-burn | hard-light | soft-light | difference | exclusion | hue | saturation | color | luminosity"
+	},
+		box: box,
+		"br-style": {
+		syntax: "none | hidden | dotted | dashed | solid | double | groove | ridge | inset | outset"
+	},
+		"br-width": {
+		syntax: "<length> | thin | medium | thick"
+	},
+		"brightness()": {
+		syntax: "brightness( <number-percentage> )"
+	},
+		"calc()": {
+		syntax: "calc( <calc-sum> )"
+	},
+		"calc-sum": {
+		syntax: "<calc-product> [ [ '+' | '-' ] <calc-product> ]*"
+	},
+		"calc-product": {
+		syntax: "<calc-value> [ '*' <calc-value> | '/' <number> ]*"
+	},
+		"calc-value": {
+		syntax: "<number> | <dimension> | <percentage> | ( <calc-sum> )"
+	},
+		"cf-final-image": {
+		syntax: "<image> | <color>"
+	},
+		"cf-mixing-image": {
+		syntax: "<percentage>? && <image>"
+	},
+		"circle()": {
+		syntax: "circle( [ <shape-radius> ]? [ at <position> ]? )"
+	},
+		"class-selector": {
+		syntax: "'.' <ident-token>"
+	},
+		"clip-source": {
+		syntax: "<url>"
+	},
+		color: color$1,
+		"color-stop": {
+		syntax: "<color> <length-percentage>?"
+	},
+		"color-stop-list": {
+		syntax: "<color-stop>#{2,}"
+	},
+		"common-lig-values": {
+		syntax: "[ common-ligatures | no-common-ligatures ]"
+	},
+		"composite-style": {
+		syntax: "clear | copy | source-over | source-in | source-out | source-atop | destination-over | destination-in | destination-out | destination-atop | xor"
+	},
+		"compositing-operator": {
+		syntax: "add | subtract | intersect | exclude"
+	},
+		"compound-selector": {
+		syntax: "[ <type-selector>? <subclass-selector>* [ <pseudo-element-selector> <pseudo-class-selector>* ]* ]!"
+	},
+		"compound-selector-list": {
+		syntax: "<compound-selector>#"
+	},
+		"contextual-alt-values": {
+		syntax: "[ contextual | no-contextual ]"
+	},
+		"content-distribution": {
+		syntax: "space-between | space-around | space-evenly | stretch"
+	},
+		"content-list": {
+		syntax: "[ <string> | contents | <image> | <quote> | <target> | <leader()> ]+"
+	},
+		"content-position": {
+		syntax: "center | start | end | flex-start | flex-end"
+	},
+		"content-replacement": {
+		syntax: "<image>"
+	},
+		"contrast()": {
+		syntax: "contrast( [ <number-percentage> ] )"
+	},
+		"counter-style": {
+		syntax: "<counter-style-name> | symbols()"
+	},
+		"counter-style-name": {
+		syntax: "<custom-ident>"
+	},
+		"cross-fade()": {
+		syntax: "cross-fade( <cf-mixing-image> , <cf-final-image>? )"
+	},
+		"cubic-bezier-timing-function": {
+		syntax: "ease | ease-in | ease-out | ease-in-out | cubic-bezier(<number>, <number>, <number>, <number>)"
+	},
+		"deprecated-system-color": {
+		syntax: "ActiveBorder | ActiveCaption | AppWorkspace | Background | ButtonFace | ButtonHighlight | ButtonShadow | ButtonText | CaptionText | GrayText | Highlight | HighlightText | InactiveBorder | InactiveCaption | InactiveCaptionText | InfoBackground | InfoText | Menu | MenuText | Scrollbar | ThreeDDarkShadow | ThreeDFace | ThreeDHighlight | ThreeDLightShadow | ThreeDShadow | Window | WindowFrame | WindowText"
+	},
+		"discretionary-lig-values": {
+		syntax: "[ discretionary-ligatures | no-discretionary-ligatures ]"
+	},
+		"display-box": {
+		syntax: "contents | none"
+	},
+		"display-inside": {
+		syntax: "flow | flow-root | table | flex | grid | subgrid | ruby"
+	},
+		"display-internal": {
+		syntax: "table-row-group | table-header-group | table-footer-group | table-row | table-cell | table-column-group | table-column | table-caption | ruby-base | ruby-text | ruby-base-container | ruby-text-container"
+	},
+		"display-legacy": {
+		syntax: "inline-block | inline-list-item | inline-table | inline-flex | inline-grid"
+	},
+		"display-listitem": {
+		syntax: "<display-outside>? && [ flow | flow-root ]? && list-item"
+	},
+		"display-outside": {
+		syntax: "block | inline | run-in"
+	},
+		"drop-shadow()": {
+		syntax: "drop-shadow( <length>{2,3} <color>? )"
+	},
+		"east-asian-variant-values": {
+		syntax: "[ jis78 | jis83 | jis90 | jis04 | simplified | traditional ]"
+	},
+		"east-asian-width-values": {
+		syntax: "[ full-width | proportional-width ]"
+	},
+		"element()": {
+		syntax: "element( <id-selector> )"
+	},
+		"ellipse()": {
+		syntax: "ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )"
+	},
+		"ending-shape": {
+		syntax: "circle | ellipse"
+	},
+		"explicit-track-list": {
+		syntax: "[ <line-names>? <track-size> ]+ <line-names>?"
+	},
+		"family-name": {
+		syntax: "<string> | <custom-ident>+"
+	},
+		"feature-tag-value": {
+		syntax: "<string> [ <integer> | on | off ]?"
+	},
+		"feature-type": {
+		syntax: "@stylistic | @historical-forms | @styleset | @character-variant | @swash | @ornaments | @annotation"
+	},
+		"feature-value-block": {
+		syntax: "<feature-type> {\n  <feature-value-declaration-list>\n}"
+	},
+		"feature-value-block-list": {
+		syntax: "<feature-value-block>+"
+	},
+		"feature-value-declaration": {
+		syntax: "<custom-ident>: <integer>+;"
+	},
+		"feature-value-declaration-list": {
+		syntax: "<feature-value-declaration>"
+	},
+		"feature-value-name": {
+		syntax: "<custom-ident>"
+	},
+		"fill-rule": {
+		syntax: "nonzero | evenodd"
+	},
+		"filter-function": {
+		syntax: "<blur()> | <brightness()> | <contrast()> | <drop-shadow()> | <grayscale()> | <hue-rotate()> | <invert()> | <opacity()> | <saturate()> | <sepia()>"
+	},
+		"filter-function-list": {
+		syntax: "[ <filter-function> | <url> ]+"
+	},
+		"final-bg-layer": {
+		syntax: "<'background-color'> || <bg-image> || <bg-position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box>"
+	},
+		"fit-content()": {
+		syntax: "fit-content( [ <length> | <percentage> ] )"
+	},
+		"fixed-breadth": {
+		syntax: "<length-percentage>"
+	},
+		"fixed-repeat": {
+		syntax: "repeat( [ <positive-integer> ] , [ <line-names>? <fixed-size> ]+ <line-names>? )"
+	},
+		"fixed-size": {
+		syntax: "<fixed-breadth> | minmax( <fixed-breadth> , <track-breadth> ) | minmax( <inflexible-breadth> , <fixed-breadth> )"
+	},
+		"font-stretch-absolute": {
+		syntax: "normal | ultra-condensed | extra-condensed | condensed | semi-condensed | semi-expanded | expanded | extra-expanded | ultra-expanded | <percentage>"
+	},
+		"font-variant-css21": {
+		syntax: "[ normal | small-caps ]"
+	},
+		"font-weight-absolute": {
+		syntax: "normal | bold | <number>"
+	},
+		"frames-timing-function": {
+		syntax: "frames(<integer>)"
+	},
+		"frequency-percentage": {
+		syntax: "<frequency> | <percentage>"
+	},
+		"general-enclosed": {
+		syntax: "[ <function-token> <any-value> ) ] | ( <ident> <any-value> )"
+	},
+		"generic-family": {
+		syntax: "serif | sans-serif | cursive | fantasy | monospace"
+	},
+		"generic-name": {
+		syntax: "serif | sans-serif | cursive | fantasy | monospace"
+	},
+		"geometry-box": {
+		syntax: "<shape-box> | fill-box | stroke-box | view-box"
+	},
+		gradient: gradient,
+		"grayscale()": {
+		syntax: "grayscale( <number-percentage> )"
+	},
+		"grid-line": {
+		syntax: "auto | <custom-ident> | [ <integer> && <custom-ident>? ] | [ span && [ <integer> || <custom-ident> ] ]"
+	},
+		"historical-lig-values": {
+		syntax: "[ historical-ligatures | no-historical-ligatures ]"
+	},
+		"hsl()": {
+		syntax: "hsl( <hue> <percentage> <percentage> [ / <alpha-value> ]? ) | hsl( <hue>, <percentage>, <percentage>, <alpha-value>? )"
+	},
+		"hsla()": {
+		syntax: "hsla( <hue> <percentage> <percentage> [ / <alpha-value> ]? ) | hsla( <hue>, <percentage>, <percentage>, <alpha-value>? )"
+	},
+		hue: hue,
+		"hue-rotate()": {
+		syntax: "hue-rotate( <angle> )"
+	},
+		"id-selector": {
+		syntax: "<hash-token>"
+	},
+		image: image,
+		"image()": {
+		syntax: "image( [ [ <image> | <string> ]? , <color>? ]! )"
+	},
+		"image-set()": {
+		syntax: "image-set( <image-set-option># )"
+	},
+		"image-set-option": {
+		syntax: "[ <image> | <string> ] <resolution>"
+	},
+		"inflexible-breadth": {
+		syntax: "<length> | <percentage> | min-content | max-content | auto"
+	},
+		"inset()": {
+		syntax: "inset( <length-percentage>{1,4} [ round <border-radius> ]? )"
+	},
+		"invert()": {
+		syntax: "invert( <number-percentage> )"
+	},
+		"keyframes-name": {
+		syntax: "<custom-ident> | <string>"
+	},
+		"keyframe-block": {
+		syntax: "<keyframe-selector># {\n  <declaration-list>\n}"
+	},
+		"keyframe-block-list": {
+		syntax: "<keyframe-block>+"
+	},
+		"keyframe-selector": {
+		syntax: "from | to | <percentage>"
+	},
+		"leader()": {
+		syntax: "leader( <leader-type> )"
+	},
+		"leader-type": {
+		syntax: "dotted | solid | space | <string>"
+	},
+		"length-percentage": {
+		syntax: "<length> | <percentage>"
+	},
+		"line-names": {
+		syntax: "'[' <custom-ident>* ']'"
+	},
+		"line-name-list": {
+		syntax: "[ <line-names> | <name-repeat> ]+"
+	},
+		"linear-gradient()": {
+		syntax: "linear-gradient( [ <angle> | to <side-or-corner> ]? , <color-stop-list> )"
+	},
+		"mask-layer": {
+		syntax: "<mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || <geometry-box> || [ <geometry-box> | no-clip ] || <compositing-operator> || <masking-mode>"
+	},
+		"mask-position": {
+		syntax: "[ <length-percentage> | left | center | right ] [ <length-percentage> | top | center | bottom ]?"
+	},
+		"mask-reference": {
+		syntax: "none | <image> | <mask-source>"
+	},
+		"mask-source": {
+		syntax: "<url>"
+	},
+		"masking-mode": {
+		syntax: "alpha | luminance | match-source"
+	},
+		"matrix()": {
+		syntax: "matrix( <number> [, <number> ]{5,5} )"
+	},
+		"matrix3d()": {
+		syntax: "matrix3d( <number> [, <number> ]{15,15} )"
+	},
+		"media-and": {
+		syntax: "<media-in-parens> [ and <media-in-parens> ]+"
+	},
+		"media-condition": {
+		syntax: "<media-not> | <media-and> | <media-or> | <media-in-parens>"
+	},
+		"media-condition-without-or": {
+		syntax: "<media-not> | <media-and> | <media-in-parens>"
+	},
+		"media-feature": {
+		syntax: "( [ <mf-plain> | <mf-boolean> | <mf-range> ] )"
+	},
+		"media-in-parens": {
+		syntax: "( <media-condition> ) | <media-feature> | <general-enclosed>"
+	},
+		"media-not": {
+		syntax: "not <media-in-parens>"
+	},
+		"media-or": {
+		syntax: "<media-in-parens> [ or <media-in-parens> ]+"
+	},
+		"media-query": {
+		syntax: "<media-condition> | [ not | only ]? <media-type> [ and <media-condition-without-or> ]?"
+	},
+		"media-query-list": {
+		syntax: "<media-query>#"
+	},
+		"media-type": {
+		syntax: "<ident>"
+	},
+		"mf-boolean": {
+		syntax: "<mf-name>"
+	},
+		"mf-name": {
+		syntax: "<ident>"
+	},
+		"mf-plain": {
+		syntax: "<mf-name> : <mf-value>"
+	},
+		"mf-range": {
+		syntax: "<mf-name> [ '<' | '>' ]? '='? <mf-value>\n| <mf-value> [ '<' | '>' ]? '='? <mf-name>\n| <mf-value> '<' '='? <mf-name> '<' '='? <mf-value>\n| <mf-value> '>' '='? <mf-name> '>' '='? <mf-value>"
+	},
+		"mf-value": {
+		syntax: "<number> | <dimension> | <ident> | <ratio>"
+	},
+		"minmax()": {
+		syntax: "minmax( [ <length> | <percentage> | <flex> | min-content | max-content | auto ] , [ <length> | <percentage> | <flex> | min-content | max-content | auto ] )"
+	},
+		"named-color": {
+		syntax: "transparent | aliceblue | antiquewhite | aqua | aquamarine | azure | beige | bisque | black | blanchedalmond | blue | blueviolet | brown | burlywood | cadetblue | chartreuse | chocolate | coral | cornflowerblue | cornsilk | crimson | cyan | darkblue | darkcyan | darkgoldenrod | darkgray | darkgreen | darkgrey | darkkhaki | darkmagenta | darkolivegreen | darkorange | darkorchid | darkred | darksalmon | darkseagreen | darkslateblue | darkslategray | darkslategrey | darkturquoise | darkviolet | deeppink | deepskyblue | dimgray | dimgrey | dodgerblue | firebrick | floralwhite | forestgreen | fuchsia | gainsboro | ghostwhite | gold | goldenrod | gray | green | greenyellow | grey | honeydew | hotpink | indianred | indigo | ivory | khaki | lavender | lavenderblush | lawngreen | lemonchiffon | lightblue | lightcoral | lightcyan | lightgoldenrodyellow | lightgray | lightgreen | lightgrey | lightpink | lightsalmon | lightseagreen | lightskyblue | lightslategray | lightslategrey | lightsteelblue | lightyellow | lime | limegreen | linen | magenta | maroon | mediumaquamarine | mediumblue | mediumorchid | mediumpurple | mediumseagreen | mediumslateblue | mediumspringgreen | mediumturquoise | mediumvioletred | midnightblue | mintcream | mistyrose | moccasin | navajowhite | navy | oldlace | olive | olivedrab | orange | orangered | orchid | palegoldenrod | palegreen | paleturquoise | palevioletred | papayawhip | peachpuff | peru | pink | plum | powderblue | purple | rebeccapurple | red | rosybrown | royalblue | saddlebrown | salmon | sandybrown | seagreen | seashell | sienna | silver | skyblue | slateblue | slategray | slategrey | snow | springgreen | steelblue | tan | teal | thistle | tomato | turquoise | violet | wheat | white | whitesmoke | yellow | yellowgreen"
+	},
+		"namespace-prefix": {
+		syntax: "<ident>"
+	},
+		"ns-prefix": {
+		syntax: "[ <ident-token> | '*' ]? '|'"
+	},
+		"number-percentage": {
+		syntax: "<number> | <percentage>"
+	},
+		"numeric-figure-values": {
+		syntax: "[ lining-nums | oldstyle-nums ]"
+	},
+		"numeric-fraction-values": {
+		syntax: "[ diagonal-fractions | stacked-fractions ]"
+	},
+		"numeric-spacing-values": {
+		syntax: "[ proportional-nums | tabular-nums ]"
+	},
+		nth: nth,
+		"opacity()": {
+		syntax: "opacity( [ <number-percentage> ] )"
+	},
+		"overflow-position": {
+		syntax: "unsafe | safe"
+	},
+		"outline-radius": {
+		syntax: "<length> | <percentage>"
+	},
+		"page-body": {
+		syntax: "<declaration>? [ ; <page-body> ]? | <page-margin-box> <page-body>"
+	},
+		"page-margin-box": {
+		syntax: "<page-margin-box-type> {\n  <declaration-list>\n}"
+	},
+		"page-margin-box-type": {
+		syntax: "@top-left-corner | @top-left | @top-center | @top-right | @top-right-corner | @bottom-left-corner | @bottom-left | @bottom-center | @bottom-right | @bottom-right-corner | @left-top | @left-middle | @left-bottom | @right-top | @right-middle | @right-bottom"
+	},
+		"page-selector-list": {
+		syntax: "[ <page-selector># ]?"
+	},
+		"page-selector": {
+		syntax: "<pseudo-page>+ | <ident> <pseudo-page>*"
+	},
+		"perspective()": {
+		syntax: "perspective( <length> )"
+	},
+		"polygon()": {
+		syntax: "polygon( <fill-rule>? , [ <length-percentage> <length-percentage> ]# )"
+	},
+		position: position$1,
+		"pseudo-class-selector": {
+		syntax: "':' <ident-token> | ':' <function-token> <any-value> ')'"
+	},
+		"pseudo-element-selector": {
+		syntax: "':' <pseudo-class-selector>"
+	},
+		"pseudo-page": {
+		syntax: ": [ left | right | first | blank ]"
+	},
+		quote: quote,
+		"radial-gradient()": {
+		syntax: "radial-gradient( [ <ending-shape> || <size> ]? [ at <position> ]? , <color-stop-list> )"
+	},
+		"relative-size": {
+		syntax: "larger | smaller"
+	},
+		"repeat-style": {
+		syntax: "repeat-x | repeat-y | [ repeat | space | round | no-repeat ]{1,2}"
+	},
+		"repeating-linear-gradient()": {
+		syntax: "repeating-linear-gradient( [ <angle> | to <side-or-corner> ]? , <color-stop-list> )"
+	},
+		"repeating-radial-gradient()": {
+		syntax: "repeating-radial-gradient( [ <ending-shape> || <size> ]? [ at <position> ]? , <color-stop-list> )"
+	},
+		"rgb()": {
+		syntax: "rgb( <percentage>{3} [ / <alpha-value> ]? ) | rgb( <number>{3} [ / <alpha-value> ]? ) | rgb( <percentage>#{3} , <alpha-value>? ) | rgb( <number>#{3} , <alpha-value>? )"
+	},
+		"rgba()": {
+		syntax: "rgba( <percentage>{3} [ / <alpha-value> ]? ) | rgba( <number>{3} [ / <alpha-value> ]? ) | rgba( <percentage>#{3} , <alpha-value>? ) | rgba( <number>#{3} , <alpha-value>? )"
+	},
+		"rotate()": {
+		syntax: "rotate( <angle> )"
+	},
+		"rotate3d()": {
+		syntax: "rotate3d( <number> , <number> , <number> , <angle> )"
+	},
+		"rotateX()": {
+		syntax: "rotateX( <angle> )"
+	},
+		"rotateY()": {
+		syntax: "rotateY( <angle> )"
+	},
+		"rotateZ()": {
+		syntax: "rotateZ( <angle> )"
+	},
+		"saturate()": {
+		syntax: "saturate( <number-percentage> )"
+	},
+		"scale()": {
+		syntax: "scale( <number> [, <number> ]? )"
+	},
+		"scale3d()": {
+		syntax: "scale3d( <number> , <number> , <number> )"
+	},
+		"scaleX()": {
+		syntax: "scaleX( <number> )"
+	},
+		"scaleY()": {
+		syntax: "scaleY( <number> )"
+	},
+		"scaleZ()": {
+		syntax: "scaleZ( <number> )"
+	},
+		"self-position": {
+		syntax: "center | start | end | self-start | self-end | flex-start | flex-end"
+	},
+		"shape-radius": {
+		syntax: "<length-percentage> | closest-side | farthest-side"
+	},
+		"skew()": {
+		syntax: "skew( <angle> [, <angle> ]? )"
+	},
+		"skewX()": {
+		syntax: "skewX( <angle> )"
+	},
+		"skewY()": {
+		syntax: "skewY( <angle> )"
+	},
+		"sepia()": {
+		syntax: "sepia( <number-percentage> )"
+	},
+		shadow: shadow,
+		"shadow-t": {
+		syntax: "[ <length>{2,3} && <color>? ]"
+	},
+		shape: shape$1,
+		"shape-box": {
+		syntax: "<box> | margin-box"
+	},
+		"side-or-corner": {
+		syntax: "[ left | right ] || [ top | bottom ]"
+	},
+		"single-animation": {
+		syntax: "<time> || <single-timing-function> || <time> || <single-animation-iteration-count> || <single-animation-direction> || <single-animation-fill-mode> || <single-animation-play-state> || [ none | <keyframes-name> ]"
+	},
+		"single-animation-direction": {
+		syntax: "normal | reverse | alternate | alternate-reverse"
+	},
+		"single-animation-fill-mode": {
+		syntax: "none | forwards | backwards | both"
+	},
+		"single-animation-iteration-count": {
+		syntax: "infinite | <number>"
+	},
+		"single-animation-play-state": {
+		syntax: "running | paused"
+	},
+		"single-timing-function": {
+		syntax: "linear | <cubic-bezier-timing-function> | <step-timing-function> | <frames-timing-function>"
+	},
+		"single-transition": {
+		syntax: "[ none | <single-transition-property> ] || <time> || <single-transition-timing-function> || <time>"
+	},
+		"single-transition-timing-function": {
+		syntax: "<single-timing-function>"
+	},
+		"single-transition-property": {
+		syntax: "all | <custom-ident>"
+	},
+		size: size,
+		"step-timing-function": {
+		syntax: "step-start | step-end | steps(<integer>[, [ start | end ] ]?)"
+	},
+		"subclass-selector": {
+		syntax: "<id-selector> | <class-selector> | <attribute-selector> | <pseudo-class-selector>"
+	},
+		symbol: symbol,
+		target: target,
+		"target-counter()": {
+		syntax: "target-counter( [ <string> | <url> ] , <custom-ident> , <counter-style>? )"
+	},
+		"target-counters()": {
+		syntax: "target-counters( [ <string> | <url> ] , <custom-ident> , <string> , <counter-style>? )"
+	},
+		"target-text()": {
+		syntax: "target-text( [ <string> | <url> ] , [ content | before | after | first-letter ]? )"
+	},
+		"time-percentage": {
+		syntax: "<time> | <percentage>"
+	},
+		"track-breadth": {
+		syntax: "<length-percentage> | <flex> | min-content | max-content | auto"
+	},
+		"track-list": {
+		syntax: "[ <line-names>? [ <track-size> | <track-repeat> ] ]+ <line-names>?"
+	},
+		"track-repeat": {
+		syntax: "repeat( [ <positive-integer> ] , [ <line-names>? <track-size> ]+ <line-names>? )"
+	},
+		"track-size": {
+		syntax: "<track-breadth> | minmax( <inflexible-breadth> , <track-breadth> ) | fit-content( [ <length> | <percentage> ] )"
+	},
+		"transform-function": {
+		syntax: "<matrix()> | <translate()> | <translateX()> | <translateY()> | <scale()> | <scaleX()> | <scaleY()> | <rotate()> | <skew()> | <skewX()> | <skewY()> | <matrix3d()> | <translate3d()> | <translateZ()> | <scale3d()> | <scaleZ()> | <rotate3d()> | <rotateX()> | <rotateY()> | <rotateZ()> | <perspective()>"
+	},
+		"transform-list": {
+		syntax: "<transform-function>+"
+	},
+		"translate()": {
+		syntax: "translate( <length-percentage> [, <length-percentage> ]? )"
+	},
+		"translate3d()": {
+		syntax: "translate3d( <length-percentage> , <length-percentage> , <length> )"
+	},
+		"translateX()": {
+		syntax: "translateX( <length-percentage> )"
+	},
+		"translateY()": {
+		syntax: "translateY( <length-percentage> )"
+	},
+		"translateZ()": {
+		syntax: "translateZ( <length> )"
+	},
+		"type-or-unit": {
+		syntax: "string | integer | color | url | integer | number | length | angle | time | frequency | em | ex | px | rem | vw | vh | vmin | vmax | mm | q | cm | in | pt | pc | deg | grad | rad | ms | s | Hz | kHz | %"
+	},
+		"type-selector": {
+		syntax: "<wq-name> | <ns-prefix>? '*'"
+	},
+		"var()": {
+		syntax: "var( <custom-property-name> [, <declaration-value> ]? )"
+	},
+		"viewport-length": {
+		syntax: "auto | <length-percentage>"
+	},
+		"wq-name": {
+		syntax: "<ns-prefix>? <ident-token>"
+	}
+	};
+
+	var syntaxes$1 = /*#__PURE__*/Object.freeze({
+		attachment: attachment,
+		box: box,
+		color: color$1,
+		gradient: gradient,
+		hue: hue,
+		image: image,
+		nth: nth,
+		position: position$1,
+		quote: quote,
+		shadow: shadow,
+		shape: shape$1,
+		size: size,
+		symbol: symbol,
+		target: target,
+		default: syntaxes
+	});
+
+	var properties$3 = {
+		"--*": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"-moz-background-clip": {
+			comment: "deprecated syntax in old Firefox, https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
+			syntax: "padding | border"
+		},
+		"-moz-border-radius-bottomleft": {
+			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-left-radius",
+			syntax: "<'border-bottom-left-radius'>"
+		},
+		"-moz-border-radius-bottomright": {
+			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
+			syntax: "<'border-bottom-right-radius'>"
+		},
+		"-moz-border-radius-topleft": {
+			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-left-radius",
+			syntax: "<'border-top-left-radius'>"
+		},
+		"-moz-border-radius-topright": {
+			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
+			syntax: "<'border-bottom-right-radius'>"
+		},
+		"-moz-osx-font-smoothing": {
+			comment: "misssed old syntax https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
+			syntax: "auto | grayscale"
+		},
+		"-moz-user-select": {
+			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
+			syntax: "none | text | all | -moz-none"
+		},
+		"-ms-flex-align": {
+			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
+			syntax: "start | end | center | baseline | stretch"
+		},
+		"-ms-flex-item-align": {
+			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
+			syntax: "auto | start | end | center | baseline | stretch"
+		},
+		"-ms-flex-line-pack": {
+			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack",
+			syntax: "start | end | center | justify | distribute | stretch"
+		},
+		"-ms-flex-negative": {
+			comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
+			syntax: "<'flex-shrink'>"
+		},
+		"-ms-flex-pack": {
+			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack",
+			syntax: "start | end | center | justify | distribute"
+		},
+		"-ms-flex-order": {
+			comment: "misssed old syntax implemented in IE; https://msdn.microsoft.com/en-us/library/jj127303(v=vs.85).aspx",
+			syntax: "<integer>"
+		},
+		"-ms-flex-positive": {
+			comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
+			syntax: "<'flex-grow'>"
+		},
+		"-ms-flex-preferred-size": {
+			comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
+			syntax: "<'flex-basis'>"
+		},
+		"-ms-interpolation-mode": {
+			comment: "https://msdn.microsoft.com/en-us/library/ff521095(v=vs.85).aspx",
+			syntax: "nearest-neighbor | bicubic"
+		},
+		"-ms-grid-column-align": {
+			comment: "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466338.aspx",
+			syntax: "start | end | center | stretch"
+		},
+		"-ms-grid-row-align": {
+			comment: "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466348.aspx",
+			syntax: "start | end | center | stretch"
+		},
+		"-webkit-appearance": {
+			comment: "webkit specific keywords",
+			references: [
+				"http://css-infos.net/property/-webkit-appearance"
+			],
+			syntax: "none | button | button-bevel | caps-lock-indicator | caret | checkbox | default-button | listbox | listitem | media-fullscreen-button | media-mute-button | media-play-button | media-seek-back-button | media-seek-forward-button | media-slider | media-sliderthumb | menulist | menulist-button | menulist-text | menulist-textfield | 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"
+		},
+		"-webkit-background-clip": {
+			comment: "https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
+			syntax: "[ <box> | border | padding | content | text ]#"
+		},
+		"-webkit-column-break-after": {
+			comment: "added, http://help.dottoro.com/lcrthhhv.php",
+			syntax: "always | auto | avoid"
+		},
+		"-webkit-column-break-before": {
+			comment: "added, http://help.dottoro.com/lcxquvkf.php",
+			syntax: "always | auto | avoid"
+		},
+		"-webkit-column-break-inside": {
+			comment: "added, http://help.dottoro.com/lclhnthl.php",
+			syntax: "always | auto | avoid"
+		},
+		"-webkit-font-smoothing": {
+			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
+			syntax: "auto | none | antialiased | subpixel-antialiased"
+		},
+		"-webkit-line-clamp": {
+			comment: "non-standard and deprecated but may still using by some sites",
+			syntax: "<positive-integer>"
+		},
+		"-webkit-mask-box-image": {
+			comment: "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
+			syntax: "[ <url> | <gradient> | none ] [ <length-percentage>{4} <-webkit-mask-box-repeat>{2} ]?"
+		},
+		"-webkit-mask-clip": {
+			comment: "change type to <-webkit-mask-clip-style> since it differ from <mask-clip>, extra space between [ and ,",
+			syntax: "<-webkit-mask-clip-style> [, <-webkit-mask-clip-style> ]*"
+		},
+		"-webkit-print-color-adjust": {
+			comment: "missed",
+			references: [
+				"https://developer.mozilla.org/en/docs/Web/CSS/-webkit-print-color-adjust"
+			],
+			syntax: "economy | exact"
+		},
+		"-webkit-text-security": {
+			comment: "missed; http://help.dottoro.com/lcbkewgt.php",
+			syntax: "none | circle | disc | square"
+		},
+		"-webkit-user-drag": {
+			comment: "missed; http://help.dottoro.com/lcbixvwm.php",
+			syntax: "none | element | auto"
+		},
+		"-webkit-user-select": {
+			comment: "auto is supported by old webkit, https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
+			syntax: "auto | none | text | all"
+		},
+		"alignment-baseline": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/text.html#AlignmentBaselineProperty"
+			],
+			syntax: "auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge | ideographic | alphabetic | hanging | mathematical"
+		},
+		"baseline-shift": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/text.html#BaselineShiftProperty"
+			],
+			syntax: "baseline | sub | super | <svg-length>"
+		},
+		behavior: {
+			comment: "added old IE property https://msdn.microsoft.com/en-us/library/ms530723(v=vs.85).aspx",
+			syntax: "<url>+"
+		},
+		"clip-rule": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/masking.html#ClipRuleProperty"
+			],
+			syntax: "nonzero | evenodd"
+		},
+		cue: {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<'cue-before'> <'cue-after'>?"
+		},
+		"cue-after": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<url> <decibel>? | none"
+		},
+		"cue-before": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<url> <decibel>? | none"
+		},
+		cursor: {
+			comment: "added legacy keywords: hand, -webkit-grab. -webkit-grabbing, -webkit-zoom-in, -webkit-zoom-out, -moz-grab, -moz-grabbing, -moz-zoom-in, -moz-zoom-out",
+			refenrences: [
+				"https://www.sitepoint.com/css3-cursor-styles/"
+			],
+			syntax: "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing | hand | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out | -moz-grab | -moz-grabbing | -moz-zoom-in | -moz-zoom-out ] ]"
+		},
+		display: {
+			comment: "extended with -ms-flexbox",
+			syntax: "none | inline | block | list-item | inline-list-item | inline-block | inline-table | table | table-cell | table-column | table-column-group | table-footer-group | table-header-group | table-row | table-row-group | flex | inline-flex | grid | inline-grid | run-in | ruby | ruby-base | ruby-text | ruby-base-container | ruby-text-container | contents | -ms-flexbox | -ms-inline-flexbox | -ms-grid | -ms-inline-grid | -webkit-flex | -webkit-inline-flex | -webkit-box | -webkit-inline-box | -moz-inline-stack | -moz-box | -moz-inline-box"
+		},
+		position: {
+			comment: "extended with -webkit-sticky",
+			syntax: "static | relative | absolute | sticky | fixed | -webkit-sticky"
+		},
+		"dominant-baseline": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/text.html#DominantBaselineProperty"
+			],
+			syntax: "auto | use-script | no-change | reset-size | ideographic | alphabetic | hanging | mathematical | central | middle | text-after-edge | text-before-edge"
+		},
+		"image-rendering": {
+			comment: "extended with <-non-standard-image-rendering>, added SVG keywords optimizeSpeed and optimizeQuality",
+			references: [
+				"https://developer.mozilla.org/en/docs/Web/CSS/image-rendering",
+				"https://www.w3.org/TR/SVG/painting.html#ImageRenderingProperty"
+			],
+			syntax: "auto | crisp-edges | pixelated | optimizeSpeed | optimizeQuality | <-non-standard-image-rendering>"
+		},
+		fill: {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#FillProperty"
+			],
+			syntax: "<paint>"
+		},
+		"fill-opacity": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#FillProperty"
+			],
+			syntax: "<number-zero-one>"
+		},
+		"fill-rule": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#FillProperty"
+			],
+			syntax: "nonzero | evenodd"
+		},
+		filter: {
+			comment: "extend with IE legacy syntaxes",
+			syntax: "none | <filter-function-list> | <-ms-filter>"
+		},
+		font: {
+			comment: "extend with non-standard fonts",
+			syntax: "[ [ <'font-style'> || <font-variant-css21> || <'font-weight'> || <'font-stretch'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ] | caption | icon | menu | message-box | small-caption | status-bar | <-non-standard-font>"
+		},
+		"glyph-orientation-horizontal": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/text.html#GlyphOrientationHorizontalProperty"
+			],
+			syntax: "<angle>"
+		},
+		"glyph-orientation-vertical": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/text.html#GlyphOrientationVerticalProperty"
+			],
+			syntax: "<angle>"
+		},
+		kerning: {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/text.html#KerningProperty"
+			],
+			syntax: "auto | <svg-length>"
+		},
+		"letter-spacing": {
+			comment: "fix syntax <length> -> <length-percentage>",
+			references: [
+				"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/letter-spacing"
+			],
+			syntax: "normal | <length-percentage>"
+		},
+		"line-height-step": {
+			comment: "fix extra spaces around",
+			syntax: "none | <length>"
+		},
+		marker: {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+			],
+			syntax: "none | <url>"
+		},
+		"marker-end": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+			],
+			syntax: "none | <url>"
+		},
+		"marker-mid": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+			],
+			syntax: "none | <url>"
+		},
+		"marker-start": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+			],
+			syntax: "none | <url>"
+		},
+		"max-width": {
+			comment: "extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/max-width",
+			syntax: "<length> | <percentage> | none | max-content | min-content | fit-content | fill-available | <-non-standard-width>"
+		},
+		"min-width": {
+			comment: "extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
+			syntax: "<length> | <percentage> | auto | max-content | min-content | fit-content | fill-available | <-non-standard-width>"
+		},
+		opacity: {
+			comment: "strict to 0..1 <number> -> <number-zero-one>",
+			syntax: "<number-zero-one>"
+		},
+		overflow: {
+			comment: "extend by vendor keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
+			syntax: "visible | hidden | scroll | auto | <-non-standard-overflow>"
+		},
+		pause: {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<'pause-before'> <'pause-after'>?"
+		},
+		"pause-after": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
+		},
+		"pause-before": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
+		},
+		rest: {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<'rest-before'> <'rest-after'>?"
+		},
+		"rest-after": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
+		},
+		"rest-before": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
+		},
+		"shape-rendering": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#ShapeRenderingPropert"
+			],
+			syntax: "auto | optimizeSpeed | crispEdges | geometricPrecision"
+		},
+		src: {
+			comment: "added @font-face's src property https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src",
+			syntax: "[ <url> [ format( <string># ) ]? | local( <family-name> ) ]#"
+		},
+		speak: {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "auto | none | normal"
+		},
+		"speak-as": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "normal | spell-out || digits || [ literal-punctuation | no-punctuation ]"
+		},
+		stroke: {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "<paint>"
+		},
+		"stroke-dasharray": {
+			comment: "added SVG property; a list of comma and/or white space separated <length>s and <percentage>s",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "none | [ <svg-length>+ ]#"
+		},
+		"stroke-dashoffset": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "<svg-length>"
+		},
+		"stroke-linecap": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "butt | round | square"
+		},
+		"stroke-linejoin": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "miter | round | bevel"
+		},
+		"stroke-miterlimit": {
+			comment: "added SVG property (<miterlimit> = <number-one-or-greater>) ",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "<number-one-or-greater>"
+		},
+		"stroke-opacity": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "<number-zero-one>"
+		},
+		"stroke-width": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+			],
+			syntax: "<svg-length>"
+		},
+		"text-anchor": {
+			comment: "added SVG property",
+			references: [
+				"https://www.w3.org/TR/SVG/text.html#TextAlignmentProperties"
+			],
+			syntax: "start | middle | end"
+		},
+		"transform-origin": {
+			comment: "move first group to the end since less collecting",
+			syntax: "[ [ <length-percentage> | left | center | right ] && [ <length-percentage> | top | center | bottom ] ] <length>? | [ <length-percentage> | left | center | right | top | bottom ]"
+		},
+		"unicode-bidi": {
+			comment: "added prefixed keywords https://developer.mozilla.org/en-US/docs/Web/CSS/unicode-bidi",
+			syntax: "normal | embed | isolate | bidi-override | isolate-override | plaintext | -moz-isolate | -moz-isolate-override | -moz-plaintext | -webkit-isolate"
+		},
+		"unicode-range": {
+			comment: "added missed property https://developer.mozilla.org/en-US/docs/Web/CSS/%40font-face/unicode-range",
+			syntax: "<unicode-range>#"
+		},
+		"voice-balance": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<number> | left | center | right | leftwards | rightwards"
+		},
+		"voice-duration": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "auto | <time>"
+		},
+		"voice-family": {
+			comment: "<name> -> <family-name>, https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "[ [ <family-name> | <generic-voice> ] , ]* [ <family-name> | <generic-voice> ] | preserve"
+		},
+		"voice-pitch": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
+		},
+		"voice-range": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
+		},
+		"voice-rate": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "[ normal | x-slow | slow | medium | fast | x-fast ] || <percentage>"
+		},
+		"voice-stress": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "normal | strong | moderate | none | reduced"
+		},
+		"voice-volume": {
+			comment: "https://www.w3.org/TR/css3-speech/#property-index",
+			syntax: "silent | [ [ x-soft | soft | medium | loud | x-loud ] || <decibel> ]"
+		},
+		"word-break": {
+			comment: "extend with non-standard keywords",
+			syntax: "normal | break-all | keep-all | <-non-standard-word-break>"
+		},
+		"writing-mode": {
+			comment: "extend with SVG keywords",
+			syntax: "horizontal-tb | vertical-rl | vertical-lr | sideways-rl | sideways-lr | <svg-writing-mode>"
+		}
+	};
+	var syntaxes$2 = {
+		"-legacy-gradient": {
+			comment: "added collection of legacy gradient syntaxes",
+			syntax: "<-webkit-gradient()> | <-legacy-linear-gradient> | <-legacy-repeating-linear-gradient> | <-legacy-radial-gradient> | <-legacy-repeating-radial-gradient>"
+		},
+		"-legacy-linear-gradient": {
+			comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
+			syntax: "-moz-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-linear-gradient( <-legacy-linear-gradient-arguments> )"
+		},
+		"-legacy-repeating-linear-gradient": {
+			comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
+			syntax: "-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )"
+		},
+		"-legacy-linear-gradient-arguments": {
+			comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
+			syntax: "[ <angle> | <side-or-corner> ]? , <color-stop-list>"
+		},
+		"-legacy-radial-gradient": {
+			comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
+			syntax: "-moz-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-radial-gradient( <-legacy-radial-gradient-arguments> )"
+		},
+		"-legacy-repeating-radial-gradient": {
+			comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
+			syntax: "-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )"
+		},
+		"-legacy-radial-gradient-arguments": {
+			comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
+			syntax: "[ <position> , ]? [ [ [ <-legacy-radial-gradient-shape> || <-legacy-radial-gradient-size> ] | [ <length> | <percentage> ]{2} ] , ]? <color-stop-list>"
+		},
+		"-legacy-radial-gradient-size": {
+			comment: "before a standard it contains 2 extra keywords (`contain` and `cover`) https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltsize",
+			syntax: "closest-side | closest-corner | farthest-side | farthest-corner | contain | cover"
+		},
+		"-legacy-radial-gradient-shape": {
+			comment: "define to duoble sure it doesn't extends in future https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltshape",
+			syntax: "circle | ellipse"
+		},
+		"-non-standard-font": {
+			comment: "non standard fonts",
+			preferences: [
+				"https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
+			],
+			syntax: "-apple-system-body | -apple-system-headline | -apple-system-subheadline | -apple-system-caption1 | -apple-system-caption2 | -apple-system-footnote | -apple-system-short-body | -apple-system-short-headline | -apple-system-short-subheadline | -apple-system-short-caption1 | -apple-system-short-footnote | -apple-system-tall-body"
+		},
+		"-non-standard-color": {
+			comment: "non standard colors",
+			references: [
+				"http://cssdot.ru/%D0%A1%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%D1%87%D0%BD%D0%B8%D0%BA_CSS/color-i305.html",
+				"https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#Mozilla_Color_Preference_Extensions"
+			],
+			syntax: "-moz-ButtonDefault | -moz-ButtonHoverFace | -moz-ButtonHoverText | -moz-CellHighlight | -moz-CellHighlightText | -moz-Combobox | -moz-ComboboxText | -moz-Dialog | -moz-DialogText | -moz-dragtargetzone | -moz-EvenTreeRow | -moz-Field | -moz-FieldText | -moz-html-CellHighlight | -moz-html-CellHighlightText | -moz-mac-accentdarkestshadow | -moz-mac-accentdarkshadow | -moz-mac-accentface | -moz-mac-accentlightesthighlight | -moz-mac-accentlightshadow | -moz-mac-accentregularhighlight | -moz-mac-accentregularshadow | -moz-mac-chrome-active | -moz-mac-chrome-inactive | -moz-mac-focusring | -moz-mac-menuselect | -moz-mac-menushadow | -moz-mac-menutextselect | -moz-MenuHover | -moz-MenuHoverText | -moz-MenuBarText | -moz-MenuBarHoverText | -moz-nativehyperlinktext | -moz-OddTreeRow | -moz-win-communicationstext | -moz-win-mediatext | -moz-activehyperlinktext | -moz-default-background-color | -moz-default-color | -moz-hyperlinktext | -moz-visitedhyperlinktext | -webkit-activelink | -webkit-focus-ring-color | -webkit-link | -webkit-text"
+		},
+		"-non-standard-image-rendering": {
+			comment: "non-standard keywords http://phrogz.net/tmp/canvas_image_zoom.html",
+			syntax: "optimize-contrast | -moz-crisp-edges | -o-crisp-edges | -webkit-optimize-contrast"
+		},
+		"-non-standard-overflow": {
+			comment: "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
+			syntax: "-moz-scrollbars-none | -moz-scrollbars-horizontal | -moz-scrollbars-vertical | -moz-hidden-unscrollable"
+		},
+		"-non-standard-width": {
+			comment: "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
+			syntax: "min-intrinsic | intrinsic | -moz-min-content | -moz-max-content | -webkit-min-content | -webkit-max-content"
+		},
+		"-non-standard-word-break": {
+			comment: "non-standard keywords https://css-tricks.com/almanac/properties/w/word-break/",
+			syntax: "break-word"
+		},
+		"-webkit-gradient()": {
+			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/ - TODO: simplify when after match algorithm improvement ( [, point, radius | , point] -> [, radius]? , point )",
+			syntax: "-webkit-gradient( <-webkit-gradient-type>, <-webkit-gradient-point> [, <-webkit-gradient-point> | , <-webkit-gradient-radius>, <-webkit-gradient-point> ] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )"
+		},
+		"-webkit-gradient-color-stop": {
+			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+			syntax: "from( <color> ) | color-stop( [ <number-zero-one> | <percentage> ] , <color> ) | to( <color> )"
+		},
+		"-webkit-gradient-point": {
+			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+			syntax: "[ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]"
+		},
+		"-webkit-gradient-radius": {
+			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+			syntax: "<length> | <percentage>"
+		},
+		"-webkit-gradient-type": {
+			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+			syntax: "linear | radial"
+		},
+		"-webkit-mask-box-repeat": {
+			comment: "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
+			syntax: "repeat | stretch | round"
+		},
+		"-webkit-mask-clip-style": {
+			comment: "missed; there is no enough information about `-webkit-mask-clip` property, but looks like all those keywords are working",
+			syntax: "border | border-box | padding | padding-box | content | content-box | text"
+		},
+		"-ms-filter": {
+			syntax: "[ <progid> | FlipH | FlipV ]+"
+		},
+		age: {
+			comment: "https://www.w3.org/TR/css3-speech/#voice-family",
+			syntax: "child | young | old"
+		},
+		"attr()": {
+			comment: "drop it since it's a generic",
+			syntax: null
+		},
+		"border-radius": {
+			comment: "missed, https://drafts.csswg.org/css-backgrounds-3/#the-border-radius",
+			syntax: "<length-percentage>{1,2}"
+		},
+		bottom: {
+			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+			syntax: "<length> | auto"
+		},
+		"content-list": {
+			comment: "missed -> https://drafts.csswg.org/css-content/#typedef-content-list (document-url, <target> and leader() is omitted util stabilization)",
+			syntax: "[ <string> | contents | <url> | <quote> | <attr()> | counter( <ident>, <'list-style-type'>? ) ]+"
+		},
+		"inset()": {
+			comment: "changed <border-radius> to <'border-radius'>",
+			syntax: "inset( <length-percentage>{1,4} [ round <'border-radius'> ]? )"
+		},
+		"generic-voice": {
+			comment: "https://www.w3.org/TR/css3-speech/#voice-family",
+			syntax: "[ <age>? <gender> <integer>? ]"
+		},
+		gender: {
+			comment: "https://www.w3.org/TR/css3-speech/#voice-family",
+			syntax: "male | female | neutral"
+		},
+		"generic-family": {
+			comment: "added -apple-system",
+			references: [
+				"https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
+			],
+			syntax: "serif | sans-serif | cursive | fantasy | monospace | -apple-system"
+		},
+		gradient: {
+			comment: "added -webkit-gradient() since may to be used for legacy support",
+			syntax: "<-legacy-gradient> | <linear-gradient()> | <repeating-linear-gradient()> | <radial-gradient()> | <repeating-radial-gradient()>"
+		},
+		left: {
+			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+			syntax: "<length> | auto"
+		},
+		"mask-image": {
+			comment: "missed; https://drafts.fxtf.org/css-masking-1/#the-mask-image",
+			syntax: "<mask-reference>#"
+		},
+		"matrix()": {
+			comment: "redundant max",
+			syntax: "matrix( <number> [, <number> ]{5} )"
+		},
+		"matrix3d()": {
+			comment: "redundant max",
+			syntax: "matrix3d( <number> [, <number> ]{15} )"
+		},
+		"name-repeat": {
+			comment: "missed, and looks like obsolete, keep it as is since other property syntaxes should be changed too; https://www.w3.org/TR/2015/WD-css-grid-1-20150917/#typedef-name-repeat",
+			syntax: "repeat( [ <positive-integer> | auto-fill ], <line-names>+)"
+		},
+		"named-color": {
+			comment: "replaced <ident> to list of colors according to https://www.w3.org/TR/css-color-4/#named-colors",
+			syntax: "transparent | aliceblue | antiquewhite | aqua | aquamarine | azure | beige | bisque | black | blanchedalmond | blue | blueviolet | brown | burlywood | cadetblue | chartreuse | chocolate | coral | cornflowerblue | cornsilk | crimson | cyan | darkblue | darkcyan | darkgoldenrod | darkgray | darkgreen | darkgrey | darkkhaki | darkmagenta | darkolivegreen | darkorange | darkorchid | darkred | darksalmon | darkseagreen | darkslateblue | darkslategray | darkslategrey | darkturquoise | darkviolet | deeppink | deepskyblue | dimgray | dimgrey | dodgerblue | firebrick | floralwhite | forestgreen | fuchsia | gainsboro | ghostwhite | gold | goldenrod | gray | green | greenyellow | grey | honeydew | hotpink | indianred | indigo | ivory | khaki | lavender | lavenderblush | lawngreen | lemonchiffon | lightblue | lightcoral | lightcyan | lightgoldenrodyellow | lightgray | lightgreen | lightgrey | lightpink | lightsalmon | lightseagreen | lightskyblue | lightslategray | lightslategrey | lightsteelblue | lightyellow | lime | limegreen | linen | magenta | maroon | mediumaquamarine | mediumblue | mediumorchid | mediumpurple | mediumseagreen | mediumslateblue | mediumspringgreen | mediumturquoise | mediumvioletred | midnightblue | mintcream | mistyrose | moccasin | navajowhite | navy | oldlace | olive | olivedrab | orange | orangered | orchid | palegoldenrod | palegreen | paleturquoise | palevioletred | papayawhip | peachpuff | peru | pink | plum | powderblue | purple | rebeccapurple | red | rosybrown | royalblue | saddlebrown | salmon | sandybrown | seagreen | seashell | sienna | silver | skyblue | slateblue | slategray | slategrey | snow | springgreen | steelblue | tan | teal | thistle | tomato | turquoise | violet | wheat | white | whitesmoke | yellow | yellowgreen | <-non-standard-color>"
+		},
+		"outline-radius": {
+			comment: "missed, looks like it's a similar to <border-radius> https://developer.mozilla.org/en/docs/Web/CSS/-moz-outline-radius",
+			syntax: "<border-radius>"
+		},
+		paint: {
+			comment: "simplified SVG syntax (omit <icccolor>, replace <funciri> for <url>) https://www.w3.org/TR/SVG/painting.html#SpecifyingPaint",
+			syntax: "none | currentColor | <color> | <url> [ none | currentColor | <color> ]?"
+		},
+		"path()": {
+			comment: "missed, `motion` property was renamed, but left it as is for now; path() syntax was get from last draft https://drafts.fxtf.org/motion-1/#funcdef-offset-path-path",
+			syntax: "path( <string> )"
+		},
+		right: {
+			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+			syntax: "<length> | auto"
+		},
+		shape: {
+			comment: "missed spaces in function body and add backwards compatible syntax",
+			syntax: "rect( [ [ <top>, <right>, <bottom>, <left> ] | [ <top> <right> <bottom> <left> ] ] )"
+		},
+		"single-transition": {
+			comment: "moved <single-transition-timing-function> in the beginning to avoid wrong match to <single-transition-property>",
+			syntax: "<single-transition-timing-function> || [ none | <single-transition-property> ] || <time> || <time>"
+		},
+		"svg-length": {
+			comment: "All coordinates and lengths in SVG can be specified with or without a unit identifier",
+			references: [
+				"https://www.w3.org/TR/SVG11/coords.html#Units"
+			],
+			syntax: "<percentage> | <length> | <number>"
+		},
+		"svg-writing-mode": {
+			comment: "SVG specific keywords (deprecated for CSS)",
+			references: [
+				"https://developer.mozilla.org/en/docs/Web/CSS/writing-mode",
+				"https://www.w3.org/TR/SVG/text.html#WritingModeProperty"
+			],
+			syntax: "lr-tb | rl-tb | tb-rl | lr | rl | tb"
+		},
+		top: {
+			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+			syntax: "<length> | auto"
+		},
+		x: {
+			comment: "missed; not sure we should add it, but no others except `cursor` is using it so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
+			syntax: "<number>"
+		},
+		y: {
+			comment: "missed; not sure we should add it, but no others except `cursor` is using so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
+			syntax: "<number>"
+		},
+		"var()": {
+			comment: "drop it since it's a generic (also syntax is incorrect and can't be parsed)",
+			syntax: null
+		},
+		"an-plus-b": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"feature-type": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"feature-value-block": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"feature-value-declaration": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"feature-value-block-list": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"feature-value-declaration-list": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"general-enclosed": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"keyframe-block": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"keyframe-block-list": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"mf-plain": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"mf-range": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"mf-value": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-and": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-condition": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-not": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-or": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-in-parens": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-feature": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-condition-without-or": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-query": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"media-query-list": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		nth: {
+			comment: "syntax has <an-plus-b> that doesn't support currently, drop for now",
+			syntax: null
+		},
+		"page-selector": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"page-selector-list": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"page-body": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"page-margin-box": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"page-margin-box-type": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		},
+		"pseudo-page": {
+			comment: "syntax is incorrect and can't be parsed, drop for now",
+			syntax: null
+		}
+	};
+	var patch = {
+		properties: properties$3,
+		syntaxes: syntaxes$2
+	};
+
+	var patch$1 = /*#__PURE__*/Object.freeze({
+		properties: properties$3,
+		syntaxes: syntaxes$2,
+		default: patch
+	});
+
+	var mdnProperties = getCjsExportFromNamespace(properties$2);
+
+	var mdnSyntaxes = getCjsExportFromNamespace(syntaxes$1);
+
+	var patch$2 = getCjsExportFromNamespace(patch$1);
+
+	function buildDictionary(dict, patchDict) {
+	    var result = {};
+
+	    // copy all syntaxes for an original dict
+	    for (var key in dict) {
+	        result[key] = dict[key].syntax;
+	    }
+
+	    // apply a patch
+	    for (var key in patchDict) {
+	        if (key in dict) {
+	            if (patchDict[key].syntax) {
+	                result[key] = patchDict[key].syntax;
+	            } else {
+	                delete result[key];
+	            }
+	        } else {
+	            if (patchDict[key].syntax) {
+	                result[key] = patchDict[key].syntax;
+	            }
+	        }
+	    }
+
+	    return result;
+	}
+
+	var data = {
+	    properties: buildDictionary(mdnProperties, patch$2.properties),
+	    types: buildDictionary(mdnSyntaxes, patch$2.syntaxes)
+	};
+
+	var cmpChar$1 = tokenizer.cmpChar;
+	var isNumber$3 = tokenizer.isNumber;
+	var TYPE$4 = tokenizer.TYPE;
+
+	var IDENTIFIER$3 = TYPE$4.Identifier;
+	var NUMBER$2 = TYPE$4.Number;
+	var PLUSSIGN$4 = TYPE$4.PlusSign;
+	var HYPHENMINUS$4 = TYPE$4.HyphenMinus;
+	var N$5 = 110; // 'n'.charCodeAt(0)
+	var DISALLOW_SIGN = true;
+	var ALLOW_SIGN = false;
+
+	function checkTokenIsInteger(scanner, disallowSign) {
+	    var pos = scanner.tokenStart;
+
+	    if (scanner.source.charCodeAt(pos) === PLUSSIGN$4 ||
+	        scanner.source.charCodeAt(pos) === HYPHENMINUS$4) {
+	        if (disallowSign) {
+	            scanner.error();
+	        }
+	        pos++;
+	    }
+
+	    for (; pos < scanner.tokenEnd; pos++) {
+	        if (!isNumber$3(scanner.source.charCodeAt(pos))) {
+	            scanner.error('Unexpected input', pos);
+	        }
+	    }
+	}
+
+	// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
+	var AnPlusB = {
+	    name: 'AnPlusB',
+	    structure: {
+	        a: [String, null],
+	        b: [String, null]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var end = start;
+	        var prefix = '';
+	        var a = null;
+	        var b = null;
+
+	        if (this.scanner.tokenType === NUMBER$2 ||
+	            this.scanner.tokenType === PLUSSIGN$4) {
+	            checkTokenIsInteger(this.scanner, ALLOW_SIGN);
+	            prefix = this.scanner.getTokenValue();
+	            this.scanner.next();
+	            end = this.scanner.tokenStart;
+	        }
+
+	        if (this.scanner.tokenType === IDENTIFIER$3) {
+	            var bStart = this.scanner.tokenStart;
+
+	            if (cmpChar$1(this.scanner.source, bStart, HYPHENMINUS$4)) {
+	                if (prefix === '') {
+	                    prefix = '-';
+	                    bStart++;
+	                } else {
+	                    this.scanner.error('Unexpected hyphen minus');
+	                }
+	            }
+
+	            if (!cmpChar$1(this.scanner.source, bStart, N$5)) {
+	                this.scanner.error();
+	            }
+
+	            a = prefix === ''  ? '1'  :
+	                prefix === '+' ? '+1' :
+	                prefix === '-' ? '-1' :
+	                prefix;
+
+	            var len = this.scanner.tokenEnd - bStart;
+	            if (len > 1) {
+	                // ..n-..
+	                if (this.scanner.source.charCodeAt(bStart + 1) !== HYPHENMINUS$4) {
+	                    this.scanner.error('Unexpected input', bStart + 1);
+	                }
+
+	                if (len > 2) {
+	                    // ..n-{number}..
+	                    this.scanner.tokenStart = bStart + 2;
+	                } else {
+	                    // ..n- {number}
+	                    this.scanner.next();
+	                    this.scanner.skipSC();
+	                }
+
+	                checkTokenIsInteger(this.scanner, DISALLOW_SIGN);
+	                b = '-' + this.scanner.getTokenValue();
+	                this.scanner.next();
+	                end = this.scanner.tokenStart;
+	            } else {
+	                prefix = '';
+	                this.scanner.next();
+	                end = this.scanner.tokenStart;
+	                this.scanner.skipSC();
+
+	                if (this.scanner.tokenType === HYPHENMINUS$4 ||
+	                    this.scanner.tokenType === PLUSSIGN$4) {
+	                    prefix = this.scanner.getTokenValue();
+	                    this.scanner.next();
+	                    this.scanner.skipSC();
+	                }
+
+	                if (this.scanner.tokenType === NUMBER$2) {
+	                    checkTokenIsInteger(this.scanner, prefix !== '');
+
+	                    if (!isNumber$3(this.scanner.source.charCodeAt(this.scanner.tokenStart))) {
+	                        prefix = this.scanner.source.charAt(this.scanner.tokenStart);
+	                        this.scanner.tokenStart++;
+	                    }
+
+	                    if (prefix === '') {
+	                        // should be an operator before number
+	                        this.scanner.error();
+	                    } else if (prefix === '+') {
+	                        // plus is using by default
+	                        prefix = '';
+	                    }
+
+	                    b = prefix + this.scanner.getTokenValue();
+
+	                    this.scanner.next();
+	                    end = this.scanner.tokenStart;
+	                } else {
+	                    if (prefix) {
+	                        this.scanner.eat(NUMBER$2);
+	                    }
+	                }
+	            }
+	        } else {
+	            if (prefix === '' || prefix === '+') { // no number
+	                this.scanner.error(
+	                    'Number or identifier is expected',
+	                    this.scanner.tokenStart + (
+	                        this.scanner.tokenType === PLUSSIGN$4 ||
+	                        this.scanner.tokenType === HYPHENMINUS$4
+	                    )
+	                );
+	            }
+
+	            b = prefix;
+	        }
+
+	        return {
+	            type: 'AnPlusB',
+	            loc: this.getLocation(start, end),
+	            a: a,
+	            b: b
+	        };
+	    },
+	    generate: function(node) {
+	        var a = node.a !== null && node.a !== undefined;
+	        var b = node.b !== null && node.b !== undefined;
+
+	        if (a) {
+	            this.chunk(
+	                node.a === '+1' ? '+n' :
+	                node.a ===  '1' ?  'n' :
+	                node.a === '-1' ? '-n' :
+	                node.a + 'n'
+	            );
+
+	            if (b) {
+	                b = String(node.b);
+	                if (b.charAt(0) === '-' || b.charAt(0) === '+') {
+	                    this.chunk(b.charAt(0));
+	                    this.chunk(b.substr(1));
+	                } else {
+	                    this.chunk('+');
+	                    this.chunk(b);
+	                }
+	            }
+	        } else {
+	            this.chunk(String(node.b));
+	        }
+	    }
+	};
+
+	var TYPE$5 = tokenizer.TYPE;
+
+	var ATKEYWORD$2 = TYPE$5.AtKeyword;
+	var SEMICOLON = TYPE$5.Semicolon;
+	var LEFTCURLYBRACKET$2 = TYPE$5.LeftCurlyBracket;
+	var RIGHTCURLYBRACKET$2 = TYPE$5.RightCurlyBracket;
+
+	function consumeRaw(startToken) {
+	    return this.Raw(startToken, SEMICOLON, LEFTCURLYBRACKET$2, false, true);
+	}
+
+	function isDeclarationBlockAtrule() {
+	    for (var offset = 1, type; type = this.scanner.lookupType(offset); offset++) {
+	        if (type === RIGHTCURLYBRACKET$2) {
+	            return true;
+	        }
+
+	        if (type === LEFTCURLYBRACKET$2 ||
+	            type === ATKEYWORD$2) {
+	            return false;
+	        }
+	    }
+
+	    return false;
+	}
+
+	var Atrule = {
+	    name: 'Atrule',
+	    structure: {
+	        name: String,
+	        prelude: ['AtrulePrelude', 'Raw', null],
+	        block: ['Block', null]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var name;
+	        var nameLowerCase;
+	        var prelude = null;
+	        var block = null;
+
+	        this.scanner.eat(ATKEYWORD$2);
+
+	        name = this.scanner.substrToCursor(start + 1);
+	        nameLowerCase = name.toLowerCase();
+	        this.scanner.skipSC();
+
+	        // parse prelude
+	        if (this.scanner.eof === false &&
+	            this.scanner.tokenType !== LEFTCURLYBRACKET$2 &&
+	            this.scanner.tokenType !== SEMICOLON) {
+	            if (this.parseAtrulePrelude) {
+	                prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name), consumeRaw);
+
+	                // turn empty AtrulePrelude into null
+	                if (prelude.type === 'AtrulePrelude' && prelude.children.head === null) {
+	                    prelude = null;
+	                }
+	            } else {
+	                prelude = consumeRaw.call(this, this.scanner.currentToken);
+	            }
+
+	            this.scanner.skipSC();
+	        }
+
+	        switch (this.scanner.tokenType) {
+	            case SEMICOLON:
+	                this.scanner.next();
+	                break;
+
+	            case LEFTCURLYBRACKET$2:
+	                if (this.atrule.hasOwnProperty(nameLowerCase) &&
+	                    typeof this.atrule[nameLowerCase].block === 'function') {
+	                    block = this.atrule[nameLowerCase].block.call(this);
+	                } else {
+	                    // TODO: should consume block content as Raw?
+	                    block = this.Block(isDeclarationBlockAtrule.call(this));
+	                }
+
+	                break;
+	        }
+
+	        return {
+	            type: 'Atrule',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: name,
+	            prelude: prelude,
+	            block: block
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('@');
+	        this.chunk(node.name);
+
+	        if (node.prelude !== null) {
+	            this.chunk(' ');
+	            this.node(node.prelude);
+	        }
+
+	        if (node.block) {
+	            this.node(node.block);
+	        } else {
+	            this.chunk(';');
+	        }
+	    },
+	    walkContext: 'atrule'
+	};
+
+	var TYPE$6 = tokenizer.TYPE;
+
+	var SEMICOLON$1 = TYPE$6.Semicolon;
+	var LEFTCURLYBRACKET$3 = TYPE$6.LeftCurlyBracket;
+
+	var AtrulePrelude = {
+	    name: 'AtrulePrelude',
+	    structure: {
+	        children: [[]]
+	    },
+	    parse: function(name) {
+	        var children = null;
+
+	        if (name !== null) {
+	            name = name.toLowerCase();
+	        }
+
+	        this.scanner.skipSC();
+
+	        if (this.atrule.hasOwnProperty(name) &&
+	            typeof this.atrule[name].prelude === 'function') {
+	            // custom consumer
+	            children = this.atrule[name].prelude.call(this);
+	        } else {
+	            // default consumer
+	            children = this.readSequence(this.scope.AtrulePrelude);
+	        }
+
+	        this.scanner.skipSC();
+
+	        if (this.scanner.eof !== true &&
+	            this.scanner.tokenType !== LEFTCURLYBRACKET$3 &&
+	            this.scanner.tokenType !== SEMICOLON$1) {
+	            this.scanner.error('Semicolon or block is expected');
+	        }
+
+	        if (children === null) {
+	            children = this.createList();
+	        }
+
+	        return {
+	            type: 'AtrulePrelude',
+	            loc: this.getLocationFromList(children),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node);
+	    },
+	    walkContext: 'atrulePrelude'
+	};
+
+	var TYPE$7 = tokenizer.TYPE;
+
+	var IDENTIFIER$4 = TYPE$7.Identifier;
+	var STRING$2 = TYPE$7.String;
+	var DOLLARSIGN = TYPE$7.DollarSign;
+	var ASTERISK$1 = TYPE$7.Asterisk;
+	var COLON = TYPE$7.Colon;
+	var EQUALSSIGN = TYPE$7.EqualsSign;
+	var LEFTSQUAREBRACKET$2 = TYPE$7.LeftSquareBracket;
+	var RIGHTSQUAREBRACKET$2 = TYPE$7.RightSquareBracket;
+	var CIRCUMFLEXACCENT = TYPE$7.CircumflexAccent;
+	var VERTICALLINE$1 = TYPE$7.VerticalLine;
+	var TILDE = TYPE$7.Tilde;
+
+	function getAttributeName() {
+	    if (this.scanner.eof) {
+	        this.scanner.error('Unexpected end of input');
+	    }
+
+	    var start = this.scanner.tokenStart;
+	    var expectIdentifier = false;
+	    var checkColon = true;
+
+	    if (this.scanner.tokenType === ASTERISK$1) {
+	        expectIdentifier = true;
+	        checkColon = false;
+	        this.scanner.next();
+	    } else if (this.scanner.tokenType !== VERTICALLINE$1) {
+	        this.scanner.eat(IDENTIFIER$4);
+	    }
+
+	    if (this.scanner.tokenType === VERTICALLINE$1) {
+	        if (this.scanner.lookupType(1) !== EQUALSSIGN) {
+	            this.scanner.next();
+	            this.scanner.eat(IDENTIFIER$4);
+	        } else if (expectIdentifier) {
+	            this.scanner.error('Identifier is expected', this.scanner.tokenEnd);
+	        }
+	    } else if (expectIdentifier) {
+	        this.scanner.error('Vertical line is expected');
+	    }
+
+	    if (checkColon && this.scanner.tokenType === COLON) {
+	        this.scanner.next();
+	        this.scanner.eat(IDENTIFIER$4);
+	    }
+
+	    return {
+	        type: 'Identifier',
+	        loc: this.getLocation(start, this.scanner.tokenStart),
+	        name: this.scanner.substrToCursor(start)
+	    };
+	}
+
+	function getOperator() {
+	    var start = this.scanner.tokenStart;
+	    var tokenType = this.scanner.tokenType;
+
+	    if (tokenType !== EQUALSSIGN &&        // =
+	        tokenType !== TILDE &&             // ~=
+	        tokenType !== CIRCUMFLEXACCENT &&  // ^=
+	        tokenType !== DOLLARSIGN &&        // $=
+	        tokenType !== ASTERISK$1 &&          // *=
+	        tokenType !== VERTICALLINE$1         // |=
+	    ) {
+	        this.scanner.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');
+	    }
+
+	    if (tokenType === EQUALSSIGN) {
+	        this.scanner.next();
+	    } else {
+	        this.scanner.next();
+	        this.scanner.eat(EQUALSSIGN);
+	    }
+
+	    return this.scanner.substrToCursor(start);
+	}
+
+	// '[' S* attrib_name ']'
+	// '[' S* attrib_name S* attrib_matcher S* [ IDENT | STRING ] S* attrib_flags? S* ']'
+	var AttributeSelector = {
+	    name: 'AttributeSelector',
+	    structure: {
+	        name: 'Identifier',
+	        matcher: [String, null],
+	        value: ['String', 'Identifier', null],
+	        flags: [String, null]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var name;
+	        var matcher = null;
+	        var value = null;
+	        var flags = null;
+
+	        this.scanner.eat(LEFTSQUAREBRACKET$2);
+	        this.scanner.skipSC();
+
+	        name = getAttributeName.call(this);
+	        this.scanner.skipSC();
+
+	        if (this.scanner.tokenType !== RIGHTSQUAREBRACKET$2) {
+	            // avoid case `[name i]`
+	            if (this.scanner.tokenType !== IDENTIFIER$4) {
+	                matcher = getOperator.call(this);
+
+	                this.scanner.skipSC();
+
+	                value = this.scanner.tokenType === STRING$2
+	                    ? this.String()
+	                    : this.Identifier();
+
+	                this.scanner.skipSC();
+	            }
+
+	            // attribute flags
+	            if (this.scanner.tokenType === IDENTIFIER$4) {
+	                flags = this.scanner.getTokenValue();
+	                this.scanner.next();
+
+	                this.scanner.skipSC();
+	            }
+	        }
+
+	        this.scanner.eat(RIGHTSQUAREBRACKET$2);
+
+	        return {
+	            type: 'AttributeSelector',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: name,
+	            matcher: matcher,
+	            value: value,
+	            flags: flags
+	        };
+	    },
+	    generate: function(node) {
+	        var flagsPrefix = ' ';
+
+	        this.chunk('[');
+	        this.node(node.name);
+
+	        if (node.matcher !== null) {
+	            this.chunk(node.matcher);
+
+	            if (node.value !== null) {
+	                this.node(node.value);
+
+	                // space between string and flags is not required
+	                if (node.value.type === 'String') {
+	                    flagsPrefix = '';
+	                }
+	            }
+	        }
+
+	        if (node.flags !== null) {
+	            this.chunk(flagsPrefix);
+	            this.chunk(node.flags);
+	        }
+
+	        this.chunk(']');
+	    }
+	};
+
+	var TYPE$8 = tokenizer.TYPE;
+
+	var WHITESPACE$3 = TYPE$8.WhiteSpace;
+	var COMMENT$3 = TYPE$8.Comment;
+	var SEMICOLON$2 = TYPE$8.Semicolon;
+	var ATKEYWORD$3 = TYPE$8.AtKeyword;
+	var LEFTCURLYBRACKET$4 = TYPE$8.LeftCurlyBracket;
+	var RIGHTCURLYBRACKET$3 = TYPE$8.RightCurlyBracket;
+
+	function consumeRaw$1(startToken) {
+	    return this.Raw(startToken, 0, 0, false, true);
+	}
+	function consumeRule() {
+	    return this.parseWithFallback(this.Rule, consumeRaw$1);
+	}
+	function consumeRawDeclaration(startToken) {
+	    return this.Raw(startToken, 0, SEMICOLON$2, true, true);
+	}
+	function consumeDeclaration() {
+	    if (this.scanner.tokenType === SEMICOLON$2) {
+	        return consumeRawDeclaration.call(this, this.scanner.currentToken);
+	    }
+
+	    var node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);
+
+	    if (this.scanner.tokenType === SEMICOLON$2) {
+	        this.scanner.next();
+	    }
+
+	    return node;
+	}
+
+	var Block = {
+	    name: 'Block',
+	    structure: {
+	        children: [[
+	            'Atrule',
+	            'Rule',
+	            'Declaration'
+	        ]]
+	    },
+	    parse: function(isDeclaration) {
+	        var consumer = isDeclaration ? consumeDeclaration : consumeRule;
+
+	        var start = this.scanner.tokenStart;
+	        var children = this.createList();
+
+	        this.scanner.eat(LEFTCURLYBRACKET$4);
+
+	        scan:
+	        while (!this.scanner.eof) {
+	            switch (this.scanner.tokenType) {
+	                case RIGHTCURLYBRACKET$3:
+	                    break scan;
+
+	                case WHITESPACE$3:
+	                case COMMENT$3:
+	                    this.scanner.next();
+	                    break;
+
+	                case ATKEYWORD$3:
+	                    children.push(this.parseWithFallback(this.Atrule, consumeRaw$1));
+	                    break;
+
+	                default:
+	                    children.push(consumer.call(this));
+	            }
+	        }
+
+	        if (!this.scanner.eof) {
+	            this.scanner.eat(RIGHTCURLYBRACKET$3);
+	        }
+
+	        return {
+	            type: 'Block',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('{');
+	        this.children(node, function(prev) {
+	            if (prev.type === 'Declaration') {
+	                this.chunk(';');
+	            }
+	        });
+	        this.chunk('}');
+	    },
+	    walkContext: 'block'
+	};
+
+	var TYPE$9 = tokenizer.TYPE;
+	var LEFTSQUAREBRACKET$3 = TYPE$9.LeftSquareBracket;
+	var RIGHTSQUAREBRACKET$3 = TYPE$9.RightSquareBracket;
+
+	var Brackets = {
+	    name: 'Brackets',
+	    structure: {
+	        children: [[]]
+	    },
+	    parse: function(readSequence, recognizer) {
+	        var start = this.scanner.tokenStart;
+	        var children = null;
+
+	        this.scanner.eat(LEFTSQUAREBRACKET$3);
+
+	        children = readSequence.call(this, recognizer);
+
+	        if (!this.scanner.eof) {
+	            this.scanner.eat(RIGHTSQUAREBRACKET$3);
+	        }
+
+	        return {
+	            type: 'Brackets',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('[');
+	        this.children(node);
+	        this.chunk(']');
+	    }
+	};
+
+	var CDC$2 = tokenizer.TYPE.CDC;
+
+	var CDC_1 = {
+	    name: 'CDC',
+	    structure: [],
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+
+	        this.scanner.eat(CDC$2); // -->
+
+	        return {
+	            type: 'CDC',
+	            loc: this.getLocation(start, this.scanner.tokenStart)
+	        };
+	    },
+	    generate: function() {
+	        this.chunk('-->');
+	    }
+	};
+
+	var CDO$2 = tokenizer.TYPE.CDO;
+
+	var CDO_1 = {
+	    name: 'CDO',
+	    structure: [],
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+
+	        this.scanner.eat(CDO$2); // <!--
+
+	        return {
+	            type: 'CDO',
+	            loc: this.getLocation(start, this.scanner.tokenStart)
+	        };
+	    },
+	    generate: function() {
+	        this.chunk('<!--');
+	    }
+	};
+
+	var TYPE$a = tokenizer.TYPE;
+	var IDENTIFIER$5 = TYPE$a.Identifier;
+	var FULLSTOP$2 = TYPE$a.FullStop;
+
+	// '.' ident
+	var ClassSelector = {
+	    name: 'ClassSelector',
+	    structure: {
+	        name: String
+	    },
+	    parse: function() {
+	        this.scanner.eat(FULLSTOP$2);
+
+	        return {
+	            type: 'ClassSelector',
+	            loc: this.getLocation(this.scanner.tokenStart - 1, this.scanner.tokenEnd),
+	            name: this.scanner.consume(IDENTIFIER$5)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('.');
+	        this.chunk(node.name);
+	    }
+	};
+
+	var TYPE$b = tokenizer.TYPE;
+
+	var PLUSSIGN$5 = TYPE$b.PlusSign;
+	var SOLIDUS = TYPE$b.Solidus;
+	var GREATERTHANSIGN$2 = TYPE$b.GreaterThanSign;
+	var TILDE$1 = TYPE$b.Tilde;
+
+	// + | > | ~ | /deep/
+	var Combinator = {
+	    name: 'Combinator',
+	    structure: {
+	        name: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+
+	        switch (this.scanner.tokenType) {
+	            case GREATERTHANSIGN$2:
+	            case PLUSSIGN$5:
+	            case TILDE$1:
+	                this.scanner.next();
+	                break;
+
+	            case SOLIDUS:
+	                this.scanner.next();
+	                this.scanner.expectIdentifier('deep');
+	                this.scanner.eat(SOLIDUS);
+	                break;
+
+	            default:
+	                this.scanner.error('Combinator is expected');
+	        }
+
+	        return {
+	            type: 'Combinator',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: this.scanner.substrToCursor(start)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.name);
+	    }
+	};
+
+	var TYPE$c = tokenizer.TYPE;
+
+	var ASTERISK$2 = TYPE$c.Asterisk;
+	var SOLIDUS$1 = TYPE$c.Solidus;
+
+	// '/*' .* '*/'
+	var Comment = {
+	    name: 'Comment',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var end = this.scanner.tokenEnd;
+
+	        if ((end - start + 2) >= 2 &&
+	            this.scanner.source.charCodeAt(end - 2) === ASTERISK$2 &&
+	            this.scanner.source.charCodeAt(end - 1) === SOLIDUS$1) {
+	            end -= 2;
+	        }
+
+	        this.scanner.next();
+
+	        return {
+	            type: 'Comment',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            value: this.scanner.source.substring(start + 2, end)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('/*');
+	        this.chunk(node.value);
+	        this.chunk('*/');
+	    }
+	};
+
+	var isCustomProperty$1 = names.isCustomProperty;
+	var TYPE$d = tokenizer.TYPE;
+
+	var IDENTIFIER$6 = TYPE$d.Identifier;
+	var COLON$1 = TYPE$d.Colon;
+	var EXCLAMATIONMARK$2 = TYPE$d.ExclamationMark;
+	var SOLIDUS$2 = TYPE$d.Solidus;
+	var ASTERISK$3 = TYPE$d.Asterisk;
+	var DOLLARSIGN$1 = TYPE$d.DollarSign;
+	var HYPHENMINUS$5 = TYPE$d.HyphenMinus;
+	var SEMICOLON$3 = TYPE$d.Semicolon;
+	var PLUSSIGN$6 = TYPE$d.PlusSign;
+	var NUMBERSIGN$2 = TYPE$d.NumberSign;
+
+	function consumeValueRaw(startToken) {
+	    return this.Raw(startToken, EXCLAMATIONMARK$2, SEMICOLON$3, false, true);
+	}
+
+	function consumeCustomPropertyRaw(startToken) {
+	    return this.Raw(startToken, EXCLAMATIONMARK$2, SEMICOLON$3, false, false);
+	}
+
+	function consumeValue() {
+	    var startValueToken = this.scanner.currentToken;
+	    var value = this.Value();
+
+	    if (value.type !== 'Raw' &&
+	        this.scanner.eof === false &&
+	        this.scanner.tokenType !== SEMICOLON$3 &&
+	        this.scanner.tokenType !== EXCLAMATIONMARK$2 &&
+	        this.scanner.isBalanceEdge(startValueToken) === false) {
+	        this.scanner.error();
+	    }
+
+	    return value;
+	}
+
+	var Declaration = {
+	    name: 'Declaration',
+	    structure: {
+	        important: [Boolean, String],
+	        property: String,
+	        value: ['Value', 'Raw']
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var startToken = this.scanner.currentToken;
+	        var property = readProperty$1.call(this);
+	        var customProperty = isCustomProperty$1(property);
+	        var parseValue = customProperty ? this.parseCustomProperty : this.parseValue;
+	        var consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;
+	        var important = false;
+	        var value;
+
+	        this.scanner.skipSC();
+	        this.scanner.eat(COLON$1);
+
+	        if (!customProperty) {
+	            this.scanner.skipSC();
+	        }
+
+	        if (parseValue) {
+	            value = this.parseWithFallback(consumeValue, consumeRaw);
+	        } else {
+	            value = consumeRaw.call(this, this.scanner.currentToken);
+	        }
+
+	        if (this.scanner.tokenType === EXCLAMATIONMARK$2) {
+	            important = getImportant(this.scanner);
+	            this.scanner.skipSC();
+	        }
+
+	        // Do not include semicolon to range per spec
+	        // https://drafts.csswg.org/css-syntax/#declaration-diagram
+
+	        if (this.scanner.eof === false &&
+	            this.scanner.tokenType !== SEMICOLON$3 &&
+	            this.scanner.isBalanceEdge(startToken) === false) {
+	            this.scanner.error();
+	        }
+
+	        return {
+	            type: 'Declaration',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            important: important,
+	            property: property,
+	            value: value
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.property);
+	        this.chunk(':');
+	        this.node(node.value);
+
+	        if (node.important) {
+	            this.chunk(node.important === true ? '!important' : '!' + node.important);
+	        }
+	    },
+	    walkContext: 'declaration'
+	};
+
+	function readProperty$1() {
+	    var start = this.scanner.tokenStart;
+	    var prefix = 0;
+
+	    // hacks
+	    switch (this.scanner.tokenType) {
+	        case ASTERISK$3:
+	        case DOLLARSIGN$1:
+	        case PLUSSIGN$6:
+	        case NUMBERSIGN$2:
+	            prefix = 1;
+	            break;
+
+	        // TODO: not sure we should support this hack
+	        case SOLIDUS$2:
+	            prefix = this.scanner.lookupType(1) === SOLIDUS$2 ? 2 : 1;
+	            break;
+	    }
+
+	    if (this.scanner.lookupType(prefix) === HYPHENMINUS$5) {
+	        prefix++;
+	    }
+
+	    if (prefix) {
+	        this.scanner.skip(prefix);
+	    }
+
+	    this.scanner.eat(IDENTIFIER$6);
+
+	    return this.scanner.substrToCursor(start);
+	}
+
+	// ! ws* important
+	function getImportant(scanner) {
+	    scanner.eat(EXCLAMATIONMARK$2);
+	    scanner.skipSC();
+
+	    var important = scanner.consume(IDENTIFIER$6);
+
+	    // store original value in case it differ from `important`
+	    // for better original source restoring and hacks like `!ie` support
+	    return important === 'important' ? true : important;
+	}
+
+	var TYPE$e = tokenizer.TYPE;
+
+	var WHITESPACE$4 = TYPE$e.WhiteSpace;
+	var COMMENT$4 = TYPE$e.Comment;
+	var SEMICOLON$4 = TYPE$e.Semicolon;
+
+	function consumeRaw$2(startToken) {
+	    return this.Raw(startToken, 0, SEMICOLON$4, true, true);
+	}
+
+	var DeclarationList = {
+	    name: 'DeclarationList',
+	    structure: {
+	        children: [[
+	            'Declaration'
+	        ]]
+	    },
+	    parse: function() {
+	        var children = this.createList();
+
+	        scan:
+	        while (!this.scanner.eof) {
+	            switch (this.scanner.tokenType) {
+	                case WHITESPACE$4:
+	                case COMMENT$4:
+	                case SEMICOLON$4:
+	                    this.scanner.next();
+	                    break;
+
+	                default:
+	                    children.push(this.parseWithFallback(this.Declaration, consumeRaw$2));
+	            }
+	        }
+
+	        return {
+	            type: 'DeclarationList',
+	            loc: this.getLocationFromList(children),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node, function(prev) {
+	            if (prev.type === 'Declaration') {
+	                this.chunk(';');
+	            }
+	        });
+	    }
+	};
+
+	var NUMBER$3 = tokenizer.TYPE.Number;
+
+	// special reader for units to avoid adjoined IE hacks (i.e. '1px\9')
+	function readUnit(scanner) {
+	    var unit = scanner.getTokenValue();
+	    var backSlashPos = unit.indexOf('\\');
+
+	    if (backSlashPos > 0) {
+	        // patch token offset
+	        scanner.tokenStart += backSlashPos;
+
+	        // return part before backslash
+	        return unit.substring(0, backSlashPos);
+	    }
+
+	    // no backslash in unit name
+	    scanner.next();
+
+	    return unit;
+	}
+
+	// number ident
+	var Dimension = {
+	    name: 'Dimension',
+	    structure: {
+	        value: String,
+	        unit: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var value = this.scanner.consume(NUMBER$3);
+	        var unit = readUnit(this.scanner);
+
+	        return {
+	            type: 'Dimension',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            value: value,
+	            unit: unit
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	        this.chunk(node.unit);
+	    }
+	};
+
+	var TYPE$f = tokenizer.TYPE;
+	var RIGHTPARENTHESIS$3 = TYPE$f.RightParenthesis;
+
+	// <function-token> <sequence> ')'
+	var _Function = {
+	    name: 'Function',
+	    structure: {
+	        name: String,
+	        children: [[]]
+	    },
+	    parse: function(readSequence, recognizer) {
+	        var start = this.scanner.tokenStart;
+	        var name = this.scanner.consumeFunctionName();
+	        var nameLowerCase = name.toLowerCase();
+	        var children;
+
+	        children = recognizer.hasOwnProperty(nameLowerCase)
+	            ? recognizer[nameLowerCase].call(this, recognizer)
+	            : readSequence.call(this, recognizer);
+
+	        if (!this.scanner.eof) {
+	            this.scanner.eat(RIGHTPARENTHESIS$3);
+	        }
+
+	        return {
+	            type: 'Function',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: name,
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.name);
+	        this.chunk('(');
+	        this.children(node);
+	        this.chunk(')');
+	    },
+	    walkContext: 'function'
+	};
+
+	var isHex$2 = tokenizer.isHex;
+	var TYPE$g = tokenizer.TYPE;
+
+	var IDENTIFIER$7 = TYPE$g.Identifier;
+	var NUMBER$4 = TYPE$g.Number;
+	var NUMBERSIGN$3 = TYPE$g.NumberSign;
+
+	function consumeHexSequence(scanner, required) {
+	    if (!isHex$2(scanner.source.charCodeAt(scanner.tokenStart))) {
+	        if (required) {
+	            scanner.error('Unexpected input', scanner.tokenStart);
+	        } else {
+	            return;
+	        }
+	    }
+
+	    for (var pos = scanner.tokenStart + 1; pos < scanner.tokenEnd; pos++) {
+	        var code = scanner.source.charCodeAt(pos);
+
+	        // break on non-hex char
+	        if (!isHex$2(code)) {
+	            // break token, exclude symbol
+	            scanner.tokenStart = pos;
+	            return;
+	        }
+	    }
+
+	    // token is full hex sequence, go to next token
+	    scanner.next();
+	}
+
+	// # ident
+	var HexColor = {
+	    name: 'HexColor',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+
+	        this.scanner.eat(NUMBERSIGN$3);
+
+	        scan:
+	        switch (this.scanner.tokenType) {
+	            case NUMBER$4:
+	                consumeHexSequence(this.scanner, true);
+
+	                // if token is identifier then number consists of hex only,
+	                // try to add identifier to result
+	                if (this.scanner.tokenType === IDENTIFIER$7) {
+	                    consumeHexSequence(this.scanner, false);
+	                }
+
+	                break;
+
+	            case IDENTIFIER$7:
+	                consumeHexSequence(this.scanner, true);
+	                break;
+
+	            default:
+	                this.scanner.error('Number or identifier is expected');
+	        }
+
+	        return {
+	            type: 'HexColor',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            value: this.scanner.substrToCursor(start + 1) // skip #
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('#');
+	        this.chunk(node.value);
+	    }
+	};
+
+	var TYPE$h = tokenizer.TYPE;
+	var IDENTIFIER$8 = TYPE$h.Identifier;
+
+	var Identifier = {
+	    name: 'Identifier',
+	    structure: {
+	        name: String
+	    },
+	    parse: function() {
+	        return {
+	            type: 'Identifier',
+	            loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+	            name: this.scanner.consume(IDENTIFIER$8)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.name);
+	    }
+	};
+
+	var TYPE$i = tokenizer.TYPE;
+	var IDENTIFIER$9 = TYPE$i.Identifier;
+	var NUMBERSIGN$4 = TYPE$i.NumberSign;
+
+	// '#' ident
+	var IdSelector = {
+	    name: 'IdSelector',
+	    structure: {
+	        name: String
+	    },
+	    parse: function() {
+	        this.scanner.eat(NUMBERSIGN$4);
+
+	        return {
+	            type: 'IdSelector',
+	            loc: this.getLocation(this.scanner.tokenStart - 1, this.scanner.tokenEnd),
+	            name: this.scanner.consume(IDENTIFIER$9)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('#');
+	        this.chunk(node.name);
+	    }
+	};
+
+	var TYPE$j = tokenizer.TYPE;
+
+	var IDENTIFIER$a = TYPE$j.Identifier;
+	var NUMBER$5 = TYPE$j.Number;
+	var LEFTPARENTHESIS$3 = TYPE$j.LeftParenthesis;
+	var RIGHTPARENTHESIS$4 = TYPE$j.RightParenthesis;
+	var COLON$2 = TYPE$j.Colon;
+	var SOLIDUS$3 = TYPE$j.Solidus;
+
+	var MediaFeature = {
+	    name: 'MediaFeature',
+	    structure: {
+	        name: String,
+	        value: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var name;
+	        var value = null;
+
+	        this.scanner.eat(LEFTPARENTHESIS$3);
+	        this.scanner.skipSC();
+
+	        name = this.scanner.consume(IDENTIFIER$a);
+	        this.scanner.skipSC();
+
+	        if (this.scanner.tokenType !== RIGHTPARENTHESIS$4) {
+	            this.scanner.eat(COLON$2);
+	            this.scanner.skipSC();
+
+	            switch (this.scanner.tokenType) {
+	                case NUMBER$5:
+	                    if (this.scanner.lookupType(1) === IDENTIFIER$a) {
+	                        value = this.Dimension();
+	                    } else if (this.scanner.lookupNonWSType(1) === SOLIDUS$3) {
+	                        value = this.Ratio();
+	                    } else {
+	                        value = this.Number();
+	                    }
+
+	                    break;
+
+	                case IDENTIFIER$a:
+	                    value = this.Identifier();
+
+	                    break;
+
+	                default:
+	                    this.scanner.error('Number, dimension, ratio or identifier is expected');
+	            }
+
+	            this.scanner.skipSC();
+	        }
+
+	        this.scanner.eat(RIGHTPARENTHESIS$4);
+
+	        return {
+	            type: 'MediaFeature',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: name,
+	            value: value
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('(');
+	        this.chunk(node.name);
+	        if (node.value !== null) {
+	            this.chunk(':');
+	            this.node(node.value);
+	        }
+	        this.chunk(')');
+	    }
+	};
+
+	var TYPE$k = tokenizer.TYPE;
+
+	var WHITESPACE$5 = TYPE$k.WhiteSpace;
+	var COMMENT$5 = TYPE$k.Comment;
+	var IDENTIFIER$b = TYPE$k.Identifier;
+	var LEFTPARENTHESIS$4 = TYPE$k.LeftParenthesis;
+
+	var MediaQuery = {
+	    name: 'MediaQuery',
+	    structure: {
+	        children: [[
+	            'Identifier',
+	            'MediaFeature',
+	            'WhiteSpace'
+	        ]]
+	    },
+	    parse: function() {
+	        this.scanner.skipSC();
+
+	        var children = this.createList();
+	        var child = null;
+	        var space = null;
+
+	        scan:
+	        while (!this.scanner.eof) {
+	            switch (this.scanner.tokenType) {
+	                case COMMENT$5:
+	                    this.scanner.next();
+	                    continue;
+
+	                case WHITESPACE$5:
+	                    space = this.WhiteSpace();
+	                    continue;
+
+	                case IDENTIFIER$b:
+	                    child = this.Identifier();
+	                    break;
+
+	                case LEFTPARENTHESIS$4:
+	                    child = this.MediaFeature();
+	                    break;
+
+	                default:
+	                    break scan;
+	            }
+
+	            if (space !== null) {
+	                children.push(space);
+	                space = null;
+	            }
+
+	            children.push(child);
+	        }
+
+	        if (child === null) {
+	            this.scanner.error('Identifier or parenthesis is expected');
+	        }
+
+	        return {
+	            type: 'MediaQuery',
+	            loc: this.getLocationFromList(children),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node);
+	    }
+	};
+
+	var COMMA$1 = tokenizer.TYPE.Comma;
+
+	var MediaQueryList = {
+	    name: 'MediaQueryList',
+	    structure: {
+	        children: [[
+	            'MediaQuery'
+	        ]]
+	    },
+	    parse: function(relative) {
+	        var children = this.createList();
+
+	        this.scanner.skipSC();
+
+	        while (!this.scanner.eof) {
+	            children.push(this.MediaQuery(relative));
+
+	            if (this.scanner.tokenType !== COMMA$1) {
+	                break;
+	            }
+
+	            this.scanner.next();
+	        }
+
+	        return {
+	            type: 'MediaQueryList',
+	            loc: this.getLocationFromList(children),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node, function() {
+	            this.chunk(',');
+	        });
+	    }
+	};
+
+	// https://drafts.csswg.org/css-syntax-3/#the-anb-type
+	var Nth = {
+	    name: 'Nth',
+	    structure: {
+	        nth: ['AnPlusB', 'Identifier'],
+	        selector: ['SelectorList', null]
+	    },
+	    parse: function(allowOfClause) {
+	        this.scanner.skipSC();
+
+	        var start = this.scanner.tokenStart;
+	        var end = start;
+	        var selector = null;
+	        var query;
+
+	        if (this.scanner.lookupValue(0, 'odd') || this.scanner.lookupValue(0, 'even')) {
+	            query = this.Identifier();
+	        } else {
+	            query = this.AnPlusB();
+	        }
+
+	        this.scanner.skipSC();
+
+	        if (allowOfClause && this.scanner.lookupValue(0, 'of')) {
+	            this.scanner.next();
+
+	            selector = this.SelectorList();
+
+	            if (this.needPositions) {
+	                end = this.getLastListNode(selector.children).loc.end.offset;
+	            }
+	        } else {
+	            if (this.needPositions) {
+	                end = query.loc.end.offset;
+	            }
+	        }
+
+	        return {
+	            type: 'Nth',
+	            loc: this.getLocation(start, end),
+	            nth: query,
+	            selector: selector
+	        };
+	    },
+	    generate: function(node) {
+	        this.node(node.nth);
+	        if (node.selector !== null) {
+	            this.chunk(' of ');
+	            this.node(node.selector);
+	        }
+	    }
+	};
+
+	var NUMBER$6 = tokenizer.TYPE.Number;
+
+	var _Number = {
+	    name: 'Number',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        return {
+	            type: 'Number',
+	            loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+	            value: this.scanner.consume(NUMBER$6)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	    }
+	};
+
+	// '/' | '*' | ',' | ':' | '+' | '-'
+	var Operator = {
+	    name: 'Operator',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+
+	        this.scanner.next();
+
+	        return {
+	            type: 'Operator',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            value: this.scanner.substrToCursor(start)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	    }
+	};
+
+	var TYPE$l = tokenizer.TYPE;
+	var LEFTPARENTHESIS$5 = TYPE$l.LeftParenthesis;
+	var RIGHTPARENTHESIS$5 = TYPE$l.RightParenthesis;
+
+	var Parentheses = {
+	    name: 'Parentheses',
+	    structure: {
+	        children: [[]]
+	    },
+	    parse: function(readSequence, recognizer) {
+	        var start = this.scanner.tokenStart;
+	        var children = null;
+
+	        this.scanner.eat(LEFTPARENTHESIS$5);
+
+	        children = readSequence.call(this, recognizer);
+
+	        if (!this.scanner.eof) {
+	            this.scanner.eat(RIGHTPARENTHESIS$5);
+	        }
+
+	        return {
+	            type: 'Parentheses',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('(');
+	        this.children(node);
+	        this.chunk(')');
+	    }
+	};
+
+	var TYPE$m = tokenizer.TYPE;
+
+	var NUMBER$7 = TYPE$m.Number;
+	var PERCENTSIGN = TYPE$m.PercentSign;
+
+	var Percentage = {
+	    name: 'Percentage',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var number = this.scanner.consume(NUMBER$7);
+
+	        this.scanner.eat(PERCENTSIGN);
+
+	        return {
+	            type: 'Percentage',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            value: number
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	        this.chunk('%');
+	    }
+	};
+
+	var TYPE$n = tokenizer.TYPE;
+
+	var IDENTIFIER$c = TYPE$n.Identifier;
+	var FUNCTION$2 = TYPE$n.Function;
+	var COLON$3 = TYPE$n.Colon;
+	var RIGHTPARENTHESIS$6 = TYPE$n.RightParenthesis;
+
+	// : ident [ '(' .. ')' ]?
+	var PseudoClassSelector = {
+	    name: 'PseudoClassSelector',
+	    structure: {
+	        name: String,
+	        children: [['Raw'], null]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var children = null;
+	        var name;
+	        var nameLowerCase;
+
+	        this.scanner.eat(COLON$3);
+
+	        if (this.scanner.tokenType === FUNCTION$2) {
+	            name = this.scanner.consumeFunctionName();
+	            nameLowerCase = name.toLowerCase();
+
+	            if (this.pseudo.hasOwnProperty(nameLowerCase)) {
+	                this.scanner.skipSC();
+	                children = this.pseudo[nameLowerCase].call(this);
+	                this.scanner.skipSC();
+	            } else {
+	                children = this.createList();
+	                children.push(
+	                    this.Raw(this.scanner.currentToken, 0, 0, false, false)
+	                );
+	            }
+
+	            this.scanner.eat(RIGHTPARENTHESIS$6);
+	        } else {
+	            name = this.scanner.consume(IDENTIFIER$c);
+	        }
+
+	        return {
+	            type: 'PseudoClassSelector',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: name,
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(':');
+	        this.chunk(node.name);
+
+	        if (node.children !== null) {
+	            this.chunk('(');
+	            this.children(node);
+	            this.chunk(')');
+	        }
+	    },
+	    walkContext: 'function'
+	};
+
+	var TYPE$o = tokenizer.TYPE;
+
+	var IDENTIFIER$d = TYPE$o.Identifier;
+	var FUNCTION$3 = TYPE$o.Function;
+	var COLON$4 = TYPE$o.Colon;
+	var RIGHTPARENTHESIS$7 = TYPE$o.RightParenthesis;
+
+	// :: ident [ '(' .. ')' ]?
+	var PseudoElementSelector = {
+	    name: 'PseudoElementSelector',
+	    structure: {
+	        name: String,
+	        children: [['Raw'], null]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var children = null;
+	        var name;
+	        var nameLowerCase;
+
+	        this.scanner.eat(COLON$4);
+	        this.scanner.eat(COLON$4);
+
+	        if (this.scanner.tokenType === FUNCTION$3) {
+	            name = this.scanner.consumeFunctionName();
+	            nameLowerCase = name.toLowerCase();
+
+	            if (this.pseudo.hasOwnProperty(nameLowerCase)) {
+	                this.scanner.skipSC();
+	                children = this.pseudo[nameLowerCase].call(this);
+	                this.scanner.skipSC();
+	            } else {
+	                children = this.createList();
+	                children.push(
+	                    this.Raw(this.scanner.currentToken, 0, 0, false, false)
+	                );
+	            }
+
+	            this.scanner.eat(RIGHTPARENTHESIS$7);
+	        } else {
+	            name = this.scanner.consume(IDENTIFIER$d);
+	        }
+
+	        return {
+	            type: 'PseudoElementSelector',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: name,
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('::');
+	        this.chunk(node.name);
+
+	        if (node.children !== null) {
+	            this.chunk('(');
+	            this.children(node);
+	            this.chunk(')');
+	        }
+	    },
+	    walkContext: 'function'
+	};
+
+	var isNumber$4 = tokenizer.isNumber;
+	var TYPE$p = tokenizer.TYPE;
+	var NUMBER$8 = TYPE$p.Number;
+	var SOLIDUS$4 = TYPE$p.Solidus;
+	var FULLSTOP$3 = TYPE$p.FullStop;
+
+	// Terms of <ratio> should to be a positive number (not zero or negative)
+	// (see https://drafts.csswg.org/mediaqueries-3/#values)
+	// However, -o-min-device-pixel-ratio takes fractional values as a ratio's term
+	// and this is using by various sites. Therefore we relax checking on parse
+	// to test a term is unsigned number without exponent part.
+	// Additional checks may to be applied on lexer validation.
+	function consumeNumber$1(scanner) {
+	    var value = scanner.consumeNonWS(NUMBER$8);
+
+	    for (var i = 0; i < value.length; i++) {
+	        var code = value.charCodeAt(i);
+	        if (!isNumber$4(code) && code !== FULLSTOP$3) {
+	            scanner.error('Unsigned number is expected', scanner.tokenStart - value.length + i);
+	        }
+	    }
+
+	    if (Number(value) === 0) {
+	        scanner.error('Zero number is not allowed', scanner.tokenStart - value.length);
+	    }
+
+	    return value;
+	}
+
+	// <positive-integer> S* '/' S* <positive-integer>
+	var Ratio = {
+	    name: 'Ratio',
+	    structure: {
+	        left: String,
+	        right: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var left = consumeNumber$1(this.scanner);
+	        var right;
+
+	        this.scanner.eatNonWS(SOLIDUS$4);
+	        right = consumeNumber$1(this.scanner);
+
+	        return {
+	            type: 'Ratio',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            left: left,
+	            right: right
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.left);
+	        this.chunk('/');
+	        this.chunk(node.right);
+	    }
+	};
+
+	var Raw = {
+	    name: 'Raw',
+	    structure: {
+	        value: String
+	    },
+	    parse: function(startToken, endTokenType1, endTokenType2, includeTokenType2, excludeWhiteSpace) {
+	        var startOffset = this.scanner.getTokenStart(startToken);
+	        var endOffset;
+
+	        this.scanner.skip(
+	            this.scanner.getRawLength(
+	                startToken,
+	                endTokenType1,
+	                endTokenType2,
+	                includeTokenType2
+	            )
+	        );
+
+	        if (excludeWhiteSpace && this.scanner.tokenStart > startOffset) {
+	            endOffset = this.scanner.getOffsetExcludeWS();
+	        } else {
+	            endOffset = this.scanner.tokenStart;
+	        }
+
+	        return {
+	            type: 'Raw',
+	            loc: this.getLocation(startOffset, endOffset),
+	            value: this.scanner.source.substring(startOffset, endOffset)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	    }
+	};
+
+	var TYPE$q = tokenizer.TYPE;
+
+	var LEFTCURLYBRACKET$5 = TYPE$q.LeftCurlyBracket;
+
+	function consumeRaw$3(startToken) {
+	    return this.Raw(startToken, LEFTCURLYBRACKET$5, 0, false, true);
+	}
+
+	function consumePrelude() {
+	    var prelude = this.SelectorList();
+
+	    if (prelude.type !== 'Raw' &&
+	        this.scanner.eof === false &&
+	        this.scanner.tokenType !== LEFTCURLYBRACKET$5) {
+	        this.scanner.error();
+	    }
+
+	    return prelude;
+	}
+
+	var Rule = {
+	    name: 'Rule',
+	    structure: {
+	        prelude: ['SelectorList', 'Raw'],
+	        block: ['Block']
+	    },
+	    parse: function() {
+	        var startToken = this.scanner.currentToken;
+	        var startOffset = this.scanner.tokenStart;
+	        var prelude;
+	        var block;
+
+	        if (this.parseRulePrelude) {
+	            prelude = this.parseWithFallback(consumePrelude, consumeRaw$3);
+	        } else {
+	            prelude = consumeRaw$3.call(this, startToken);
+	        }
+
+	        block = this.Block(true);
+
+	        return {
+	            type: 'Rule',
+	            loc: this.getLocation(startOffset, this.scanner.tokenStart),
+	            prelude: prelude,
+	            block: block
+	        };
+	    },
+	    generate: function(node) {
+	        this.node(node.prelude);
+	        this.node(node.block);
+	    },
+	    walkContext: 'rule'
+	};
+
+	var Selector = {
+	    name: 'Selector',
+	    structure: {
+	        children: [[
+	            'TypeSelector',
+	            'IdSelector',
+	            'ClassSelector',
+	            'AttributeSelector',
+	            'PseudoClassSelector',
+	            'PseudoElementSelector',
+	            'Combinator',
+	            'WhiteSpace'
+	        ]]
+	    },
+	    parse: function() {
+	        var children = this.readSequence(this.scope.Selector);
+
+	        // nothing were consumed
+	        if (this.getFirstListNode(children) === null) {
+	            this.scanner.error('Selector is expected');
+	        }
+
+	        return {
+	            type: 'Selector',
+	            loc: this.getLocationFromList(children),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node);
+	    }
+	};
+
+	var TYPE$r = tokenizer.TYPE;
+
+	var COMMA$2 = TYPE$r.Comma;
+
+	var SelectorList = {
+	    name: 'SelectorList',
+	    structure: {
+	        children: [[
+	            'Selector',
+	            'Raw'
+	        ]]
+	    },
+	    parse: function() {
+	        var children = this.createList();
+
+	        while (!this.scanner.eof) {
+	            children.push(this.Selector());
+
+	            if (this.scanner.tokenType === COMMA$2) {
+	                this.scanner.next();
+	                continue;
+	            }
+
+	            break;
+	        }
+
+	        return {
+	            type: 'SelectorList',
+	            loc: this.getLocationFromList(children),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node, function() {
+	            this.chunk(',');
+	        });
+	    },
+	    walkContext: 'selector'
+	};
+
+	var STRING$3 = tokenizer.TYPE.String;
+
+	var _String = {
+	    name: 'String',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        return {
+	            type: 'String',
+	            loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+	            value: this.scanner.consume(STRING$3)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	    }
+	};
+
+	var TYPE$s = tokenizer.TYPE;
+
+	var WHITESPACE$6 = TYPE$s.WhiteSpace;
+	var COMMENT$6 = TYPE$s.Comment;
+	var EXCLAMATIONMARK$3 = TYPE$s.ExclamationMark;
+	var ATKEYWORD$4 = TYPE$s.AtKeyword;
+	var CDO$3 = TYPE$s.CDO;
+	var CDC$3 = TYPE$s.CDC;
+
+	function consumeRaw$4(startToken) {
+	    return this.Raw(startToken, 0, 0, false, false);
+	}
+
+	var StyleSheet = {
+	    name: 'StyleSheet',
+	    structure: {
+	        children: [[
+	            'Comment',
+	            'CDO',
+	            'CDC',
+	            'Atrule',
+	            'Rule',
+	            'Raw'
+	        ]]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var children = this.createList();
+	        var child;
+
+	        scan:
+	        while (!this.scanner.eof) {
+	            switch (this.scanner.tokenType) {
+	                case WHITESPACE$6:
+	                    this.scanner.next();
+	                    continue;
+
+	                case COMMENT$6:
+	                    // ignore comments except exclamation comments (i.e. /*! .. */) on top level
+	                    if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 2) !== EXCLAMATIONMARK$3) {
+	                        this.scanner.next();
+	                        continue;
+	                    }
+
+	                    child = this.Comment();
+	                    break;
+
+	                case CDO$3: // <!--
+	                    child = this.CDO();
+	                    break;
+
+	                case CDC$3: // -->
+	                    child = this.CDC();
+	                    break;
+
+	                // CSS Syntax Module Level 3
+	                // §2.2 Error handling
+	                // At the "top level" of a stylesheet, an <at-keyword-token> starts an at-rule.
+	                case ATKEYWORD$4:
+	                    child = this.parseWithFallback(this.Atrule, consumeRaw$4);
+	                    break;
+
+	                // Anything else starts a qualified rule ...
+	                default:
+	                    child = this.parseWithFallback(this.Rule, consumeRaw$4);
+	            }
+
+	            children.push(child);
+	        }
+
+	        return {
+	            type: 'StyleSheet',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node);
+	    },
+	    walkContext: 'stylesheet'
+	};
+
+	var TYPE$t = tokenizer.TYPE;
+
+	var IDENTIFIER$e = TYPE$t.Identifier;
+	var ASTERISK$4 = TYPE$t.Asterisk;
+	var VERTICALLINE$2 = TYPE$t.VerticalLine;
+
+	function eatIdentifierOrAsterisk() {
+	    if (this.scanner.tokenType !== IDENTIFIER$e &&
+	        this.scanner.tokenType !== ASTERISK$4) {
+	        this.scanner.error('Identifier or asterisk is expected');
+	    }
+
+	    this.scanner.next();
+	}
+
+	// ident
+	// ident|ident
+	// ident|*
+	// *
+	// *|ident
+	// *|*
+	// |ident
+	// |*
+	var TypeSelector = {
+	    name: 'TypeSelector',
+	    structure: {
+	        name: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+
+	        if (this.scanner.tokenType === VERTICALLINE$2) {
+	            this.scanner.next();
+	            eatIdentifierOrAsterisk.call(this);
+	        } else {
+	            eatIdentifierOrAsterisk.call(this);
+
+	            if (this.scanner.tokenType === VERTICALLINE$2) {
+	                this.scanner.next();
+	                eatIdentifierOrAsterisk.call(this);
+	            }
+	        }
+
+	        return {
+	            type: 'TypeSelector',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            name: this.scanner.substrToCursor(start)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.name);
+	    }
+	};
+
+	var isHex$3 = tokenizer.isHex;
+	var TYPE$u = tokenizer.TYPE;
+
+	var IDENTIFIER$f = TYPE$u.Identifier;
+	var NUMBER$9 = TYPE$u.Number;
+	var PLUSSIGN$7 = TYPE$u.PlusSign;
+	var HYPHENMINUS$6 = TYPE$u.HyphenMinus;
+	var FULLSTOP$4 = TYPE$u.FullStop;
+	var QUESTIONMARK$1 = TYPE$u.QuestionMark;
+
+	function scanUnicodeNumber(scanner) {
+	    for (var pos = scanner.tokenStart + 1; pos < scanner.tokenEnd; pos++) {
+	        var code = scanner.source.charCodeAt(pos);
+
+	        // break on fullstop or hyperminus/plussign after exponent
+	        if (code === FULLSTOP$4 || code === PLUSSIGN$7) {
+	            // break token, exclude symbol
+	            scanner.tokenStart = pos;
+	            return false;
+	        }
+	    }
+
+	    return true;
+	}
+
+	// https://drafts.csswg.org/css-syntax-3/#urange
+	function scanUnicodeRange(scanner) {
+	    var hexStart = scanner.tokenStart + 1; // skip +
+	    var hexLength = 0;
+
+	    scan: {
+	        if (scanner.tokenType === NUMBER$9) {
+	            if (scanner.source.charCodeAt(scanner.tokenStart) !== FULLSTOP$4 && scanUnicodeNumber(scanner)) {
+	                scanner.next();
+	            } else if (scanner.source.charCodeAt(scanner.tokenStart) !== HYPHENMINUS$6) {
+	                break scan;
+	            }
+	        } else {
+	            scanner.next(); // PLUSSIGN
+	        }
+
+	        if (scanner.tokenType === HYPHENMINUS$6) {
+	            scanner.next();
+	        }
+
+	        if (scanner.tokenType === NUMBER$9) {
+	            scanner.next();
+	        }
+
+	        if (scanner.tokenType === IDENTIFIER$f) {
+	            scanner.next();
+	        }
+
+	        if (scanner.tokenStart === hexStart) {
+	            scanner.error('Unexpected input', hexStart);
+	        }
+	    }
+
+	    // validate for U+x{1,6} or U+x{1,6}-x{1,6}
+	    // where x is [0-9a-fA-F]
+	    for (var i = hexStart, wasHyphenMinus = false; i < scanner.tokenStart; i++) {
+	        var code = scanner.source.charCodeAt(i);
+
+	        if (isHex$3(code) === false && (code !== HYPHENMINUS$6 || wasHyphenMinus)) {
+	            scanner.error('Unexpected input', i);
+	        }
+
+	        if (code === HYPHENMINUS$6) {
+	            // hex sequence shouldn't be an empty
+	            if (hexLength === 0) {
+	                scanner.error('Unexpected input', i);
+	            }
+
+	            wasHyphenMinus = true;
+	            hexLength = 0;
+	        } else {
+	            hexLength++;
+
+	            // too long hex sequence
+	            if (hexLength > 6) {
+	                scanner.error('Too long hex sequence', i);
+	            }
+	        }
+
+	    }
+
+	    // check we have a non-zero sequence
+	    if (hexLength === 0) {
+	        scanner.error('Unexpected input', i - 1);
+	    }
+
+	    // U+abc???
+	    if (!wasHyphenMinus) {
+	        // consume as many U+003F QUESTION MARK (?) code points as possible
+	        for (; hexLength < 6 && !scanner.eof; scanner.next()) {
+	            if (scanner.tokenType !== QUESTIONMARK$1) {
+	                break;
+	            }
+
+	            hexLength++;
+	        }
+	    }
+	}
+
+	var UnicodeRange = {
+	    name: 'UnicodeRange',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+
+	        this.scanner.next(); // U or u
+	        scanUnicodeRange(this.scanner);
+
+	        return {
+	            type: 'UnicodeRange',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            value: this.scanner.substrToCursor(start)
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	    }
+	};
+
+	var TYPE$v = tokenizer.TYPE;
+
+	var STRING$4 = TYPE$v.String;
+	var URL$3 = TYPE$v.Url;
+	var RAW$2 = TYPE$v.Raw;
+	var RIGHTPARENTHESIS$8 = TYPE$v.RightParenthesis;
+
+	// url '(' S* (string | raw) S* ')'
+	var Url = {
+	    name: 'Url',
+	    structure: {
+	        value: ['String', 'Raw']
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var value;
+
+	        this.scanner.eat(URL$3);
+	        this.scanner.skipSC();
+
+	        switch (this.scanner.tokenType) {
+	            case STRING$4:
+	                value = this.String();
+	                break;
+
+	            case RAW$2:
+	                value = this.Raw(this.scanner.currentToken, 0, RAW$2, true, false);
+	                break;
+
+	            default:
+	                this.scanner.error('String or Raw is expected');
+	        }
+
+	        this.scanner.skipSC();
+	        this.scanner.eat(RIGHTPARENTHESIS$8);
+
+	        return {
+	            type: 'Url',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            value: value
+	        };
+	    },
+	    generate: function(node) {
+	        this.chunk('url');
+	        this.chunk('(');
+	        this.node(node.value);
+	        this.chunk(')');
+	    }
+	};
+
+	var Value = {
+	    name: 'Value',
+	    structure: {
+	        children: [[]]
+	    },
+	    parse: function() {
+	        var start = this.scanner.tokenStart;
+	        var children = this.readSequence(this.scope.Value);
+
+	        return {
+	            type: 'Value',
+	            loc: this.getLocation(start, this.scanner.tokenStart),
+	            children: children
+	        };
+	    },
+	    generate: function(node) {
+	        this.children(node);
+	    }
+	};
+
+	var WHITESPACE$7 = tokenizer.TYPE.WhiteSpace;
+	var SPACE$4 = Object.freeze({
+	    type: 'WhiteSpace',
+	    loc: null,
+	    value: ' '
+	});
+
+	var WhiteSpace = {
+	    name: 'WhiteSpace',
+	    structure: {
+	        value: String
+	    },
+	    parse: function() {
+	        this.scanner.eat(WHITESPACE$7);
+	        return SPACE$4;
+
+	        // return {
+	        //     type: 'WhiteSpace',
+	        //     loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+	        //     value: this.scanner.consume(WHITESPACE)
+	        // };
+	    },
+	    generate: function(node) {
+	        this.chunk(node.value);
+	    }
+	};
+
+	var node = {
+	    AnPlusB: AnPlusB,
+	    Atrule: Atrule,
+	    AtrulePrelude: AtrulePrelude,
+	    AttributeSelector: AttributeSelector,
+	    Block: Block,
+	    Brackets: Brackets,
+	    CDC: CDC_1,
+	    CDO: CDO_1,
+	    ClassSelector: ClassSelector,
+	    Combinator: Combinator,
+	    Comment: Comment,
+	    Declaration: Declaration,
+	    DeclarationList: DeclarationList,
+	    Dimension: Dimension,
+	    Function: _Function,
+	    HexColor: HexColor,
+	    Identifier: Identifier,
+	    IdSelector: IdSelector,
+	    MediaFeature: MediaFeature,
+	    MediaQuery: MediaQuery,
+	    MediaQueryList: MediaQueryList,
+	    Nth: Nth,
+	    Number: _Number,
+	    Operator: Operator,
+	    Parentheses: Parentheses,
+	    Percentage: Percentage,
+	    PseudoClassSelector: PseudoClassSelector,
+	    PseudoElementSelector: PseudoElementSelector,
+	    Ratio: Ratio,
+	    Raw: Raw,
+	    Rule: Rule,
+	    Selector: Selector,
+	    SelectorList: SelectorList,
+	    String: _String,
+	    StyleSheet: StyleSheet,
+	    TypeSelector: TypeSelector,
+	    UnicodeRange: UnicodeRange,
+	    Url: Url,
+	    Value: Value,
+	    WhiteSpace: WhiteSpace
+	};
+
+	var lexer = {
+	    generic: true,
+	    types: data.types,
+	    properties: data.properties,
+	    node: node
+	};
+
+	var cmpChar$2 = tokenizer.cmpChar;
+	var TYPE$w = tokenizer.TYPE;
+
+	var IDENTIFIER$g = TYPE$w.Identifier;
+	var STRING$5 = TYPE$w.String;
+	var NUMBER$a = TYPE$w.Number;
+	var FUNCTION$4 = TYPE$w.Function;
+	var URL$4 = TYPE$w.Url;
+	var NUMBERSIGN$5 = TYPE$w.NumberSign;
+	var LEFTPARENTHESIS$6 = TYPE$w.LeftParenthesis;
+	var LEFTSQUAREBRACKET$4 = TYPE$w.LeftSquareBracket;
+	var PLUSSIGN$8 = TYPE$w.PlusSign;
+	var HYPHENMINUS$7 = TYPE$w.HyphenMinus;
+	var COMMA$3 = TYPE$w.Comma;
+	var SOLIDUS$5 = TYPE$w.Solidus;
+	var ASTERISK$5 = TYPE$w.Asterisk;
+	var PERCENTSIGN$1 = TYPE$w.PercentSign;
+	var BACKSLASH = TYPE$w.Backslash;
+	var U = 117; // 'u'.charCodeAt(0)
+
+	var _default = function defaultRecognizer(context) {
+	    switch (this.scanner.tokenType) {
+	        case NUMBERSIGN$5:
+	            return this.HexColor();
+
+	        case COMMA$3:
+	            context.space = null;
+	            context.ignoreWSAfter = true;
+	            return this.Operator();
+
+	        case SOLIDUS$5:
+	        case ASTERISK$5:
+	        case PLUSSIGN$8:
+	        case HYPHENMINUS$7:
+	            return this.Operator();
+
+	        case LEFTPARENTHESIS$6:
+	            return this.Parentheses(this.readSequence, context.recognizer);
+
+	        case LEFTSQUAREBRACKET$4:
+	            return this.Brackets(this.readSequence, context.recognizer);
+
+	        case STRING$5:
+	            return this.String();
+
+	        case NUMBER$a:
+	            switch (this.scanner.lookupType(1)) {
+	                case PERCENTSIGN$1:
+	                    return this.Percentage();
+
+	                case IDENTIFIER$g:
+	                    // edge case: number with folowing \0 and \9 hack shouldn't to be a Dimension
+	                    if (cmpChar$2(this.scanner.source, this.scanner.tokenEnd, BACKSLASH)) {
+	                        return this.Number();
+	                    } else {
+	                        return this.Dimension();
+	                    }
+
+	                default:
+	                    return this.Number();
+	            }
+
+	        case FUNCTION$4:
+	            return this.Function(this.readSequence, context.recognizer);
+
+	        case URL$4:
+	            return this.Url();
+
+	        case IDENTIFIER$g:
+	            // check for unicode range, it should start with u+ or U+
+	            if (cmpChar$2(this.scanner.source, this.scanner.tokenStart, U) &&
+	                cmpChar$2(this.scanner.source, this.scanner.tokenStart + 1, PLUSSIGN$8)) {
+	                return this.UnicodeRange();
+	            } else {
+	                return this.Identifier();
+	            }
+	    }
+	};
+
+	var atrulePrelude = {
+	    getNode: _default
+	};
+
+	var TYPE$x = tokenizer.TYPE;
+
+	var IDENTIFIER$h = TYPE$x.Identifier;
+	var NUMBER$b = TYPE$x.Number;
+	var NUMBERSIGN$6 = TYPE$x.NumberSign;
+	var LEFTSQUAREBRACKET$5 = TYPE$x.LeftSquareBracket;
+	var PLUSSIGN$9 = TYPE$x.PlusSign;
+	var SOLIDUS$6 = TYPE$x.Solidus;
+	var ASTERISK$6 = TYPE$x.Asterisk;
+	var FULLSTOP$5 = TYPE$x.FullStop;
+	var COLON$5 = TYPE$x.Colon;
+	var GREATERTHANSIGN$3 = TYPE$x.GreaterThanSign;
+	var VERTICALLINE$3 = TYPE$x.VerticalLine;
+	var TILDE$2 = TYPE$x.Tilde;
+
+	function getNode(context) {
+	    switch (this.scanner.tokenType) {
+	        case PLUSSIGN$9:
+	        case GREATERTHANSIGN$3:
+	        case TILDE$2:
+	            context.space = null;
+	            context.ignoreWSAfter = true;
+	            return this.Combinator();
+
+	        case SOLIDUS$6:  // /deep/
+	            return this.Combinator();
+
+	        case FULLSTOP$5:
+	            return this.ClassSelector();
+
+	        case LEFTSQUAREBRACKET$5:
+	            return this.AttributeSelector();
+
+	        case NUMBERSIGN$6:
+	            return this.IdSelector();
+
+	        case COLON$5:
+	            if (this.scanner.lookupType(1) === COLON$5) {
+	                return this.PseudoElementSelector();
+	            } else {
+	                return this.PseudoClassSelector();
+	            }
+
+	        case IDENTIFIER$h:
+	        case ASTERISK$6:
+	        case VERTICALLINE$3:
+	            return this.TypeSelector();
+
+	        case NUMBER$b:
+	            return this.Percentage();
+	    }
+	}
+	var selector = {
+	    getNode: getNode
+	};
+
+	// https://drafts.csswg.org/css-images-4/#element-notation
+	// https://developer.mozilla.org/en-US/docs/Web/CSS/element
+	var element = function() {
+	    this.scanner.skipSC();
+
+	    var children = this.createSingleNodeList(
+	        this.IdSelector()
+	    );
+
+	    this.scanner.skipSC();
+
+	    return children;
+	};
+
+	// legacy IE function
+	// expression '(' raw ')'
+	var expression$1 = function() {
+	    return this.createSingleNodeList(
+	        this.Raw(this.scanner.currentToken, 0, 0, false, false)
+	    );
+	};
+
+	var TYPE$y = tokenizer.TYPE;
+
+	var IDENTIFIER$i = TYPE$y.Identifier;
+	var COMMA$4 = TYPE$y.Comma;
+	var SEMICOLON$5 = TYPE$y.Semicolon;
+	var HYPHENMINUS$8 = TYPE$y.HyphenMinus;
+	var EXCLAMATIONMARK$4 = TYPE$y.ExclamationMark;
+
+	// var '(' ident (',' <value>? )? ')'
+	var _var = function() {
+	    var children = this.createList();
+
+	    this.scanner.skipSC();
+
+	    var identStart = this.scanner.tokenStart;
+
+	    this.scanner.eat(HYPHENMINUS$8);
+	    if (this.scanner.source.charCodeAt(this.scanner.tokenStart) !== HYPHENMINUS$8) {
+	        this.scanner.error('HyphenMinus is expected');
+	    }
+	    this.scanner.eat(IDENTIFIER$i);
+
+	    children.push({
+	        type: 'Identifier',
+	        loc: this.getLocation(identStart, this.scanner.tokenStart),
+	        name: this.scanner.substrToCursor(identStart)
+	    });
+
+	    this.scanner.skipSC();
+
+	    if (this.scanner.tokenType === COMMA$4) {
+	        children.push(this.Operator());
+	        children.push(this.parseCustomProperty
+	            ? this.Value(null)
+	            : this.Raw(this.scanner.currentToken, EXCLAMATIONMARK$4, SEMICOLON$5, false, false)
+	        );
+	    }
+
+	    return children;
+	};
+
+	var value = {
+	    getNode: _default,
+	    '-moz-element': element,
+	    'element': element,
+	    'expression': expression$1,
+	    'var': _var
+	};
+
+	var scope = {
+	    AtrulePrelude: atrulePrelude,
+	    Selector: selector,
+	    Value: value
+	};
+
+	var fontFace = {
+	    parse: {
+	        prelude: null,
+	        block: function() {
+	            return this.Block(true);
+	        }
+	    }
+	};
+
+	var TYPE$z = tokenizer.TYPE;
+
+	var STRING$6 = TYPE$z.String;
+	var IDENTIFIER$j = TYPE$z.Identifier;
+	var URL$5 = TYPE$z.Url;
+	var LEFTPARENTHESIS$7 = TYPE$z.LeftParenthesis;
+
+	var _import = {
+	    parse: {
+	        prelude: function() {
+	            var children = this.createList();
+
+	            this.scanner.skipSC();
+
+	            switch (this.scanner.tokenType) {
+	                case STRING$6:
+	                    children.push(this.String());
+	                    break;
+
+	                case URL$5:
+	                    children.push(this.Url());
+	                    break;
+
+	                default:
+	                    this.scanner.error('String or url() is expected');
+	            }
+
+	            if (this.scanner.lookupNonWSType(0) === IDENTIFIER$j ||
+	                this.scanner.lookupNonWSType(0) === LEFTPARENTHESIS$7) {
+	                children.push(this.WhiteSpace());
+	                children.push(this.MediaQueryList());
+	            }
+
+	            return children;
+	        },
+	        block: null
+	    }
+	};
+
+	var media = {
+	    parse: {
+	        prelude: function() {
+	            return this.createSingleNodeList(
+	                this.MediaQueryList()
+	            );
+	        },
+	        block: function() {
+	            return this.Block(false);
+	        }
+	    }
+	};
+
+	var page = {
+	    parse: {
+	        prelude: function() {
+	            return this.createSingleNodeList(
+	                this.SelectorList()
+	            );
+	        },
+	        block: function() {
+	            return this.Block(true);
+	        }
+	    }
+	};
+
+	var TYPE$A = tokenizer.TYPE;
+
+	var WHITESPACE$8 = TYPE$A.WhiteSpace;
+	var COMMENT$7 = TYPE$A.Comment;
+	var IDENTIFIER$k = TYPE$A.Identifier;
+	var FUNCTION$5 = TYPE$A.Function;
+	var LEFTPARENTHESIS$8 = TYPE$A.LeftParenthesis;
+	var HYPHENMINUS$9 = TYPE$A.HyphenMinus;
+	var COLON$6 = TYPE$A.Colon;
+
+	function consumeRaw$5() {
+	    return this.createSingleNodeList(
+	        this.Raw(this.scanner.currentToken, 0, 0, false, false)
+	    );
+	}
+
+	function parentheses() {
+	    var index = 0;
+
+	    this.scanner.skipSC();
+
+	    // TODO: make it simplier
+	    if (this.scanner.tokenType === IDENTIFIER$k) {
+	        index = 1;
+	    } else if (this.scanner.tokenType === HYPHENMINUS$9 &&
+	               this.scanner.lookupType(1) === IDENTIFIER$k) {
+	        index = 2;
+	    }
+
+	    if (index !== 0 && this.scanner.lookupNonWSType(index) === COLON$6) {
+	        return this.createSingleNodeList(
+	            this.Declaration()
+	        );
+	    }
+
+	    return readSequence.call(this);
+	}
+
+	function readSequence() {
+	    var children = this.createList();
+	    var space = null;
+	    var child;
+
+	    this.scanner.skipSC();
+
+	    scan:
+	    while (!this.scanner.eof) {
+	        switch (this.scanner.tokenType) {
+	            case WHITESPACE$8:
+	                space = this.WhiteSpace();
+	                continue;
+
+	            case COMMENT$7:
+	                this.scanner.next();
+	                continue;
+
+	            case FUNCTION$5:
+	                child = this.Function(consumeRaw$5, this.scope.AtrulePrelude);
+	                break;
+
+	            case IDENTIFIER$k:
+	                child = this.Identifier();
+	                break;
+
+	            case LEFTPARENTHESIS$8:
+	                child = this.Parentheses(parentheses, this.scope.AtrulePrelude);
+	                break;
+
+	            default:
+	                break scan;
+	        }
+
+	        if (space !== null) {
+	            children.push(space);
+	            space = null;
+	        }
+
+	        children.push(child);
+	    }
+
+	    return children;
+	}
+
+	var supports = {
+	    parse: {
+	        prelude: function() {
+	            var children = readSequence.call(this);
+
+	            if (this.getFirstListNode(children) === null) {
+	                this.scanner.error('Condition is expected');
+	            }
+
+	            return children;
+	        },
+	        block: function() {
+	            return this.Block(false);
+	        }
+	    }
+	};
+
+	var atrule = {
+	    'font-face': fontFace,
+	    'import': _import,
+	    'media': media,
+	    'page': page,
+	    'supports': supports
+	};
+
+	var dir = {
+	    parse: function() {
+	        return this.createSingleNodeList(
+	            this.Identifier()
+	        );
+	    }
+	};
+
+	var has$1 = {
+	    parse: function() {
+	        return this.createSingleNodeList(
+	            this.SelectorList()
+	        );
+	    }
+	};
+
+	var lang = {
+	    parse: function() {
+	        return this.createSingleNodeList(
+	            this.Identifier()
+	        );
+	    }
+	};
+
+	var selectorList = {
+	    parse: function selectorList() {
+	        return this.createSingleNodeList(
+	            this.SelectorList()
+	        );
+	    }
+	};
+
+	var matches = selectorList;
+
+	var not = selectorList;
+
+	var ALLOW_OF_CLAUSE = true;
+
+	var nthWithOfClause = {
+	    parse: function nthWithOfClause() {
+	        return this.createSingleNodeList(
+	            this.Nth(ALLOW_OF_CLAUSE)
+	        );
+	    }
+	};
+
+	var nthChild = nthWithOfClause;
+
+	var nthLastChild = nthWithOfClause;
+
+	var DISALLOW_OF_CLAUSE = false;
+
+	var nth$1 = {
+	    parse: function nth() {
+	        return this.createSingleNodeList(
+	            this.Nth(DISALLOW_OF_CLAUSE)
+	        );
+	    }
+	};
+
+	var nthLastOfType = nth$1;
+
+	var nthOfType = nth$1;
+
+	var slotted = {
+	    parse: function compoundSelector() {
+	        return this.createSingleNodeList(
+	            this.Selector()
+	        );
+	    }
+	};
+
+	var pseudo = {
+	    'dir': dir,
+	    'has': has$1,
+	    'lang': lang,
+	    'matches': matches,
+	    'not': not,
+	    'nth-child': nthChild,
+	    'nth-last-child': nthLastChild,
+	    'nth-last-of-type': nthLastOfType,
+	    'nth-of-type': nthOfType,
+	    'slotted': slotted
+	};
+
+	var parser = {
+	    parseContext: {
+	        default: 'StyleSheet',
+	        stylesheet: 'StyleSheet',
+	        atrule: 'Atrule',
+	        atrulePrelude: function(options) {
+	            return this.AtrulePrelude(options.atrule ? String(options.atrule) : null);
+	        },
+	        mediaQueryList: 'MediaQueryList',
+	        mediaQuery: 'MediaQuery',
+	        rule: 'Rule',
+	        selectorList: 'SelectorList',
+	        selector: 'Selector',
+	        block: function() {
+	            return this.Block(true);
+	        },
+	        declarationList: 'DeclarationList',
+	        declaration: 'Declaration',
+	        value: 'Value'
+	    },
+	    scope: scope,
+	    atrule: atrule,
+	    pseudo: pseudo,
+	    node: node
+	};
+
+	var walker = {
+	    node: node
+	};
+
+	function merge() {
+	    var dest = {};
+
+	    for (var i = 0; i < arguments.length; i++) {
+	        var src = arguments[i];
+	        for (var key in src) {
+	            dest[key] = src[key];
+	        }
+	    }
+
+	    return dest;
+	}
+
+	var syntax = create$5.create(
+	    merge(
+	        lexer,
+	        parser,
+	        walker
+	    )
+	);
+
+	var lib = syntax;
+
+	class Sheet {
+		constructor(url, hooks) {
+
+			if (hooks) {
+				this.hooks = hooks;
+			} else {
+				this.hooks = {};
+				this.hooks.onUrl = new Hook(this);
+				this.hooks.onAtPage = new Hook(this);
+				this.hooks.onAtMedia = new Hook(this);
+				this.hooks.onRule = new Hook(this);
+				this.hooks.onDeclaration = new Hook(this);
+				this.hooks.onContent = new Hook(this);
+				this.hooks.onImport = new Hook(this);
+
+				this.hooks.beforeTreeParse = new Hook(this);
+				this.hooks.beforeTreeWalk = new Hook(this);
+				this.hooks.afterTreeWalk = new Hook(this);
+			}
+
+			try {
+				this.url = new URL(url, window.location.href);
+			} catch (e) {
+				this.url = new URL(window.location.href);
+			}
+		}
+
+
+
+		// parse
+		async parse(text) {
+			this.text = text;
+
+			await this.hooks.beforeTreeParse.trigger(this.text, this);
+
+			// send to csstree
+			this.ast = lib.parse(this._text);
+
+			await this.hooks.beforeTreeWalk.trigger(this.ast);
+
+			// Replace urls
+			this.replaceUrls(this.ast);
+
+			// Scope
+			this.id = UUID();
+			// this.addScope(this.ast, this.uuid);
+
+			// Replace IDs with data-id
+			this.replaceIds(this.ast);
+
+			this.imported = [];
+
+			// Trigger Hooks
+			this.urls(this.ast);
+			this.rules(this.ast);
+			this.atrules(this.ast);
+
+			await this.hooks.afterTreeWalk.trigger(this.ast, this);
+
+			// return ast
+			return this.ast;
+		}
+
+		insertRule(rule) {
+			let inserted = this.ast.children.appendData(rule);
+			inserted.forEach((item) => {
+				this.declarations(item);
+			});
+		}
+
+		urls(ast) {
+			lib.walk(ast, {
+				visit: "Url",
+				enter: (node, item, list) => {
+					this.hooks.onUrl.trigger(node, item, list);
+				}
+			});
+		}
+
+		atrules(ast) {
+			lib.walk(ast, {
+				visit: "Atrule",
+				enter: (node, item, list) => {
+					const basename = lib.keyword(node.name).basename;
+
+					if (basename === "page") {
+						this.hooks.onAtPage.trigger(node, item, list);
+						this.declarations(node, item, list);
+					}
+
+					if (basename === "media") {
+						this.hooks.onAtMedia.trigger(node, item, list);
+						this.declarations(node, item, list);
+					}
+
+					if (basename === "import") {
+						this.hooks.onImport.trigger(node, item, list);
+						this.imports(node, item, list);
+					}
+				}
+			});
+		}
+
+
+		rules(ast) {
+			lib.walk(ast, {
+				visit: "Rule",
+				enter: (ruleNode, ruleItem, rulelist) => {
+					// console.log("rule", ruleNode);
+
+					this.hooks.onRule.trigger(ruleNode, ruleItem, rulelist);
+					this.declarations(ruleNode, ruleItem, rulelist);
+				}
+			});
+		}
+
+		declarations(ruleNode, ruleItem, rulelist) {
+			lib.walk(ruleNode, {
+				visit: "Declaration",
+				enter: (declarationNode, dItem, dList) => {
+					// console.log(declarationNode);
+
+					this.hooks.onDeclaration.trigger(declarationNode, dItem, dList, {ruleNode, ruleItem, rulelist});
+
+					if (declarationNode.property === "content") {
+						lib.walk(declarationNode, {
+							visit: "Function",
+							enter: (funcNode, fItem, fList) => {
+								this.hooks.onContent.trigger(funcNode, fItem, fList, {declarationNode, dItem, dList}, {ruleNode, ruleItem, rulelist});
+							}
+						});
+					}
+
+				}
+			});
+		}
+
+		replaceUrls(ast) {
+			lib.walk(ast, {
+				visit: "Url",
+				enter: (node, item, list) => {
+					let href = node.value.value.replace(/["']/g, "");
+					let url = new URL(href, this.url);
+					node.value.value = url.toString();
+				}
+			});
+		}
+
+		addScope(ast, id) {
+			// Get all selector lists
+			// add an id
+			lib.walk(ast, {
+				visit: "Selector",
+				enter: (node, item, list) => {
+					let children = node.children;
+					children.prepend(children.createItem({
+						type: "WhiteSpace",
+						value: " "
+					}));
+					children.prepend(children.createItem({
+						type: "IdSelector",
+						name: id,
+						loc: null,
+						children: null
+					}));
+				}
+			});
+		}
+
+		getNamedPageSelectors(ast) {
+			let namedPageSelectors = {};
+			lib.walk(ast, {
+				visit: "Rule",
+				enter: (node, item, list) => {
+					lib.walk(node, {
+						visit: "Declaration",
+						enter: (declaration, dItem, dList) => {
+							if (declaration.property === "page") {
+								let value = declaration.value.children.first();
+								let name = value.name;
+								let selector = lib.generate(node.prelude);
+								namedPageSelectors[name] = {
+									name: name,
+									selector: selector
+								};
+
+								// dList.remove(dItem);
+
+								// Add in page break
+								declaration.property = "break-before";
+								value.type = "Identifier";
+								value.name = "always";
+
+							}
+						}
+					});
+				}
+			});
+			return namedPageSelectors;
+		}
+
+		replaceIds(ast) {
+			lib.walk(ast, {
+				visit: "Rule",
+				enter: (node, item, list) => {
+
+					lib.walk(node, {
+						visit: "IdSelector",
+						enter: (idNode, idItem, idList) => {
+							let name = idNode.name;
+							idNode.flags = null;
+							idNode.matcher = "=";
+							idNode.name = {type: "Identifier", loc: null, name: "data-id"};
+							idNode.type = "AttributeSelector";
+							idNode.value = {type: "String", loc: null, value: `"${name}"`};
+						}
+					});
+				}
+			});
+		}
+
+		imports(node, item, list) {
+			// console.log("import", node, item, list);
+			let queries = [];
+			lib.walk(node, {
+				visit: "MediaQuery",
+				enter: (mqNode, mqItem, mqList) => {
+					lib.walk(mqNode, {
+						visit: "Identifier",
+						enter: (identNode, identItem, identList) => {
+							queries.push(identNode.name);
+						}
+					});
+				}
+			});
+
+			// Just basic media query support for now
+			let shouldNotApply = queries.some((query, index) => {
+				let q = query;
+				if (q === "not") {
+					q = queries[index + 1];
+					return !(q === "screen" || q === "speech");
+				} else {
+					return (q === "screen" || q === "speech");
+				}
+			});
+
+			if (shouldNotApply) {
+				return;
+			}
+
+			lib.walk(node, {
+				visit: "String",
+				enter: (urlNode, urlItem, urlList) => {
+					let href = urlNode.value.replace(/["']/g, "");
+					let url = new URL(href, this.url);
+					let value = url.toString();
+
+					this.imported.push(value);
+
+					// Remove the original
+					list.remove(item);
+				}
+			});
+		}
+
+		set text(t) {
+			this._text = t;
+		}
+
+		get text() {
+			return this._text;
+		}
+
+		// generate string
+		toString(ast) {
+			return lib.generate(ast || this.ast);
+		}
+	}
+
+	var baseStyles = `
+:root {
+	--pagedjs-width: 8.5in;
+	--pagedjs-height: 11in;
+	--pagedjs-pagebox-width: 8.5in;
+	--pagedjs-pagebox-height: 11in;
+	--pagedjs-margin-top: 1in;
+	--pagedjs-margin-right: 1in;
+	--pagedjs-margin-bottom: 1in;
+	--pagedjs-margin-left: 1in;
+	--pagedjs-bleed-top: 0;
+	--pagedjs-bleed-right: 0;
+	--pagedjs-bleed-bottom: 0;
+	--pagedjs-bleed-left: 0;
+	--pagedjs-crop-color: black;
+	--pagedjs-crop-offset: 2mm;
+	--pagedjs-crop-stroke: 1px;
+	--pagedjs-cross-size: 5mm;
+	--pagedjs-mark-cross-display: none;
+	--pagedjs-mark-crop-display: none;
+	--pagedjs-page-count: 0;
+}
+
+@page {
+	size: letter;
+	margin: 0;
+}
+
+.pagedjs_sheet {
+	box-sizing: border-box;
+	width: var(--pagedjs-width);
+	height: var(--pagedjs-height);
+	overflow: hidden;
+	position: relative;
+	display: grid;
+	grid-template-columns: [bleed-left] var(--pagedjs-bleed-left) [sheet-center] calc(var(--pagedjs-width) - var(--pagedjs-bleed-left) - var(--pagedjs-bleed-right)) [bleed-right] var(--pagedjs-bleed-right);
+	grid-template-rows: [bleed-top] var(--pagedjs-bleed-top) [sheet-middle] calc(var(--pagedjs-height) - var(--pagedjs-bleed-top) - var(--pagedjs-bleed-bottom)) [bleed-bottom] var(--pagedjs-bleed-bottom);
+}
+
+.pagedjs_bleed {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	flex-wrap: nowrap;
+	overflow: hidden;
+}
+
+.pagedjs_bleed-top {
+	grid-column: bleed-left / -1;
+	grid-row: bleed-top;
+	flex-direction: row;
+}
+
+.pagedjs_bleed-bottom {
+	grid-column: bleed-left / -1;
+	grid-row: bleed-bottom;
+	flex-direction: row;
+}
+
+.pagedjs_bleed-left {
+	grid-column: bleed-left;
+	grid-row: bleed-top / -1;
+	flex-direction: column;
+}
+
+.pagedjs_bleed-right {
+	grid-column: bleed-right;
+	grid-row: bleed-top / -1;
+	flex-direction: column;
+}
+
+.pagedjs_marks-crop {
+	display: var(--pagedjs-mark-crop-display);
+	flex-grow: 0;
+	flex-shrink: 0;
+}
+
+.pagedjs_bleed-top .pagedjs_marks-crop:nth-child(1),
+.pagedjs_bleed-bottom .pagedjs_marks-crop:nth-child(1) {
+	width: calc(var(--pagedjs-bleed-left) - var(--pagedjs-crop-stroke));
+	border-right: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
+}
+
+.pagedjs_bleed-top .pagedjs_marks-crop:nth-child(3),
+.pagedjs_bleed-bottom .pagedjs_marks-crop:nth-child(3) {
+	width: calc(var(--pagedjs-bleed-right) - var(--pagedjs-crop-stroke));
+	border-left: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
+}
+
+.pagedjs_bleed-top .pagedjs_marks-crop {
+	align-self: flex-start;
+	height: calc(var(--pagedjs-bleed-top) - var(--pagedjs-crop-offset));
+}
+
+.pagedjs_bleed-bottom .pagedjs_marks-crop {
+	align-self: flex-end;
+	height: calc(var(--pagedjs-bleed-bottom) - var(--pagedjs-crop-offset));
+}
+
+.pagedjs_bleed-left .pagedjs_marks-crop:nth-child(1),
+.pagedjs_bleed-right .pagedjs_marks-crop:nth-child(1) {
+	height: calc(var(--pagedjs-bleed-top) - var(--pagedjs-crop-stroke));
+	border-bottom: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
+}
+
+.pagedjs_bleed-left .pagedjs_marks-crop:nth-child(3),
+.pagedjs_bleed-right .pagedjs_marks-crop:nth-child(3) {
+	height: calc(var(--pagedjs-bleed-bottom) - var(--pagedjs-crop-stroke));
+	border-top: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
+}
+
+.pagedjs_bleed-left .pagedjs_marks-crop {
+	width: calc(var(--pagedjs-bleed-left) - var(--pagedjs-crop-offset));
+	align-self: flex-start;
+}
+
+.pagedjs_bleed-right .pagedjs_marks-crop {
+	width: calc(var(--pagedjs-bleed-right) - var(--pagedjs-crop-offset));
+	align-self: flex-end;
+}
+
+.pagedjs_marks-middle {
+	display: flex;
+	flex-grow: 1;
+	flex-shrink: 0;
+	align-items: center;
+	justify-content: center;
+}
+
+.pagedjs_marks-cross {
+	display: var(--pagedjs-mark-cross-display);
+	background-image: url(data:image/svg+xml;base64,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);
+  background-repeat: no-repeat;
+  background-position: 50% 50%;
+  background-size: var(--pagedjs-cross-size);
+
+  z-index: 2147483647;
+	width: var(--pagedjs-cross-size);
+	height: var(--pagedjs-cross-size);
+}
+
+.pagedjs_pagebox {
+	box-sizing: border-box;
+	width: var(--pagedjs-pagebox-width);
+	height: var(--pagedjs-pagebox-height);
+	position: relative;
+	display: grid;
+	grid-template-columns: [left] var(--pagedjs-margin-left) [center] calc(var(--pagedjs-pagebox-width) - var(--pagedjs-margin-left) - var(--pagedjs-margin-right)) [right] var(--pagedjs-margin-right);
+	grid-template-rows: [header] var(--pagedjs-margin-top) [page] calc(var(--pagedjs-pagebox-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom)) [footer] var(--pagedjs-margin-bottom);
+	grid-column: sheet-center;
+	grid-row: sheet-middle;
+}
+
+.pagedjs_pagebox * {
+	box-sizing: border-box;
+}
+
+.pagedjs_margin-top {
+	width: calc(var(--pagedjs-pagebox-width) - var(--pagedjs-margin-left) - var(--pagedjs-margin-right));
+	height: var(--pagedjs-margin-top);
+	grid-column: center;
+	grid-row: header;
+	flex-wrap: nowrap;
+	display: grid;
+	grid-template-columns: repeat(3, 1fr);
+	grid-template-rows: 100%;
+}
+
+.pagedjs_margin-top-left-corner-holder {
+	width: var(--pagedjs-margin-left);
+	height: var(--pagedjs-margin-top);
+	display: flex;
+	grid-column: left;
+	grid-row: header;
+}
+
+.pagedjs_margin-top-right-corner-holder {
+	width: var(--pagedjs-margin-right);
+	height: var(--pagedjs-margin-top);
+	display: flex;
+	grid-column: right;
+	grid-row: header;
+}
+
+.pagedjs_margin-top-left-corner {
+	width: var(--pagedjs-margin-left);
+}
+
+.pagedjs_margin-top-right-corner {
+	width: var(--pagedjs-margin-right);
+}
+
+.pagedjs_margin-right {
+	height: calc(var(--pagedjs-pagebox-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
+	width: var(--pagedjs-margin-right);
+	right: 0;
+	grid-column: right;
+	grid-row: page;
+	display: grid;
+	grid-template-rows: repeat(3, 33.3333%);
+	grid-template-columns: 100%;
+}
+
+.pagedjs_margin-bottom {
+	width: calc(var(--pagedjs-pagebox-width) - var(--pagedjs-margin-left) - var(--pagedjs-margin-right));
+	height: var(--pagedjs-margin-bottom);
+	grid-column: center;
+	grid-row: footer;
+	display: grid;
+	grid-template-columns: repeat(3, 1fr);
+	grid-template-rows: 100%;
+}
+
+.pagedjs_margin-bottom-left-corner-holder {
+	width: var(--pagedjs-margin-left);
+	height: var(--pagedjs-margin-bottom);
+	display: flex;
+	grid-column: left;
+	grid-row: footer;
+}
+
+.pagedjs_margin-bottom-right-corner-holder {
+	width: var(--pagedjs-margin-right);
+	height: var(--pagedjs-margin-bottom);
+	display: flex;
+	grid-column: right;
+	grid-row: footer;
+}
+
+.pagedjs_margin-bottom-left-corner {
+	width: var(--pagedjs-margin-left);
+}
+
+.pagedjs_margin-bottom-right-corner {
+	width: var(--pagedjs-margin-right);
+}
+
+
+
+.pagedjs_margin-left {
+	height: calc(var(--pagedjs-pagebox-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
+	width: var(--pagedjs-margin-left);
+	grid-column: left;
+	grid-row: page;
+	display: grid;
+	grid-template-rows: repeat(3, 33.33333%);
+	grid-template-columns: 100%;
+}
+
+.pagedjs_pages .pagedjs_pagebox .pagedjs_margin:not(.hasContent) {
+	visibility: hidden;
+}
+
+.pagedjs_pagebox > .pagedjs_area {
+	grid-column: center;
+	grid-row: page;
+	width: 100%;
+	height: 100%;
+}
+
+.pagedjs_pagebox > .pagedjs_area > .pagedjs_page_content {
+	width: 100%;
+	height: 100%;
+	position: relative;
+	column-fill: auto;
+}
+
+.pagedjs_page {
+	counter-increment: page;
+	width: var(--pagedjs-width);
+	height: var(--pagedjs-height);
+}
+
+.pagedjs_pages {
+	counter-reset: pages var(--pagedjs-page-count);
+}
+
+
+.pagedjs_pagebox .pagedjs_margin-top-left-corner,
+.pagedjs_pagebox .pagedjs_margin-top-right-corner,
+.pagedjs_pagebox .pagedjs_margin-bottom-left-corner,
+.pagedjs_pagebox .pagedjs_margin-bottom-right-corner,
+.pagedjs_pagebox .pagedjs_margin-top-left,
+.pagedjs_pagebox .pagedjs_margin-top-right,
+.pagedjs_pagebox .pagedjs_margin-bottom-left,
+.pagedjs_pagebox .pagedjs_margin-bottom-right,
+.pagedjs_pagebox .pagedjs_margin-top-center,
+.pagedjs_pagebox .pagedjs_margin-bottom-center,
+.pagedjs_pagebox .pagedjs_margin-top-center,
+.pagedjs_pagebox .pagedjs_margin-bottom-center,
+.pagedjs_margin-right-middle,
+.pagedjs_margin-left-middle  {
+	display: flex;
+	align-items: center;
+}
+
+.pagedjs_margin-right-top,
+.pagedjs_margin-left-top  {
+	display: flex;
+	align-items: flex-top;
+}
+
+
+.pagedjs_margin-right-bottom,
+.pagedjs_margin-left-bottom  {
+	display: flex;
+	align-items: flex-end;
+}
+
+
+
+/*
+.pagedjs_pagebox .pagedjs_margin-top-center,
+.pagedjs_pagebox .pagedjs_margin-bottom-center {
+	height: 100%;
+	display: none;
+	align-items: center;
+	flex: 1 0 33%;
+	margin: 0 auto;
+}
+
+.pagedjs_pagebox .pagedjs_margin-top-left-corner,
+.pagedjs_pagebox .pagedjs_margin-top-right-corner,
+.pagedjs_pagebox .pagedjs_margin-bottom-right-corner,
+.pagedjs_pagebox .pagedjs_margin-bottom-left-corner {
+	display: none;
+	align-items: center;
+}
+
+.pagedjs_pagebox .pagedjs_margin-left-top,
+.pagedjs_pagebox .pagedjs_margin-right-top {
+	display: none;
+	align-items: flex-start;
+}
+
+.pagedjs_pagebox .pagedjs_margin-right-middle,
+.pagedjs_pagebox .pagedjs_margin-left-middle {
+	display: none;
+	align-items: center;
+}
+
+.pagedjs_pagebox .pagedjs_margin-left-bottom,
+.pagedjs_pagebox .pagedjs_margin-right-bottom {
+	display: none;
+	align-items: flex-end;
+}
+*/
+
+.pagedjs_pagebox .pagedjs_margin-top-left,
+.pagedjs_pagebox .pagedjs_margin-top-right-corner,
+.pagedjs_pagebox .pagedjs_margin-bottom-left,
+.pagedjs_pagebox .pagedjs_margin-bottom-right-corner { text-align: left; }
+
+.pagedjs_pagebox .pagedjs_margin-top-left-corner,
+.pagedjs_pagebox .pagedjs_margin-top-right,
+.pagedjs_pagebox .pagedjs_margin-bottom-left-corner,
+.pagedjs_pagebox .pagedjs_margin-bottom-right { text-align: right; }
+
+.pagedjs_pagebox .pagedjs_margin-top-center,
+.pagedjs_pagebox .pagedjs_margin-bottom-center,
+.pagedjs_pagebox .pagedjs_margin-left-top,
+.pagedjs_pagebox .pagedjs_margin-left-middle,
+.pagedjs_pagebox .pagedjs_margin-left-bottom,
+.pagedjs_pagebox .pagedjs_margin-right-top,
+.pagedjs_pagebox .pagedjs_margin-right-middle,
+.pagedjs_pagebox .pagedjs_margin-right-bottom { text-align: center; }
+
+.pagedjs_pages .pagedjs_margin .pagedjs_margin-content {
+	width: 100%;
+}
+
+.pagedjs_pages .pagedjs_margin-left .pagedjs_margin-content::after,
+.pagedjs_pages .pagedjs_margin-top .pagedjs_margin-content::after,
+.pagedjs_pages .pagedjs_margin-right .pagedjs_margin-content::after,
+.pagedjs_pages .pagedjs_margin-bottom .pagedjs_margin-content::after {
+	display: block;
+}
+
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-to] {
+	margin-bottom: unset;
+	padding-bottom: unset;
+}
+
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from] {
+	text-indent: unset;
+	margin-top: unset;
+	padding-top: unset;
+	initial-letter: unset;
+}
+
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from] > *::first-letter,
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from]::first-letter {
+	color: unset;
+	font-size: unset;
+	font-weight: unset;
+	font-family: unset;
+	color: unset;
+	line-height: unset;
+	float: unset;
+	padding: unset;
+	margin: unset;
+}
+
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-to]:after,
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-to]::after {
+	content: unset;
+}
+
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from]:before,
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from]::before {
+	content: unset;
+}
+
+.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div li[data-split-from]:first-of-type {
+	list-style: none;
+}
+
+/*
+[data-page]:not([data-split-from]),
+[data-break-before="page"]:not([data-split-from]),
+[data-break-before="always"]:not([data-split-from]),
+[data-break-before="left"]:not([data-split-from]),
+[data-break-before="right"]:not([data-split-from]),
+[data-break-before="recto"]:not([data-split-from]),
+[data-break-before="verso"]:not([data-split-from])
+{
+	break-before: column;
+}
+
+[data-page]:not([data-split-to]),
+[data-break-after="page"]:not([data-split-to]),
+[data-break-after="always"]:not([data-split-to]),
+[data-break-after="left"]:not([data-split-to]),
+[data-break-after="right"]:not([data-split-to]),
+[data-break-after="recto"]:not([data-split-to]),
+[data-break-after="verso"]:not([data-split-to])
+{
+	break-after: column;
+}
+*/
+
+.pagedjs_clear-after::after {
+	content: none !important;
+}
+
+img {
+	height: auto;
+}
+
+@media print {
+	html {
+		width: 100%;
+		height: 100%;
+	}
+	body {
+		margin: 0;
+		padding: 0;
+		width: 100% !important;
+		height: 100% !important;
+		min-width: 100%;
+		max-width: 100%;
+		min-height: 100%;
+		max-height: 100%;
+	}
+	.pagedjs_pages {
+		width: var(--pagedjs-width);
+		display: block !important;
+		transform: none !important;
+		height: 100% !important;
+		min-height: 100%;
+		max-height: 100%;
+		overflow: visible;
+	}
+	.pagedjs_page {
+		margin: 0;
+		padding: 0;
+		max-height: 100%;
+		min-height: 100%;
+		height: 100% !important;
+		page-break-after: always;
+		break-after: page;
+	}
+}
+`;
+
+	async function request(url, options={}) {
+		return new Promise(function(resolve, reject) {
+			let request = new XMLHttpRequest();
+
+			request.open(options.method || 'get', url, true);
+
+			for (let i in options.headers) {
+				request.setRequestHeader(i, options.headers[i]);
+			}
+
+			request.withCredentials = options.credentials=='include';
+
+			request.onload = () => {
+	 			// Chrome returns a status code of 0 for local files
+	 			const status = request.status === 0 && url.startsWith('file://') ? 200 : request.status;
+				resolve(new Response(request.responseText, {status}));
+			};
+
+			request.onerror = reject;
+
+			request.send(options.body || null);
+		});
+	}
+
+	class Polisher {
+		constructor(setup) {
+			this.sheets = [];
+			this.inserted = [];
+
+			this.hooks = {};
+			this.hooks.onUrl = new Hook(this);
+			this.hooks.onAtPage = new Hook(this);
+			this.hooks.onAtMedia = new Hook(this);
+			this.hooks.onRule = new Hook(this);
+			this.hooks.onDeclaration = new Hook(this);
+			this.hooks.onContent = new Hook(this);
+			this.hooks.onImport = new Hook(this);
+
+			this.hooks.beforeTreeParse = new Hook(this);
+			this.hooks.beforeTreeWalk = new Hook(this);
+			this.hooks.afterTreeWalk = new Hook(this);
+
+			if (setup !== false) {
+				this.setup();
+			}
+		}
+
+		setup() {
+			this.base = this.insert(baseStyles);
+			this.styleEl = document.createElement("style");
+			document.head.appendChild(this.styleEl);
+			this.styleSheet = this.styleEl.sheet;
+			return this.styleSheet;
+		}
+
+		async add() {
+			let fetched = [];
+			let urls = [];
+
+			for (var i = 0; i < arguments.length; i++) {
+				let f;
+
+				if (typeof arguments[i] === "object") {
+					for (let url in arguments[i]) {
+						let obj = arguments[i];
+						f = new Promise(function(resolve, reject) {
+							urls.push(url);
+							resolve(obj[url]);
+						});
+					}
+				} else {
+					urls.push(arguments[i]);
+					f = request(arguments[i]).then((response) => {
+						return response.text();
+					});
+				}
+
+
+				fetched.push(f);
+			}
+
+			return await Promise.all(fetched)
+				.then(async (originals) => {
+					let text = "";
+					for (let index = 0; index < originals.length; index++) {
+						text = await this.convertViaSheet(originals[index], urls[index]);
+						this.insert(text);
+					}
+					return text;
+				});
+		}
+
+		async convertViaSheet(cssStr, href) {
+			let sheet = new Sheet(href, this.hooks);
+			await sheet.parse(cssStr);
+
+			// Insert the imported sheets first
+			for (let url of sheet.imported) {
+				let str = await request(url).then((response) => {
+					return response.text();
+				});
+				let text = await this.convertViaSheet(str, url);
+				this.insert(text);
+			}
+
+			this.sheets.push(sheet);
+
+			if (typeof sheet.width !== "undefined") {
+				this.width = sheet.width;
+			}
+			if (typeof sheet.height !== "undefined") {
+				this.height = sheet.height;
+			}
+			if (typeof sheet.orientation !== "undefined") {
+				this.orientation = sheet.orientation;
+			}
+			return sheet.toString();
+		}
+
+		insert(text){
+			let head = document.querySelector("head");
+			let style = document.createElement("style");
+			style.type = "text/css";
+			style.setAttribute("data-pagedjs-inserted-styles", "true");
+
+			style.appendChild(document.createTextNode(text));
+
+			head.appendChild(style);
+
+			this.inserted.push(style);
+			return style;
+		}
+
+		destroy() {
+			this.styleEl.remove();
+			this.inserted.forEach((s) => {
+				s.remove();
+			});
+			this.sheets = [];
+		}
+	}
+
+	class Handler {
+		constructor(chunker, polisher, caller) {
+			let hooks = Object.assign({}, chunker && chunker.hooks, polisher && polisher.hooks, caller && caller.hooks);
+			this.chunker = chunker;
+			this.polisher = polisher;
+			this.caller = caller;
+
+			for (let name in hooks) {
+				if (name in this) {
+					let hook = hooks[name];
+					hook.register(this[name].bind(this));
+				}
+			}
+		}
+	}
+
+	eventEmitter(Handler.prototype);
+
+	// https://www.w3.org/TR/css3-page/#page-size-prop
+
+	var pageSizes = {
+		"A0": {
+			width: {
+				value: 841,
+				unit: "mm"
+			},
+			height: {
+				value: 1189,
+				unit: "mm"
+			}
+		},
+		"A1": {
+			width: {
+				value: 594,
+				unit: "mm"
+			},
+			height: {
+				value: 841,
+				unit: "mm"
+			}
+		},
+		"A2": {
+			width: {
+				value: 420,
+				unit: "mm"
+			},
+			height: {
+				value: 594,
+				unit: "mm"
+			}
+		},
+		"A3": {
+			width: {
+				value: 297,
+				unit: "mm"
+			},
+			height: {
+				value: 420,
+				unit: "mm"
+			}
+		},
+		"A4": {
+			width: {
+				value: 210,
+				unit: "mm"
+			},
+			height: {
+				value: 297,
+				unit: "mm"
+			}
+		},
+		"A5": {
+			width: {
+				value: 148,
+				unit: "mm"
+			},
+			height: {
+				value: 210,
+				unit: "mm"
+			}
+		},
+		"A6": {
+			width: {
+				value: 105,
+				unit: "mm"
+			},
+			height: {
+				value: 148,
+				unit: "mm"
+			}
+		},
+		"A7": {
+			width: {
+				value: 74,
+				unit: "mm"
+			},
+			height: {
+				value: 105,
+				unit: "mm"
+			}
+		},
+		"A8": {
+			width: {
+				value: 52,
+				unit: "mm"
+			},
+			height: {
+				value: 74,
+				unit: "mm"
+			}
+		},
+		"A9": {
+			width: {
+				value: 37,
+				unit: "mm"
+			},
+			height: {
+				value: 52,
+				unit: "mm"
+			}
+		},
+		"A10": {
+			width: {
+				value: 26,
+				unit: "mm"
+			},
+			height: {
+				value: 37,
+				unit: "mm"
+			}
+		},
+		"B4": {
+			width: {
+				value: 250,
+				unit: "mm"
+			},
+			height: {
+				value: 353,
+				unit: "mm"
+			}
+		},
+		"B5": {
+			width: {
+				value: 250,
+				unit: "mm"
+			},
+			height: {
+				value: 250,
+				unit: "mm"
+			}
+		},
+		"letter": {
+			width: {
+				value: 8.5,
+				unit: "in"
+			},
+			height: {
+				value: 11,
+				unit: "in"
+			}
+		},
+		"legal": {
+			width: {
+				value: 8.5,
+				unit: "mm"
+			},
+			height: {
+				value: 14,
+				unit: "mm"
+			}
+		},
+		"ledger": {
+			width: {
+				value: 11,
+				unit: "mm"
+			},
+			height: {
+				value: 17,
+				unit: "mm"
+			}
+		}
+	};
+
+	class AtPage extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+
+			this.pages = {};
+
+			this.width = undefined;
+			this.height = undefined;
+			this.orientation = undefined;
+
+			this.marginalia = {};
+		}
+
+		pageModel(selector) {
+			return {
+				selector: selector,
+				name: undefined,
+				psuedo: undefined,
+				nth: undefined,
+				marginalia: {},
+				width: undefined,
+				height: undefined,
+				orientation: undefined,
+				margin : {
+					top: {},
+					right: {},
+					left: {},
+					bottom: {}
+				},
+				block: {},
+				marks: undefined
+			};
+		}
+
+		// Find and Remove @page rules
+		onAtPage(node, item, list) {
+			let page, marginalia;
+			let selector = "";
+			let named, psuedo, nth;
+			let needsMerge = false;
+
+			if (node.prelude) {
+				named = this.getTypeSelector(node);
+				psuedo = this.getPsuedoSelector(node);
+				nth = this.getNthSelector(node);
+				selector = lib.generate(node.prelude);
+			} else {
+				selector = "*";
+			}
+
+			if (selector in this.pages) {
+				// this.pages[selector] = Object.assign(this.pages[selector], page);
+				// console.log("after", selector, this.pages[selector]);
+
+				// this.pages[selector].added = false;
+				page = this.pages[selector];
+				marginalia = this.replaceMarginalia(node);
+				needsMerge = true;
+			} else {
+				page = this.pageModel(selector);
+				marginalia = this.replaceMarginalia(node);
+				this.pages[selector] = page;
+			}
+
+			page.name = named;
+			page.psuedo = psuedo;
+			page.nth = nth;
+
+			if (needsMerge) {
+				page.marginalia = Object.assign(page.marginalia, marginalia);
+			} else {
+				page.marginalia = marginalia;
+			}
+
+			let declarations = this.replaceDeclartations(node);
+
+			if (declarations.size) {
+				page.size = declarations.size;
+				page.width = declarations.size.width;
+				page.height = declarations.size.height;
+				page.orientation = declarations.size.orientation;
+				page.format = declarations.size.format;
+			}
+
+			if (declarations.bleed && declarations.bleed[0] != "auto") {
+				switch (declarations.bleed.length) {
+					case 4: // top right bottom left
+						page.bleed = {
+							top: declarations.bleed[0],
+							right: declarations.bleed[1],
+							bottom: declarations.bleed[2],
+							left: declarations.bleed[3]
+						};
+						break;
+					case 3: // top right bottom right
+						page.bleed = {
+							top: declarations.bleed[0],
+							right: declarations.bleed[1],
+							bottom: declarations.bleed[2],
+							left: declarations.bleed[1]
+						};
+						break;
+					case 2: // top right top right
+						page.bleed = {
+							top: declarations.bleed[0],
+							right: declarations.bleed[1],
+							bottom: declarations.bleed[0],
+							left: declarations.bleed[1]
+						};
+						break;
+					default:
+						page.bleed = {
+							top: declarations.bleed[0],
+							right: declarations.bleed[0],
+							bottom: declarations.bleed[0],
+							left: declarations.bleed[0]
+						};
+				}
+			}
+
+			if (declarations.marks) {
+				if (!declarations.bleed || declarations.bleed && declarations.bleed[0] === "auto") {
+					// Spec say 6pt, but needs more space for marks
+					page.bleed = {
+						top: { value: 6, unit: "mm" },
+						right: { value: 6, unit: "mm" },
+						bottom: { value: 6, unit: "mm" },
+						left: { value: 6, unit: "mm" }
+					};
+				}
+
+				page.marks = declarations.marks;
+			}
+
+			if (declarations.margin) {
+				page.margin = declarations.margin;
+			}
+
+			if (declarations.marks) {
+				page.marks = declarations.marks;
+			}
+
+			if (needsMerge) {
+				page.block.children.appendList(node.block.children);
+			} else {
+				page.block = node.block;
+			}
+
+			// Remove the rule
+			list.remove(item);
+		}
+
+		/* Handled in breaks */
+		/*
+		afterParsed(parsed) {
+			for (let b in this.named) {
+				// Find elements
+				let elements = parsed.querySelectorAll(b);
+				// Add break data
+				for (var i = 0; i < elements.length; i++) {
+					elements[i].setAttribute("data-page", this.named[b]);
+				}
+			}
+		}
+		*/
+
+		afterTreeWalk(ast, sheet) {
+			this.addPageClasses(this.pages, ast, sheet);
+
+			if ("*" in this.pages) {
+				let width = this.pages["*"].width;
+				let height = this.pages["*"].height;
+				let format = this.pages["*"].format;
+				let orientation = this.pages["*"].orientation;
+				let bleed = this.pages["*"].bleed;
+				let marks = this.pages["*"].marks;
+
+
+				if ((width && height) &&
+						(this.width !== width || this.height !== height)) {
+					this.width = width;
+					this.height = height;
+					this.format = format;
+					this.orientation = orientation;
+
+					this.addRootVars(ast, width, height, orientation, bleed, marks);
+					this.addRootPage(ast, this.pages["*"].size, bleed);
+
+					this.emit("size", { width, height, orientation, format, bleed });
+				}
+
+			}
+		}
+
+		getTypeSelector(ast) {
+			// Find page name
+			let name;
+
+			lib.walk(ast, {
+				visit: "TypeSelector",
+				enter: (node, item, list) => {
+					name = node.name;
+				}
+			});
+
+			return name;
+		}
+
+		getPsuedoSelector(ast) {
+			// Find if it has :left & :right & :black & :first
+			let name;
+			lib.walk(ast, {
+				visit: "PseudoClassSelector",
+				enter: (node, item, list) => {
+					if (node.name !== "nth") {
+						name = node.name;
+					}
+				}
+			});
+
+			return name;
+		}
+
+		getNthSelector(ast) {
+			// Find if it has :nth
+			let nth;
+			lib.walk(ast, {
+				visit: "PseudoClassSelector",
+				enter: (node, item, list) => {
+					if (node.name === "nth" && node.children) {
+						let raw = node.children.first();
+						nth = raw.value;
+					}
+				}
+			});
+
+			return nth;
+		}
+
+		replaceMarginalia(ast) {
+			let parsed = {};
+
+			lib.walk(ast.block, {
+				visit: "Atrule",
+				enter: (node, item, list) => {
+					let name = node.name;
+					if (name === "top") {
+						name = "top-center";
+					}
+					if (name === "right") {
+						name = "right-middle";
+					}
+					if (name === "left") {
+						name = "left-middle";
+					}
+					if (name === "bottom") {
+						name = "bottom-center";
+					}
+					parsed[name] = node.block;
+					list.remove(item);
+				}
+			});
+
+			return parsed;
+		}
+
+		replaceDeclartations(ast) {
+			let parsed = {};
+
+			lib.walk(ast.block, {
+				visit: "Declaration",
+				enter: (declaration, dItem, dList) => {
+					let prop = lib.property(declaration.property).name;
+					let value = declaration.value;
+
+					if (prop === "marks") {
+						parsed.marks = [];
+						lib.walk(declaration, {
+							visit: "Identifier",
+							enter: (ident) => {
+								parsed.marks.push(ident.name);
+							}
+						});
+						dList.remove(dItem);
+					} else if (prop === "margin") {
+						parsed.margin = this.getMargins(declaration);
+						dList.remove(dItem);
+					} else if (prop.indexOf("margin-") === 0) {
+						let m = prop.substring("margin-".length);
+						if (!parsed.margin) {
+							parsed.margin = {
+								top: {},
+								right: {},
+								left: {},
+								bottom: {}
+							};
+						}
+						parsed.margin[m] = declaration.value.children.first();
+						dList.remove(dItem);
+					} else if (prop === "size") {
+						parsed.size = this.getSize(declaration);
+						dList.remove(dItem);
+					} else if (prop === "bleed") {
+						parsed.bleed = [];
+
+						lib.walk(declaration, {
+							enter: (subNode) => {
+								switch (subNode.type) {
+									case "String": // bleed: "auto"
+										if (subNode.value.indexOf("auto") > -1) {
+											parsed.bleed.push("auto");
+										}
+										break;
+									case "Dimension": // bleed: 1in 2in, bleed: 20px ect.
+										parsed.bleed.push({
+											value: subNode.value,
+											unit: subNode.unit
+										});
+										break;
+									case "Number":
+										parsed.bleed.push({
+											value: subNode.value,
+											unit: "px"
+										});
+										break;
+									default:
+										// ignore
+								}
+
+							}
+						});
+
+						dList.remove(dItem);
+					}
+
+				}
+			});
+
+			return parsed;
+		}
+
+		getSize(declaration) {
+			let width, height, orientation, format;
+
+			// Get size: Xmm Ymm
+			lib.walk(declaration, {
+				visit: "Dimension",
+				enter: (node, item, list) => {
+					let {value, unit} = node;
+					if (typeof width === "undefined") {
+						width = { value, unit };
+					} else if (typeof height === "undefined") {
+						height = { value, unit };
+					}
+				}
+			});
+
+			// Get size: "A4"
+			lib.walk(declaration, {
+				visit: "String",
+				enter: (node, item, list) => {
+					let name = node.value.replace(/["|']/g, "");
+					let s = pageSizes[name];
+					if (s) {
+						width = s.width;
+						height = s.height;
+					}
+				}
+			});
+
+			// Get Format or Landscape or Portrait
+			lib.walk(declaration, {
+				visit: "Identifier",
+				enter: (node, item, list) => {
+					let name = node.name;
+					if (name === "landscape" || name === "portrait") {
+						orientation = node.name;
+					} else if (name !== "auto") {
+						let s = pageSizes[name];
+						if (s) {
+							width = s.width;
+							height = s.height;
+						}
+						format = name;
+					}
+				}
+			});
+
+			return {
+				width,
+				height,
+				orientation,
+				format
+			};
+		}
+
+		getMargins(declaration) {
+			let margins = [];
+			let margin = {
+				top: {},
+				right: {},
+				left: {},
+				bottom: {}
+			};
+
+			lib.walk(declaration, {
+				visit: "Dimension",
+				enter: (node, item, list) => {
+					margins.push(node);
+				}
+			});
+
+			if (margins.length === 1) {
+				for (let m in margin) {
+					margin[m] = margins[0];
+				}
+			} else if (margins.length === 2) {
+				margin.top = margins[0];
+				margin.right = margins[1];
+				margin.bottom = margins[0];
+				margin.left = margins[1];
+			} else if (margins.length === 3) {
+				margin.top = margins[0];
+				margin.right = margins[1];
+				margin.bottom = margins[2];
+				margin.left = margins[1];
+			} else if (margins.length === 4) {
+				margin.top = margins[0];
+				margin.right = margins[1];
+				margin.bottom = margins[2];
+				margin.left = margins[3];
+			}
+
+			return margin;
+		}
+
+		addPageClasses(pages, ast, sheet) {
+			// First add * page
+			if ("*" in pages && !pages["*"].added) {
+				let p = this.createPage(pages["*"], ast.children, sheet);
+				sheet.insertRule(p);
+				pages["*"].added = true;
+			}
+			// Add :left & :right
+			if (":left" in pages && !pages[":left"].added) {
+				let left = this.createPage(pages[":left"], ast.children, sheet);
+				sheet.insertRule(left);
+				pages[":left"].added = true;
+			}
+			if (":right" in pages && !pages[":right"].added) {
+				let right = this.createPage(pages[":right"], ast.children, sheet);
+				sheet.insertRule(right);
+				pages[":right"].added = true;
+			}
+			// Add :first & :blank
+			if (":first" in pages && !pages[":first"].first) {
+				let first = this.createPage(pages[":first"], ast.children, sheet);
+				sheet.insertRule(first);
+				pages[":first"].added = true;
+			}
+			if (":blank" in pages && !pages[":blank"].added) {
+				let blank = this.createPage(pages[":blank"], ast.children, sheet);
+				sheet.insertRule(blank);
+				pages[":blank"].added = true;
+			}
+			// Add nth pages
+			for (let pg in pages) {
+				if (pages[pg].nth && !pages[pg].added) {
+					let nth = this.createPage(pages[pg], ast.children, sheet);
+					sheet.insertRule(nth);
+					pages[pg].added = true;
+				}
+			}
+
+			// Add named pages
+			for (let pg in pages) {
+				if (pages[pg].name && !pages[pg].added) {
+					let named = this.createPage(pages[pg], ast.children, sheet);
+					sheet.insertRule(named);
+					pages[pg].added = true;
+				}
+			}
+
+		}
+
+		createPage(page, ruleList, sheet) {
+
+			let selectors = this.selectorsForPage(page);
+			let children = page.block.children.copy();
+			let block = {
+				type: "Block",
+				loc: 0,
+				children: children
+			};
+			let rule = this.createRule(selectors, block);
+
+			this.addMarginVars(page.margin, children, children.first());
+
+			if (page.width) {
+				this.addDimensions(page.width, page.height, page.orientation, children, children.first());
+			}
+
+			if (page.marginalia) {
+				this.addMarginaliaStyles(page, ruleList, rule, sheet);
+				this.addMarginaliaContent(page, ruleList, rule, sheet);
+			}
+
+			return rule;
+		}
+
+		addMarginVars(margin, list, item) {
+			// variables for margins
+			for (let m in margin) {
+				if (typeof margin[m].value !== "undefined") {
+					let value = margin[m].value + (margin[m].unit || "");
+					let mVar = list.createItem({
+						type: "Declaration",
+						property: "--pagedjs-margin-" + m,
+						value: {
+							type: "Raw",
+							value: value
+						}
+					});
+					list.append(mVar, item);
+				}
+			}
+		}
+
+		addDimensions(width, height, orientation, list, item) {
+			let widthString, heightString;
+
+			widthString = CSSValueToString(width);
+			heightString = CSSValueToString(height);
+
+			if (orientation && orientation !== "portrait") {
+				// reverse for orientation
+				[widthString, heightString] = [heightString, widthString];
+			}
+
+			// width variable
+			let wVar = this.createVariable("--pagedjs-pagebox-width", widthString);
+			list.appendData(wVar);
+
+			// height variable
+			let hVar = this.createVariable("--pagedjs-pagebox-height", heightString);
+			list.appendData(hVar);
+
+			// let w = this.createDimension("width", width);
+			// let h = this.createDimension("height", height);
+			// list.appendData(w);
+			// list.appendData(h);
+		}
+
+		addMarginaliaStyles(page, list, item, sheet) {
+			for (let loc in page.marginalia) {
+				let block = lib.clone(page.marginalia[loc]);
+				let hasContent$$1 = false;
+
+				if(block.children.isEmpty()) {
+					continue;
+				}
+
+				lib.walk(block, {
+					visit: "Declaration",
+					enter: (node, item, list) => {
+						if (node.property === "content") {
+							if (node.value.children && node.value.children.first().name === "none") {
+								hasContent$$1 = false;
+							} else {
+								hasContent$$1 = true;
+							}
+							list.remove(item);
+						}
+						if (node.property === "vertical-align") {
+							lib.walk(node, {
+								visit: "Identifier",
+								enter: (identNode, identItem, identlist) => {
+									let name = identNode.name;
+									if (name === "top") {
+										identNode.name = "flex-start";
+									} else if (name === "middle") {
+										identNode.name = "center";
+									} else if (name === "bottom") {
+										identNode.name = "flex-end";
+									}
+								}
+							});
+							node.property = "align-items";
+						}
+
+						if (node.property === "width" &&
+							(loc === "top-left" ||
+							 loc === "top-center" ||
+							 loc === "top-right" ||
+							 loc === "bottom-left" ||
+							 loc === "bottom-center" ||
+							 loc === "bottom-right")) {
+							let c = lib.clone(node);
+							c.property = "max-width";
+							list.appendData(c);
+						}
+
+						if (node.property === "height" &&
+							(loc === "left-top" ||
+							 loc === "left-middle" ||
+							 loc === "left-bottom" ||
+							 loc === "right-top" ||
+							 loc === "right-middle" ||
+							 loc === "right-bottom")) {
+							let c = lib.clone(node);
+							c.property = "max-height";
+							list.appendData(c);
+						}
+					}
+				});
+
+				let marginSelectors = this.selectorsForPageMargin(page, loc);
+				let marginRule = this.createRule(marginSelectors, block);
+
+				list.appendData(marginRule);
+
+				let sel = lib.generate({
+					type: "Selector",
+					children: marginSelectors
+				});
+
+				this.marginalia[sel] = {
+					page: page,
+					selector: sel,
+					block: page.marginalia[loc],
+					hasContent: hasContent$$1
+				};
+
+			}
+		}
+
+		addMarginaliaContent(page, list, item, sheet) {
+			let displayNone;
+			// Just content
+			for (let loc in page.marginalia) {
+				let content = lib.clone(page.marginalia[loc]);
+				lib.walk(content, {
+					visit: "Declaration",
+					enter: (node, item, list) => {
+						if (node.property !== "content") {
+							list.remove(item);
+						}
+
+						if (node.value.children && node.value.children.first().name === "none") {
+							displayNone = true;
+						}
+					}
+				});
+
+				if(content.children.isEmpty()) {
+					continue;
+				}
+
+				let displaySelectors = this.selectorsForPageMargin(page, loc);
+				let displayDeclaration;
+
+				displaySelectors.insertData({
+					type: "Combinator",
+					name: ">"
+				});
+
+				displaySelectors.insertData({
+					type: "ClassSelector",
+					name: "pagedjs_margin-content"
+				});
+
+				displaySelectors.insertData({
+					type: "Combinator",
+					name: ">"
+				});
+
+				displaySelectors.insertData({
+					type: "TypeSelector",
+					name: "*"
+				});
+
+				if (displayNone) {
+					displayDeclaration = this.createDeclaration("display", "none");
+				} else {
+					displayDeclaration = this.createDeclaration("display", "block");
+				}
+
+				let displayRule = this.createRule(displaySelectors, [displayDeclaration]);
+				sheet.insertRule(displayRule);
+
+				// insert content rule
+				let contentSelectors = this.selectorsForPageMargin(page, loc);
+
+				contentSelectors.insertData({
+					type: "Combinator",
+					name: ">"
+				});
+
+				contentSelectors.insertData({
+					type: "ClassSelector",
+					name: "pagedjs_margin-content"
+				});
+
+				contentSelectors.insertData({
+					type: "PseudoElementSelector",
+					name: "after",
+					children: null
+				});
+
+				let contentRule = this.createRule(contentSelectors, content);
+				sheet.insertRule(contentRule);
+			}
+		}
+
+		addRootVars(ast, width, height, orientation, bleed, marks) {
+			let rules = [];
+			let selectors = new lib.List();
+			selectors.insertData({
+				type: "PseudoClassSelector",
+				name: "root",
+				children: null
+			});
+
+			let widthString, heightString;
+
+			if (!bleed) {
+				widthString = CSSValueToString(width);
+				heightString = CSSValueToString(height);
+			} else {
+				widthString = `calc( ${CSSValueToString(width)} + ${CSSValueToString(bleed.left)} + ${CSSValueToString(bleed.right)} )`;
+				heightString = `calc( ${CSSValueToString(height)} + ${CSSValueToString(bleed.top)} + ${CSSValueToString(bleed.bottom)} )`;
+
+				let bleedTop = this.createVariable("--pagedjs-bleed-top", CSSValueToString(bleed.top));
+				let bleedRight = this.createVariable("--pagedjs-bleed-right", CSSValueToString(bleed.right));
+				let bleedBottom = this.createVariable("--pagedjs-bleed-bottom", CSSValueToString(bleed.bottom));
+				let bleedLeft = this.createVariable("--pagedjs-bleed-left", CSSValueToString(bleed.left));
+
+				let pageWidthVar = this.createVariable("--pagedjs-width", CSSValueToString(width));
+				let pageHeightVar = this.createVariable("--pagedjs-height", CSSValueToString(height));
+
+				rules.push(bleedTop, bleedRight, bleedBottom, bleedLeft, pageWidthVar, pageHeightVar);
+			}
+
+			if (marks) {
+				marks.forEach((mark) => {
+					let markDisplay = this.createVariable("--pagedjs-mark-" + mark + "-display", "block");
+					rules.push(markDisplay);
+				});
+			}
+
+			// orientation variable
+			if (orientation) {
+				let oVar = this.createVariable("--pagedjs-orientation", orientation);
+				rules.push(oVar);
+
+				if (orientation !== "portrait") {
+					// reverse for orientation
+					[widthString, heightString] = [heightString, widthString];
+				}
+			}
+
+			let wVar = this.createVariable("--pagedjs-width", widthString);
+			let hVar = this.createVariable("--pagedjs-height", heightString);
+
+			rules.push(wVar, hVar);
+
+			let rule = this.createRule(selectors, rules);
+
+			ast.children.appendData(rule);
+		}
+
+		/*
+		@page {
+			size: var(--pagedjs-width) var(--pagedjs-height);
+			margin: 0;
+			padding: 0;
+		}
+		*/
+		addRootPage(ast, size, bleed) {
+			let { width, height, orientation, format } = size;
+			let children = new lib.List();
+			let dimensions = new lib.List();
+
+			if (bleed) {
+				let widthCalculations = new lib.List();
+				let heightCalculations = new lib.List();
+
+				// width
+				widthCalculations.appendData({
+					type: "Dimension",
+					unit: width.unit,
+					value: width.value
+				});
+
+				widthCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				widthCalculations.appendData({
+					type: "Operator",
+					value: "+"
+				});
+
+				widthCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				widthCalculations.appendData({
+					type: "Dimension",
+					unit: bleed.left.unit,
+					value: bleed.left.value
+				});
+
+				widthCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				widthCalculations.appendData({
+					type: "Operator",
+					value: "+"
+				});
+
+				widthCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				widthCalculations.appendData({
+					type: "Dimension",
+					unit: bleed.right.unit,
+					value: bleed.right.value
+				});
+
+				// height
+				heightCalculations.appendData({
+					type: "Dimension",
+					unit: height.unit,
+					value: height.value
+				});
+
+				heightCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				heightCalculations.appendData({
+					type: "Operator",
+					value: "+"
+				});
+
+				heightCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				heightCalculations.appendData({
+					type: "Dimension",
+					unit: bleed.top.unit,
+					value: bleed.top.value
+				});
+
+				heightCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				heightCalculations.appendData({
+					type: "Operator",
+					value: "+"
+				});
+
+				heightCalculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				heightCalculations.appendData({
+					type: "Dimension",
+					unit: bleed.bottom.unit,
+					value: bleed.bottom.value
+				});
+
+				dimensions.appendData({
+					type: "Function",
+					name: "calc",
+					children: widthCalculations
+				});
+
+				dimensions.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				dimensions.appendData({
+					type: "Function",
+					name: "calc",
+					children: heightCalculations
+				});
+
+			} else if (format) {
+				dimensions.appendData({
+					type: "Identifier",
+					name: format
+				});
+
+				if (orientation) {
+					dimensions.appendData({
+						type: "WhiteSpace",
+						value: " "
+					});
+
+					dimensions.appendData({
+						type: "Identifier",
+						name: orientation
+					});
+				}
+			} else {
+				dimensions.appendData({
+					type: "Dimension",
+					unit: width.unit,
+					value: width.value
+				});
+
+				dimensions.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				dimensions.appendData({
+					type: "Dimension",
+					unit: height.unit,
+					value: height.value
+				});
+			}
+
+			children.appendData({
+				type: "Declaration",
+				property: "size",
+				loc: null,
+				value: {
+					type: "Value",
+					children: dimensions
+				}
+			});
+
+			children.appendData({
+				type: "Declaration",
+				property: "margin",
+				loc: null,
+				value: {
+					type: "Value",
+					children: [{
+						type: "Dimension",
+						unit: "px",
+						value: 0
+					}]
+				}
+			});
+
+			children.appendData({
+				type: "Declaration",
+				property: "padding",
+				loc: null,
+				value: {
+					type: "Value",
+					children: [{
+						type: "Dimension",
+						unit: "px",
+						value: 0
+					}]
+				}
+			});
+
+
+			let rule = ast.children.createItem({
+				type: "Atrule",
+				prelude: null,
+				name: "page",
+				block: {
+					type: "Block",
+					loc: null,
+					children: children
+				}
+			});
+
+			ast.children.append(rule);
+		}
+
+		getNth(nth) {
+			let n = nth.indexOf("n");
+			let plus = nth.indexOf("+");
+			let splitN = nth.split("n");
+			let splitP = nth.split("+");
+			let a = null;
+			let b = null;
+			if (n > -1) {
+				a = splitN[0];
+				if (plus > -1) {
+					b = splitP[1];
+				}
+			} else {
+				b = nth;
+			}
+
+			return {
+				type: "Nth",
+				loc: null,
+				selector: null,
+				nth: {
+					type: "AnPlusB",
+					loc: null,
+					a: a,
+					b: b
+				}
+			};
+		}
+
+		addPageAttributes(page, start, pages) {
+			let named = start.dataset.page;
+
+			if (named) {
+				page.name = named;
+				page.element.classList.add("pagedjs_named_page");
+				page.element.classList.add("pagedjs_" + named + "_page");
+
+				if (!start.dataset.splitFrom) {
+					page.element.classList.add("pagedjs_" + named + "_first_page");
+				}
+			}
+		}
+
+		getStartElement(content, breakToken) {
+			let node = breakToken && breakToken.node;
+
+			if (!content && !breakToken) {
+				return;
+			}
+
+			// No break
+			if (!node) {
+				return content.children[0];
+			}
+
+			// Top level element
+			if (node.nodeType === 1 && node.parentNode.nodeType === 11) {
+				return node;
+			}
+
+			// Named page
+			if (node.nodeType === 1 && node.dataset.page) {
+				return node;
+			}
+
+			// Get top level Named parent
+			let fragment = rebuildAncestors(node);
+			let pages = fragment.querySelectorAll("[data-page]");
+
+			if (pages.length) {
+				return pages[pages.length - 1];
+			} else {
+				return fragment.children[0];
+			}
+		}
+
+		beforePageLayout(page, contents, breakToken, chunker) {
+			let start = this.getStartElement(contents, breakToken);
+			if (start) {
+				this.addPageAttributes(page, start, chunker.pages);
+			}
+		}
+
+		afterPageLayout(fragment, page, breakToken, chunker) {
+			for (let m in this.marginalia) {
+				let margin = this.marginalia[m];
+				let sels = m.split(" ");
+
+				let content;
+				if (page.element.matches(sels[0]) && margin.hasContent) {
+					content = page.element.querySelector(sels[1]);
+					content.classList.add("hasContent");
+				}
+			}
+
+			// check center
+			["top", "bottom"].forEach((loc) => {
+				let marginGroup = page.element.querySelector(".pagedjs_margin-" + loc);
+				let center = page.element.querySelector(".pagedjs_margin-" + loc + "-center");
+				let left = page.element.querySelector(".pagedjs_margin-" + loc + "-left");
+				let right = page.element.querySelector(".pagedjs_margin-" + loc + "-right");
+
+				let centerContent = center.classList.contains("hasContent");
+				let leftContent = left.classList.contains("hasContent");
+				let rightContent = right.classList.contains("hasContent");
+				let centerWidth, leftWidth, rightWidth;
+
+				if (leftContent) {
+					leftWidth = window.getComputedStyle(left)["max-width"];
+				}
+
+				if (rightContent) {
+					rightWidth = window.getComputedStyle(right)["max-width"];
+				}
+
+
+				if (centerContent) {
+					centerWidth = window.getComputedStyle(center)["max-width"];
+
+					if(centerWidth === "none" || centerWidth === "auto") {
+						if(!leftContent && !rightContent){
+							marginGroup.style["grid-template-columns"] = "0 1fr 0";
+						}else if(leftContent){
+							if(!rightContent){
+								if(leftWidth !== "none" && leftWidth !== "auto"){
+									marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + leftWidth;
+								}else{
+									marginGroup.style["grid-template-columns"] = "auto auto 1fr";
+									left.style["white-space"] = "nowrap";
+									center.style["white-space"] = "nowrap";
+									let leftOuterWidth = left.offsetWidth;
+									let centerOuterWidth = center.offsetWidth;
+									let outerwidths = leftOuterWidth + centerOuterWidth;
+									let newcenterWidth = centerOuterWidth * 100 / outerwidths;
+									marginGroup.style["grid-template-columns"] = "minmax(16.66%, 1fr) minmax(33%, " + newcenterWidth + "%) minmax(16.66%, 1fr)";
+									left.style["white-space"] = "normal";
+									center.style["white-space"] = "normal";
+								}
+							}else{
+								if(leftWidth !== "none" && leftWidth !== "auto"){
+									if(rightWidth !== "none" && rightWidth !== "auto"){
+										marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + rightWidth;
+									}else{
+										marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + leftWidth;
+									}
+								}else{
+									if(rightWidth !== "none" && rightWidth !== "auto"){
+										marginGroup.style["grid-template-columns"] = rightWidth + " 1fr " + rightWidth;
+									}else{
+										marginGroup.style["grid-template-columns"] = "auto auto 1fr";
+										left.style["white-space"] = "nowrap";
+										center.style["white-space"] = "nowrap";
+										right.style["white-space"] = "nowrap";
+										let leftOuterWidth = left.offsetWidth;
+										let centerOuterWidth = center.offsetWidth;
+										let rightOuterWidth = right.offsetWidth;
+										let outerwidths = leftOuterWidth + centerOuterWidth + rightOuterWidth;
+										let newcenterWidth = centerOuterWidth * 100 / outerwidths;
+										if(newcenterWidth > 40){
+											marginGroup.style["grid-template-columns"] = "minmax(16.66%, 1fr) minmax(33%, " + newcenterWidth + "%) minmax(16.66%, 1fr)";
+										}else{
+											marginGroup.style["grid-template-columns"] = "repeat(3, 1fr)";
+										}
+										left.style["white-space"] = "normal";
+										center.style["white-space"] = "normal";
+										right.style["white-space"] = "normal";
+									}
+								}
+							}
+						}else{
+							if(rightWidth !== "none" && rightWidth !== "auto"){
+								marginGroup.style["grid-template-columns"] = rightWidth + " 1fr " + rightWidth;
+							}else{
+								marginGroup.style["grid-template-columns"] = "auto auto 1fr";
+								right.style["white-space"] = "nowrap";
+								center.style["white-space"] = "nowrap";
+								let rightOuterWidth = right.offsetWidth;
+								let centerOuterWidth = center.offsetWidth;
+								let outerwidths = rightOuterWidth + centerOuterWidth;
+								let newcenterWidth = centerOuterWidth * 100 / outerwidths;
+								marginGroup.style["grid-template-columns"] = "minmax(16.66%, 1fr) minmax(33%, " + newcenterWidth + "%) minmax(16.66%, 1fr)";
+								right.style["white-space"] = "normal";
+								center.style["white-space"] = "normal";
+							}
+						}
+					}else if(centerWidth !== "none" && centerWidth !== "auto"){
+						if(leftContent && leftWidth !== "none" && leftWidth !== "auto"){
+							marginGroup.style["grid-template-columns"] = leftWidth + " " + centerWidth + " 1fr";
+						}else if(rightContent && rightWidth !== "none" && rightWidth !== "auto"){
+							marginGroup.style["grid-template-columns"] = "1fr " + centerWidth + " " + rightWidth;
+						}else{
+							marginGroup.style["grid-template-columns"] = "1fr " + centerWidth + " 1fr";
+						}
+
+					}
+
+				}else{
+					if(leftContent){
+						if(!rightContent){
+							marginGroup.style["grid-template-columns"] = "1fr 0 0";
+						}else{
+							if(leftWidth !== "none" && leftWidth !== "auto"){
+								if(rightWidth !== "none" && rightWidth !== "auto"){
+									marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + rightWidth;
+								}else{
+									marginGroup.style["grid-template-columns"] = leftWidth + " 0 1fr";
+								}
+							}else{
+								if(rightWidth !== "none" && rightWidth !== "auto"){
+									marginGroup.style["grid-template-columns"] = "1fr 0 " + rightWidth;
+								}else{
+									marginGroup.style["grid-template-columns"] = "auto 1fr auto";
+									left.style["white-space"] = "nowrap";
+									right.style["white-space"] = "nowrap";
+									let leftOuterWidth = left.offsetWidth;
+									let rightOuterWidth = right.offsetWidth;
+									let outerwidths = leftOuterWidth + rightOuterWidth;
+									let newLeftWidth = leftOuterWidth * 100 / outerwidths;
+									marginGroup.style["grid-template-columns"] = "minmax(16.66%, " + newLeftWidth  + "%) 0 1fr";
+									left.style["white-space"] = "normal";
+									right.style["white-space"] = "normal";
+								}
+							}
+						}
+					}else{
+						if(rightWidth !== "none" && rightWidth !== "auto"){
+							marginGroup.style["grid-template-columns"] = "1fr 0 " + rightWidth;
+						}else{
+							marginGroup.style["grid-template-columns"] = "0 0 1fr";
+						}
+					}
+				}
+			});
+
+			// check middle
+			["left", "right"].forEach((loc) => {
+				let middle = page.element.querySelector(".pagedjs_margin-" + loc + "-middle.hasContent");
+				let marginGroup = page.element.querySelector(".pagedjs_margin-" + loc);
+				let top = page.element.querySelector(".pagedjs_margin-" + loc + "-top");
+				let bottom = page.element.querySelector(".pagedjs_margin-" + loc + "-bottom");
+				let topContent = top.classList.contains("hasContent");
+				let bottomContent = bottom.classList.contains("hasContent");
+				let middleHeight, topHeight, bottomHeight;
+
+				if (topContent) {
+					topHeight = window.getComputedStyle(top)["max-height"];
+				}
+
+				if (bottomContent) {
+					bottomHeight = window.getComputedStyle(bottom)["max-height"];
+				}
+
+				if (middle) {
+					middleHeight = window.getComputedStyle(middle)["max-height"];
+
+					if(middleHeight === "none" || middleHeight === "auto") {
+						if(!topContent && !bottomContent){
+							marginGroup.style["grid-template-rows"] = "0 1fr 0";
+						}else if(topContent){
+							if(!bottomContent){
+								if(topHeight !== "none" && topHeight !== "auto"){
+									marginGroup.style["grid-template-rows"] = topHeight + " calc(100% - " + topHeight + "*2) " + topHeight;
+								}
+							}else{
+								if(topHeight !== "none" && topHeight !== "auto"){
+									if(bottomHeight !== "none" && bottomHeight !== "auto"){
+										marginGroup.style["grid-template-rows"] = topHeight + " calc(100% - " + topHeight + " - " + bottomHeight + ") " + bottomHeight;
+									}else{
+										marginGroup.style["grid-template-rows"] = topHeight + " calc(100% - " + topHeight + "*2) " + topHeight;
+									}
+								}else{
+									if(bottomHeight !== "none" && bottomHeight !== "auto"){
+										marginGroup.style["grid-template-rows"] = bottomHeight + " calc(100% - " + bottomHeight + "*2) " + bottomHeight;
+									}
+								}
+							}
+						}else{
+							if(bottomHeight !== "none" && bottomHeight !== "auto"){
+								marginGroup.style["grid-template-rows"] = bottomHeight + " calc(100% - " + bottomHeight + "*2) " + bottomHeight;
+							}
+						}
+					}else{
+						if(topContent && topHeight !== "none" && topHeight !== "auto"){
+							marginGroup.style["grid-template-rows"] = topHeight +" " + middleHeight + " calc(100% - (" + topHeight + " + " + middleHeight + "))";
+						}else if(bottomContent && bottomHeight !== "none" && bottomHeight !== "auto"){
+							marginGroup.style["grid-template-rows"] = "1fr " + middleHeight + " " + bottomHeight;
+						}else{
+							marginGroup.style["grid-template-rows"] = "calc((100% - " + middleHeight + ")/2) " + middleHeight + " calc((100% - " + middleHeight + ")/2)";
+						}
+
+					}
+
+				}else{
+					if(topContent){
+						if(!bottomContent){
+							marginGroup.style["grid-template-rows"] = "1fr 0 0";
+						}else{
+							if(topHeight !== "none" && topHeight !== "auto"){
+								if(bottomHeight !== "none" && bottomHeight !== "auto"){
+									marginGroup.style["grid-template-rows"] = topHeight + " 1fr " + bottomHeight;
+								}else{
+									marginGroup.style["grid-template-rows"] = topHeight + " 0 1fr";
+								}
+							}else{
+								if(bottomHeight !== "none" && bottomHeight !== "auto"){
+									marginGroup.style["grid-template-rows"] = "1fr 0 " + bottomHeight;
+								}else{
+									marginGroup.style["grid-template-rows"] = "1fr 0 1fr";
+								}
+							}
+						}
+					}else{
+						if(bottomHeight !== "none" && bottomHeight !== "auto"){
+							marginGroup.style["grid-template-rows"] = "1fr 0 " + bottomHeight;
+						}else{
+							marginGroup.style["grid-template-rows"] = "0 0 1fr";
+						}
+					}
+				}
+
+
+
+			});
+
+		}
+
+		// CSS Tree Helpers
+
+		selectorsForPage(page) {
+			let nthlist;
+			let nth;
+
+			let selectors = new lib.List();
+
+			selectors.insertData({
+				type: "ClassSelector",
+				name: "pagedjs_page"
+			});
+
+			// Named page
+			if (page.name) {
+				selectors.insertData({
+					type: "ClassSelector",
+					name: "pagedjs_named_page"
+				});
+
+				selectors.insertData({
+					type: "ClassSelector",
+					name: "pagedjs_" + page.name + "_page"
+				});
+			}
+
+			// PsuedoSelector
+			if (page.psuedo && !(page.name && page.psuedo === "first")) {
+				selectors.insertData({
+					type: "ClassSelector",
+					name: "pagedjs_" + page.psuedo + "_page"
+				});
+			}
+
+			if (page.name && page.psuedo === "first") {
+				selectors.insertData({
+					type: "ClassSelector",
+					name: "pagedjs_" + page.name + "_" + page.psuedo + "_page"
+				});
+			}
+
+			// Nth
+			if (page.nth) {
+				nthlist = new lib.List();
+				nth = this.getNth(page.nth);
+
+				nthlist.insertData(nth);
+
+				selectors.insertData({
+					type: "PseudoClassSelector",
+					name: "nth-of-type",
+					children: nthlist
+				});
+			}
+
+			return selectors;
+		}
+
+		selectorsForPageMargin(page, margin) {
+			let selectors = this.selectorsForPage(page);
+
+			selectors.insertData({
+				type: "Combinator",
+				name: " "
+			});
+
+			selectors.insertData({
+				type: "ClassSelector",
+				name: "pagedjs_margin-" + margin
+			});
+
+			return selectors;
+		}
+
+		createDeclaration(property, value, important) {
+			let children = new lib.List();
+
+			children.insertData({
+				type: "Identifier",
+				loc: null,
+				name: value
+			});
+
+			return {
+				type: "Declaration",
+				loc: null,
+				important: important,
+				property: property,
+				value: {
+					type: "Value",
+					loc: null,
+					children: children
+				}
+			};
+		}
+
+		createVariable(property, value) {
+			return {
+				type: "Declaration",
+				loc: null,
+				property: property,
+				value: {
+					type: "Raw",
+					value: value
+				}
+			};
+		}
+
+		createCalculatedDimension(property, items, important, operator="+") {
+			let children = new lib.List();
+			let calculations = new lib.List();
+
+			items.forEach((item, index) => {
+				calculations.appendData({
+					type: "Dimension",
+					unit: item.unit,
+					value: item.value
+				});
+
+				calculations.appendData({
+					type: "WhiteSpace",
+					value: " "
+				});
+
+				if (index + 1 < items.length) {
+					calculations.appendData({
+						type: "Operator",
+						value: operator
+					});
+
+					calculations.appendData({
+						type: "WhiteSpace",
+						value: " "
+					});
+				}
+			});
+
+			children.insertData({
+				type: "Function",
+				loc: null,
+				name: "calc",
+				children: calculations
+			});
+
+			return {
+				type: "Declaration",
+				loc: null,
+				important: important,
+				property: property,
+				value: {
+					type: "Value",
+					loc: null,
+					children: children
+				}
+			};
+		}
+
+		createDimension(property, cssValue, important) {
+			let children = new lib.List();
+
+			children.insertData({
+				type: "Dimension",
+				loc: null,
+				value: cssValue.value,
+				unit: cssValue.unit
+			});
+
+			return {
+				type: "Declaration",
+				loc: null,
+				important: important,
+				property: property,
+				value: {
+					type: "Value",
+					loc: null,
+					children: children
+				}
+			};
+		}
+
+		createBlock(declarations) {
+			let block = new lib.List();
+
+			declarations.forEach((declaration) => {
+				block.insertData(declaration);
+			});
+
+			return {
+				type: "Block",
+				loc: null,
+				children: block
+			};
+		}
+
+		createRule(selectors, block) {
+			let selectorList = new lib.List();
+			selectorList.insertData({
+				type: "Selector",
+				children: selectors
+			});
+
+			if (Array.isArray(block)) {
+				block = this.createBlock(block);
+			}
+
+			return {
+				type: "Rule",
+				prelude: {
+					type: "SelectorList",
+					children: selectorList
+				},
+				block: block
+			};
+		}
+
+	}
+
+	class Breaks extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+
+			this.breaks = {};
+		}
+
+		onDeclaration(declaration, dItem, dList, rule) {
+			let property = declaration.property;
+
+			if (property === "page") {
+				let children = declaration.value.children.first();
+				let value = children.name;
+				let selector = lib.generate(rule.ruleNode.prelude);
+				let name = value;
+
+				let breaker = {
+					property: property,
+					value: value,
+					selector: selector,
+					name: name
+				};
+
+				selector.split(",").forEach((s) => {
+					if (!this.breaks[s]) {
+						this.breaks[s] = [breaker];
+					} else {
+						this.breaks[s].push(breaker);
+					}
+				});
+
+				dList.remove(dItem);
+			}
+
+			if (property === "break-before" ||
+					property === "break-after" ||
+					property === "page-break-before" ||
+					property === "page-break-after"
+			) {
+				let child$$1 = declaration.value.children.first();
+				let value = child$$1.name;
+				let selector = lib.generate(rule.ruleNode.prelude);
+
+				if (property === "page-break-before") {
+					property = "break-before";
+				} else if (property === "page-break-after") {
+					property = "break-after";
+				}
+
+				let breaker = {
+					property: property,
+					value: value,
+					selector: selector
+				};
+
+				selector.split(",").forEach((s) => {
+					if (!this.breaks[s]) {
+						this.breaks[s] = [breaker];
+					} else {
+						this.breaks[s].push(breaker);
+					}
+				});
+
+				// Remove from CSS -- handle right / left in module
+				dList.remove(dItem);
+			}
+		}
+
+		afterParsed(parsed) {
+			this.processBreaks(parsed, this.breaks);
+		}
+
+		processBreaks(parsed, breaks) {
+			for (let b in breaks) {
+				// Find elements
+				let elements = parsed.querySelectorAll(b);
+				// Add break data
+				for (var i = 0; i < elements.length; i++) {
+					for (let prop of breaks[b]) {
+
+						if (prop.property === "break-after") {
+							let nodeAfter$$1 = elementAfter(elements[i], parsed);
+
+							elements[i].setAttribute("data-break-after", prop.value);
+
+							if (nodeAfter$$1) {
+								nodeAfter$$1.setAttribute("data-previous-break-after", prop.value);
+							}
+						} else if (prop.property === "page") {
+							elements[i].setAttribute("data-page", prop.value);
+
+							let nodeAfter$$1 = elementAfter(elements[i], parsed);
+
+							if (nodeAfter$$1) {
+								nodeAfter$$1.setAttribute("data-after-page", prop.value);
+							}
+						} else {
+							elements[i].setAttribute("data-" + prop.property, prop.value);
+						}
+					}
+				}
+			}
+		}
+
+		mergeBreaks(pageBreaks, newBreaks) {
+			for (let b in newBreaks) {
+				if (b in pageBreaks) {
+					pageBreaks[b] = pageBreaks[b].concat(newBreaks[b]);
+				} else {
+					pageBreaks[b] = newBreaks[b];
+				}
+			}
+			return pageBreaks;
+		}
+
+		addBreakAttributes(pageElement, page) {
+			let before = pageElement.querySelector("[data-break-before]");
+			let after = pageElement.querySelector("[data-break-after]");
+			let previousBreakAfter = pageElement.querySelector("[data-previous-break-after]");
+
+			if (before) {
+				if (before.dataset.splitFrom) {
+					page.splitFrom = before.dataset.splitFrom;
+					pageElement.setAttribute("data-split-from", before.dataset.splitFrom);
+				} else if (before.dataset.breakBefore && before.dataset.breakBefore !== "avoid") {
+					page.breakBefore = before.dataset.breakBefore;
+					pageElement.setAttribute("data-break-before", before.dataset.breakBefore);
+				}
+			}
+
+			if (after && after.dataset) {
+				if (after.dataset.splitTo) {
+					page.splitTo = after.dataset.splitTo;
+					pageElement.setAttribute("data-split-to", after.dataset.splitTo);
+				} else if (after.dataset.breakAfter && after.dataset.breakAfter !== "avoid") {
+					page.breakAfter = after.dataset.breakAfter;
+					pageElement.setAttribute("data-break-after", after.dataset.breakAfter);
+				}
+			}
+
+			if (previousBreakAfter && previousBreakAfter.dataset) {
+				if (previousBreakAfter.dataset.previousBreakAfter && previousBreakAfter.dataset.previousBreakAfter !== "avoid") {
+					page.previousBreakAfter = previousBreakAfter.dataset.previousBreakAfter;
+				}
+			}
+		}
+
+		afterPageLayout(pageElement, page) {
+			this.addBreakAttributes(pageElement, page);
+		}
+	}
+
+	class PrintMedia extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+		}
+
+		onAtMedia(node, item, list) {
+			let media = this.getMediaName(node);
+			let rules;
+
+			if (media === "print") {
+				rules = node.block.children;
+
+				// Remove rules from the @media block
+				node.block.children = new lib.List();
+
+				// Append rules to the end of main rules list
+				list.appendList(rules);
+			}
+
+		}
+
+		getMediaName(node) {
+			let media = "";
+
+			if (typeof node.prelude === "undefined" ||
+					node.prelude.type !== "AtrulePrelude" ) {
+				return;
+			}
+
+			lib.walk(node.prelude, {
+				visit: "Identifier",
+				enter: (identNode, iItem, iList) => {
+					media = identNode.name;
+				}
+			});
+			return media;
+		}
+
+
+	}
+
+	class Splits extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+		}
+
+		afterPageLayout(pageElement, page, breakToken, chunker) {
+			let splits = Array.from(pageElement.querySelectorAll("[data-split-from]"));
+			let pages = pageElement.parentNode;
+			let index = Array.prototype.indexOf.call(pages.children, pageElement);
+			let prevPage;
+
+			if (index === 0) {
+				return;
+			}
+
+			prevPage = pages.children[index - 1];
+
+			splits.forEach((split) => {
+				let ref = split.dataset.ref;
+				let from = prevPage.querySelector("[data-ref='"+ ref +"']:not([data-split-to])");
+
+				if (from) {
+					from.dataset.splitTo = ref;
+
+					if (!from.dataset.splitFrom) {
+						from.dataset.splitOriginal = true;
+					}
+
+					this.handleAlignment(from);
+				}
+			});
+		}
+
+		handleAlignment(node) {
+			let styles = window.getComputedStyle(node);
+			let align = styles["text-align"];
+			let alignLast = styles["text-align-last"];
+			if (align === "justify" && alignLast === "auto") {
+				node.style["text-align-last"] = "justify";
+			}
+		}
+
+	}
+
+	class Counters extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+
+			this.styleSheet = polisher.styleSheet;
+			this.counters = {};
+		}
+
+		onDeclaration(declaration, dItem, dList, rule) {
+			let property = declaration.property;
+
+			if (property === "counter-increment") {
+				let inc = this.handleIncrement(declaration, rule);
+				if (inc) {
+					dList.remove(dItem);
+				}
+			} else if (property === "counter-reset") {
+				let reset = this.handleReset(declaration, rule);
+				if (reset) {
+					dList.remove(dItem);
+				}
+			}
+		}
+
+		onContent(funcNode, fItem, fList, declaration, rule) {
+			if (funcNode.name === "counter") ;
+		}
+
+		afterParsed(parsed) {
+			this.processCounters(parsed, this.counters);
+		}
+
+		addCounter(name) {
+			if (name in this.counters) {
+				return this.counters[name];
+			}
+
+			this.counters[name] = {
+				name: name,
+				increments: {},
+				resets: {}
+			};
+
+			return this.counters[name];
+		}
+
+		handleIncrement(declaration, rule) {
+			let identifier = declaration.value.children.first();
+			let number = declaration.value.children.getSize() > 1
+								&& declaration.value.children.last().value;
+			let name = identifier && identifier.name;
+
+			if (name === "page" || name.indexOf("target-counter-") === 0) {
+				return;
+			}
+
+			let selector = lib.generate(rule.ruleNode.prelude);
+
+			let counter;
+			if (!(name in this.counters)) {
+				counter = this.addCounter(name);
+			} else {
+				counter = this.counters[name];
+			}
+
+			return counter.increments[selector] = {
+				selector: selector,
+				number: number || 1
+			};
+		}
+
+		handleReset(declaration, rule) {
+			let identifier = declaration.value.children.first();
+			let number = declaration.value.children.getSize() > 1
+								&& declaration.value.children.last().value;
+			let name = identifier && identifier.name;
+			let selector = lib.generate(rule.ruleNode.prelude);
+			let counter;
+
+			if (!(name in this.counters)) {
+				counter = this.addCounter(name);
+			} else {
+				counter = this.counters[name];
+			}
+
+			return counter.resets[selector] = {
+				selector: selector,
+				number: number || 0
+			};
+		}
+
+		processCounters(parsed, counters) {
+			let counter;
+			for (let c in counters) {
+				counter = this.counters[c];
+				this.processCounterIncrements(parsed, counter);
+				this.processCounterResets(parsed, counter);
+				this.addCounterValues(parsed, counter);
+			}
+		}
+
+		processCounterIncrements(parsed, counter) {
+			let increment;
+			for (let inc in counter.increments) {
+				increment = counter.increments[inc];
+				// Find elements for increments
+				let incrementElements = parsed.querySelectorAll(increment.selector);
+				// Add counter data
+				for (var i = 0; i < incrementElements.length; i++) {
+					incrementElements[i].setAttribute("data-counter-"+ counter.name +"-increment", increment.number);
+				}
+			}
+		}
+
+		processCounterResets(parsed, counter) {
+			let reset;
+			for (let r in counter.resets) {
+				reset = counter.resets[r];
+				// Find elements for resets
+				let resetElements = parsed.querySelectorAll(reset.selector);
+				// Add counter data
+				for (var i = 0; i < resetElements.length; i++) {
+					resetElements[i].setAttribute("data-counter-"+ counter.name +"-reset", reset.number);
+				}
+			}
+		}
+
+		addCounterValues(parsed, counter) {
+			let counterName = counter.name;
+			let elements = parsed.querySelectorAll("[data-counter-"+ counterName +"-reset], [data-counter-"+ counterName +"-increment]");
+
+			let count = 0;
+			let element;
+			let increment, reset;
+
+			for (var i = 0; i < elements.length; i++) {
+				element = elements[i];
+
+				if (element.hasAttribute("data-counter-"+ counterName +"-reset")) {
+					reset = element.getAttribute("data-counter-"+ counterName +"-reset");
+					count = parseInt(reset);
+				}
+
+				if (element.hasAttribute("data-counter-"+ counterName +"-increment")) {
+
+					increment = element.getAttribute("data-counter-"+ counterName +"-increment");
+
+					this.styleSheet.insertRule(`[data-ref="${element.dataset.ref}"] { counter-reset: ${counterName} ${count} }`, this.styleSheet.cssRules.length);
+					this.styleSheet.insertRule(`[data-ref="${element.dataset.ref}"] { counter-increment: ${counterName} ${increment}}`, this.styleSheet.cssRules.length);
+
+					count += parseInt(increment);
+
+					element.setAttribute("data-counter-"+counterName+"-value", count);
+				}
+
+			}
+		}
+
+		afterPageLayout(pageElement, page) {
+			let pgreset = pageElement.querySelectorAll("[data-counter-page-reset]");
+			pgreset.forEach((reset) => {
+				let value = reset.datasetCounterPageReset;
+				this.styleSheet.insertRule(`[data-page-number="${pageElement.dataset.pageNumber}"] { counter-reset: page ${value} }`, this.styleSheet.cssRules.length);
+			});
+		}
+
+	}
+
+	class Lists extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+		}
+		afterParsed(content) {
+			const orderedLists = content.querySelectorAll("ol");
+
+			for (var list of orderedLists) {
+				this.addDataNumbers(list);
+			}
+		}
+
+		afterPageLayout(pageElement, page, breakToken, chunker) {
+			var orderedLists = pageElement.getElementsByTagName("ol");
+			for (var list of orderedLists) {
+				if (list.hasChildNodes()) {
+				list.start = list.firstElementChild.dataset.itemNum;
+				}
+				else {
+					list.parentNode.removeChild(list);
+				}
+			}
+		}
+
+		addDataNumbers(list) {
+			let items = list.children;
+			for (var i = 0; i < items.length; i++) {
+				items[i].setAttribute("data-item-num", i + 1);
+			}
+		}
+
+	}
+
+	var pagedMediaHandlers = [
+		AtPage,
+		Breaks,
+		PrintMedia,
+		Splits,
+		Counters,
+		Lists
+	];
+
+	class RunningHeaders extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+
+			this.runningSelectors = {};
+			this.elements = {};
+		}
+
+		onDeclaration(declaration, dItem, dList, rule) {
+			if (declaration.property === "position") {
+				let selector = lib.generate(rule.ruleNode.prelude);
+				let identifier = declaration.value.children.first().name;
+
+				if (identifier === "running") {
+					let value;
+					lib.walk(declaration, {
+						visit: "Function",
+						enter: (node, item, list) => {
+							value = node.children.first().name;
+						}
+					});
+
+					this.runningSelectors[value] = {
+						identifier: identifier,
+						value: value,
+						selector: selector
+					};
+				}
+			}
+
+			if (declaration.property === "content") {
+
+				lib.walk(declaration, {
+					visit: "Function",
+					enter: (funcNode, fItem, fList) => {
+
+						if (funcNode.name.indexOf("element") > -1) {
+
+							let selector = lib.generate(rule.ruleNode.prelude);
+
+							let func = funcNode.name;
+
+							let value = funcNode.children.first().name;
+
+							let args = [value];
+
+							// we only handle first for now
+							let style = "first";
+
+							selector.split(",").forEach((s) => {
+								// remove before / after
+								s = s.replace(/::after|::before/, "");
+
+								this.elements[s] = {
+									func: func,
+									args: args,
+									value: value,
+									style: style,
+									selector: s,
+									fullSelector: selector
+								};
+							});
+						}
+
+					}
+				});
+			}
+		}
+
+		afterParsed(fragment) {
+			for (let name of Object.keys(this.runningSelectors)) {
+				let set = this.runningSelectors[name];
+				let selected = Array.from(fragment.querySelectorAll(set.selector));
+
+				if (set.identifier === "running") {
+					for (let header of selected) {
+						header.style.display = "none";
+					}
+				}
+
+			}
+		}
+
+		afterPageLayout(fragment) {
+			for (let name of Object.keys(this.runningSelectors)) {
+				let set = this.runningSelectors[name];
+				let selected = fragment.querySelector(set.selector);
+				if (selected) {
+					// let cssVar;
+					if (set.identifier === "running") {
+						// cssVar = selected.textContent.replace(/\\([\s\S])|(["|'])/g,"\\$1$2");
+						// this.styleSheet.insertRule(`:root { --string-${name}: "${cssVar}"; }`, this.styleSheet.cssRules.length);
+						// fragment.style.setProperty(`--string-${name}`, `"${cssVar}"`);
+						set.first = selected;
+					} else {
+						console.warn(set.value + "needs css replacement");
+					}
+				}
+			}
+
+			// move elements
+			if (!this.orderedSelectors) {
+				this.orderedSelectors = this.orderSelectors(this.elements);
+			}
+
+			for (let selector of this.orderedSelectors) {
+				if (selector) {
+
+					let el = this.elements[selector];
+					let selected = fragment.querySelector(selector);
+					if (selected) {
+						let running = this.runningSelectors[el.args[0]];
+						if (running && running.first) {
+							selected.innerHTML = ""; // Clear node
+							// selected.classList.add("pagedjs_clear-after"); // Clear ::after
+							let clone = running.first.cloneNode(true);
+							clone.style.display = null;
+							selected.appendChild(clone);
+						}
+					}
+				}
+			}
+		}
+
+		/**
+		* Assign a weight to @page selector classes
+		* 1) page
+		* 2) left & right
+		* 3) blank
+		* 4) first & nth
+		* 5) named page
+		* 6) named left & right
+		* 7) named first & nth
+		* @param {string} [s] selector string
+		* @return {int} weight
+		*/
+		pageWeight(s) {
+			let weight = 1;
+			let selector = s.split(" ");
+			let parts = selector.length && selector[0].split(".");
+
+			parts.shift(); // remove empty first part
+
+			switch (parts.length) {
+				case 4:
+					if (parts[3] === "pagedjs_first_page") {
+						weight = 7;
+					} else if (parts[3] === "pagedjs_left_page" || parts[3] === "pagedjs_right_page") {
+						weight = 6;
+					}
+					break;
+				case 3:
+					if (parts[1] === "pagedjs_named_page") {
+						if (parts[2].indexOf(":nth-of-type") > -1) {
+							weight = 7;
+						} else {
+							weight = 5;
+						}
+					}
+					break;
+				case 2:
+					if (parts[1] === "pagedjs_first_page") {
+						weight = 4;
+					} else if (parts[1] === "pagedjs_blank_page") {
+						weight = 3;
+					} else if (parts[1] === "pagedjs_left_page" || parts[1] === "pagedjs_right_page") {
+						weight = 2;
+					}
+					break;
+				default:
+					if (parts[0].indexOf(":nth-of-type") > -1) {
+						weight = 4;
+					} else {
+						weight = 1;
+					}
+			}
+
+			return weight;
+		}
+
+		/**
+		* Orders the selectors based on weight
+		*
+		* Does not try to deduplicate base on specifity of the selector
+		* Previous matched selector will just be overwritten
+		* @param {obj} [obj] selectors object
+		* @return {Array} orderedSelectors
+		*/
+		orderSelectors(obj) {
+			let selectors = Object.keys(obj);
+			let weighted = {
+				1: [],
+				2: [],
+				3: [],
+				4: [],
+				5: [],
+				6: [],
+				7: []
+			};
+
+			let orderedSelectors = [];
+
+			for (let s of selectors) {
+				let w = this.pageWeight(s);
+				weighted[w].unshift(s);
+			}
+
+			for (var i = 1; i <= 7; i++) {
+				orderedSelectors = orderedSelectors.concat(weighted[i]);
+			}
+
+			return orderedSelectors;
+		}
+
+		beforeTreeParse(text, sheet) {
+			// element(x) is parsed as image element selector, so update element to element-ident
+			sheet.text = text.replace(/element[\s]*\(([^|^#)]*)\)/g, "element-ident($1)");
+		}
+	}
+
+	class StringSets extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+
+			this.stringSetSelectors = {};
+		}
+
+		onDeclaration(declaration, dItem, dList, rule) {
+			if (declaration.property === "string-set") {
+				let selector = lib.generate(rule.ruleNode.prelude);
+
+				let identifier = declaration.value.children.first().name;
+
+				let value;
+				lib.walk(declaration, {
+					visit: "Function",
+					enter: (node, item, list) => {
+						value = lib.generate(node);
+					}
+				});
+
+				this.stringSetSelectors[identifier] = {
+					identifier: identifier,
+					value: value,
+					selector: selector
+				};
+			}
+		}
+
+		onContent(funcNode, fItem, fList, declaration, rule) {
+			if (funcNode.name === "string") {
+				let identifier = funcNode.children && funcNode.children.first().name;
+				funcNode.name = "var";
+				funcNode.children = new lib.List();
+
+				funcNode.children.append(funcNode.children.createItem({
+					type: "Identifier",
+					loc: null,
+					name: "--pagedjs-string-" + identifier
+				}));
+			}
+		}
+
+		afterPageLayout(fragment) {
+			for (let name of Object.keys(this.stringSetSelectors)) {
+				let set = this.stringSetSelectors[name];
+				let selected = fragment.querySelector(set.selector);
+				if (selected) {
+					let cssVar;
+					if (set.value === "content" || set.value === "content()" || set.value === "content(text)") {
+						cssVar = selected.textContent.replace(/\\([\s\S])|(["|'])/g,"\\$1$2");
+						// this.styleSheet.insertRule(`:root { --pagedjs-string-${name}: "${cssVar}"; }`, this.styleSheet.cssRules.length);
+						// fragment.style.setProperty(`--pagedjs-string-${name}`, `"${cssVar}"`);
+						set.first = cssVar;
+						fragment.style.setProperty(`--pagedjs-string-${name}`, `"${set.first}"`);
+					} else {
+						console.warn(set.value + "needs css replacement");
+					}
+				} else {
+					// Use the previous values
+					if (set.first) {
+						fragment.style.setProperty(`--pagedjs-string-${name}`, `"${set.first}"`);
+					}
+				}
+			}
+		}
+	}
+
+	class TargetCounters extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+
+			this.styleSheet = polisher.styleSheet;
+
+			this.counterTargets = {};
+		}
+
+		onContent(funcNode, fItem, fList, declaration, rule) {
+			if (funcNode.name === "target-counter") {
+				let selector = lib.generate(rule.ruleNode.prelude);
+				let first = funcNode.children.first();
+				let func = first.name;
+
+				let value = lib.generate(funcNode);
+
+				let args = [];
+
+				first.children.forEach((child) => {
+					if (child.type === "Identifier") {
+						args.push(child.name);
+					}
+				});
+
+				let counter;
+				let style;
+				let styleIdentifier;
+
+				funcNode.children.forEach((child) => {
+					if (child.type === "Identifier") {
+						if (!counter) {
+							counter = child.name;
+						} else if (!style) {
+							styleIdentifier = lib.clone(child);
+							style = child.name;
+						}
+					}
+				});
+
+				let variable = "target-counter-" + UUID();
+
+				selector.split(",").forEach((s) => {
+					this.counterTargets[s] = {
+						func: func,
+						args: args,
+						value: value,
+						counter: counter,
+						style: style,
+						selector: s,
+						fullSelector: selector,
+						variable: variable
+					};
+				});
+
+				// Replace with counter
+				funcNode.name = "counter";
+				funcNode.children = new lib.List();
+				funcNode.children.appendData({
+					type: "Identifier",
+					loc: 0,
+					name: variable
+				});
+				if (styleIdentifier) {
+					funcNode.children.appendData({type: "Operator", loc: null, value: ","});
+					funcNode.children.appendData(styleIdentifier);
+				}
+			}
+		}
+
+		afterPageLayout(fragment, page, breakToken, chunker) {
+			Object.keys(this.counterTargets).forEach((name) => {
+				let target = this.counterTargets[name];
+				let split = target.selector.split("::");
+				let query = split[0];
+
+				let queried = chunker.pagesArea.querySelectorAll(query + ":not([data-" + target.variable + "])");
+
+				queried.forEach((selected, index) => {
+					// TODO: handle func other than attr
+					if (target.func !== "attr") {
+						return;
+					}
+					let val = attr(selected, target.args);
+					let element = chunker.pagesArea.querySelector(querySelectorEscape(val));
+
+					if (element) {
+						let selector = UUID();
+						selected.setAttribute("data-" + target.variable, selector);
+						// TODO: handle other counter types (by query)
+						if (target.counter === "page") {
+							let pages = chunker.pagesArea.querySelectorAll(".pagedjs_page");
+							let pg = 0;
+							for (var i = 0; i < pages.length; i++) {
+								let styles = window.getComputedStyle(pages[i]);
+								let reset = styles["counter-reset"].replace("page", "").trim();
+
+								if (reset !== "none") {
+									pg = parseInt(reset);
+								}
+								pg += 1;
+
+								if (pages[i].contains( element )){
+									break;
+								}
+							}
+
+							let psuedo = "";
+							if (split.length > 1) {
+								psuedo += "::" + split[1];
+							}
+							this.styleSheet.insertRule(`[data-${target.variable}="${selector}"]${psuedo} { counter-reset: ${target.variable} ${pg}; }`, this.styleSheet.cssRules.length);
+						} else {
+							let value = element.getAttribute(`data-counter-${target.counter}-value`);
+							if (value) {
+								this.styleSheet.insertRule(`[data-${target.variable}="${selector}"]${psuedo} { counter-reset: ${target.variable} ${target.variable} ${parseInt(value)}; }`, this.styleSheet.cssRules.length);
+							}
+						}
+					}
+				});
+			});
+		}
+	}
+
+	class TargetText extends Handler {
+		constructor(chunker, polisher, caller) {
+			super(chunker, polisher, caller);
+
+			this.styleSheet = polisher.styleSheet;
+			this.textTargets = {};
+		}
+
+		onContent(funcNode, fItem, fList, declaration, rule) {
+			if (funcNode.name === "target-text") {
+				let selector = lib.generate(rule.ruleNode.prelude);
+				let first = funcNode.children.first();
+				let last = funcNode.children.last();
+				let func = first.name;
+
+				let value = lib.generate(funcNode);
+
+				let args = [];
+
+				first.children.forEach((child) => {
+					if (child.type === "Identifier") {
+						args.push(child.name);
+					}
+				});
+
+				let style;
+				if (last !== first) {
+					style = last.name;
+				}
+
+				let variable = "--pagedjs-" + UUID();
+
+				selector.split(",").forEach((s) => {
+					this.textTargets[s] = {
+						func: func,
+						args: args,
+						value: value,
+						style: style || "content",
+						selector: s,
+						fullSelector: selector,
+						variable: variable
+					};
+				});
+
+				// Replace with variable
+				funcNode.name = "var";
+				funcNode.children = new lib.List();
+				funcNode.children.appendData({
+					type: "Identifier",
+					loc: 0,
+					name: variable
+				});
+			}
+		}
+
+		afterParsed(fragment) {
+			Object.keys(this.textTargets).forEach((name) => {
+				let target = this.textTargets[name];
+				let split = target.selector.split("::");
+				let query = split[0];
+				let queried = fragment.querySelectorAll(query);
+				queried.forEach((selected, index) => {
+					let val = attr(selected, target.args);
+					let element = fragment.querySelector(querySelectorEscape(val));
+					if (element) {
+						if (target.style === "content") {
+							let selector = UUID();
+							selected.setAttribute("data-target-text", selector);
+
+							let psuedo = "";
+							if (split.length > 1) {
+								psuedo += "::" + split[1];
+							}
+
+							let textContent = element.textContent.trim().replace(/["']/g, (match) => {
+								return "\\" + match;
+							}).replace(/[\n]/g, (match) => {
+								return "\\00000A";
+							});
+
+							// this.styleSheet.insertRule(`[data-target-text="${selector}"]${psuedo} { content: "${element.textContent}" }`, this.styleSheet.cssRules.length);
+							this.styleSheet.insertRule(`[data-target-text="${selector}"]${psuedo} { ${target.variable}: "${textContent}" }`, this.styleSheet.cssRules.length);
+
+						}
+					} else {
+						console.warn("missed target", val);
+					}
+				});
+
+			});
+		}
+	}
+
+	var generatedContentHandlers = [
+		RunningHeaders,
+		StringSets,
+		TargetCounters,
+		TargetText
+	];
+
+	var isImplemented$3 = function () {
+		var from = Array.from, arr, result;
+		if (typeof from !== "function") return false;
+		arr = ["raz", "dwa"];
+		result = from(arr);
+		return Boolean(result && (result !== arr) && (result[1] === "dwa"));
+	};
+
+	var validTypes = { object: true, symbol: true };
+
+	var isImplemented$4 = function () {
+		if (typeof Symbol !== 'function') return false;
+		try { } catch (e) { return false; }
+
+		// Return 'true' also for polyfills
+		if (!validTypes[typeof Symbol.iterator]) return false;
+		if (!validTypes[typeof Symbol.toPrimitive]) return false;
+		if (!validTypes[typeof Symbol.toStringTag]) return false;
+
+		return true;
+	};
+
+	var isSymbol = function (x) {
+		if (!x) return false;
+		if (typeof x === 'symbol') return true;
+		if (!x.constructor) return false;
+		if (x.constructor.name !== 'Symbol') return false;
+		return (x[x.constructor.toStringTag] === 'Symbol');
+	};
+
+	var validateSymbol = function (value) {
+		if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
+		return value;
+	};
+
+	var create$6 = Object.create, defineProperties = Object.defineProperties
+	  , defineProperty = Object.defineProperty, objPrototype = Object.prototype
+	  , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create$6(null)
+	  , isNativeSafe;
+
+	if (typeof Symbol === 'function') {
+		NativeSymbol = Symbol;
+		try {
+			String(NativeSymbol());
+			isNativeSafe = true;
+		} catch (ignore) {}
+	}
+
+	var generateName = (function () {
+		var created = create$6(null);
+		return function (desc) {
+			var postfix = 0, name, ie11BugWorkaround;
+			while (created[desc + (postfix || '')]) ++postfix;
+			desc += (postfix || '');
+			created[desc] = true;
+			name = '@@' + desc;
+			defineProperty(objPrototype, name, d_1.gs(null, function (value) {
+				// For IE11 issue see:
+				// https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
+				//    ie11-broken-getters-on-dom-objects
+				// https://github.com/medikoo/es6-symbol/issues/12
+				if (ie11BugWorkaround) return;
+				ie11BugWorkaround = true;
+				defineProperty(this, name, d_1(value));
+				ie11BugWorkaround = false;
+			}));
+			return name;
+		};
+	}());
+
+	// Internal constructor (not one exposed) for creating Symbol instances.
+	// This one is used to ensure that `someSymbol instanceof Symbol` always return false
+	HiddenSymbol = function Symbol(description) {
+		if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
+		return SymbolPolyfill(description);
+	};
+
+	// Exposed `Symbol` constructor
+	// (returns instances of HiddenSymbol)
+	var polyfill = SymbolPolyfill = function Symbol(description) {
+		var symbol;
+		if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
+		if (isNativeSafe) return NativeSymbol(description);
+		symbol = create$6(HiddenSymbol.prototype);
+		description = (description === undefined ? '' : String(description));
+		return defineProperties(symbol, {
+			__description__: d_1('', description),
+			__name__: d_1('', generateName(description))
+		});
+	};
+	defineProperties(SymbolPolyfill, {
+		for: d_1(function (key) {
+			if (globalSymbols[key]) return globalSymbols[key];
+			return (globalSymbols[key] = SymbolPolyfill(String(key)));
+		}),
+		keyFor: d_1(function (s) {
+			var key;
+			validateSymbol(s);
+			for (key in globalSymbols) if (globalSymbols[key] === s) return key;
+		}),
+
+		// To ensure proper interoperability with other native functions (e.g. Array.from)
+		// fallback to eventual native implementation of given symbol
+		hasInstance: d_1('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
+		isConcatSpreadable: d_1('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
+			SymbolPolyfill('isConcatSpreadable')),
+		iterator: d_1('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
+		match: d_1('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
+		replace: d_1('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
+		search: d_1('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
+		species: d_1('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
+		split: d_1('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
+		toPrimitive: d_1('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
+		toStringTag: d_1('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
+		unscopables: d_1('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
+	});
+
+	// Internal tweaks for real symbol producer
+	defineProperties(HiddenSymbol.prototype, {
+		constructor: d_1(SymbolPolyfill),
+		toString: d_1('', function () { return this.__name__; })
+	});
+
+	// Proper implementation of methods exposed on Symbol.prototype
+	// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
+	defineProperties(SymbolPolyfill.prototype, {
+		toString: d_1(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
+		valueOf: d_1(function () { return validateSymbol(this); })
+	});
+	defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d_1('', function () {
+		var symbol = validateSymbol(this);
+		if (typeof symbol === 'symbol') return symbol;
+		return symbol.toString();
+	}));
+	defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d_1('c', 'Symbol'));
+
+	// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
+	defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
+		d_1('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
+
+	// Note: It's important to define `toPrimitive` as last one, as some implementations
+	// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
+	// And that may invoke error in definition flow:
+	// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
+	defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
+		d_1('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
+
+	var es6Symbol = isImplemented$4() ? Symbol : polyfill;
+
+	var objToString = Object.prototype.toString
+	  , id = objToString.call(
+		(function () {
+			return arguments;
+		})()
+	);
+
+	var isArguments = function (value) {
+		return objToString.call(value) === id;
+	};
+
+	var objToString$1 = Object.prototype.toString, id$1 = objToString$1.call(noop);
+
+	var isFunction = function (value) {
+		return typeof value === "function" && objToString$1.call(value) === id$1;
+	};
+
+	var isImplemented$5 = function () {
+		var sign = Math.sign;
+		if (typeof sign !== "function") return false;
+		return (sign(10) === 1) && (sign(-20) === -1);
+	};
+
+	var shim$3 = function (value) {
+		value = Number(value);
+		if (isNaN(value) || (value === 0)) return value;
+		return value > 0 ? 1 : -1;
+	};
+
+	var sign = isImplemented$5()
+		? Math.sign
+		: shim$3;
+
+	var abs = Math.abs, floor = Math.floor;
+
+	var toInteger = function (value) {
+		if (isNaN(value)) return 0;
+		value = Number(value);
+		if ((value === 0) || !isFinite(value)) return value;
+		return sign(value) * floor(abs(value));
+	};
+
+	var max$1 = Math.max;
+
+	var toPosInteger = function (value) {
+	 return max$1(0, toInteger(value));
+	};
+
+	var objToString$2 = Object.prototype.toString, id$2 = objToString$2.call("");
+
+	var isString = function (value) {
+		return (
+			typeof value === "string" ||
+			(value &&
+				typeof value === "object" &&
+				(value instanceof String || objToString$2.call(value) === id$2)) ||
+			false
+		);
+	};
+
+	var iteratorSymbol = es6Symbol.iterator
+	  , isArray        = Array.isArray
+	  , call           = Function.prototype.call
+	  , desc           = { configurable: true, enumerable: true, writable: true, value: null }
+	  , defineProperty$1 = Object.defineProperty;
+
+	// eslint-disable-next-line complexity
+	var shim$4 = function (arrayLike /*, mapFn, thisArg*/) {
+		var mapFn = arguments[1]
+		  , thisArg = arguments[2]
+		  , Context
+		  , i
+		  , j
+		  , arr
+		  , length
+		  , code
+		  , iterator
+		  , result
+		  , getIterator
+		  , value;
+
+		arrayLike = Object(validValue(arrayLike));
+
+		if (isValue(mapFn)) validCallable(mapFn);
+		if (!this || this === Array || !isFunction(this)) {
+			// Result: Plain array
+			if (!mapFn) {
+				if (isArguments(arrayLike)) {
+					// Source: Arguments
+					length = arrayLike.length;
+					if (length !== 1) return Array.apply(null, arrayLike);
+					arr = new Array(1);
+					arr[0] = arrayLike[0];
+					return arr;
+				}
+				if (isArray(arrayLike)) {
+					// Source: Array
+					arr = new Array(length = arrayLike.length);
+					for (i = 0; i < length; ++i) arr[i] = arrayLike[i];
+					return arr;
+				}
+			}
+			arr = [];
+		} else {
+			// Result: Non plain array
+			Context = this;
+		}
+
+		if (!isArray(arrayLike)) {
+			if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
+				// Source: Iterator
+				iterator = validCallable(getIterator).call(arrayLike);
+				if (Context) arr = new Context();
+				result = iterator.next();
+				i = 0;
+				while (!result.done) {
+					value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
+					if (Context) {
+						desc.value = value;
+						defineProperty$1(arr, i, desc);
+					} else {
+						arr[i] = value;
+					}
+					result = iterator.next();
+					++i;
+				}
+				length = i;
+			} else if (isString(arrayLike)) {
+				// Source: String
+				length = arrayLike.length;
+				if (Context) arr = new Context();
+				for (i = 0, j = 0; i < length; ++i) {
+					value = arrayLike[i];
+					if (i + 1 < length) {
+						code = value.charCodeAt(0);
+						// eslint-disable-next-line max-depth
+						if (code >= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
+					}
+					value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
+					if (Context) {
+						desc.value = value;
+						defineProperty$1(arr, j, desc);
+					} else {
+						arr[j] = value;
+					}
+					++j;
+				}
+				length = j;
+			}
+		}
+		if (length === undefined) {
+			// Source: array or array-like
+			length = toPosInteger(arrayLike.length);
+			if (Context) arr = new Context(length);
+			for (i = 0; i < length; ++i) {
+				value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
+				if (Context) {
+					desc.value = value;
+					defineProperty$1(arr, i, desc);
+				} else {
+					arr[i] = value;
+				}
+			}
+		}
+		if (Context) {
+			desc.value = null;
+			arr.length = length;
+		}
+		return arr;
+	};
+
+	var from_1 = isImplemented$3()
+		? Array.from
+		: shim$4;
+
+	var isImplemented$6 = function () {
+		var numberIsNaN = Number.isNaN;
+		if (typeof numberIsNaN !== "function") return false;
+		return !numberIsNaN({}) && numberIsNaN(NaN) && !numberIsNaN(34);
+	};
+
+	var shim$5 = function (value) {
+		// eslint-disable-next-line no-self-compare
+		return value !== value;
+	};
+
+	var isNan = isImplemented$6()
+		? Number.isNaN
+		: shim$5;
+
+	var indexOf$2           = Array.prototype.indexOf
+	  , objHasOwnProperty = Object.prototype.hasOwnProperty
+	  , abs$1               = Math.abs
+	  , floor$1             = Math.floor;
+
+	var eIndexOf = function (searchElement /*, fromIndex*/) {
+		var i, length, fromIndex, val;
+		if (!isNan(searchElement)) return indexOf$2.apply(this, arguments);
+
+		length = toPosInteger(validValue(this).length);
+		fromIndex = arguments[1];
+		if (isNaN(fromIndex)) fromIndex = 0;
+		else if (fromIndex >= 0) fromIndex = floor$1(fromIndex);
+		else fromIndex = toPosInteger(this.length) - floor$1(abs$1(fromIndex));
+
+		for (i = fromIndex; i < length; ++i) {
+			if (objHasOwnProperty.call(this, i)) {
+				val = this[i];
+				if (isNan(val)) return i; // Jslint: ignore
+			}
+		}
+		return -1;
+	};
+
+	var forEach$1 = Array.prototype.forEach
+	  , splice  = Array.prototype.splice;
+
+	// eslint-disable-next-line no-unused-vars
+	var remove = function (itemToRemove /*, …item*/) {
+		forEach$1.call(
+			arguments,
+			function (item) {
+				var index = eIndexOf.call(this, item);
+				if (index !== -1) splice.call(this, index, 1);
+			},
+			this
+		);
+	};
+
+	var map = { function: true, object: true };
+
+	var isObject$1 = function (value) {
+		return (isValue(value) && map[typeof value]) || false;
+	};
+
+	var validObject = function (value) {
+		if (!isObject$1(value)) throw new TypeError(value + " is not an Object");
+		return value;
+	};
+
+	var emit           = eventEmitter.methods.emit
+
+	  , defineProperty$2 = Object.defineProperty
+	  , hasOwnProperty$6 = Object.prototype.hasOwnProperty
+	  , getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+	var pipe = function (e1, e2/*, name*/) {
+		var pipes, pipe, desc, name;
+
+		(validObject(e1) && validObject(e2));
+		name = arguments[2];
+		if (name === undefined) name = 'emit';
+
+		pipe = {
+			close: function () { remove.call(pipes, e2); }
+		};
+		if (hasOwnProperty$6.call(e1, '__eePipes__')) {
+			(pipes = e1.__eePipes__).push(e2);
+			return pipe;
+		}
+		defineProperty$2(e1, '__eePipes__', d_1('c', pipes = [e2]));
+		desc = getOwnPropertyDescriptor(e1, name);
+		if (!desc) {
+			desc = d_1('c', undefined);
+		} else {
+			delete desc.get;
+			delete desc.set;
+		}
+		desc.value = function () {
+			var i, emitter, data = from_1(pipes);
+			emit.apply(this, arguments);
+			for (i = 0; (emitter = data[i]); ++i) emit.apply(emitter, arguments);
+		};
+		defineProperty$2(e1, name, desc);
+		return pipe;
+	};
+
+	let registeredHandlers = [...pagedMediaHandlers, ...generatedContentHandlers];
+
+	class Handlers {
+		constructor(chunker, polisher, caller) {
+
+			registeredHandlers.forEach((Handler) => {
+				let handler = new Handler(chunker, polisher, caller);
+				pipe(handler, this);
+			});
+		}
+	}
+
+	eventEmitter(Handlers.prototype);
+
+	function registerHandlers() {
+		for (var i = 0; i < arguments.length; i++) {
+			registeredHandlers.push(arguments[i]);
+		}
+	}
+
+	function initializeHandlers(chunker, polisher, caller) {
+		let handlers = new Handlers(chunker, polisher, caller);
+		return handlers;
+	}
+
+	class Previewer {
+		constructor() {
+			// this.preview = this.getParams("preview") !== "false";
+
+			// Process styles
+			this.polisher = new Polisher(false);
+
+			// Chunk contents
+			this.chunker = new Chunker();
+
+			// Hooks
+			this.hooks = {};
+
+			// default size
+			this.size = {
+				width: {
+					value: 8.5,
+					unit: "in"
+				},
+				height: {
+					value: 11,
+					unit: "in"
+				},
+				format: undefined,
+				orientation: undefined
+			};
+
+			let counter = 0;
+			this.chunker.on("page", (page) => {
+				counter += 1;
+				this.emit("page", page);
+				if (typeof window.PuppeteerLogger !== "undefined") {
+					window.PuppeteerLogger("page", counter);
+				}
+			});
+
+			this.chunker.on("rendering", () => {
+				this.emit("rendering", this.chunker);
+			});
+		}
+
+		initializeHandlers() {
+			let handlers = initializeHandlers(this.chunker, this.polisher, this);
+
+			handlers.on("size", (size) => {
+				this.size = size;
+				this.emit("size", size);
+			});
+
+			return handlers;
+		}
+
+		registerHandlers() {
+			return registerHandlers.apply(registerHandlers, arguments);
+		}
+
+		getParams(name) {
+			let param;
+			let url = new URL(window.location);
+			let params = new URLSearchParams(url.search);
+			for(var pair of params.entries()) {
+				if(pair[0] === name) {
+					param = pair[1];
+				}
+			}
+
+			return param;
+		}
+
+		wrapContent() {
+			// Wrap body in template tag
+			let body = document.querySelector("body");
+
+			// Check if a template exists
+			let template;
+			template = body.querySelector(":scope > template[data-ref='pagedjs-content']");
+
+			if (!template) {
+				// Otherwise create one
+				template = document.createElement("template");
+				template.dataset.ref = "pagedjs-content";
+				template.innerHTML = body.innerHTML;
+				body.innerHTML = "";
+				body.appendChild(template);
+			}
+
+			return template.content;
+		}
+
+		removeStyles(doc=document) {
+			// Get all stylesheets
+			let stylesheets = Array.from(doc.querySelectorAll("link[rel='stylesheet']"));
+			let hrefs = stylesheets.map((sheet) => {
+				sheet.remove();
+				return sheet.href;
+			});
+
+			// Get inline styles
+			let inlineStyles = Array.from(doc.querySelectorAll("style:not([data-pagedjs-inserted-styles])"));
+			inlineStyles.forEach((inlineStyle) => {
+				let obj = {};
+				obj[window.location.href] = inlineStyle.textContent;
+				hrefs.push(obj);
+				inlineStyle.remove();
+			});
+
+			return hrefs;
+		}
+
+		async preview(content, stylesheets, renderTo) {
+
+			if (!content) {
+				content = this.wrapContent();
+			}
+
+			if (!stylesheets) {
+				stylesheets = this.removeStyles();
+			}
+
+			this.polisher.setup();
+
+			this.handlers = this.initializeHandlers();
+
+			await this.polisher.add(...stylesheets);
+
+			let startTime = performance.now();
+
+			// Render flow
+			let flow = await this.chunker.flow(content, renderTo);
+
+			let endTime = performance.now();
+			let msg = "Rendering " + flow.total + " pages took " + (endTime - startTime) + " milliseconds.";
+
+			flow.performance = (endTime - startTime);
+			flow.size = this.size;
+
+			this.emit("rendered", msg, this.size.width && this.size.width.value + this.size.width.unit, this.size.height && this.size.height.value + this.size.height.unit, this.size.orientation, this.size.format);
+			if (typeof window.onPagesRendered !== "undefined") {
+				window.onPagesRendered(msg, this.size.width && this.size.width.value + this.size.width.unit, this.size.height && this.size.height.value + this.size.height.unit, this.size.orientation, this.size.format);
+			}
+
+			return flow;
+		}
+	}
+
+	eventEmitter(Previewer.prototype);
+
+
+
+	var Paged = /*#__PURE__*/Object.freeze({
+		Chunker: Chunker,
+		Polisher: Polisher,
+		Previewer: Previewer,
+		Handler: Handler,
+		registerHandlers: registerHandlers,
+		initializeHandlers: initializeHandlers
+	});
+
+	window.Paged = Paged;
+
+	let ready = new Promise(function(resolve, reject){
+		if (document.readyState === "interactive" || document.readyState === "complete") {
+			resolve(document.readyState);
+			return;
+		}
+
+		document.onreadystatechange = function ($) {
+			if (document.readyState === "interactive") {
+				resolve(document.readyState);
+			}
+		};
+	});
+
+	let config = window.PagedConfig || {
+		auto: true,
+		before: undefined,
+		after: undefined,
+		content: undefined,
+		stylesheets: undefined,
+		renderTo: undefined
+	};
+
+	let previewer = new Previewer(config.content, config.stylesheets, config.renderTo);
+
+
+	ready.then(async function () {
+		let done;
+		if (config.before) {
+			await config.before();
+		}
+
+		if(config.auto !== false) {
+			done = await previewer.preview();
+		}
+
+
+		if (config.after) {
+			await config.after(done);
+		}
+	});
+
+	return previewer;
+
+}));
diff --git a/docs/lua/footnotes.lua b/docs/lua/footnotes.lua
new file mode 100644
index 0000000000..35c75159f8
--- /dev/null
+++ b/docs/lua/footnotes.lua
@@ -0,0 +1,27 @@
+--[[
+    This filter transforms Pandoc's notes in spans.
+    See https://stackoverflow.com/questions/51548827/pandoc-lua-filter-how-to-preserve-footnotes-formatting
+    and https://github.com/jgm/pandoc/pull/4799
+
+    Requires Pandoc >= 2.2.3
+--]]
+
+local options = {} -- where we store pandoc Meta
+local noteId = 0 -- ids for notes
+
+local function getMeta(meta)
+  options = meta
+  return nil -- Do not modify Meta
+end
+
+local function noteToSpan(note)
+  if not options["paged-footnotes"] then return nil end
+  noteId = noteId + 1
+  local inlines = pandoc.utils.blocks_to_inlines(note.content, {pandoc.Str'\010'}) -- insert \n between Pandoc's blocks
+  local attr = {}
+  attr["data-pagedown-footnote-number"] = noteId
+  attr["style"] = "white-space: pre-line;" -- use pre-line to render \n
+  return pandoc.Span(inlines, pandoc.Attr("fn" .. noteId, {"footnote"}, attr))
+end
+
+return {{Meta = getMeta}, {Note = noteToSpan}}
diff --git a/docs/lua/jss.lua b/docs/lua/jss.lua
new file mode 100644
index 0000000000..ee8f841362
--- /dev/null
+++ b/docs/lua/jss.lua
@@ -0,0 +1,99 @@
+--[[
+    A Pandoc filter for the Journal of Statistical Software template
+    This filter performs the following actions:
+    - store plain keywords in a pandoc variable named keywords-plain
+    - calculate the rank for each author
+    - build the DOI from the volume and issue parameters and store it in a variable named doi
+    - use fallback values for missing month, year, volume or issue
+--]]
+local isInteger = function(number)
+  return math.floor(number) == number
+end
+
+local padVolume = function(volume)
+  local volumeString = tostring(volume)
+  if volume < 10 then return "00" .. volumeString end
+  if volume < 100 then return "0" .. volumeString end
+  return volumeString
+end
+
+local padIssue = function(issue)
+  local issueString = tostring(issue)
+  if issue < 10 then return "0" .. issueString end
+  return issueString
+end
+
+local getDOI = function(volume, issue)
+  -- store a fallback DOI
+  local fallback = "10.18637/jss.v000.i00"
+
+  -- if volume or issue is missing, return the fallback DOI
+  if not volume or not issue then return fallback end
+
+  local volumeNumber = tonumber(pandoc.utils.stringify(volume))
+  local issueNumber = tonumber(pandoc.utils.stringify(issue))
+
+  -- if volume or issue cannot be coerced to a number, return the fallback DOI
+  if not volumeNumber or not issueNumber then return fallback end
+
+  -- if volume or issue is a number lesser than 1, return the fallback DOI
+  if volumeNumber < 1 or issueNumber < 1 then return fallback end
+
+  -- if volume or issue is not an integer, return the fallback DOI
+  if not isInteger(volumeNumber) or not isInteger(issueNumber) then return fallback end
+
+  -- build the DOI
+  return "10.18637/jss.v" .. padVolume(volumeNumber) .. ".i" .. padIssue(issueNumber)
+end
+
+
+Meta = function(meta)
+  ---------------------------------------
+  --           Keywords                --
+  ---------------------------------------
+  -- Test if there is one keyword:
+  if not meta.keywords then error("At least one keyword must be supplied.") end
+  -- Store plain keywords:
+  local plainKeywords = {}
+
+  if meta.keywords.t == "MetaList" then
+    for i, v in ipairs(meta.keywords) do
+      plainKeywords[i] = pandoc.utils.stringify(v)
+    end
+  else
+    -- we have only one keyword
+    plainKeywords = {pandoc.utils.stringify(meta.keywords)}
+  end
+
+  meta["keywords-plain"] = plainKeywords
+
+  ---------------------------------------
+  --              Author               --
+  ---------------------------------------
+  local author = meta.author
+
+  if author.t == "MetaInlines" then
+    meta.author = {data = author, rank = "1"}
+  else
+    for i, v in ipairs(author) do
+      meta.author[i] = {data = v, rank = tostring(i)}
+    end
+  end
+
+  ----------------------------------------
+  --  Build DOI from volume and issue   --
+  ----------------------------------------
+  meta.doi = getDOI(meta.volume, meta.issue)
+
+  ----------------------------------------
+  -- Fallback values for missing params --
+  ----------------------------------------
+  if not meta.month then meta.month = "MMMMMM" end
+  if not meta.year then meta.year = "YYYY" end
+  if not meta.volume then meta.volume = "VV" end
+  if not meta.issue then meta.issue = "II" end
+  if not meta.submitdate then meta.submitdate = "yyyy-mm-dd" end
+  if not meta.acceptdate then meta.acceptdate = "yyyy-mm-dd" end
+
+  return meta
+end
diff --git a/docs/lua/loft.lua b/docs/lua/loft.lua
new file mode 100644
index 0000000000..52a3bc0422
--- /dev/null
+++ b/docs/lua/loft.lua
@@ -0,0 +1,121 @@
+--[[
+    A pandoc filter that generates Lists Of Figures and Tables (loft).
+    This filter enables the lot and lof options as in LaTeX output formats.
+
+    The user can also customise the titles with lot-title and lof-title:
+    ---
+    lof:
+    lof-title: "Illustrations" # markdown styling is supported
+    ---
+--]]
+
+local options = {}     -- where we store pandoc Meta
+local tablesList = {}  -- where we store the list of tables
+local figuresList = {} -- where we store the list of figures
+
+-- The following function stores pandoc Meta in the options local variable
+local function getMeta(meta)
+  options = meta
+  -- If there is no given titles, use default titles
+  if not options["lot-title"] then
+    options["lot-title"] = pandoc.MetaInlines("List of Tables")
+  end
+  if not options["lof-title"] then
+    options["lof-title"] = pandoc.MetaInlines("List of Figures")
+  end
+  return nil -- Do not modify Meta
+end
+
+-- This function is called only for Div of class figure inserted by bookdown
+local function getFigCaption(div)
+  local listOfBlocks = div.content
+  local found
+  for i, block in ipairs(listOfBlocks) do
+    if block.t == "RawBlock" then
+      if block.c[2] == '<p class="caption">' then
+        found = i + 1
+        break
+      end
+    end
+  end
+  if found then
+    return pandoc.utils.stringify(div.content[found])
+  else
+    return nil
+  end
+end
+
+-- This function looks for div of class figure.
+-- It builds and saves the items used by the list of figures.
+local function addFigRef(div)
+  local captionText
+  local figref
+
+  -- do not build the lof if not required
+  if not options.lof then return nil end
+
+  if div.classes:includes("figure") then
+    captionText = getFigCaption(div)
+    if not captionText then return nil end
+
+    -- build figure reference from figure caption
+    figref = "@ref" .. string.gsub(captionText, "#", "")
+    figref = string.gsub(figref, "%)", ") ") -- add a space
+    -- insert figure reference in figuresList
+    table.insert(figuresList, {pandoc.Plain(pandoc.Str(figref))})
+  end
+  return nil -- Do not modify Div
+end
+
+-- This function inspects the tables captions.
+-- When a bookdown id is found, it builds and saves the items used by
+--  the list of tables.
+local function addTabRef(tab)
+  local caption
+  local found
+  local tabref
+
+  -- do not build the lot if not required
+  if not options.lot then return nil end
+
+  caption = pandoc.utils.stringify(tab.caption)
+  -- test the presence of a bookdown table id
+  found = string.find(caption, "%(#tab:.*%)")
+  if found then
+    -- build table reference from table caption
+    tabref = "@ref" .. string.gsub(caption, "#", "")
+    tabref = string.gsub(tabref, "%)", ") ") -- add a space
+    -- insert table reference in tablesList
+    table.insert(tablesList, {pandoc.Plain(pandoc.Str(tabref))})
+  end
+  return nil -- Do not modify Table
+end
+
+local function appendLoft(doc)
+  local lotHeader
+  local lofHeader
+  local idprefix = options.idprefix or ""
+
+  if options.lof then
+    table.insert(doc.blocks, 1, pandoc.BulletList(figuresList))
+    lofHeader =
+      pandoc.Header(1,
+                    {table.unpack(options["lof-title"])},
+                    pandoc.Attr(idprefix .. "LOF", {"lof", "unnumbered", "front-matter"}, {})
+      )
+    table.insert(doc.blocks, 1, lofHeader)
+  end
+
+  if options.lot then
+    table.insert(doc.blocks, 1, pandoc.BulletList(tablesList))
+    lotHeader =
+      pandoc.Header(1,
+                    {table.unpack(options["lot-title"])},
+                    pandoc.Attr(idprefix .. "LOT", {"lot", "unnumbered", "front-matter"}, {})
+      )
+    table.insert(doc.blocks, 1, lotHeader)
+  end
+  return pandoc.Pandoc(doc.blocks, doc.meta)
+end
+
+return {{Meta = getMeta}, {Div = addFigRef, Table = addTabRef, Doc = appendLoft}}
diff --git a/docs/lua/uri-to-fn.lua b/docs/lua/uri-to-fn.lua
new file mode 100644
index 0000000000..346213a5cd
--- /dev/null
+++ b/docs/lua/uri-to-fn.lua
@@ -0,0 +1,59 @@
+local options = {} -- where we store pandoc Meta
+
+-- This function tests the pandoc version againt a target version
+-- The target version has to be of the form {2, 3} or {2, 3, 1}
+local function pandocAvailable(target)
+ -- use a shallow copy of PANDOC_VERSION
+ -- this is required since pandoc 2.7.3, see https://github.com/rstudio/pagedown/issues/111
+  local pandocVersion = {}
+  for i = 1,3 do
+    table.insert(pandocVersion, PANDOC_VERSION[i])
+  end
+  pandocVersion[3] = pandocVersion[3] or 0 -- because there is not always a patch number
+  target[3] = target[3] or 0
+
+  for i = 1,3 do
+    if pandocVersion[i] > target[i] then return true end
+    if pandocVersion[i] < target[i] then return false end
+  end
+  return true
+end
+
+local function getMeta(meta)
+  options = meta
+  return nil -- Do not modify Meta
+end
+
+local function uriToFootnote(link)
+  local target = link.target
+  local content = link.content
+  local contentString = pandoc.utils.stringify(content)
+  local footnoteContent
+  local classes = {}
+  local attr
+
+  if not options["links-to-footnotes"] then return nil end
+  if target == contentString then return nil end
+  if target == "mailto:" .. contentString then return nil end
+
+  if string.find(target, "://") then
+    if pandocAvailable({2, 3, 1}) then classes = {"uri"} end
+    attr = pandoc.Attr("", classes, {})
+    footnoteContent = {pandoc.Para({pandoc.Link(target, target, "", attr)})}
+    table.insert(content, pandoc.Note(footnoteContent))
+    return content
+  end
+
+  if string.find(target, "^mailto:") then
+    if pandocAvailable({2, 3, 1}) then classes = {"email"} end
+    attr = pandoc.Attr("", classes, {})
+    footnoteContent = {pandoc.Para({
+      pandoc.Link(string.gsub(target, "^mailto:", ""), target, "", attr)
+    })}
+    table.insert(content, pandoc.Note(footnoteContent))
+    return content
+  end
+
+end
+
+return {{Meta = getMeta}, {Link = uriToFootnote}}
diff --git a/index.md b/index.md
index aa6c0cb838..cf5ad7991b 100644
--- a/index.md
+++ b/index.md
@@ -1,13 +1,13 @@
 ---
-layout: cv
-title: Isaac Newtons's CV
+layout: resume
+title: Brigham Young's Resume
 ---
-# Isaac Newton
+# Brigham Young
 Physicist, Mathematician, Cambridge professor.
 
 <div id="webaddress">
-<a href="isaac@applesdofall.org">isaac@applesdofall.org</a>
-| <a href="http://en.wikipedia.org/wiki/Isaac_Newton">My wikipedia page</a>
+<a href="datascience@byui.edu">datascience@byui.edu</a>
+| <a href="https://byuidatascience.github.io/development.html">Data Science Program</a>
 </div>
 
 

From 2e9072b8f387bfb6804045daa91dec75ae1e1fb4 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 09:22:19 -0600
Subject: [PATCH 13/20] resume from pagedown

---
 docs/_layouts/resume.html | 160 ++++++++++++++++++++++++++++++++++----
 docs/html/resume.html     | 144 ----------------------------------
 2 files changed, 144 insertions(+), 160 deletions(-)
 delete mode 100644 docs/html/resume.html

diff --git a/docs/_layouts/resume.html b/docs/_layouts/resume.html
index d72786c4eb..dec8192053 100644
--- a/docs/_layouts/resume.html
+++ b/docs/_layouts/resume.html
@@ -1,16 +1,144 @@
-<!doctype html>
-<html>
-<head>
-  <meta charset=utf-8 />
-  <title> {% if page.title %} {{ page.title }} | {% endif %} RESUME</title>
-  <link href="media/{{ site.style }}-screen.css" type="text/css" rel="stylesheet" media="screen">
-  <link href="media/{{ site.style }}-print.css" type="text/css" rel="stylesheet" media="print">
-</head>
-<body>
-  <div id="main">
-    <div id="content">
-    {{ content }}
-    </div>
-  </div>
-</body>
-</html>
\ No newline at end of file
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta name="generator" content="pandoc" />
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    $for(author-meta)$<meta name="author" content="$author-meta$" />$endfor$
+    $if(date-meta)$<meta name="date" content="$date-meta$" />$endif$
+    <title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
+
+    $if(math)$
+    $if(mathjax)$
+    <!-- dynamically load mathjax for compatibility with self-contained -->
+    <script>
+    (function() {
+      // Retrieve previous config object if defined
+      window.PagedConfig = window.PagedConfig || {};
+      let beforePaged = PagedConfig.before;
+      window.PagedConfig.before = async () => {
+        if (beforePaged) await beforePaged();
+        return new Promise((resolve, reject) => {
+          var script = document.createElement("script");
+          script.type = "text/javascript";
+          var src = `$mathjaxurl$` + "?config=TeX-MML-AM_CHTML";
+          if (location.protocol !== "file:" && /^https?:/.test(src))
+            src = src.replace(/^https?:/, '');
+          script.src = src;
+          window.MathJax = {
+            AuthorInit: () => {
+              MathJax.Hub.Register.StartupHook("Begin", () => {
+                MathJax.Hub.Queue(resolve);
+              });
+            }
+          };
+          document.getElementsByTagName("head")[0].appendChild(script);
+        });
+      };
+    })();
+    </script>
+    $endif$
+    $endif$
+
+    $for(header-includes)$
+    $header-includes$
+    $endfor$
+
+    $for(css)$
+    <link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
+    $endfor$
+
+  </head>
+  <body>
+$for(include-before)$
+$include-before$
+$endfor$
+
+$body$
+
+<script>
+(function() {
+  var i, s, j, el, els;
+  var create_el = function(type, className, content, isHTML) {
+    var el = document.createElement(type);
+    if (className) el.className = className;
+    if (content) {
+      if (isHTML) {el.innerHTML = content;} else {el.innerText = content;}
+    }
+    return el;
+  }
+
+  // replace h2 title with h1
+  var title = document.getElementById('title').querySelector('h2');
+  title.parentNode.replaceChild(create_el('h1', false, title.innerHTML, true), title);
+
+  // add the class .aside to #aside
+  el = document.getElementById('aside');
+  if (el) el.className += ' aside';
+
+  // tweak class names of sections, and add icons
+  els = document.getElementById('main').querySelectorAll('.level2');
+  for (i = 0; i < els.length; i++) {
+    el = els[i];
+    if (i === 0 && el.id === 'title') continue;
+    el.className += ' main-block';
+    if (el.dataset['concise']) el.className += ' concise';
+    // if there is no icon, add an icon:
+    if (el.firstElementChild.firstChild && el.firstElementChild.firstChild.nodeName !== 'I') {
+      s = el.dataset['icon'] || 'bookmark';
+      el.firstElementChild.insertBefore(create_el('i', 'fa fa-' + s), el.firstElementChild.firstChild);
+    }
+  }
+
+  // tweak class names of blocks in sections
+  els = document.getElementById('main').querySelectorAll('.level3');
+  for (i = 0; i < els.length; i++) {
+    el = els[i];
+    if (el.parentNode.id === 'title') continue;
+    el.className += ' blocks';
+    el.innerHTML = '<div class="date"></div>' + '<div class="decorator"></div>' +
+      '<div class="details"><header></header><div></div></div>' + el.innerHTML;
+    var ps = el.querySelectorAll('p');
+    // move the date paragraph to the date div
+    if (ps.length >= 3) {
+      s = ps[2].innerText;
+      s = s === 'N/A' ? [] : s.split(' - ');
+      el.removeChild(ps[2]);
+      for (j = 0; j < s.length && j < 2; j++) {
+        el.children[0].appendChild(create_el('span', false, s[j]))
+      }
+    }
+    // move title, description, location to the details div
+    (function(h) {
+      h.appendChild(el.children[3]);
+      var p = el.children[3];  // description
+      if (p.innerText !== 'N/A') {
+        h.appendChild(create_el('span', 'place', p.innerHTML, true));
+      }
+      el.removeChild(p);
+      p = el.children[3];  // location
+      if (p.innerText !== 'N/A') {
+        s = create_el('span', 'location', p.innerHTML, true);
+        s.innerHTML = '<i class="fa fa-map-marker-alt"></i> ' + s.innerHTML;
+        h.appendChild(s);
+      }
+      el.removeChild(p);
+    })(el.children[2].firstElementChild);
+    // move the rest of content in a block into the last div of the details div
+    s = el.children[2];
+    while (j = s.nextSibling) {
+      if (j.className === 'aside') { s = j; continue; }
+      el.children[2].lastElementChild.append(j);
+    }
+  }
+})();
+</script>
+
+$for(include-after)$
+$include-after$
+$endfor$
+
+  </body>
+</html>
diff --git a/docs/html/resume.html b/docs/html/resume.html
deleted file mode 100644
index dec8192053..0000000000
--- a/docs/html/resume.html
+++ /dev/null
@@ -1,144 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
-  <head>
-    <meta charset="utf-8" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <meta name="generator" content="pandoc" />
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-
-    $for(author-meta)$<meta name="author" content="$author-meta$" />$endfor$
-    $if(date-meta)$<meta name="date" content="$date-meta$" />$endif$
-    <title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
-
-    $if(math)$
-    $if(mathjax)$
-    <!-- dynamically load mathjax for compatibility with self-contained -->
-    <script>
-    (function() {
-      // Retrieve previous config object if defined
-      window.PagedConfig = window.PagedConfig || {};
-      let beforePaged = PagedConfig.before;
-      window.PagedConfig.before = async () => {
-        if (beforePaged) await beforePaged();
-        return new Promise((resolve, reject) => {
-          var script = document.createElement("script");
-          script.type = "text/javascript";
-          var src = `$mathjaxurl$` + "?config=TeX-MML-AM_CHTML";
-          if (location.protocol !== "file:" && /^https?:/.test(src))
-            src = src.replace(/^https?:/, '');
-          script.src = src;
-          window.MathJax = {
-            AuthorInit: () => {
-              MathJax.Hub.Register.StartupHook("Begin", () => {
-                MathJax.Hub.Queue(resolve);
-              });
-            }
-          };
-          document.getElementsByTagName("head")[0].appendChild(script);
-        });
-      };
-    })();
-    </script>
-    $endif$
-    $endif$
-
-    $for(header-includes)$
-    $header-includes$
-    $endfor$
-
-    $for(css)$
-    <link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
-    $endfor$
-
-  </head>
-  <body>
-$for(include-before)$
-$include-before$
-$endfor$
-
-$body$
-
-<script>
-(function() {
-  var i, s, j, el, els;
-  var create_el = function(type, className, content, isHTML) {
-    var el = document.createElement(type);
-    if (className) el.className = className;
-    if (content) {
-      if (isHTML) {el.innerHTML = content;} else {el.innerText = content;}
-    }
-    return el;
-  }
-
-  // replace h2 title with h1
-  var title = document.getElementById('title').querySelector('h2');
-  title.parentNode.replaceChild(create_el('h1', false, title.innerHTML, true), title);
-
-  // add the class .aside to #aside
-  el = document.getElementById('aside');
-  if (el) el.className += ' aside';
-
-  // tweak class names of sections, and add icons
-  els = document.getElementById('main').querySelectorAll('.level2');
-  for (i = 0; i < els.length; i++) {
-    el = els[i];
-    if (i === 0 && el.id === 'title') continue;
-    el.className += ' main-block';
-    if (el.dataset['concise']) el.className += ' concise';
-    // if there is no icon, add an icon:
-    if (el.firstElementChild.firstChild && el.firstElementChild.firstChild.nodeName !== 'I') {
-      s = el.dataset['icon'] || 'bookmark';
-      el.firstElementChild.insertBefore(create_el('i', 'fa fa-' + s), el.firstElementChild.firstChild);
-    }
-  }
-
-  // tweak class names of blocks in sections
-  els = document.getElementById('main').querySelectorAll('.level3');
-  for (i = 0; i < els.length; i++) {
-    el = els[i];
-    if (el.parentNode.id === 'title') continue;
-    el.className += ' blocks';
-    el.innerHTML = '<div class="date"></div>' + '<div class="decorator"></div>' +
-      '<div class="details"><header></header><div></div></div>' + el.innerHTML;
-    var ps = el.querySelectorAll('p');
-    // move the date paragraph to the date div
-    if (ps.length >= 3) {
-      s = ps[2].innerText;
-      s = s === 'N/A' ? [] : s.split(' - ');
-      el.removeChild(ps[2]);
-      for (j = 0; j < s.length && j < 2; j++) {
-        el.children[0].appendChild(create_el('span', false, s[j]))
-      }
-    }
-    // move title, description, location to the details div
-    (function(h) {
-      h.appendChild(el.children[3]);
-      var p = el.children[3];  // description
-      if (p.innerText !== 'N/A') {
-        h.appendChild(create_el('span', 'place', p.innerHTML, true));
-      }
-      el.removeChild(p);
-      p = el.children[3];  // location
-      if (p.innerText !== 'N/A') {
-        s = create_el('span', 'location', p.innerHTML, true);
-        s.innerHTML = '<i class="fa fa-map-marker-alt"></i> ' + s.innerHTML;
-        h.appendChild(s);
-      }
-      el.removeChild(p);
-    })(el.children[2].firstElementChild);
-    // move the rest of content in a block into the last div of the details div
-    s = el.children[2];
-    while (j = s.nextSibling) {
-      if (j.className === 'aside') { s = j; continue; }
-      el.children[2].lastElementChild.append(j);
-    }
-  }
-})();
-</script>
-
-$for(include-after)$
-$include-after$
-$endfor$
-
-  </body>
-</html>

From 51d1ca146ffd726b83302b73c6ebb71dc2d0c3ef Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Fri, 7 Aug 2020 23:01:34 -0600
Subject: [PATCH 14/20] back to original

---
 docs/_config.yml                     |     2 +-
 docs/_layouts/resume.html            |   144 -
 docs/js/chrome_print.js              |    68 -
 docs/js/config.js                    |    81 -
 docs/js/hooks.js                     |   510 -
 docs/js/paged-latest.js              |    23 -
 docs/js/paged.js                     | 27610 -------------------------
 docs/lua/footnotes.lua               |    27 -
 docs/lua/jss.lua                     |    99 -
 docs/lua/loft.lua                    |   121 -
 docs/lua/uri-to-fn.lua               |    59 -
 docs/media/pagedownresume-print.css  |   434 -
 docs/media/pagedownresume-screen.css |   434 -
 13 files changed, 1 insertion(+), 29611 deletions(-)
 delete mode 100644 docs/_layouts/resume.html
 delete mode 100644 docs/js/chrome_print.js
 delete mode 100644 docs/js/config.js
 delete mode 100644 docs/js/hooks.js
 delete mode 100644 docs/js/paged-latest.js
 delete mode 100644 docs/js/paged.js
 delete mode 100644 docs/lua/footnotes.lua
 delete mode 100644 docs/lua/jss.lua
 delete mode 100644 docs/lua/loft.lua
 delete mode 100644 docs/lua/uri-to-fn.lua
 delete mode 100644 docs/media/pagedownresume-print.css
 delete mode 100644 docs/media/pagedownresume-screen.css

diff --git a/docs/_config.yml b/docs/_config.yml
index 0f1d8e1c92..823f4de072 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -1,2 +1,2 @@
 markdown:   kramdown
-style:  pagedownresume
+style:  davewhipp
diff --git a/docs/_layouts/resume.html b/docs/_layouts/resume.html
deleted file mode 100644
index dec8192053..0000000000
--- a/docs/_layouts/resume.html
+++ /dev/null
@@ -1,144 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
-  <head>
-    <meta charset="utf-8" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <meta name="generator" content="pandoc" />
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-
-    $for(author-meta)$<meta name="author" content="$author-meta$" />$endfor$
-    $if(date-meta)$<meta name="date" content="$date-meta$" />$endif$
-    <title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
-
-    $if(math)$
-    $if(mathjax)$
-    <!-- dynamically load mathjax for compatibility with self-contained -->
-    <script>
-    (function() {
-      // Retrieve previous config object if defined
-      window.PagedConfig = window.PagedConfig || {};
-      let beforePaged = PagedConfig.before;
-      window.PagedConfig.before = async () => {
-        if (beforePaged) await beforePaged();
-        return new Promise((resolve, reject) => {
-          var script = document.createElement("script");
-          script.type = "text/javascript";
-          var src = `$mathjaxurl$` + "?config=TeX-MML-AM_CHTML";
-          if (location.protocol !== "file:" && /^https?:/.test(src))
-            src = src.replace(/^https?:/, '');
-          script.src = src;
-          window.MathJax = {
-            AuthorInit: () => {
-              MathJax.Hub.Register.StartupHook("Begin", () => {
-                MathJax.Hub.Queue(resolve);
-              });
-            }
-          };
-          document.getElementsByTagName("head")[0].appendChild(script);
-        });
-      };
-    })();
-    </script>
-    $endif$
-    $endif$
-
-    $for(header-includes)$
-    $header-includes$
-    $endfor$
-
-    $for(css)$
-    <link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
-    $endfor$
-
-  </head>
-  <body>
-$for(include-before)$
-$include-before$
-$endfor$
-
-$body$
-
-<script>
-(function() {
-  var i, s, j, el, els;
-  var create_el = function(type, className, content, isHTML) {
-    var el = document.createElement(type);
-    if (className) el.className = className;
-    if (content) {
-      if (isHTML) {el.innerHTML = content;} else {el.innerText = content;}
-    }
-    return el;
-  }
-
-  // replace h2 title with h1
-  var title = document.getElementById('title').querySelector('h2');
-  title.parentNode.replaceChild(create_el('h1', false, title.innerHTML, true), title);
-
-  // add the class .aside to #aside
-  el = document.getElementById('aside');
-  if (el) el.className += ' aside';
-
-  // tweak class names of sections, and add icons
-  els = document.getElementById('main').querySelectorAll('.level2');
-  for (i = 0; i < els.length; i++) {
-    el = els[i];
-    if (i === 0 && el.id === 'title') continue;
-    el.className += ' main-block';
-    if (el.dataset['concise']) el.className += ' concise';
-    // if there is no icon, add an icon:
-    if (el.firstElementChild.firstChild && el.firstElementChild.firstChild.nodeName !== 'I') {
-      s = el.dataset['icon'] || 'bookmark';
-      el.firstElementChild.insertBefore(create_el('i', 'fa fa-' + s), el.firstElementChild.firstChild);
-    }
-  }
-
-  // tweak class names of blocks in sections
-  els = document.getElementById('main').querySelectorAll('.level3');
-  for (i = 0; i < els.length; i++) {
-    el = els[i];
-    if (el.parentNode.id === 'title') continue;
-    el.className += ' blocks';
-    el.innerHTML = '<div class="date"></div>' + '<div class="decorator"></div>' +
-      '<div class="details"><header></header><div></div></div>' + el.innerHTML;
-    var ps = el.querySelectorAll('p');
-    // move the date paragraph to the date div
-    if (ps.length >= 3) {
-      s = ps[2].innerText;
-      s = s === 'N/A' ? [] : s.split(' - ');
-      el.removeChild(ps[2]);
-      for (j = 0; j < s.length && j < 2; j++) {
-        el.children[0].appendChild(create_el('span', false, s[j]))
-      }
-    }
-    // move title, description, location to the details div
-    (function(h) {
-      h.appendChild(el.children[3]);
-      var p = el.children[3];  // description
-      if (p.innerText !== 'N/A') {
-        h.appendChild(create_el('span', 'place', p.innerHTML, true));
-      }
-      el.removeChild(p);
-      p = el.children[3];  // location
-      if (p.innerText !== 'N/A') {
-        s = create_el('span', 'location', p.innerHTML, true);
-        s.innerHTML = '<i class="fa fa-map-marker-alt"></i> ' + s.innerHTML;
-        h.appendChild(s);
-      }
-      el.removeChild(p);
-    })(el.children[2].firstElementChild);
-    // move the rest of content in a block into the last div of the details div
-    s = el.children[2];
-    while (j = s.nextSibling) {
-      if (j.className === 'aside') { s = j; continue; }
-      el.children[2].lastElementChild.append(j);
-    }
-  }
-})();
-</script>
-
-$for(include-after)$
-$include-after$
-$endfor$
-
-  </body>
-</html>
diff --git a/docs/js/chrome_print.js b/docs/js/chrome_print.js
deleted file mode 100644
index 581687b80e..0000000000
--- a/docs/js/chrome_print.js
+++ /dev/null
@@ -1,68 +0,0 @@
-{
-  let RevealReady = new Promise((resolve) => {
-    window.addEventListener(
-      'DOMContentLoaded',
-      () => {
-        if (window.Reveal) {
-          if (!window.location.search.match( /print-pdf/gi )) {
-            window.location.search = 'print-pdf';
-            return;
-          }
-          Reveal.addEventListener('ready', resolve);
-          if (Reveal.isReady()) resolve();
-        } else {
-          resolve();
-        }
-      },
-      {capture: true, once: true}
-    );
-  });
-
-  let HTMLWidgetsReady = new Promise((resolve) => {
-    window.addEventListener(
-      'DOMContentLoaded',
-      () => {
-        if (window.HTMLWidgets) {
-          HTMLWidgets.addPostRenderHandler(resolve);
-        } else {
-          resolve();
-        }
-      },
-      {capture: true, once: true}
-    );
-  });
-
-  let MathJaxReady = new Promise((resolve) => {
-    window.addEventListener(
-      'load',
-      () => {
-        if (window.MathJax) {
-          if (window.MathJax.Hub) {
-           window.MathJax.Hub.Register.StartupHook('Begin', () => {
-              window.MathJax.Hub.Queue(resolve);
-            });
-          } else {
-            let previousAuthorInit = window.MathJax.AuthorInit || function () {};
-            window.MathJax.AuthorInit = function() {
-              previousAuthorInit();
-              MathJax.Hub.Register.StartupHook('Begin', () => {
-                MathJax.Hub.Queue(resolve);
-              });
-            };
-          }
-        }
-        else {
-          resolve();
-        }
-      },
-      {capture: true, once: true}
-    );
-  });
-
-  window.pagedownReady = Promise.all([
-    RevealReady,
-    MathJaxReady,
-    HTMLWidgetsReady,
-    document.fonts.ready
-  ]);
-}
diff --git a/docs/js/config.js b/docs/js/config.js
deleted file mode 100644
index e926a7fdae..0000000000
--- a/docs/js/config.js
+++ /dev/null
@@ -1,81 +0,0 @@
-// Configuration script for paged.js
-
-(function() {
-  // Retrieve previous config object if defined
-  window.PagedConfig = window.PagedConfig || {};
-  const {before: beforePaged, after: afterPaged} = window.PagedConfig;
-
-  // utils
-  const insertCSS = text => {
-    let style = document.createElement('style');
-		style.type = 'text/css';
-		style.appendChild(document.createTextNode(text));
-    document.head.appendChild(style);
-  };
-
-  // Util function for front and back covers images
-  const insertCSSForCover = type => {
-    const links = document.querySelectorAll('link[id^=' + type + ']');
-    if (!links.length) return;
-    const re = new RegExp(type + '-\\d+');
-    let text = ':root {--' + type + ': var(--' + type + '-1);';
-    for (const link of links) {
-      text += '--' + re.exec(link.id)[0] + ': url("' + link.href + '");';
-    }
-    text += '}';
-    insertCSS(text);
-  };
-
-  const insertPageBreaksCSS = () => {
-    insertCSS(`
-    .page-break-after {break-after: page;}
-    .page-break-before {break-before: page;}
-    `);
-  };
-
-  window.PagedConfig.before = async () => {
-    // Front and back covers support
-    let frontCover = document.querySelector('.front-cover');
-    let backCover = document.querySelector('.back-cover');
-    if (frontCover) document.body.prepend(frontCover);
-    if (backCover) document.body.append(backCover);
-    insertCSSForCover('front-cover');
-    insertCSSForCover('back-cover');
-    insertPageBreaksCSS();
-
-    if (beforePaged) await beforePaged();
-  };
-
-  window.PagedConfig.after = (flow) => {
-    // force redraw, see https://github.com/rstudio/pagedown/issues/35#issuecomment-475905361
-    // and https://stackoverflow.com/a/24753578/6500804
-    document.body.style.display = 'none';
-    document.body.offsetHeight;
-    document.body.style.display = '';
-
-    // run previous PagedConfig.after function if defined
-    if (afterPaged) afterPaged(flow);
-
-    // pagedownListener is a binding added by the chrome_print function
-    // this binding exists only when chrome_print opens the html file
-    if (window.pagedownListener) {
-      // the html file is opened for printing
-      // call the binding to signal to the R session that Paged.js has finished
-      pagedownListener(JSON.stringify({
-        pagedjs: true,
-        pages: flow.total,
-        elapsedtime: flow.performance
-      }));
-      return;
-    }
-    if (sessionStorage.getItem('pagedown-scroll')) {
-      // scroll to the last position before the page is reloaded
-      window.scrollTo(0, sessionStorage.getItem('pagedown-scroll'));
-      return;
-    }
-    if (window.location.hash) {
-      const id = window.location.hash.replace(/^#/, '');
-      document.getElementById(id).scrollIntoView({behavior: 'smooth'});
-    }
-  };
-})();
diff --git a/docs/js/hooks.js b/docs/js/hooks.js
deleted file mode 100644
index 76f00f0549..0000000000
--- a/docs/js/hooks.js
+++ /dev/null
@@ -1,510 +0,0 @@
-// Hooks for paged.js
-{
-  // Utils
-  let pandocMeta, pandocMetaToString;
-  {
-    let el = document.getElementById('pandoc-meta');
-    pandocMeta = el ? JSON.parse(el.firstChild.data) : {};
-  }
-
-  pandocMetaToString = meta => {
-    let el = document.createElement('div');
-    el.innerHTML = meta;
-    return el.innerText;
-  };
-
-  let isString = value => {
-    return typeof value === 'string' || value instanceof String;
-  };
-
-  let isArray = value => {
-    return value && typeof value === 'object' && value.constructor === Array;
-  };
-
-  // This hook is an attempt to fix https://github.com/rstudio/pagedown/issues/131
-  // Sometimes, the {break-after: avoid;} declaration applied on headers
-  // lead to duplicated headers. I hate this bug.
-  // This is linked to the way the HTML source is written
-  // When we have the \n character like this: <div>\n<h1>...</h1>
-  // the header may be duplicated.
-  // But, if we have <div><h1>...</h1> without any \n, the problem disappear
-  // I think this handler can fix most of cases
-  // Obviously, we cannot suppress all the \n in the HTML document
-  // because carriage returns are important in <pre> elements.
-  // Tested with Chrome 76.0.3809.100/Windows
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-      this.carriageReturn = String.fromCharCode(10);
-    }
-
-    checkNode(node) {
-      if (!node) return;
-      if (node.nodeType !== 3) return;
-      if (node.textContent === this.carriageReturn) {
-        node.remove();
-      }
-    }
-
-    afterParsed(parsed) {
-      let template = document.querySelector('template').content;
-      const breakAfterAvoidElements = template.querySelectorAll('[data-break-after="avoid"], [data-break-before="avoid"]');
-      for (let el of breakAfterAvoidElements) {
-        this.checkNode(el.previousSibling);
-        this.checkNode(el.nextSibling);
-      }
-    }
-  });
-
-  // This hook creates a list of abbreviations
-  // Note: we also could implement this feature using a Pandoc filter
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-    }
-    beforeParsed(content) {
-      const abbreviations = content.querySelectorAll('abbr');
-      if(abbreviations.length === 0) return;
-      const loaTitle = 'List of Abbreviations';
-      const loaId = 'LOA';
-      const tocList = content.querySelector('.toc ul');
-      let listOfAbbreviations = document.createElement('div');
-      let descriptionList = document.createElement('dl');
-      content.appendChild(listOfAbbreviations);
-      listOfAbbreviations.id = loaId;
-      listOfAbbreviations.classList.add('section', 'front-matter', 'level1', 'loa');
-      listOfAbbreviations.innerHTML = '<h1>' + loaTitle + '</h1>';
-      listOfAbbreviations.appendChild(descriptionList);
-      for(let abbr of abbreviations) {
-        if(!abbr.title) continue;
-        let term = document.createElement('dt');
-        let definition = document.createElement('dd');
-        descriptionList.appendChild(term);
-        descriptionList.appendChild(definition);
-        term.innerHTML = abbr.innerHTML;
-        definition.innerText = abbr.title;
-      }
-      if (tocList) {
-        const loaTOCItem = document.createElement('li');
-        loaTOCItem.innerHTML = '<a href="#' + loaId + '">' + loaTitle + '</a>';
-        tocList.appendChild(loaTOCItem);
-      }
-    }
-  });
-
-  // This hook moves the sections of class front-matter in the div.front-matter-container
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-    }
-
-    beforeParsed(content) {
-      const frontMatter = content.querySelector('.front-matter-container');
-      if (!frontMatter) return;
-
-      // move front matter sections in the front matter container
-      const frontMatterSections = content.querySelectorAll('.level1.front-matter');
-      for (const section of frontMatterSections) {
-        frontMatter.appendChild(section);
-      }
-
-      // add the class front-matter-ref to any <a></a> element
-      // referring to an entry in the front matter
-      const anchors = content.querySelectorAll('a[href^="#"]:not([href*=":"])');
-      for (const a of anchors) {
-        const ref = a.getAttribute('href').replace(/^#/, '');
-        const element = content.getElementById(ref);
-        if (frontMatter.contains(element)) a.classList.add('front-matter-ref');
-      }
-
-      // update the toc, lof and lot for front matter sections
-      const frontMatterSectionsLinks = content.querySelectorAll('.toc .front-matter-ref, .lof .front-matter-ref, .lot .front-matter-ref');
-      for (let i = frontMatterSectionsLinks.length - 1; i >= 0; i--) {
-        const listItem = frontMatterSectionsLinks[i].parentNode;
-        const list = listItem.parentNode;
-        list.insertBefore(listItem, list.firstChild);
-      }
-    }
-  });
-
-  // This hook expands the links in the lists of figures and tables
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-    }
-
-    beforeParsed(content) {
-      const items = content.querySelectorAll('.lof li, .lot li');
-      for (const item of items) {
-        const anchor = item.firstChild;
-        anchor.innerText = item.innerText;
-        item.innerText = '';
-        item.append(anchor);
-      }
-    }
-  });
-
-  // This hook adds spans for leading symbols
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-    }
-
-    beforeParsed(content) {
-      const anchors = content.querySelectorAll('.toc a, .lof a, .lot a');
-      for (const a of anchors) {
-        a.innerHTML = a.innerHTML + '<span class="leaders"></span>';
-      }
-    }
-  });
-
-  // This hook appends short titles spans
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-    }
-
-    beforeParsed(content) {
-    /* A factory returning a function that appends short titles spans.
-       The text content of these spans are reused for running titles (see default.css).
-       Argument: level - An integer between 1 and 6.
-    */
-    function appendShortTitleSpans(level) {
-      return () => {
-        const divs = Array.from(content.querySelectorAll('.level' + level));
-
-        function addSpan(div) {
-          const mainHeader = div.getElementsByTagName('h' + level)[0];
-          if (!mainHeader) return;
-          const mainTitle = mainHeader.textContent;
-          const spanSectionNumber = mainHeader.getElementsByClassName('header-section-number')[0];
-          const mainNumber = !!spanSectionNumber ? spanSectionNumber.textContent : '';
-          const runningTitle = 'shortTitle' in div.dataset ? mainNumber + ' ' + div.dataset.shortTitle : mainTitle;
-          const span = document.createElement('span');
-          span.className = 'shorttitle' + level;
-          span.innerText = runningTitle;
-          span.style.display = "none";
-          mainHeader.appendChild(span);
-          if (level == 1 && div.querySelector('.level2') === null) {
-            let span2 = document.createElement('span');
-            span2.className = 'shorttitle2';
-            span2.innerText = ' ';
-            span2.style.display = "none";
-            span.insertAdjacentElement('afterend', span2);
-          }
-        }
-
-        for (const div of divs) {
-          addSpan(div);
-        }
-      };
-    }
-
-    appendShortTitleSpans(1)();
-    appendShortTitleSpans(2)();
-    }
-  });
-
-  // Footnotes support
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-
-      this.splittedParagraphRefs = [];
-    }
-
-    beforeParsed(content) {
-      // remove footnotes in toc, lof, lot
-      // see https://github.com/rstudio/pagedown/issues/54
-      let removeThese = content.querySelectorAll('.toc .footnote, .lof .footnote, .lot .footnote');
-      for (const el of removeThese) {
-        el.remove();
-      }
-
-      let footnotes = content.querySelectorAll('.footnote');
-
-      for (let footnote of footnotes) {
-        let parentElement = footnote.parentElement;
-        let footnoteCall = document.createElement('a');
-        let footnoteNumber = footnote.dataset.pagedownFootnoteNumber;
-
-        footnoteCall.className = 'footnote-ref'; // same class as Pandoc
-        footnoteCall.setAttribute('id', 'fnref' + footnoteNumber); // same notation as Pandoc
-        footnoteCall.setAttribute('href', '#' + footnote.id);
-        footnoteCall.innerHTML = '<sup>' + footnoteNumber +'</sup>';
-        parentElement.insertBefore(footnoteCall, footnote);
-
-        // Here comes a hack. Fortunately, it works with Chrome and FF.
-        let handler = document.createElement('p');
-        handler.className = 'footnoteHandler';
-        parentElement.insertBefore(handler, footnote);
-        handler.appendChild(footnote);
-        handler.style.display = 'inline-block';
-        handler.style.width = '100%';
-        handler.style.float = 'right';
-        handler.style.pageBreakInside = 'avoid';
-      }
-    }
-
-    afterPageLayout(pageFragment, page, breakToken) {
-      function hasItemParent(node) {
-        if (node.parentElement === null) {
-          return false;
-        } else {
-          if (node.parentElement.tagName === 'LI') {
-            return true;
-          } else {
-            return hasItemParent(node.parentElement);
-          }
-        }
-      }
-      // If a li item is broken, we store the reference of the p child element
-      // see https://github.com/rstudio/pagedown/issues/23#issue-376548000
-      if (breakToken !== undefined) {
-        if (breakToken.node.nodeName === "#text" && hasItemParent(breakToken.node)) {
-          this.splittedParagraphRefs.push(breakToken.node.parentElement.dataset.ref);
-        }
-      }
-    }
-
-    afterRendered(pages) {
-      for (let page of pages) {
-        const footnotes = page.element.querySelectorAll('.footnote');
-        if (footnotes.length === 0) {
-          continue;
-        }
-
-        const pageContent = page.element.querySelector('.pagedjs_page_content');
-        let hr = document.createElement('hr');
-        let footnoteArea = document.createElement('div');
-
-        pageContent.style.display = 'flex';
-        pageContent.style.flexDirection = 'column';
-
-        hr.className = 'footnote-break';
-        hr.style.marginTop = 'auto';
-        hr.style.marginBottom = 0;
-        hr.style.marginLeft = 0;
-        hr.style.marginRight = 'auto';
-        pageContent.appendChild(hr);
-
-        footnoteArea.className = 'footnote-area';
-        pageContent.appendChild(footnoteArea);
-
-        for (let footnote of footnotes) {
-          let handler = footnote.parentElement;
-
-          footnoteArea.appendChild(footnote);
-          handler.parentNode.removeChild(handler);
-
-          footnote.innerHTML = '<sup>' + footnote.dataset.pagedownFootnoteNumber + '</sup>' + footnote.innerHTML;
-          footnote.style.fontSize = 'x-small';
-          footnote.style.marginTop = 0;
-          footnote.style.marginBottom = 0;
-          footnote.style.paddingTop = 0;
-          footnote.style.paddingBottom = 0;
-          footnote.style.display = 'block';
-        }
-      }
-
-      for (let ref of this.splittedParagraphRefs) {
-        let paragraphFirstPage = document.querySelector('[data-split-to="' + ref + '"]');
-        // We test whether the paragraph is empty
-        // see https://github.com/rstudio/pagedown/issues/23#issue-376548000
-        if (paragraphFirstPage.innerText === "") {
-          paragraphFirstPage.parentElement.style.display = "none";
-          let paragraphSecondPage = document.querySelector('[data-split-from="' + ref + '"]');
-          paragraphSecondPage.parentElement.style.setProperty('list-style', 'inherit', 'important');
-        }
-      }
-    }
-  });
-
-  // Support for "Chapter " label on section with class `.chapter`
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-
-      this.options = pandocMeta['chapter_name'];
-
-      let styles;
-      if (isString(this.options)) {
-        this.options = pandocMetaToString(this.options);
-        styles = `
-        :root {
-          --chapter-name-before: "${this.options}";
-        }
-        `;
-      }
-      if (isArray(this.options)) {
-        this.options = this.options.map(pandocMetaToString);
-        styles = `
-        :root {
-          --chapter-name-before: "${this.options[0]}";
-          --chapter-name-after: "${this.options[1]}";
-        }
-        `;
-      }
-      if (styles) polisher.insert(styles);
-    }
-
-    beforeParsed(content) {
-      const tocAnchors = content.querySelectorAll('.toc a[href^="#"]:not([href*=":"]');
-      for (const anchor of tocAnchors) {
-        const ref = anchor.getAttribute('href').replace(/^#/, '');
-        const element = content.getElementById(ref);
-        if (element.classList.contains('chapter')) {
-          anchor.classList.add('chapter-ref');
-        }
-      }
-    }
-  });
-
-  // Main text line numbering,
-  // see https://github.com/rstudio/pagedown/issues/115
-  // Original idea: Julien Taquet, thanks!
-  Paged.registerHandlers(class extends Paged.Handler {
-    constructor(chunker, polisher, caller) {
-      super(chunker, polisher, caller);
-
-      // get the number-lines option from Pandoc metavariables
-      this.options = pandocMeta['number-lines'];
-      // quit early if the "number-lines" option is false or missing
-      if (!this.options) return;
-      // retrieve the selector if provided, otherwise use the default selector
-      this.selector = this.options.selector ? pandocMetaToString(this.options.selector) : '.level1:not(.front-matter) h1, .level1 h2, .level1 h3, .level1 p';
-
-      const styles = `
-      :root {
-        --line-numbers-padding-right: 10px;
-        --line-numbers-font-size: 8pt;
-      }
-      .pagedown-linenumbers-container {
-        position: absolute;
-        margin-top: var(--pagedjs-margin-top);
-        right: calc(var(--pagedjs-width) - var(--pagedjs-margin-left));
-      }
-      .maintextlinenumbers {
-        position: absolute;
-        right: 0;
-        text-align: right;
-        padding-right: var(--line-numbers-padding-right);
-        font-size: var(--line-numbers-font-size);
-      }
-      `;
-      polisher.insert(styles);
-
-      this.resetLinesCounter();
-    }
-
-    appendLineNumbersContainer(page) {
-      const pagebox = page.element.querySelector('.pagedjs_pagebox');
-      const lineNumbersContainer = document.createElement('div');
-      lineNumbersContainer.classList.add('pagedown-linenumbers-container');
-
-      return pagebox.appendChild(lineNumbersContainer);
-    }
-
-    lineHeight(element) {
-      // If the document stylesheet does not define a value for line-height,
-      // Blink returns "normal". Therefore, parseInt may return NaN.
-      return parseInt(getComputedStyle(element).lineHeight);
-    }
-
-    innerHeight(element) {
-      let outerHeight = element.getBoundingClientRect().height;
-      let {borderTopWidth,
-           borderBottomWidth,
-           paddingTop,
-           paddingBottom} = getComputedStyle(element);
-
-      borderTopWidth = parseFloat(borderTopWidth);
-      borderBottomWidth = parseFloat(borderBottomWidth);
-      paddingTop = parseFloat(paddingTop);
-      paddingBottom = parseFloat(paddingBottom);
-
-      return Math.round(outerHeight - borderTopWidth - borderBottomWidth - paddingTop - paddingBottom);
-    }
-
-    arrayOfInt(from, length) {
-      // adapted from https://stackoverflow.com/a/50234108/6500804
-      return Array.from(Array(length).keys(), n => n + from);
-    }
-
-    incrementLinesCounter(value) {
-      this.linesCounter = this.linesCounter + value;
-    }
-
-    resetLinesCounter() {
-      this.linesCounter = 0;
-    }
-
-    isDisplayMath(element) {
-      const nodes = element.childNodes;
-      if (nodes.length != 1) return false;
-      return (nodes[0].nodeName === 'SPAN') && (nodes[0].classList.value === 'math display');
-    }
-
-    afterRendered(pages) {
-      if (!this.options) return;
-
-      for (let page of pages) {
-        const lineNumbersContainer = this.appendLineNumbersContainer(page);
-        const pageAreaY = page.area.getBoundingClientRect().y;
-        let elementsToNumber = page.area.querySelectorAll(this.selector);
-
-        for (let element of elementsToNumber) {
-          // Do not add line numbers for display math environment
-          if (this.isDisplayMath(element)) continue;
-
-          // Try to retrieve line height
-          const lineHeight = this.lineHeight(element);
-          // Test against lineHeight method returns NaN
-          if (!lineHeight) {
-            console.warn('Failed to compute line height value on "' + page.id + '".');
-            continue;
-          }
-
-          const innerHeight = this.innerHeight(element);
-
-          // Number of lines estimation
-          // There is no built-in method to detect the number of lines in a block.
-          // The main caveat is that an actual line height can differ from
-          // the line-height CSS property.
-          // Mixed fonts, subscripts, superscripts, inline math... can increase
-          // the actual line height.
-          // Here, we divide the inner height of the block by the line-height
-          // computed property and round to the floor to take into account that
-          // sometimes the actual line height is greater than its property value.
-          // This is far from perfect and can be easily broken especially by
-          // inline math.
-          const nLines = Math.floor(innerHeight / lineHeight);
-
-          // do not add line numbers for void paragraphs
-          if (nLines <= 0) continue;
-
-          const linenumbers = document.createElement('div');
-          lineNumbersContainer.appendChild(linenumbers);
-          linenumbers.classList.add('maintextlinenumbers');
-
-          const elementY = element.getBoundingClientRect().y;
-          linenumbers.style.top = (elementY - pageAreaY) + 'px';
-
-          const cs = getComputedStyle(element);
-          const paddingTop = parseFloat(cs.paddingTop) + parseFloat(cs.borderTopWidth);
-          linenumbers.style.paddingTop = paddingTop + 'px';
-
-          linenumbers.style.lineHeight = cs.lineHeight;
-
-          linenumbers.innerHTML = this.arrayOfInt(this.linesCounter + 1, nLines)
-                                      .reduce((t, v) => t + '<br />' + v);
-          this.incrementLinesCounter(nLines);
-        }
-
-        if (this.options['reset-page']) {
-          this.resetLinesCounter();
-        }
-      }
-    }
-  });
-}
diff --git a/docs/js/paged-latest.js b/docs/js/paged-latest.js
deleted file mode 100644
index 731af820c0..0000000000
--- a/docs/js/paged-latest.js
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-  config = window.PagedConfig || {};
-  window.PagedConfig = {auto: false};
-
-  let pagedjs = document.createElement('script');
-  pagedjs.src = 'https://unpkg.com/pagedjs/dist/paged.polyfill.js';
-  let pagedjsLoaded = new Promise(_ => pagedjs.onload = _);
-
-  let hooks = document.createElement('script');
-  hooks.src = document.head
-                      .querySelector('script[src*="config.js"]')
-                      .src
-                      .replace('config', 'hooks');
-  let hooksLoaded = new Promise(_ => hooks.onload = _);
-
-  document.head.appendChild(pagedjs);
-  pagedjsLoaded.then(() => document.head.appendChild(hooks));
-  hooksLoaded.then(async () => {
-    if (config.before) await config.before();
-    await PagedPolyfill.preview();
-    if (config.after) config.after();
-  });
-}
diff --git a/docs/js/paged.js b/docs/js/paged.js
deleted file mode 100644
index b013e14d52..0000000000
--- a/docs/js/paged.js
+++ /dev/null
@@ -1,27610 +0,0 @@
-(function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-	typeof define === 'function' && define.amd ? define(factory) :
-	global.PagedPolyfill = factory();
-}(typeof self !== 'undefined' ? self : this, function () { 'use strict';
-
-	function createCommonjsModule(fn, module) {
-		return module = { exports: {} }, fn(module, module.exports), module.exports;
-	}
-
-	function getCjsExportFromNamespace (n) {
-		return n && n.default || n;
-	}
-
-	var isImplemented = function () {
-		var assign = Object.assign, obj;
-		if (typeof assign !== "function") return false;
-		obj = { foo: "raz" };
-		assign(obj, { bar: "dwa" }, { trzy: "trzy" });
-		return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy";
-	};
-
-	var isImplemented$1 = function () {
-		try {
-			return true;
-		} catch (e) {
-	 return false;
-	}
-	};
-
-	// eslint-disable-next-line no-empty-function
-	var noop = function () {};
-
-	var _undefined = noop(); // Support ES3 engines
-
-	var isValue = function (val) {
-	 return (val !== _undefined) && (val !== null);
-	};
-
-	var keys = Object.keys;
-
-	var shim = function (object) {
-		return keys(isValue(object) ? Object(object) : object);
-	};
-
-	var keys$1 = isImplemented$1()
-		? Object.keys
-		: shim;
-
-	var validValue = function (value) {
-		if (!isValue(value)) throw new TypeError("Cannot use null or undefined");
-		return value;
-	};
-
-	var max   = Math.max;
-
-	var shim$1 = function (dest, src /*, …srcn*/) {
-		var error, i, length = max(arguments.length, 2), assign;
-		dest = Object(validValue(dest));
-		assign = function (key) {
-			try {
-				dest[key] = src[key];
-			} catch (e) {
-				if (!error) error = e;
-			}
-		};
-		for (i = 1; i < length; ++i) {
-			src = arguments[i];
-			keys$1(src).forEach(assign);
-		}
-		if (error !== undefined) throw error;
-		return dest;
-	};
-
-	var assign = isImplemented()
-		? Object.assign
-		: shim$1;
-
-	var forEach = Array.prototype.forEach, create = Object.create;
-
-	var process = function (src, obj) {
-		var key;
-		for (key in src) obj[key] = src[key];
-	};
-
-	// eslint-disable-next-line no-unused-vars
-	var normalizeOptions = function (opts1 /*, …options*/) {
-		var result = create(null);
-		forEach.call(arguments, function (options) {
-			if (!isValue(options)) return;
-			process(Object(options), result);
-		});
-		return result;
-	};
-
-	// Deprecated
-
-	var isCallable = function (obj) {
-	 return typeof obj === "function";
-	};
-
-	var str = "razdwatrzy";
-
-	var isImplemented$2 = function () {
-		if (typeof str.contains !== "function") return false;
-		return (str.contains("dwa") === true) && (str.contains("foo") === false);
-	};
-
-	var indexOf = String.prototype.indexOf;
-
-	var shim$2 = function (searchString/*, position*/) {
-		return indexOf.call(this, searchString, arguments[1]) > -1;
-	};
-
-	var contains = isImplemented$2()
-		? String.prototype.contains
-		: shim$2;
-
-	var d_1 = createCommonjsModule(function (module) {
-
-	var d;
-
-	d = module.exports = function (dscr, value/*, options*/) {
-		var c, e, w, options, desc;
-		if ((arguments.length < 2) || (typeof dscr !== 'string')) {
-			options = value;
-			value = dscr;
-			dscr = null;
-		} else {
-			options = arguments[2];
-		}
-		if (dscr == null) {
-			c = w = true;
-			e = false;
-		} else {
-			c = contains.call(dscr, 'c');
-			e = contains.call(dscr, 'e');
-			w = contains.call(dscr, 'w');
-		}
-
-		desc = { value: value, configurable: c, enumerable: e, writable: w };
-		return !options ? desc : assign(normalizeOptions(options), desc);
-	};
-
-	d.gs = function (dscr, get, set/*, options*/) {
-		var c, e, options, desc;
-		if (typeof dscr !== 'string') {
-			options = set;
-			set = get;
-			get = dscr;
-			dscr = null;
-		} else {
-			options = arguments[3];
-		}
-		if (get == null) {
-			get = undefined;
-		} else if (!isCallable(get)) {
-			options = get;
-			get = set = undefined;
-		} else if (set == null) {
-			set = undefined;
-		} else if (!isCallable(set)) {
-			options = set;
-			set = undefined;
-		}
-		if (dscr == null) {
-			c = true;
-			e = false;
-		} else {
-			c = contains.call(dscr, 'c');
-			e = contains.call(dscr, 'e');
-		}
-
-		desc = { get: get, set: set, configurable: c, enumerable: e };
-		return !options ? desc : assign(normalizeOptions(options), desc);
-	};
-	});
-
-	var validCallable = function (fn) {
-		if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
-		return fn;
-	};
-
-	var eventEmitter = createCommonjsModule(function (module, exports) {
-
-	var apply = Function.prototype.apply, call = Function.prototype.call
-	  , create = Object.create, defineProperty = Object.defineProperty
-	  , defineProperties = Object.defineProperties
-	  , hasOwnProperty = Object.prototype.hasOwnProperty
-	  , descriptor = { configurable: true, enumerable: false, writable: true }
-
-	  , on, once, off, emit, methods, descriptors, base;
-
-	on = function (type, listener) {
-		var data;
-
-		validCallable(listener);
-
-		if (!hasOwnProperty.call(this, '__ee__')) {
-			data = descriptor.value = create(null);
-			defineProperty(this, '__ee__', descriptor);
-			descriptor.value = null;
-		} else {
-			data = this.__ee__;
-		}
-		if (!data[type]) data[type] = listener;
-		else if (typeof data[type] === 'object') data[type].push(listener);
-		else data[type] = [data[type], listener];
-
-		return this;
-	};
-
-	once = function (type, listener) {
-		var once, self;
-
-		validCallable(listener);
-		self = this;
-		on.call(this, type, once = function () {
-			off.call(self, type, once);
-			apply.call(listener, this, arguments);
-		});
-
-		once.__eeOnceListener__ = listener;
-		return this;
-	};
-
-	off = function (type, listener) {
-		var data, listeners, candidate, i;
-
-		validCallable(listener);
-
-		if (!hasOwnProperty.call(this, '__ee__')) return this;
-		data = this.__ee__;
-		if (!data[type]) return this;
-		listeners = data[type];
-
-		if (typeof listeners === 'object') {
-			for (i = 0; (candidate = listeners[i]); ++i) {
-				if ((candidate === listener) ||
-						(candidate.__eeOnceListener__ === listener)) {
-					if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
-					else listeners.splice(i, 1);
-				}
-			}
-		} else {
-			if ((listeners === listener) ||
-					(listeners.__eeOnceListener__ === listener)) {
-				delete data[type];
-			}
-		}
-
-		return this;
-	};
-
-	emit = function (type) {
-		var i, l, listener, listeners, args;
-
-		if (!hasOwnProperty.call(this, '__ee__')) return;
-		listeners = this.__ee__[type];
-		if (!listeners) return;
-
-		if (typeof listeners === 'object') {
-			l = arguments.length;
-			args = new Array(l - 1);
-			for (i = 1; i < l; ++i) args[i - 1] = arguments[i];
-
-			listeners = listeners.slice();
-			for (i = 0; (listener = listeners[i]); ++i) {
-				apply.call(listener, this, args);
-			}
-		} else {
-			switch (arguments.length) {
-			case 1:
-				call.call(listeners, this);
-				break;
-			case 2:
-				call.call(listeners, this, arguments[1]);
-				break;
-			case 3:
-				call.call(listeners, this, arguments[1], arguments[2]);
-				break;
-			default:
-				l = arguments.length;
-				args = new Array(l - 1);
-				for (i = 1; i < l; ++i) {
-					args[i - 1] = arguments[i];
-				}
-				apply.call(listeners, this, args);
-			}
-		}
-	};
-
-	methods = {
-		on: on,
-		once: once,
-		off: off,
-		emit: emit
-	};
-
-	descriptors = {
-		on: d_1(on),
-		once: d_1(once),
-		off: d_1(off),
-		emit: d_1(emit)
-	};
-
-	base = defineProperties({}, descriptors);
-
-	module.exports = exports = function (o) {
-		return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
-	};
-	exports.methods = methods;
-	});
-	var eventEmitter_1 = eventEmitter.methods;
-
-	function getBoundingClientRect(element) {
-		if (!element) {
-			return;
-		}
-		let rect;
-		if (typeof element.getBoundingClientRect !== "undefined") {
-			rect = element.getBoundingClientRect();
-		} else {
-			let range = document.createRange();
-			range.selectNode(element);
-			rect = range.getBoundingClientRect();
-		}
-		return rect;
-	}
-
-	function getClientRects(element) {
-		if (!element) {
-			return;
-		}
-		let rect;
-		if (typeof element.getClientRects !== "undefined") {
-			rect = element.getClientRects();
-		} else {
-			let range = document.createRange();
-			range.selectNode(element);
-			rect = range.getClientRects();
-		}
-		return rect;
-	}
-
-	/**
-	 * Generates a UUID
-	 * based on: http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
-	 * @returns {string} uuid
-	 */
-	function UUID() {
-		var d = new Date().getTime();
-		if (typeof performance !== "undefined" && typeof performance.now === "function"){
-			d += performance.now(); //use high-precision timer if available
-		}
-		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-			var r = (d + Math.random() * 16) % 16 | 0;
-			d = Math.floor(d / 16);
-			return (c === "x" ? r : (r & 0x3 | 0x8)).toString(16);
-		});
-	}
-
-	function attr(element, attributes) {
-		for (var i = 0; i < attributes.length; i++) {
-			if(element.hasAttribute(attributes[i])) {
-				return element.getAttribute(attributes[i]);
-			}
-		}
-	}
-
-	/* Based on by https://mths.be/cssescape v1.5.1 by @mathias | MIT license
-	 * Allows # and .
-	 */
-	function querySelectorEscape(value) {
-		if (arguments.length == 0) {
-			throw new TypeError("`CSS.escape` requires an argument.");
-		}
-		var string = String(value);
-		var length = string.length;
-		var index = -1;
-		var codeUnit;
-		var result = "";
-		var firstCodeUnit = string.charCodeAt(0);
-		while (++index < length) {
-			codeUnit = string.charCodeAt(index);
-			// Note: there’s no need to special-case astral symbols, surrogate
-			// pairs, or lone surrogates.
-
-			// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
-			// (U+FFFD).
-			if (codeUnit == 0x0000) {
-				result += "\uFFFD";
-				continue;
-			}
-
-			if (
-				// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
-				// U+007F, […]
-				(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
-				// If the character is the first character and is in the range [0-9]
-				// (U+0030 to U+0039), […]
-				(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
-				// If the character is the second character and is in the range [0-9]
-				// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
-				(
-					index == 1 &&
-					codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
-					firstCodeUnit == 0x002D
-				)
-			) {
-				// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
-				result += "\\" + codeUnit.toString(16) + " ";
-				continue;
-			}
-
-			if (
-				// If the character is the first character and is a `-` (U+002D), and
-				// there is no second character, […]
-				index == 0 &&
-				length == 1 &&
-				codeUnit == 0x002D
-			) {
-				result += "\\" + string.charAt(index);
-				continue;
-			}
-
-			// If the character is not handled by one of the above rules and is
-			// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
-			// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
-			// U+005A), or [a-z] (U+0061 to U+007A), […]
-			if (
-				codeUnit >= 0x0080 ||
-				codeUnit == 0x002D ||
-				codeUnit == 0x005F ||
-				codeUnit == 35 || // Allow #
-				codeUnit == 46 || // Allow .
-				codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
-				codeUnit >= 0x0041 && codeUnit <= 0x005A ||
-				codeUnit >= 0x0061 && codeUnit <= 0x007A
-			) {
-				// the character itself
-				result += string.charAt(index);
-				continue;
-			}
-
-			// Otherwise, the escaped character.
-			// https://drafts.csswg.org/cssom/#escape-a-character
-			result += "\\" + string.charAt(index);
-
-		}
-		return result;
-	}
-
-	/**
-	 * Creates a new pending promise and provides methods to resolve or reject it.
-	 * From: https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred#backwards_forwards_compatible
-	 * @returns {object} defered
-	 */
-	function defer() {
-		this.resolve = null;
-
-		this.reject = null;
-
-		this.id = UUID();
-
-		this.promise = new Promise((resolve, reject) => {
-			this.resolve = resolve;
-			this.reject = reject;
-		});
-		Object.freeze(this);
-	}
-
-	const requestIdleCallback = typeof window !== "undefined" && ("requestIdleCallback" in window ? window.requestIdleCallback : window.requestAnimationFrame);
-
-	function CSSValueToString(obj) {
-		return obj.value + (obj.unit || "");
-	}
-
-	function isElement(node) {
-		return node && node.nodeType === 1;
-	}
-
-	function isText(node) {
-		return node && node.nodeType === 3;
-	}
-
-	function *walk(start, limiter) {
-		let node = start;
-
-		while (node) {
-
-			yield node;
-
-			if (node.childNodes.length) {
-				node = node.firstChild;
-			} else if (node.nextSibling) {
-				if (limiter && node === limiter) {
-					node = undefined;
-					break;
-				}
-				node = node.nextSibling;
-			} else {
-				while (node) {
-					node = node.parentNode;
-					if (limiter && node === limiter) {
-						node = undefined;
-						break;
-					}
-					if (node && node.nextSibling) {
-						node = node.nextSibling;
-						break;
-					}
-
-				}
-			}
-		}
-	}
-
-	function nodeAfter(node, limiter) {
-		let after = node;
-
-		if (after.nextSibling) {
-			if (limiter && node === limiter) {
-				return;
-			}
-			after = after.nextSibling;
-		} else {
-			while (after) {
-				after = after.parentNode;
-				if (limiter && after === limiter) {
-					after = undefined;
-					break;
-				}
-				if (after && after.nextSibling) {
-					after = after.nextSibling;
-					break;
-				}
-			}
-		}
-
-		return after;
-	}
-
-	function nodeBefore(node, limiter) {
-		let before = node;
-		if (before.previousSibling) {
-			if (limiter && node === limiter) {
-				return;
-			}
-			before = before.previousSibling;
-		} else {
-			while (before) {
-				before = before.parentNode;
-				if (limiter && before === limiter) {
-					before = undefined;
-					break;
-				}
-				if (before && before.previousSibling) {
-					before = before.previousSibling;
-					break;
-				}
-			}
-		}
-
-		return before;
-	}
-
-	function elementAfter(node, limiter) {
-		let after = nodeAfter(node);
-
-		while (after && after.nodeType !== 1) {
-			after = nodeAfter(after);
-		}
-
-		return after;
-	}
-
-	function rebuildAncestors(node) {
-		let parent, ancestor;
-		let ancestors = [];
-		let added = [];
-
-		let fragment = document.createDocumentFragment();
-
-		// Gather all ancestors
-		let element = node;
-		while(element.parentNode && element.parentNode.nodeType === 1) {
-			ancestors.unshift(element.parentNode);
-			element = element.parentNode;
-		}
-
-		for (var i = 0; i < ancestors.length; i++) {
-			ancestor = ancestors[i];
-			parent = ancestor.cloneNode(false);
-
-			parent.setAttribute("data-split-from", parent.getAttribute("data-ref"));
-			// ancestor.setAttribute("data-split-to", parent.getAttribute("data-ref"));
-
-			if (parent.hasAttribute("id")) {
-				let dataID = parent.getAttribute("id");
-				parent.setAttribute("data-id", dataID);
-				parent.removeAttribute("id");
-			}
-
-			// This is handled by css :not, but also tidied up here
-			if (parent.hasAttribute("data-break-before")) {
-				parent.removeAttribute("data-break-before");
-			}
-
-			if (parent.hasAttribute("data-previous-break-after")) {
-				parent.removeAttribute("data-previous-break-after");
-			}
-
-			if (added.length) {
-				let container = added[added.length-1];
-				container.appendChild(parent);
-			} else {
-				fragment.appendChild(parent);
-			}
-			added.push(parent);
-		}
-
-		added = undefined;
-		return fragment;
-	}
-
-	/*
-	export function split(bound, cutElement, breakAfter) {
-			let needsRemoval = [];
-			let index = indexOf(cutElement);
-
-			if (!breakAfter && index === 0) {
-				return;
-			}
-
-			if (breakAfter && index === (cutElement.parentNode.children.length - 1)) {
-				return;
-			}
-
-			// Create a fragment with rebuilt ancestors
-			let fragment = rebuildAncestors(cutElement);
-
-			// Clone cut
-			if (!breakAfter) {
-				let clone = cutElement.cloneNode(true);
-				let ref = cutElement.parentNode.getAttribute('data-ref');
-				let parent = fragment.querySelector("[data-ref='" + ref + "']");
-				parent.appendChild(clone);
-				needsRemoval.push(cutElement);
-			}
-
-			// Remove all after cut
-			let next = nodeAfter(cutElement, bound);
-			while (next) {
-				let clone = next.cloneNode(true);
-				let ref = next.parentNode.getAttribute('data-ref');
-				let parent = fragment.querySelector("[data-ref='" + ref + "']");
-				parent.appendChild(clone);
-				needsRemoval.push(next);
-				next = nodeAfter(next, bound);
-			}
-
-			// Remove originals
-			needsRemoval.forEach((node) => {
-				if (node) {
-					node.remove();
-				}
-			});
-
-			// Insert after bounds
-			bound.parentNode.insertBefore(fragment, bound.nextSibling);
-			return [bound, bound.nextSibling];
-	}
-	*/
-
-	function needsBreakBefore(node) {
-		if( typeof node !== "undefined" &&
-				typeof node.dataset !== "undefined" &&
-				typeof node.dataset.breakBefore !== "undefined" &&
-				(node.dataset.breakBefore === "always" ||
-				 node.dataset.breakBefore === "page" ||
-				 node.dataset.breakBefore === "left" ||
-				 node.dataset.breakBefore === "right" ||
-				 node.dataset.breakBefore === "recto" ||
-				 node.dataset.breakBefore === "verso")
-			 ) {
-			return true;
-		}
-
-		return false;
-	}
-
-	function needsPreviousBreakAfter(node) {
-		if( typeof node !== "undefined" &&
-				typeof node.dataset !== "undefined" &&
-				typeof node.dataset.previousBreakAfter !== "undefined" &&
-				(node.dataset.previousBreakAfter === "always" ||
-				 node.dataset.previousBreakAfter === "page" ||
-				 node.dataset.previousBreakAfter === "left" ||
-				 node.dataset.previousBreakAfter === "right" ||
-				 node.dataset.previousBreakAfter === "recto" ||
-				 node.dataset.previousBreakAfter === "verso")
-			 ) {
-			return true;
-		}
-
-		return false;
-	}
-
-	function needsPageBreak(node) {
-		if( typeof node !== "undefined" &&
-				typeof node.dataset !== "undefined" &&
-				(node.dataset.page || node.dataset.afterPage)
-			 ) {
-			return true;
-		}
-
-		return false;
-	}
-
-	function *words(node) {
-		let currentText = node.nodeValue;
-		let max = currentText.length;
-		let currentOffset = 0;
-		let currentLetter;
-
-		let range;
-
-		while(currentOffset < max) {
-			currentLetter = currentText[currentOffset];
-			if (/^[\S\u202F\u00A0]$/.test(currentLetter)) {
-				if (!range) {
-					range = document.createRange();
-					range.setStart(node, currentOffset);
-				}
-			} else {
-				if (range) {
-					range.setEnd(node, currentOffset);
-					yield range;
-					range = undefined;
-				}
-			}
-
-			currentOffset += 1;
-		}
-
-		if (range) {
-			range.setEnd(node, currentOffset);
-			yield range;
-			range = undefined;
-		}
-	}
-
-	function *letters(wordRange) {
-		let currentText = wordRange.startContainer;
-		let max = currentText.length;
-		let currentOffset = wordRange.startOffset;
-		// let currentLetter;
-
-		let range;
-
-		while(currentOffset < max) {
-			 // currentLetter = currentText[currentOffset];
-			 range = document.createRange();
-			 range.setStart(currentText, currentOffset);
-			 range.setEnd(currentText, currentOffset+1);
-
-			 yield range;
-
-			 currentOffset += 1;
-		}
-	}
-
-	function isContainer(node) {
-		let container;
-
-		if (typeof node.tagName === "undefined") {
-			return true;
-		}
-
-		if (node.style.display === "none") {
-			return false;
-		}
-
-		switch (node.tagName) {
-			// Inline
-			case "A":
-			case "ABBR":
-			case "ACRONYM":
-			case "B":
-			case "BDO":
-			case "BIG":
-			case "BR":
-			case "BUTTON":
-			case "CITE":
-			case "CODE":
-			case "DFN":
-			case "EM":
-			case "I":
-			case "IMG":
-			case "INPUT":
-			case "KBD":
-			case "LABEL":
-			case "MAP":
-			case "OBJECT":
-			case "Q":
-			case "SAMP":
-			case "SCRIPT":
-			case "SELECT":
-			case "SMALL":
-			case "SPAN":
-			case "STRONG":
-			case "SUB":
-			case "SUP":
-			case "TEXTAREA":
-			case "TIME":
-			case "TT":
-			case "VAR":
-			case "P":
-			case "H1":
-			case "H2":
-			case "H3":
-			case "H4":
-			case "H5":
-			case "H6":
-			case "FIGCAPTION":
-			case "BLOCKQUOTE":
-			case "PRE":
-			case "LI":
-			case "TR":
-			case "DT":
-			case "DD":
-			case "VIDEO":
-			case "CANVAS":
-				container = false;
-				break;
-			default:
-				container = true;
-		}
-
-		return container;
-	}
-
-	function cloneNode(n, deep=false) {
-		return n.cloneNode(deep);
-	}
-
-	function findElement(node, doc) {
-		const ref = node.getAttribute("data-ref");
-		return findRef(ref, doc);
-	}
-
-	function findRef(ref, doc) {
-		return doc.querySelector(`[data-ref='${ref}']`);
-	}
-
-	function validNode(node) {
-		if (isText(node)) {
-			return true;
-		}
-
-		if (isElement(node) && node.dataset.ref) {
-			return true;
-		}
-
-		return false;
-	}
-
-	function prevValidNode(node) {
-		while (!validNode(node)) {
-			if (node.previousSibling) {
-				node = node.previousSibling;
-			} else {
-				node = node.parentNode;
-			}
-
-			if (!node) {
-				break;
-			}
-		}
-
-		return node;
-	}
-
-
-	function indexOf$1(node) {
-		let parent = node.parentNode;
-		if (!parent) {
-			return 0;
-		}
-		return Array.prototype.indexOf.call(parent.childNodes, node);
-	}
-
-	function child(node, index) {
-		return node.childNodes[index];
-	}
-
-	function hasContent(node) {
-		if (isElement(node)) {
-			return true;
-		} else if (isText(node) &&
-				node.textContent.trim().length) {
-			return true;
-		}
-		return false;
-	}
-
-	function indexOfTextNode(node, parent) {
-		if (!isText(node)) {
-			return -1;
-		}
-		let nodeTextContent = node.textContent;
-		let child;
-		let index = -1;
-		for (var i = 0; i < parent.childNodes.length; i++) {
-			child = parent.childNodes[i];
-			if (child.nodeType === 3) {
-				let text = parent.childNodes[i].textContent;
-				if (text.includes(nodeTextContent)) {
-					index = i;
-					break;
-				}
-			}
-		}
-
-		return index;
-	}
-
-	/**
-	 * Hooks allow for injecting functions that must all complete in order before finishing
-	 * They will execute in parallel but all must finish before continuing
-	 * Functions may return a promise if they are asycn.
-	 * From epubjs/src/utils/hooks
-	 * @param {any} context scope of this
-	 * @example this.content = new Hook(this);
-	 */
-	class Hook {
-		constructor(context){
-			this.context = context || this;
-			this.hooks = [];
-		}
-
-		/**
-		 * Adds a function to be run before a hook completes
-		 * @example this.content.register(function(){...});
-		 * @return {undefined} void
-		 */
-		register(){
-			for(var i = 0; i < arguments.length; ++i) {
-				if (typeof arguments[i]  === "function") {
-					this.hooks.push(arguments[i]);
-				} else {
-					// unpack array
-					for(var j = 0; j < arguments[i].length; ++j) {
-						this.hooks.push(arguments[i][j]);
-					}
-				}
-			}
-		}
-
-		/**
-		 * Triggers a hook to run all functions
-		 * @example this.content.trigger(args).then(function(){...});
-		 * @return {Promise} results
-		 */
-		trigger(){
-			var args = arguments;
-			var context = this.context;
-			var promises = [];
-
-			this.hooks.forEach(function(task) {
-				var executing = task.apply(context, args);
-
-				if(executing && typeof executing["then"] === "function") {
-					// Task is a function that returns a promise
-					promises.push(executing);
-				}
-				// Otherwise Task resolves immediately, add resolved promise with result
-				promises.push(new Promise((resolve, reject) => {
-					resolve(executing);
-				}));
-			});
-
-
-			return Promise.all(promises);
-		}
-
-	  /**
-	   * Triggers a hook to run all functions synchronously
-	   * @example this.content.trigger(args).then(function(){...});
-	   * @return {Array} results
-	   */
-	  triggerSync(){
-	    var args = arguments;
-	    var context = this.context;
-	    var results = [];
-
-	    this.hooks.forEach(function(task) {
-	      var executing = task.apply(context, args);
-
-	      results.push(executing);
-	    });
-
-
-	    return results;
-	  }
-
-		// Adds a function to be run before a hook completes
-		list(){
-			return this.hooks;
-		}
-
-		clear(){
-			return this.hooks = [];
-		}
-	}
-
-	const MAX_CHARS_PER_BREAK = 1500;
-
-	/**
-	 * Layout
-	 * @class
-	 */
-	class Layout {
-
-		constructor(element, hooks, maxChars) {
-			this.element = element;
-
-			this.bounds = this.element.getBoundingClientRect();
-
-			if (hooks) {
-				this.hooks = hooks;
-			} else {
-				this.hooks = {};
-				this.hooks.layout = new Hook();
-				this.hooks.renderNode = new Hook();
-				this.hooks.layoutNode = new Hook();
-				this.hooks.beforeOverflow = new Hook();
-				this.hooks.onOverflow = new Hook();
-				this.hooks.onBreakToken = new Hook();
-			}
-
-			this.maxChars = maxChars || MAX_CHARS_PER_BREAK;
-		}
-
-		async renderTo(wrapper, source, breakToken, bounds=this.bounds) {
-			let start = this.getStart(source, breakToken);
-			let walker = walk(start, source);
-
-			let node;
-			let done;
-			let next;
-
-			let hasRenderedContent = false;
-			let newBreakToken;
-
-			let length = 0;
-
-			while (!done && !newBreakToken) {
-				next = walker.next();
-				node = next.value;
-				done = next.done;
-
-				if (!node) {
-					this.hooks && this.hooks.layout.trigger(wrapper, this);
-
-					let imgs = wrapper.querySelectorAll("img");
-					if (imgs.length) {
-						await this.waitForImages(imgs);
-					}
-
-					newBreakToken = this.findBreakToken(wrapper, source, bounds);
-					return newBreakToken;
-				}
-
-				this.hooks && this.hooks.layoutNode.trigger(node);
-
-				// Check if the rendered element has a break set
-				if (hasRenderedContent && this.shouldBreak(node)) {
-
-					this.hooks && this.hooks.layout.trigger(wrapper, this);
-
-					let imgs = wrapper.querySelectorAll("img");
-					if (imgs.length) {
-						await this.waitForImages(imgs);
-					}
-
-					newBreakToken = this.findBreakToken(wrapper, source, bounds);
-
-					if (!newBreakToken) {
-						newBreakToken = this.breakAt(node);
-					}
-
-					length = 0;
-
-					break;
-				}
-
-				// Should the Node be a shallow or deep clone
-				let shallow = isContainer(node);
-
-				let rendered = this.append(node, wrapper, breakToken, shallow);
-
-				length += rendered.textContent.length;
-
-				// Check if layout has content yet
-				if (!hasRenderedContent) {
-					hasRenderedContent = hasContent(node);
-				}
-
-				// Skip to the next node if a deep clone was rendered
-				if (!shallow) {
-					walker = walk(nodeAfter(node, source), source);
-				}
-
-				// Only check x characters
-				if (length >= this.maxChars) {
-
-					this.hooks && this.hooks.layout.trigger(wrapper, this);
-
-					let imgs = wrapper.querySelectorAll("img");
-					if (imgs.length) {
-						await this.waitForImages(imgs);
-					}
-
-					newBreakToken = this.findBreakToken(wrapper, source, bounds);
-
-					if (newBreakToken) {
-						length = 0;
-					}
-				}
-
-			}
-
-			return newBreakToken;
-		}
-
-		breakAt(node, offset=0) {
-			return {
-				node,
-				offset
-			};
-		}
-
-		shouldBreak(node) {
-			let previousSibling = node.previousSibling;
-			let parentNode = node.parentNode;
-			let parentBreakBefore = needsBreakBefore(node) && parentNode && !previousSibling && needsBreakBefore(parentNode);
-			let doubleBreakBefore;
-
-			if (parentBreakBefore) {
-				doubleBreakBefore = node.dataset.breakBefore === parentNode.dataset.breakBefore;
-			}
-
-			return !doubleBreakBefore && needsBreakBefore(node) || needsPreviousBreakAfter(node) || needsPageBreak(node);
-		}
-
-		getStart(source, breakToken) {
-			let start;
-			let node = breakToken && breakToken.node;
-
-			if (node) {
-				start = node;
-			} else {
-				start = source.firstChild;
-			}
-
-			return start;
-		}
-
-		append(node, dest, breakToken, shallow=true, rebuild=true) {
-
-			let clone = cloneNode(node, !shallow);
-
-			if (node.parentNode && isElement(node.parentNode)) {
-				let parent = findElement(node.parentNode, dest);
-				// Rebuild chain
-				if (parent) {
-					parent.appendChild(clone);
-				} else if (rebuild) {
-					let fragment = rebuildAncestors(node);
-					parent = findElement(node.parentNode, fragment);
-					if (!parent) {
-						dest.appendChild(clone);
-					} else if (breakToken && isText(breakToken.node) && breakToken.offset > 0) {
-						clone.textContent = clone.textContent.substring(breakToken.offset);
-						parent.appendChild(clone);
-					} else {
-						parent.appendChild(clone);
-					}
-
-					dest.appendChild(fragment);
-				} else {
-					dest.appendChild(clone);
-				}
-
-
-			} else {
-				dest.appendChild(clone);
-			}
-
-			let nodeHooks = this.hooks.renderNode.triggerSync(clone, node);
-			nodeHooks.forEach((newNode) => {
-				if (typeof newNode != "undefined") {
-					clone = newNode;
-				}
-			});
-
-			return clone;
-		}
-
-		async waitForImages(imgs) {
-			let results = Array.from(imgs).map(async (img) => {
-				return this.awaitImageLoaded(img);
-			});
-			await Promise.all(results);
-		}
-
-		async awaitImageLoaded(image) {
-			return new Promise(resolve => {
-				if (image.complete !== true) {
-					image.onload = function() {
-						let { width, height } = window.getComputedStyle(image);
-						resolve(width, height);
-					};
-					image.onerror = function(e) {
-						let { width, height } = window.getComputedStyle(image);
-						resolve(width, height, e);
-					};
-				} else {
-					let { width, height } = window.getComputedStyle(image);
-					resolve(width, height);
-				}
-			});
-		}
-
-		avoidBreakInside(node, limiter) {
-			let breakNode;
-
-			if (node === limiter) {
-				return;
-			}
-
-			while (node.parentNode) {
-				node = node.parentNode;
-
-				if (node === limiter) {
-					break;
-				}
-
-				if(window.getComputedStyle(node)["break-inside"] === "avoid") {
-					breakNode = node;
-					break;
-				}
-
-			}
-			return breakNode;
-		}
-
-		createBreakToken(overflow, rendered, source) {
-			let container = overflow.startContainer;
-			let offset = overflow.startOffset;
-			let node, renderedNode, parent, index, temp;
-
-			if (isElement(container)) {
-				temp = child(container, offset);
-
-				if (isElement(temp)) {
-					renderedNode = findElement(temp, rendered);
-
-					if (!renderedNode) {
-						// Find closest element with data-ref
-						renderedNode = findElement(prevValidNode(temp), rendered);
-						return;
-					}
-
-					node = findElement(renderedNode, source);
-					offset = 0;
-				} else {
-					renderedNode = findElement(container, rendered);
-
-					if (!renderedNode) {
-						renderedNode = findElement(prevValidNode(container), rendered);
-					}
-
-					parent = findElement(renderedNode, source);
-					index = indexOfTextNode(temp, parent);
-					node = child(parent, index);
-					offset = 0;
-				}
-			} else {
-				renderedNode = findElement(container.parentNode, rendered);
-
-				if (!renderedNode) {
-					renderedNode = findElement(prevValidNode(container.parentNode), rendered);
-				}
-
-				parent = findElement(renderedNode, source);
-				index = indexOfTextNode(container, parent);
-
-				if (index === -1) {
-					return;
-				}
-
-				node = child(parent, index);
-
-				offset += node.textContent.indexOf(container.textContent);
-			}
-
-			if (!node) {
-				return;
-			}
-
-			return {
-				node,
-				offset
-			};
-
-		}
-
-		findBreakToken(rendered, source, bounds=this.bounds, extract=true) {
-			let overflow = this.findOverflow(rendered, bounds);
-			let breakToken;
-
-			let overflowHooks = this.hooks.onOverflow.triggerSync(overflow, rendered, bounds, this);
-			overflowHooks.forEach((newOverflow) => {
-				if (typeof newOverflow != "undefined") {
-					overflow = newOverflow;
-				}
-			});
-
-			if (overflow) {
-				breakToken = this.createBreakToken(overflow, rendered, source);
-
-				let breakHooks = this.hooks.onBreakToken.triggerSync(breakToken, overflow, rendered, this);
-				breakHooks.forEach((newToken) => {
-					if (typeof newToken != "undefined") {
-						breakToken = newToken;
-					}
-				});
-
-
-				if (breakToken && breakToken.node && extract) {
-					this.removeOverflow(overflow);
-				}
-
-			}
-			return breakToken;
-		}
-
-		hasOverflow(element, bounds=this.bounds) {
-			let constrainingElement = element && element.parentNode; // this gets the element, instead of the wrapper for the width workaround
-			let { width } = element.getBoundingClientRect();
-			let scrollWidth = constrainingElement ? constrainingElement.scrollWidth : 0;
-			return Math.max(Math.floor(width), scrollWidth) > Math.round(bounds.width);
-		}
-
-		findOverflow(rendered, bounds=this.bounds) {
-			if (!this.hasOverflow(rendered, bounds)) return;
-
-			let start = Math.round(bounds.left);
-			let end =  Math.round(bounds.right);
-			let range;
-
-			let walker = walk(rendered.firstChild, rendered);
-
-			// Find Start
-			let next, done, node, offset, skip, breakAvoid, prev, br;
-			while (!done) {
-				next = walker.next();
-				done = next.done;
-				node = next.value;
-				skip = false;
-				breakAvoid = false;
-				prev = undefined;
-				br = undefined;
-
-				if (node) {
-					let pos = getBoundingClientRect(node);
-					let left = Math.floor(pos.left);
-					let right = Math.floor(pos.right);
-
-					if (!range && left >= end) {
-						// Check if it is a float
-						let isFloat = false;
-
-						if (isElement(node) ) {
-							let styles = window.getComputedStyle(node);
-							isFloat = styles.getPropertyValue("float") !== "none";
-							skip = styles.getPropertyValue("break-inside") === "avoid";
-							breakAvoid = node.dataset.breakBefore === "avoid" || node.dataset.previousBreakAfter === "avoid";
-							prev = breakAvoid && nodeBefore(node, rendered);
-							br = node.tagName === "BR" || node.tagName === "WBR";
-						}
-
-						if (prev) {
-							range = document.createRange();
-							range.setStartBefore(prev);
-							break;
-						}
-
-						if (!br && !isFloat && isElement(node)) {
-							range = document.createRange();
-							range.setStartBefore(node);
-							break;
-						}
-
-						if (isText(node) && node.textContent.trim().length) {
-							range = document.createRange();
-							range.setStartBefore(node);
-							break;
-						}
-
-					}
-
-					if (!range && isText(node) &&
-							node.textContent.trim().length &&
-							window.getComputedStyle(node.parentNode)["break-inside"] !== "avoid") {
-
-						let rects = getClientRects(node);
-						let rect;
-						left = 0;
-						for (var i = 0; i != rects.length; i++) {
-							rect = rects[i];
-							if (rect.width > 0 && (!left || rect.left > left)) {
-								left = rect.left;
-							}
-						}
-
-						if(left >= end) {
-							range = document.createRange();
-							offset = this.textBreak(node, start, end);
-							if (!offset) {
-								range = undefined;
-							} else {
-								range.setStart(node, offset);
-							}
-							break;
-						}
-					}
-
-					// Skip children
-					if (skip || right < end) {
-						next = nodeAfter(node, rendered);
-						if (next) {
-							walker = walk(next, rendered);
-						}
-
-					}
-
-				}
-			}
-
-			// Find End
-			if (range) {
-				range.setEndAfter(rendered.lastChild);
-				return range;
-			}
-
-		}
-
-		findEndToken(rendered, source, bounds=this.bounds) {
-			if (rendered.childNodes.length === 0) {
-				return;
-			}
-
-			let lastChild = rendered.lastChild;
-
-			let lastNodeIndex;
-			while (lastChild && lastChild.lastChild) {
-				if (!validNode(lastChild)) {
-					// Only get elements with refs
-					lastChild = lastChild.previousSibling;
-				} else if(!validNode(lastChild.lastChild)) {
-					// Deal with invalid dom items
-					lastChild = prevValidNode(lastChild.lastChild);
-					break;
-				} else {
-					lastChild = lastChild.lastChild;
-				}
-			}
-
-			if (isText(lastChild)) {
-
-				if (lastChild.parentNode.dataset.ref) {
-					lastNodeIndex = indexOf$1(lastChild);
-					lastChild = lastChild.parentNode;
-				} else {
-					lastChild = lastChild.previousSibling;
-				}
-			}
-
-			let original = findElement(lastChild, source);
-
-			if (lastNodeIndex) {
-				original = original.childNodes[lastNodeIndex];
-			}
-
-			let after = nodeAfter(original);
-
-			return this.breakAt(after);
-		}
-
-		textBreak(node, start, end) {
-			let wordwalker = words(node);
-			let left = 0;
-			let right = 0;
-			let word, next, done, pos;
-			let offset;
-			while (!done) {
-				next = wordwalker.next();
-				word = next.value;
-				done = next.done;
-
-				if (!word) {
-					break;
-				}
-
-				pos = getBoundingClientRect(word);
-
-				left = Math.floor(pos.left);
-				right = Math.floor(pos.right);
-
-				if (left >= end) {
-					offset = word.startOffset;
-					break;
-				}
-
-				if (right > end) {
-					let letterwalker = letters(word);
-					let letter, nextLetter, doneLetter;
-
-					while (!doneLetter) {
-						nextLetter = letterwalker.next();
-						letter = nextLetter.value;
-						doneLetter = nextLetter.done;
-
-						if (!letter) {
-							break;
-						}
-
-						pos = getBoundingClientRect(letter);
-						left = Math.floor(pos.left);
-
-						if (left >= end) {
-							offset = letter.startOffset;
-							done = true;
-
-							break;
-						}
-					}
-				}
-
-			}
-
-			return offset;
-		}
-
-		removeOverflow(overflow) {
-			let {startContainer} = overflow;
-			let extracted = overflow.extractContents();
-
-			this.hyphenateAtBreak(startContainer);
-
-			return extracted;
-		}
-
-		hyphenateAtBreak(startContainer) {
-			if (isText(startContainer)) {
-				let startText = startContainer.textContent;
-				let prevLetter = startText[startText.length-1];
-
-				// Add a hyphen if previous character is a letter or soft hyphen
-				if (/^\w|\u00AD$/.test(prevLetter)) {
-					startContainer.parentNode.classList.add("pagedjs_hyphen");
-					startContainer.textContent += "\u2011";
-				}
-			}
-		}
-	}
-
-	eventEmitter(Layout.prototype);
-
-	/**
-	 * Render a page
-	 * @class
-	 */
-	class Page {
-		constructor(pagesArea, pageTemplate, blank, hooks) {
-			this.pagesArea = pagesArea;
-			this.pageTemplate = pageTemplate;
-			this.blank = blank;
-
-			this.width = undefined;
-			this.height = undefined;
-
-			this.hooks = hooks;
-
-			// this.element = this.create(this.pageTemplate);
-		}
-
-		create(template, after) {
-			//let documentFragment = document.createRange().createContextualFragment( TEMPLATE );
-			//let page = documentFragment.children[0];
-			let clone = document.importNode(this.pageTemplate.content, true);
-
-			let page, index;
-			if (after) {
-				this.pagesArea.insertBefore(clone, after.nextElementSibling);
-				index = Array.prototype.indexOf.call(this.pagesArea.children, after.nextElementSibling);
-				page = this.pagesArea.children[index];
-			} else {
-				this.pagesArea.appendChild(clone);
-				page = this.pagesArea.lastChild;
-			}
-
-			let pagebox = page.querySelector(".pagedjs_pagebox");
-			let area = page.querySelector(".pagedjs_page_content");
-
-
-			let size = area.getBoundingClientRect();
-
-
-			area.style.columnWidth = Math.round(size.width) + "px";
-			area.style.columnGap = "calc(var(--pagedjs-margin-right) + var(--pagedjs-margin-left))";
-			// area.style.overflow = "scroll";
-
-			this.width = Math.round(size.width);
-			this.height = Math.round(size.height);
-
-			this.element = page;
-			this.pagebox = pagebox;
-			this.area = area;
-
-			return page;
-		}
-
-		createWrapper() {
-			let wrapper = document.createElement("div");
-
-			this.area.appendChild(wrapper);
-
-			this.wrapper = wrapper;
-
-			return wrapper;
-		}
-
-		index(pgnum) {
-			this.position = pgnum;
-
-			let page = this.element;
-			// let pagebox = this.pagebox;
-
-			let index = pgnum+1;
-
-			let id = `page-${index}`;
-
-			this.id = id;
-
-			// page.dataset.pageNumber = index;
-
-			page.dataset.pageNumber = index;
-			page.setAttribute('id', id);
-
-			if (this.name) {
-				page.classList.add("pagedjs_" + this.name + "_page");
-			}
-
-			if (this.blank) {
-				page.classList.add("pagedjs_blank_page");
-			}
-
-			if (pgnum === 0) {
-				page.classList.add("pagedjs_first_page");
-			}
-
-			if (pgnum % 2 !== 1) {
-				page.classList.remove("pagedjs_left_page");
-				page.classList.add("pagedjs_right_page");
-			} else {
-				page.classList.remove("pagedjs_right_page");
-				page.classList.add("pagedjs_left_page");
-			}
-		}
-
-		/*
-		size(width, height) {
-			if (width === this.width && height === this.height) {
-				return;
-			}
-			this.width = width;
-			this.height = height;
-
-			this.element.style.width = Math.round(width) + "px";
-			this.element.style.height = Math.round(height) + "px";
-			this.element.style.columnWidth = Math.round(width) + "px";
-		}
-		*/
-
-		async layout(contents, breakToken, maxChars) {
-
-			this.clear();
-
-			this.startToken = breakToken;
-
-			this.layoutMethod = new Layout(this.area, this.hooks, maxChars);
-
-			let newBreakToken = await this.layoutMethod.renderTo(this.wrapper, contents, breakToken);
-
-			this.addListeners(contents);
-
-			this.endToken = newBreakToken;
-
-			return newBreakToken;
-		}
-
-		async append(contents, breakToken) {
-
-			if (!this.layoutMethod) {
-				return this.layout(contents, breakToken);
-			}
-
-			let newBreakToken = await this.layoutMethod.renderTo(this.wrapper, contents, breakToken);
-
-			this.endToken = newBreakToken;
-
-			return newBreakToken;
-		}
-
-		getByParent(ref, entries) {
-			let e;
-			for (var i = 0; i < entries.length; i++) {
-				e = entries[i];
-				if(e.dataset.ref === ref) {
-					return e;
-				}
-			}
-		}
-
-		onOverflow(func) {
-			this._onOverflow = func;
-		}
-
-		onUnderflow(func) {
-			this._onUnderflow = func;
-		}
-
-		clear() {
-			this.removeListeners();
-			this.wrapper && this.wrapper.remove();
-			this.createWrapper();
-		}
-
-		addListeners(contents) {
-			if (typeof ResizeObserver !== "undefined") {
-				this.addResizeObserver(contents);
-			} else {
-				this._checkOverflowAfterResize = this.checkOverflowAfterResize.bind(this, contents);
-				this.element.addEventListener("overflow", this._checkOverflowAfterResize, false);
-				this.element.addEventListener("underflow", this._checkOverflowAfterResize, false);
-			}
-			// TODO: fall back to mutation observer?
-
-			this._onScroll = function() {
-				if(this.listening) {
-					this.element.scrollLeft = 0;
-				}
-			}.bind(this);
-
-			// Keep scroll left from changing
-			this.element.addEventListener("scroll", this._onScroll);
-
-			this.listening = true;
-
-			return true;
-		}
-
-		removeListeners() {
-			this.listening = false;
-
-			if (typeof ResizeObserver !== "undefined" && this.ro) {
-				this.ro.disconnect();
-			} else if (this.element) {
-				this.element.removeEventListener("overflow", this._checkOverflowAfterResize, false);
-				this.element.removeEventListener("underflow", this._checkOverflowAfterResize, false);
-			}
-
-			this.element &&this.element.removeEventListener("scroll", this._onScroll);
-
-		}
-
-		addResizeObserver(contents) {
-			let wrapper = this.wrapper;
-			let prevHeight = wrapper.getBoundingClientRect().height;
-			this.ro = new ResizeObserver( entries => {
-
-				if (!this.listening) {
-					return;
-				}
-
-				for (let entry of entries) {
-					const cr = entry.contentRect;
-
-					if (cr.height > prevHeight) {
-						this.checkOverflowAfterResize(contents);
-						prevHeight = wrapper.getBoundingClientRect().height;
-					} else if (cr.height < prevHeight ) { // TODO: calc line height && (prevHeight - cr.height) >= 22
-						this.checkUnderflowAfterResize(contents);
-						prevHeight = cr.height;
-					}
-				}
-			});
-
-			this.ro.observe(wrapper);
-		}
-
-		checkOverflowAfterResize(contents) {
-			if (!this.listening || !this.layoutMethod) {
-				return;
-			}
-
-			let newBreakToken = this.layoutMethod.findBreakToken(this.wrapper, contents);
-
-			if (newBreakToken) {
-				this.endToken = newBreakToken;
-				this._onOverflow && this._onOverflow(newBreakToken);
-			}
-		}
-
-		checkUnderflowAfterResize(contents) {
-			if (!this.listening || !this.layoutMethod) {
-				return;
-			}
-
-			let endToken = this.layoutMethod.findEndToken(this.wrapper, contents);
-
-			// let newBreakToken = this.layoutMethod.findBreakToken(this.wrapper, contents);
-
-			if (endToken) {
-				this._onUnderflow && this._onUnderflow(endToken);
-			}
-		}
-
-
-		destroy() {
-			this.removeListeners();
-
-			this.element.remove();
-
-			this.element = undefined;
-			this.wrapper = undefined;
-		}
-	}
-
-	eventEmitter(Page.prototype);
-
-	/**
-	 * Render a flow of text offscreen
-	 * @class
-	 */
-	class ContentParser {
-
-		constructor(content, cb) {
-			if (content && content.nodeType) {
-				// handle dom
-				this.dom = this.add(content);
-			} else if (typeof content === "string") {
-				this.dom = this.parse(content);
-			}
-
-			return this.dom;
-		}
-
-		parse(markup, mime) {
-			let range = document.createRange();
-			let fragment = range.createContextualFragment(markup);
-
-			this.addRefs(fragment);
-			this.removeEmpty(fragment);
-
-			return fragment;
-		}
-
-		add(contents) {
-			// let fragment = document.createDocumentFragment();
-			//
-			// let children = [...contents.childNodes];
-			// for (let child of children) {
-			// 	let clone = child.cloneNode(true);
-			// 	fragment.appendChild(clone);
-			// }
-
-			this.addRefs(contents);
-			this.removeEmpty(contents);
-
-			return contents;
-		}
-
-		addRefs(content) {
-			var treeWalker = document.createTreeWalker(
-				content,
-				NodeFilter.SHOW_ELEMENT,
-				{ acceptNode: function(node) { return NodeFilter.FILTER_ACCEPT; } },
-				false
-			);
-
-			let node = treeWalker.nextNode();
-			while(node) {
-
-				if (!node.hasAttribute("data-ref")) {
-					let uuid = UUID();
-					node.setAttribute("data-ref", uuid);
-				}
-
-				if (node.id) {
-					node.setAttribute("data-id", node.id);
-				}
-
-				// node.setAttribute("data-children", node.childNodes.length);
-
-				// node.setAttribute("data-text", node.textContent.trim().length);
-				node = treeWalker.nextNode();
-			}
-		}
-
-		removeEmpty(content) {
-			var treeWalker = document.createTreeWalker(
-				content,
-				NodeFilter.SHOW_TEXT,
-				{ acceptNode: function(node) {
-					// Only remove more than a single space
-					if (node.textContent.length > 1 && !node.textContent.trim()) {
-
-						// Don't touch whitespace if text is preformated
-						let parent = node.parentNode;
-						let pre = isElement(parent) && parent.closest("pre");
-						if (pre) {
-							return NodeFilter.FILTER_REJECT;
-						}
-
-						return NodeFilter.FILTER_ACCEPT;
-					} else {
-						return NodeFilter.FILTER_REJECT;
-					}
-				} },
-				false
-			);
-
-			let node;
-			let current;
-			node = treeWalker.nextNode();
-			while(node) {
-				current = node;
-				node = treeWalker.nextNode();
-				// if (!current.nextSibling || (current.nextSibling && current.nextSibling.nodeType === 1)) {
-				current.parentNode.removeChild(current);
-				// }
-			}
-		}
-
-		find(ref) {
-			return this.refs[ref];
-		}
-
-		// isWrapper(element) {
-		//   return wrappersRegex.test(element.nodeName);
-		// }
-
-		isText(node) {
-			return node.tagName === "TAG";
-		}
-
-		isElement(node) {
-			return node.nodeType === 1;
-		}
-
-		hasChildren(node) {
-			return node.childNodes && node.childNodes.length;
-		}
-
-
-		destroy() {
-			this.refs = undefined;
-			this.dom = undefined;
-		}
-	}
-
-	/**
-	 * Queue for handling tasks one at a time
-	 * @class
-	 * @param {scope} context what this will resolve to in the tasks
-	 */
-	class Queue {
-		constructor(context){
-			this._q = [];
-			this.context = context;
-			this.tick = requestAnimationFrame;
-			this.running = false;
-			this.paused = false;
-		}
-
-		/**
-		 * Add an item to the queue
-		 * @return {Promise} enqueued
-		 */
-		enqueue() {
-			var deferred, promise;
-			var queued;
-			var task = [].shift.call(arguments);
-			var args = arguments;
-
-			// Handle single args without context
-			// if(args && !Array.isArray(args)) {
-			//   args = [args];
-			// }
-			if(!task) {
-				throw new Error("No Task Provided");
-			}
-
-			if(typeof task === "function"){
-
-				deferred = new defer();
-				promise = deferred.promise;
-
-				queued = {
-					"task" : task,
-					"args"     : args,
-					//"context"  : context,
-					"deferred" : deferred,
-					"promise" : promise
-				};
-
-			} else {
-				// Task is a promise
-				queued = {
-					"promise" : task
-				};
-
-			}
-
-			this._q.push(queued);
-
-			// Wait to start queue flush
-			if (this.paused == false && !this.running) {
-				this.run();
-			}
-
-			return queued.promise;
-		}
-
-		/**
-		 * Run one item
-		 * @return {Promise} dequeued
-		 */
-		dequeue(){
-			var inwait, task, result;
-
-			if(this._q.length && !this.paused) {
-				inwait = this._q.shift();
-				task = inwait.task;
-				if(task){
-					// console.log(task)
-
-					result = task.apply(this.context, inwait.args);
-
-					if(result && typeof result["then"] === "function") {
-						// Task is a function that returns a promise
-						return result.then(function(){
-							inwait.deferred.resolve.apply(this.context, arguments);
-						}.bind(this), function() {
-							inwait.deferred.reject.apply(this.context, arguments);
-						}.bind(this));
-					} else {
-						// Task resolves immediately
-						inwait.deferred.resolve.apply(this.context, result);
-						return inwait.promise;
-					}
-
-
-
-				} else if(inwait.promise) {
-					// Task is a promise
-					return inwait.promise;
-				}
-
-			} else {
-				inwait = new defer();
-				inwait.deferred.resolve();
-				return inwait.promise;
-			}
-
-		}
-
-		// Run All Immediately
-		dump(){
-			while(this._q.length) {
-				this.dequeue();
-			}
-		}
-
-		/**
-		 * Run all tasks sequentially, at convince
-		 * @return {Promise} all run
-		 */
-		run(){
-
-			if(!this.running){
-				this.running = true;
-				this.defered = new defer();
-			}
-
-			this.tick.call(window, () => {
-
-				if(this._q.length) {
-
-					this.dequeue()
-						.then(function(){
-							this.run();
-						}.bind(this));
-
-				} else {
-					this.defered.resolve();
-					this.running = undefined;
-				}
-
-			});
-
-			// Unpause
-			if(this.paused == true) {
-				this.paused = false;
-			}
-
-			return this.defered.promise;
-		}
-
-		/**
-		 * Flush all, as quickly as possible
-		 * @return {Promise} ran
-		 */
-		flush(){
-
-			if(this.running){
-				return this.running;
-			}
-
-			if(this._q.length) {
-				this.running = this.dequeue()
-					.then(function(){
-						this.running = undefined;
-						return this.flush();
-					}.bind(this));
-
-				return this.running;
-			}
-
-		}
-
-		/**
-		 * Clear all items in wait
-		 * @return {void}
-		 */
-		clear(){
-			this._q = [];
-		}
-
-		/**
-		 * Get the number of tasks in the queue
-		 * @return {number} tasks
-		 */
-		length(){
-			return this._q.length;
-		}
-
-		/**
-		 * Pause a running queue
-		 * @return {void}
-		 */
-		pause(){
-			this.paused = true;
-		}
-
-		/**
-		 * End the queue
-		 * @return {void}
-		 */
-		stop(){
-			this._q = [];
-			this.running = false;
-			this.paused = true;
-		}
-	}
-
-	const TEMPLATE = `
-<div class="pagedjs_page">
-	<div class="pagedjs_sheet">
-		<div class="pagedjs_bleed pagedjs_bleed-top">
-			<div class="pagedjs_marks-crop"></div>
-			<div class="pagedjs_marks-middle">
-				<div class="pagedjs_marks-cross"></div>
-			</div>
-			<div class="pagedjs_marks-crop"></div>
-		</div>
-		<div class="pagedjs_bleed pagedjs_bleed-bottom">
-			<div class="pagedjs_marks-crop"></div>
-			<div class="pagedjs_marks-middle">
-				<div class="pagedjs_marks-cross"></div>
-			</div>		<div class="pagedjs_marks-crop"></div>
-		</div>
-		<div class="pagedjs_bleed pagedjs_bleed-left">
-			<div class="pagedjs_marks-crop"></div>
-			<div class="pagedjs_marks-middle">
-				<div class="pagedjs_marks-cross"></div>
-			</div>		<div class="pagedjs_marks-crop"></div>
-		</div>
-		<div class="pagedjs_bleed pagedjs_bleed-right">
-			<div class="pagedjs_marks-crop"></div>
-			<div class="pagedjs_marks-middle">
-				<div class="pagedjs_marks-cross"></div>
-			</div>
-			<div class="pagedjs_marks-crop"></div>
-		</div>
-		<div class="pagedjs_pagebox">
-			<div class="pagedjs_margin-top-left-corner-holder">
-				<div class="pagedjs_margin pagedjs_margin-top-left-corner"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_margin-top">
-				<div class="pagedjs_margin pagedjs_margin-top-left"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-top-center"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-top-right"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_margin-top-right-corner-holder">
-				<div class="pagedjs_margin pagedjs_margin-top-right-corner"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_margin-right">
-				<div class="pagedjs_margin pagedjs_margin-right-top"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-right-middle"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-right-bottom"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_margin-left">
-				<div class="pagedjs_margin pagedjs_margin-left-top"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-left-middle"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-left-bottom"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_margin-bottom-left-corner-holder">
-				<div class="pagedjs_margin pagedjs_margin-bottom-left-corner"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_margin-bottom">
-				<div class="pagedjs_margin pagedjs_margin-bottom-left"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-bottom-center"><div class="pagedjs_margin-content"></div></div>
-				<div class="pagedjs_margin pagedjs_margin-bottom-right"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_margin-bottom-right-corner-holder">
-				<div class="pagedjs_margin pagedjs_margin-bottom-right-corner"><div class="pagedjs_margin-content"></div></div>
-			</div>
-			<div class="pagedjs_area">
-				<div class="pagedjs_page_content"></div>
-			</div>
-		</div>
-	</div>
-</div>`;
-
-	/**
-	 * Chop up text into flows
-	 * @class
-	 */
-	class Chunker {
-		constructor(content, renderTo) {
-			// this.preview = preview;
-
-			this.hooks = {};
-			this.hooks.beforeParsed = new Hook(this);
-			this.hooks.afterParsed = new Hook(this);
-			this.hooks.beforePageLayout = new Hook(this);
-			this.hooks.layout = new Hook(this);
-			this.hooks.renderNode = new Hook(this);
-			this.hooks.layoutNode = new Hook(this);
-			this.hooks.onOverflow = new Hook(this);
-			this.hooks.onBreakToken = new Hook();
-			this.hooks.afterPageLayout = new Hook(this);
-			this.hooks.afterRendered = new Hook(this);
-
-			this.pages = [];
-			this._total = 0;
-
-			this.q = new Queue(this);
-			this.stopped = false;
-			this.rendered = false;
-
-			this.content = content;
-
-			this.charsPerBreak = [];
-			this.maxChars;
-
-			if (content) {
-				this.flow(content, renderTo);
-			}
-		}
-
-		setup(renderTo) {
-			this.pagesArea = document.createElement("div");
-			this.pagesArea.classList.add("pagedjs_pages");
-
-			if (renderTo) {
-				renderTo.appendChild(this.pagesArea);
-			} else {
-				document.querySelector("body").appendChild(this.pagesArea);
-			}
-
-			this.pageTemplate = document.createElement("template");
-			this.pageTemplate.innerHTML = TEMPLATE;
-
-		}
-
-		async flow(content, renderTo) {
-			let parsed;
-
-			await this.hooks.beforeParsed.trigger(content, this);
-
-			parsed = new ContentParser(content);
-
-			this.source = parsed;
-			this.breakToken = undefined;
-
-			if (this.pagesArea && this.pageTemplate) {
-				this.q.clear();
-				this.removePages();
-			} else {
-				this.setup(renderTo);
-			}
-
-			this.emit("rendering", content);
-
-			await this.hooks.afterParsed.trigger(parsed, this);
-
-			await this.loadFonts();
-
-			let rendered = await this.render(parsed, this.breakToken);
-			while (rendered.canceled) {
-				this.start();
-				rendered = await this.render(parsed, this.breakToken);
-			}
-
-			this.rendered = true;
-
-			await this.hooks.afterRendered.trigger(this.pages, this);
-
-			this.emit("rendered", this.pages);
-
-			return this;
-		}
-
-		// oversetPages() {
-		// 	let overset = [];
-		// 	for (let i = 0; i < this.pages.length; i++) {
-		// 		let page = this.pages[i];
-		// 		if (page.overset) {
-		// 			overset.push(page);
-		// 			// page.overset = false;
-		// 		}
-		// 	}
-		// 	return overset;
-		// }
-		//
-		// async handleOverset(parsed) {
-		// 	let overset = this.oversetPages();
-		// 	if (overset.length) {
-		// 		console.log("overset", overset);
-		// 		let index = this.pages.indexOf(overset[0]) + 1;
-		// 		console.log("INDEX", index);
-		//
-		// 		// Remove pages
-		// 		// this.removePages(index);
-		//
-		// 		// await this.render(parsed, overset[0].overset);
-		//
-		// 		// return this.handleOverset(parsed);
-		// 	}
-		// }
-
-		async render(parsed, startAt) {
-			let renderer = this.layout(parsed, startAt);
-
-			let done = false;
-			let result;
-
-			while (!done) {
-				result = await this.q.enqueue(() => { return this.renderAsync(renderer); });
-				done = result.done;
-			}
-
-			return result;
-		}
-
-		start() {
-			this.rendered = false;
-			this.stopped = false;
-		}
-
-		stop() {
-			this.stopped = true;
-			// this.q.clear();
-		}
-
-		renderOnIdle(renderer) {
-			return new Promise(resolve => {
-				requestIdleCallback(async () => {
-					if (this.stopped) {
-						return resolve({ done: true, canceled: true });
-					}
-					let result = await renderer.next();
-					if (this.stopped) {
-						resolve({ done: true, canceled: true });
-					} else {
-						resolve(result);
-					}
-				});
-			});
-		}
-
-		async renderAsync(renderer) {
-			if (this.stopped) {
-				return { done: true, canceled: true };
-			}
-			let result = await renderer.next();
-			if (this.stopped) {
-				return { done: true, canceled: true };
-			} else {
-				return result;
-			}
-		}
-
-		async handleBreaks(node) {
-			let currentPage = this.total + 1;
-			let currentPosition = currentPage % 2 === 0 ? "left" : "right";
-			// TODO: Recto and Verso should reverse for rtl languages
-			let currentSide = currentPage % 2 === 0 ? "verso" : "recto";
-			let previousBreakAfter;
-			let breakBefore;
-			let page;
-
-			if (currentPage === 1) {
-				return;
-			}
-
-			if (node &&
-					typeof node.dataset !== "undefined" &&
-					typeof node.dataset.previousBreakAfter !== "undefined") {
-				previousBreakAfter = node.dataset.previousBreakAfter;
-			}
-
-			if (node &&
-					typeof node.dataset !== "undefined" &&
-					typeof node.dataset.breakBefore !== "undefined") {
-				breakBefore = node.dataset.breakBefore;
-			}
-
-			if( previousBreakAfter &&
-					(previousBreakAfter === "left" || previousBreakAfter === "right") &&
-					previousBreakAfter !== currentPosition) {
-				page = this.addPage(true);
-			} else if( previousBreakAfter &&
-					(previousBreakAfter === "verso" || previousBreakAfter === "recto") &&
-					previousBreakAfter !== currentSide) {
-				page = this.addPage(true);
-			} else if( breakBefore &&
-					(breakBefore === "left" || breakBefore === "right") &&
-					breakBefore !== currentPosition) {
-				page = this.addPage(true);
-			} else if( breakBefore &&
-					(breakBefore === "verso" || breakBefore === "recto") &&
-					breakBefore !== currentSide) {
-				page = this.addPage(true);
-			}
-
-			if (page) {
-				await this.hooks.beforePageLayout.trigger(page, undefined, undefined, this);
-				this.emit("page", page);
-				// await this.hooks.layout.trigger(page.element, page, undefined, this);
-				await this.hooks.afterPageLayout.trigger(page.element, page, undefined, this);
-				this.emit("renderedPage", page);
-			}
-		}
-
-		async *layout(content, startAt) {
-			let breakToken = startAt || false;
-
-			while (breakToken !== undefined && (true)) {
-
-				if (breakToken && breakToken.node) {
-					await this.handleBreaks(breakToken.node);
-				} else {
-					await this.handleBreaks(content.firstChild);
-				}
-
-				let page = this.addPage();
-
-				await this.hooks.beforePageLayout.trigger(page, content, breakToken, this);
-				this.emit("page", page);
-
-				// Layout content in the page, starting from the breakToken
-				breakToken = await page.layout(content, breakToken, this.maxChars);
-
-				await this.hooks.afterPageLayout.trigger(page.element, page, breakToken, this);
-				this.emit("renderedPage", page);
-
-				this.recoredCharLength(page.wrapper.textContent.length);
-
-				yield breakToken;
-
-				// Stop if we get undefined, showing we have reached the end of the content
-			}
-		}
-
-		recoredCharLength(length) {
-			if (length === 0) {
-				return;
-			}
-
-			this.charsPerBreak.push(length);
-
-			// Keep the length of the last few breaks
-			if (this.charsPerBreak.length > 4) {
-				this.charsPerBreak.shift();
-			}
-
-			this.maxChars = this.charsPerBreak.reduce((a, b) => a + b, 0) / (this.charsPerBreak.length);
-		}
-
-		removePages(fromIndex=0) {
-
-			if (fromIndex >= this.pages.length) {
-				return;
-			}
-
-			// Remove pages
-			for (let i = fromIndex; i < this.pages.length; i++) {
-				this.pages[i].destroy();
-			}
-
-			if (fromIndex > 0) {
-				this.pages.splice(fromIndex);
-			} else {
-				this.pages = [];
-			}
-		}
-
-		addPage(blank) {
-			let lastPage = this.pages[this.pages.length - 1];
-			// Create a new page from the template
-			let page = new Page(this.pagesArea, this.pageTemplate, blank, this.hooks);
-
-			this.pages.push(page);
-
-			// Create the pages
-			page.create(undefined, lastPage && lastPage.element);
-
-			page.index(this.total);
-
-			if (!blank) {
-				// Listen for page overflow
-				page.onOverflow((overflowToken) => {
-					console.warn("overflow on", page.id, overflowToken);
-
-					// Only reflow while rendering
-					if (this.rendered) {
-						return;
-					}
-
-					let index = this.pages.indexOf(page) + 1;
-
-					// Stop the rendering
-					this.stop();
-
-					// Set the breakToken to resume at
-					this.breakToken = overflowToken;
-
-					// Remove pages
-					this.removePages(index);
-
-					if (this.rendered === true) {
-						this.rendered = false;
-
-						this.q.enqueue(async () => {
-
-							this.start();
-
-							await this.render(this.source, this.breakToken);
-
-							this.rendered = true;
-
-						});
-					}
-
-
-				});
-
-				page.onUnderflow((overflowToken) => {
-					// console.log("underflow on", page.id, overflowToken);
-
-					// page.append(this.source, overflowToken);
-
-				});
-			}
-
-			this.total = this.pages.length;
-
-			return page;
-		}
-		/*
-		insertPage(index, blank) {
-			let lastPage = this.pages[index];
-			// Create a new page from the template
-			let page = new Page(this.pagesArea, this.pageTemplate, blank, this.hooks);
-
-			let total = this.pages.splice(index, 0, page);
-
-			// Create the pages
-			page.create(undefined, lastPage && lastPage.element);
-
-			page.index(index + 1);
-
-			for (let i = index + 2; i < this.pages.length; i++) {
-				this.pages[i].index(i);
-			}
-
-			if (!blank) {
-				// Listen for page overflow
-				page.onOverflow((overflowToken) => {
-					if (total < this.pages.length) {
-						this.pages[total].layout(this.source, overflowToken);
-					} else {
-						let newPage = this.addPage();
-						newPage.layout(this.source, overflowToken);
-					}
-				});
-
-				page.onUnderflow(() => {
-					// console.log("underflow on", page.id);
-				});
-			}
-
-			this.total += 1;
-
-			return page;
-		}
-		*/
-
-		get total() {
-			return this._total;
-		}
-
-		set total(num) {
-			this.pagesArea.style.setProperty("--pagedjs-page-count", num);
-			this._total = num;
-		}
-
-		loadFonts() {
-			let fontPromises = [];
-			document.fonts.forEach((fontFace) => {
-				if (fontFace.status !== "loaded") {
-					let fontLoaded = fontFace.load().then((r) => {
-						return fontFace.family;
-					}, (r) => {
-						console.warn("Failed to preload font-family:", fontFace.family);
-						return fontFace.family;
-					});
-					fontPromises.push(fontLoaded);
-				}
-			});
-			return Promise.all(fontPromises).catch((err) => {
-				console.warn(err);
-			});
-		}
-
-		destroy() {
-			this.pagesArea.remove();
-			this.pageTemplate.remove();
-		}
-
-	}
-
-	eventEmitter(Chunker.prototype);
-
-	//
-	//            item        item        item        item
-	//          /------\    /------\    /------\    /------\
-	//          | data |    | data |    | data |    | data |
-	//  null <--+-prev |<---+-prev |<---+-prev |<---+-prev |
-	//          | next-+--->| next-+--->| next-+--->| next-+--> null
-	//          \------/    \------/    \------/    \------/
-	//             ^                                    ^
-	//             |                list                |
-	//             |              /------\              |
-	//             \--------------+-head |              |
-	//                            | tail-+--------------/
-	//                            \------/
-	//
-
-	function createItem(data) {
-	    return {
-	        prev: null,
-	        next: null,
-	        data: data
-	    };
-	}
-
-	function allocateCursor(node, prev, next) {
-	    var cursor;
-
-	    if (cursors !== null) {
-	        cursor = cursors;
-	        cursors = cursors.cursor;
-	        cursor.prev = prev;
-	        cursor.next = next;
-	        cursor.cursor = node.cursor;
-	    } else {
-	        cursor = {
-	            prev: prev,
-	            next: next,
-	            cursor: node.cursor
-	        };
-	    }
-
-	    node.cursor = cursor;
-
-	    return cursor;
-	}
-
-	function releaseCursor(node) {
-	    var cursor = node.cursor;
-
-	    node.cursor = cursor.cursor;
-	    cursor.prev = null;
-	    cursor.next = null;
-	    cursor.cursor = cursors;
-	    cursors = cursor;
-	}
-
-	var cursors = null;
-	var List = function() {
-	    this.cursor = null;
-	    this.head = null;
-	    this.tail = null;
-	};
-
-	List.createItem = createItem;
-	List.prototype.createItem = createItem;
-
-	List.prototype.updateCursors = function(prevOld, prevNew, nextOld, nextNew) {
-	    var cursor = this.cursor;
-
-	    while (cursor !== null) {
-	        if (cursor.prev === prevOld) {
-	            cursor.prev = prevNew;
-	        }
-
-	        if (cursor.next === nextOld) {
-	            cursor.next = nextNew;
-	        }
-
-	        cursor = cursor.cursor;
-	    }
-	};
-
-	List.prototype.getSize = function() {
-	    var size = 0;
-	    var cursor = this.head;
-
-	    while (cursor) {
-	        size++;
-	        cursor = cursor.next;
-	    }
-
-	    return size;
-	};
-
-	List.prototype.fromArray = function(array) {
-	    var cursor = null;
-
-	    this.head = null;
-
-	    for (var i = 0; i < array.length; i++) {
-	        var item = createItem(array[i]);
-
-	        if (cursor !== null) {
-	            cursor.next = item;
-	        } else {
-	            this.head = item;
-	        }
-
-	        item.prev = cursor;
-	        cursor = item;
-	    }
-
-	    this.tail = cursor;
-
-	    return this;
-	};
-
-	List.prototype.toArray = function() {
-	    var cursor = this.head;
-	    var result = [];
-
-	    while (cursor) {
-	        result.push(cursor.data);
-	        cursor = cursor.next;
-	    }
-
-	    return result;
-	};
-
-	List.prototype.toJSON = List.prototype.toArray;
-
-	List.prototype.isEmpty = function() {
-	    return this.head === null;
-	};
-
-	List.prototype.first = function() {
-	    return this.head && this.head.data;
-	};
-
-	List.prototype.last = function() {
-	    return this.tail && this.tail.data;
-	};
-
-	List.prototype.each = function(fn, context) {
-	    var item;
-
-	    if (context === undefined) {
-	        context = this;
-	    }
-
-	    // push cursor
-	    var cursor = allocateCursor(this, null, this.head);
-
-	    while (cursor.next !== null) {
-	        item = cursor.next;
-	        cursor.next = item.next;
-
-	        fn.call(context, item.data, item, this);
-	    }
-
-	    // pop cursor
-	    releaseCursor(this);
-	};
-
-	List.prototype.forEach = List.prototype.each;
-
-	List.prototype.eachRight = function(fn, context) {
-	    var item;
-
-	    if (context === undefined) {
-	        context = this;
-	    }
-
-	    // push cursor
-	    var cursor = allocateCursor(this, this.tail, null);
-
-	    while (cursor.prev !== null) {
-	        item = cursor.prev;
-	        cursor.prev = item.prev;
-
-	        fn.call(context, item.data, item, this);
-	    }
-
-	    // pop cursor
-	    releaseCursor(this);
-	};
-
-	List.prototype.forEachRight = List.prototype.eachRight;
-
-	List.prototype.nextUntil = function(start, fn, context) {
-	    if (start === null) {
-	        return;
-	    }
-
-	    var item;
-
-	    if (context === undefined) {
-	        context = this;
-	    }
-
-	    // push cursor
-	    var cursor = allocateCursor(this, null, start);
-
-	    while (cursor.next !== null) {
-	        item = cursor.next;
-	        cursor.next = item.next;
-
-	        if (fn.call(context, item.data, item, this)) {
-	            break;
-	        }
-	    }
-
-	    // pop cursor
-	    releaseCursor(this);
-	};
-
-	List.prototype.prevUntil = function(start, fn, context) {
-	    if (start === null) {
-	        return;
-	    }
-
-	    var item;
-
-	    if (context === undefined) {
-	        context = this;
-	    }
-
-	    // push cursor
-	    var cursor = allocateCursor(this, start, null);
-
-	    while (cursor.prev !== null) {
-	        item = cursor.prev;
-	        cursor.prev = item.prev;
-
-	        if (fn.call(context, item.data, item, this)) {
-	            break;
-	        }
-	    }
-
-	    // pop cursor
-	    releaseCursor(this);
-	};
-
-	List.prototype.some = function(fn, context) {
-	    var cursor = this.head;
-
-	    if (context === undefined) {
-	        context = this;
-	    }
-
-	    while (cursor !== null) {
-	        if (fn.call(context, cursor.data, cursor, this)) {
-	            return true;
-	        }
-
-	        cursor = cursor.next;
-	    }
-
-	    return false;
-	};
-
-	List.prototype.map = function(fn, context) {
-	    var result = new List();
-	    var cursor = this.head;
-
-	    if (context === undefined) {
-	        context = this;
-	    }
-
-	    while (cursor !== null) {
-	        result.appendData(fn.call(context, cursor.data, cursor, this));
-	        cursor = cursor.next;
-	    }
-
-	    return result;
-	};
-
-	List.prototype.filter = function(fn, context) {
-	    var result = new List();
-	    var cursor = this.head;
-
-	    if (context === undefined) {
-	        context = this;
-	    }
-
-	    while (cursor !== null) {
-	        if (fn.call(context, cursor.data, cursor, this)) {
-	            result.appendData(cursor.data);
-	        }
-	        cursor = cursor.next;
-	    }
-
-	    return result;
-	};
-
-	List.prototype.clear = function() {
-	    this.head = null;
-	    this.tail = null;
-	};
-
-	List.prototype.copy = function() {
-	    var result = new List();
-	    var cursor = this.head;
-
-	    while (cursor !== null) {
-	        result.insert(createItem(cursor.data));
-	        cursor = cursor.next;
-	    }
-
-	    return result;
-	};
-
-	List.prototype.prepend = function(item) {
-	    //      head
-	    //    ^
-	    // item
-	    this.updateCursors(null, item, this.head, item);
-
-	    // insert to the beginning of the list
-	    if (this.head !== null) {
-	        // new item <- first item
-	        this.head.prev = item;
-
-	        // new item -> first item
-	        item.next = this.head;
-	    } else {
-	        // if list has no head, then it also has no tail
-	        // in this case tail points to the new item
-	        this.tail = item;
-	    }
-
-	    // head always points to new item
-	    this.head = item;
-
-	    return this;
-	};
-
-	List.prototype.prependData = function(data) {
-	    return this.prepend(createItem(data));
-	};
-
-	List.prototype.append = function(item) {
-	    return this.insert(item);
-	};
-
-	List.prototype.appendData = function(data) {
-	    return this.insert(createItem(data));
-	};
-
-	List.prototype.insert = function(item, before) {
-	    if (before !== undefined && before !== null) {
-	        // prev   before
-	        //      ^
-	        //     item
-	        this.updateCursors(before.prev, item, before, item);
-
-	        if (before.prev === null) {
-	            // insert to the beginning of list
-	            if (this.head !== before) {
-	                throw new Error('before doesn\'t belong to list');
-	            }
-
-	            // since head points to before therefore list doesn't empty
-	            // no need to check tail
-	            this.head = item;
-	            before.prev = item;
-	            item.next = before;
-
-	            this.updateCursors(null, item);
-	        } else {
-
-	            // insert between two items
-	            before.prev.next = item;
-	            item.prev = before.prev;
-
-	            before.prev = item;
-	            item.next = before;
-	        }
-	    } else {
-	        // tail
-	        //      ^
-	        //      item
-	        this.updateCursors(this.tail, item, null, item);
-
-	        // insert to the ending of the list
-	        if (this.tail !== null) {
-	            // last item -> new item
-	            this.tail.next = item;
-
-	            // last item <- new item
-	            item.prev = this.tail;
-	        } else {
-	            // if list has no tail, then it also has no head
-	            // in this case head points to new item
-	            this.head = item;
-	        }
-
-	        // tail always points to new item
-	        this.tail = item;
-	    }
-
-	    return this;
-	};
-
-	List.prototype.insertData = function(data, before) {
-	    return this.insert(createItem(data), before);
-	};
-
-	List.prototype.remove = function(item) {
-	    //      item
-	    //       ^
-	    // prev     next
-	    this.updateCursors(item, item.prev, item, item.next);
-
-	    if (item.prev !== null) {
-	        item.prev.next = item.next;
-	    } else {
-	        if (this.head !== item) {
-	            throw new Error('item doesn\'t belong to list');
-	        }
-
-	        this.head = item.next;
-	    }
-
-	    if (item.next !== null) {
-	        item.next.prev = item.prev;
-	    } else {
-	        if (this.tail !== item) {
-	            throw new Error('item doesn\'t belong to list');
-	        }
-
-	        this.tail = item.prev;
-	    }
-
-	    item.prev = null;
-	    item.next = null;
-
-	    return item;
-	};
-
-	List.prototype.push = function(data) {
-	    this.insert(createItem(data));
-	};
-
-	List.prototype.pop = function() {
-	    if (this.tail !== null) {
-	        return this.remove(this.tail);
-	    }
-	};
-
-	List.prototype.unshift = function(data) {
-	    this.prepend(createItem(data));
-	};
-
-	List.prototype.shift = function() {
-	    if (this.head !== null) {
-	        return this.remove(this.head);
-	    }
-	};
-
-	List.prototype.prependList = function(list) {
-	    return this.insertList(list, this.head);
-	};
-
-	List.prototype.appendList = function(list) {
-	    return this.insertList(list);
-	};
-
-	List.prototype.insertList = function(list, before) {
-	    // ignore empty lists
-	    if (list.head === null) {
-	        return this;
-	    }
-
-	    if (before !== undefined && before !== null) {
-	        this.updateCursors(before.prev, list.tail, before, list.head);
-
-	        // insert in the middle of dist list
-	        if (before.prev !== null) {
-	            // before.prev <-> list.head
-	            before.prev.next = list.head;
-	            list.head.prev = before.prev;
-	        } else {
-	            this.head = list.head;
-	        }
-
-	        before.prev = list.tail;
-	        list.tail.next = before;
-	    } else {
-	        this.updateCursors(this.tail, list.tail, null, list.head);
-
-	        // insert to end of the list
-	        if (this.tail !== null) {
-	            // if destination list has a tail, then it also has a head,
-	            // but head doesn't change
-
-	            // dest tail -> source head
-	            this.tail.next = list.head;
-
-	            // dest tail <- source head
-	            list.head.prev = this.tail;
-	        } else {
-	            // if list has no a tail, then it also has no a head
-	            // in this case points head to new item
-	            this.head = list.head;
-	        }
-
-	        // tail always start point to new item
-	        this.tail = list.tail;
-	    }
-
-	    list.head = null;
-	    list.tail = null;
-
-	    return this;
-	};
-
-	List.prototype.replace = function(oldItem, newItemOrList) {
-	    if ('head' in newItemOrList) {
-	        this.insertList(newItemOrList, oldItem);
-	    } else {
-	        this.insert(newItemOrList, oldItem);
-	    }
-
-	    this.remove(oldItem);
-	};
-
-	var list = List;
-
-	var createCustomError = function createCustomError(name, message) {
-	    // use Object.create(), because some VMs prevent setting line/column otherwise
-	    // (iOS Safari 10 even throws an exception)
-	    var error = Object.create(SyntaxError.prototype);
-	    var errorStack = new Error();
-
-	    error.name = name;
-	    error.message = message;
-
-	    Object.defineProperty(error, 'stack', {
-	        get: function() {
-	            return (errorStack.stack || '').replace(/^(.+\n){1,3}/, name + ': ' + message + '\n');
-	        }
-	    });
-
-	    return error;
-	};
-
-	var MAX_LINE_LENGTH = 100;
-	var OFFSET_CORRECTION = 60;
-	var TAB_REPLACEMENT = '    ';
-
-	function sourceFragment(error, extraLines) {
-	    function processLines(start, end) {
-	        return lines.slice(start, end).map(function(line, idx) {
-	            var num = String(start + idx + 1);
-
-	            while (num.length < maxNumLength) {
-	                num = ' ' + num;
-	            }
-
-	            return num + ' |' + line;
-	        }).join('\n');
-	    }
-
-	    var lines = error.source.split(/\r\n?|\n|\f/);
-	    var line = error.line;
-	    var column = error.column;
-	    var startLine = Math.max(1, line - extraLines) - 1;
-	    var endLine = Math.min(line + extraLines, lines.length + 1);
-	    var maxNumLength = Math.max(4, String(endLine).length) + 1;
-	    var cutLeft = 0;
-
-	    // column correction according to replaced tab before column
-	    column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length;
-
-	    if (column > MAX_LINE_LENGTH) {
-	        cutLeft = column - OFFSET_CORRECTION + 3;
-	        column = OFFSET_CORRECTION - 2;
-	    }
-
-	    for (var i = startLine; i <= endLine; i++) {
-	        if (i >= 0 && i < lines.length) {
-	            lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT);
-	            lines[i] =
-	                (cutLeft > 0 && lines[i].length > cutLeft ? '\u2026' : '') +
-	                lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +
-	                (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\u2026' : '');
-	        }
-	    }
-
-	    return [
-	        processLines(startLine, line),
-	        new Array(column + maxNumLength + 2).join('-') + '^',
-	        processLines(line, endLine)
-	    ].filter(Boolean).join('\n');
-	}
-
-	var CssSyntaxError = function(message, source, offset, line, column) {
-	    var error = createCustomError('CssSyntaxError', message);
-
-	    error.source = source;
-	    error.offset = offset;
-	    error.line = line;
-	    error.column = column;
-
-	    error.sourceFragment = function(extraLines) {
-	        return sourceFragment(error, isNaN(extraLines) ? 0 : extraLines);
-	    };
-	    Object.defineProperty(error, 'formattedMessage', {
-	        get: function() {
-	            return (
-	                'Parse error: ' + error.message + '\n' +
-	                sourceFragment(error, 2)
-	            );
-	        }
-	    });
-
-	    // for backward capability
-	    error.parseError = {
-	        offset: offset,
-	        line: line,
-	        column: column
-	    };
-
-	    return error;
-	};
-
-	var error = CssSyntaxError;
-
-	// token types (note: value shouldn't intersect with used char codes)
-	var WHITESPACE = 1;
-	var IDENTIFIER = 2;
-	var NUMBER = 3;
-	var STRING = 4;
-	var COMMENT = 5;
-	var PUNCTUATOR = 6;
-	var CDO = 7;
-	var CDC = 8;
-	var ATKEYWORD = 14;
-	var FUNCTION = 15;
-	var URL$1 = 16;
-	var RAW = 17;
-
-	var TAB = 9;
-	var N = 10;
-	var F = 12;
-	var R = 13;
-	var SPACE = 32;
-
-	var TYPE = {
-	    WhiteSpace:   WHITESPACE,
-	    Identifier:   IDENTIFIER,
-	    Number:           NUMBER,
-	    String:           STRING,
-	    Comment:         COMMENT,
-	    Punctuator:   PUNCTUATOR,
-	    CDO:                 CDO,
-	    CDC:                 CDC,
-	    AtKeyword:     ATKEYWORD,
-	    Function:       FUNCTION,
-	    Url:                 URL$1,
-	    Raw:                 RAW,
-
-	    ExclamationMark:      33,  // !
-	    QuotationMark:        34,  // "
-	    NumberSign:           35,  // #
-	    DollarSign:           36,  // $
-	    PercentSign:          37,  // %
-	    Ampersand:            38,  // &
-	    Apostrophe:           39,  // '
-	    LeftParenthesis:      40,  // (
-	    RightParenthesis:     41,  // )
-	    Asterisk:             42,  // *
-	    PlusSign:             43,  // +
-	    Comma:                44,  // ,
-	    HyphenMinus:          45,  // -
-	    FullStop:             46,  // .
-	    Solidus:              47,  // /
-	    Colon:                58,  // :
-	    Semicolon:            59,  // ;
-	    LessThanSign:         60,  // <
-	    EqualsSign:           61,  // =
-	    GreaterThanSign:      62,  // >
-	    QuestionMark:         63,  // ?
-	    CommercialAt:         64,  // @
-	    LeftSquareBracket:    91,  // [
-	    Backslash:            92,  // \
-	    RightSquareBracket:   93,  // ]
-	    CircumflexAccent:     94,  // ^
-	    LowLine:              95,  // _
-	    GraveAccent:          96,  // `
-	    LeftCurlyBracket:    123,  // {
-	    VerticalLine:        124,  // |
-	    RightCurlyBracket:   125,  // }
-	    Tilde:               126   // ~
-	};
-
-	var NAME = Object.keys(TYPE).reduce(function(result, key) {
-	    result[TYPE[key]] = key;
-	    return result;
-	}, {});
-
-	// https://drafts.csswg.org/css-syntax/#tokenizer-definitions
-	// > non-ASCII code point
-	// >   A code point with a value equal to or greater than U+0080 <control>
-	// > name-start code point
-	// >   A letter, a non-ASCII code point, or U+005F LOW LINE (_).
-	// > name code point
-	// >   A name-start code point, a digit, or U+002D HYPHEN-MINUS (-)
-	// That means only ASCII code points has a special meaning and we a maps for 0..127 codes only
-	var SafeUint32Array = typeof Uint32Array !== 'undefined' ? Uint32Array : Array; // fallback on Array when TypedArray is not supported
-	var SYMBOL_TYPE = new SafeUint32Array(0x80);
-	var PUNCTUATION = new SafeUint32Array(0x80);
-	var STOP_URL_RAW = new SafeUint32Array(0x80);
-
-	for (var i = 0; i < SYMBOL_TYPE.length; i++) {
-	    SYMBOL_TYPE[i] = IDENTIFIER;
-	}
-
-	// fill categories
-	[
-	    TYPE.ExclamationMark,    // !
-	    TYPE.QuotationMark,      // "
-	    TYPE.NumberSign,         // #
-	    TYPE.DollarSign,         // $
-	    TYPE.PercentSign,        // %
-	    TYPE.Ampersand,          // &
-	    TYPE.Apostrophe,         // '
-	    TYPE.LeftParenthesis,    // (
-	    TYPE.RightParenthesis,   // )
-	    TYPE.Asterisk,           // *
-	    TYPE.PlusSign,           // +
-	    TYPE.Comma,              // ,
-	    TYPE.HyphenMinus,        // -
-	    TYPE.FullStop,           // .
-	    TYPE.Solidus,            // /
-	    TYPE.Colon,              // :
-	    TYPE.Semicolon,          // ;
-	    TYPE.LessThanSign,       // <
-	    TYPE.EqualsSign,         // =
-	    TYPE.GreaterThanSign,    // >
-	    TYPE.QuestionMark,       // ?
-	    TYPE.CommercialAt,       // @
-	    TYPE.LeftSquareBracket,  // [
-	    // TYPE.Backslash,          // \
-	    TYPE.RightSquareBracket, // ]
-	    TYPE.CircumflexAccent,   // ^
-	    // TYPE.LowLine,            // _
-	    TYPE.GraveAccent,        // `
-	    TYPE.LeftCurlyBracket,   // {
-	    TYPE.VerticalLine,       // |
-	    TYPE.RightCurlyBracket,  // }
-	    TYPE.Tilde               // ~
-	].forEach(function(key) {
-	    SYMBOL_TYPE[Number(key)] = PUNCTUATOR;
-	    PUNCTUATION[Number(key)] = PUNCTUATOR;
-	});
-
-	for (var i = 48; i <= 57; i++) {
-	    SYMBOL_TYPE[i] = NUMBER;
-	}
-
-	SYMBOL_TYPE[SPACE] = WHITESPACE;
-	SYMBOL_TYPE[TAB] = WHITESPACE;
-	SYMBOL_TYPE[N] = WHITESPACE;
-	SYMBOL_TYPE[R] = WHITESPACE;
-	SYMBOL_TYPE[F] = WHITESPACE;
-
-	SYMBOL_TYPE[TYPE.Apostrophe] = STRING;
-	SYMBOL_TYPE[TYPE.QuotationMark] = STRING;
-
-	STOP_URL_RAW[SPACE] = 1;
-	STOP_URL_RAW[TAB] = 1;
-	STOP_URL_RAW[N] = 1;
-	STOP_URL_RAW[R] = 1;
-	STOP_URL_RAW[F] = 1;
-	STOP_URL_RAW[TYPE.Apostrophe] = 1;
-	STOP_URL_RAW[TYPE.QuotationMark] = 1;
-	STOP_URL_RAW[TYPE.LeftParenthesis] = 1;
-	STOP_URL_RAW[TYPE.RightParenthesis] = 1;
-
-	// whitespace is punctuation ...
-	PUNCTUATION[SPACE] = PUNCTUATOR;
-	PUNCTUATION[TAB] = PUNCTUATOR;
-	PUNCTUATION[N] = PUNCTUATOR;
-	PUNCTUATION[R] = PUNCTUATOR;
-	PUNCTUATION[F] = PUNCTUATOR;
-	// ... hyper minus is not
-	PUNCTUATION[TYPE.HyphenMinus] = 0;
-
-	var _const = {
-	    TYPE: TYPE,
-	    NAME: NAME,
-
-	    SYMBOL_TYPE: SYMBOL_TYPE,
-	    PUNCTUATION: PUNCTUATION,
-	    STOP_URL_RAW: STOP_URL_RAW
-	};
-
-	var PUNCTUATION$1 = _const.PUNCTUATION;
-	var STOP_URL_RAW$1 = _const.STOP_URL_RAW;
-	var TYPE$1 = _const.TYPE;
-	var FULLSTOP = TYPE$1.FullStop;
-	var PLUSSIGN = TYPE$1.PlusSign;
-	var HYPHENMINUS = TYPE$1.HyphenMinus;
-	var PUNCTUATOR$1 = TYPE$1.Punctuator;
-	var TAB$1 = 9;
-	var N$1 = 10;
-	var F$1 = 12;
-	var R$1 = 13;
-	var SPACE$1 = 32;
-	var BACK_SLASH = 92;
-	var E = 101; // 'e'.charCodeAt(0)
-
-	function firstCharOffset(source) {
-	    // detect BOM (https://en.wikipedia.org/wiki/Byte_order_mark)
-	    if (source.charCodeAt(0) === 0xFEFF ||  // UTF-16BE
-	        source.charCodeAt(0) === 0xFFFE) {  // UTF-16LE
-	        return 1;
-	    }
-
-	    return 0;
-	}
-
-	function isHex(code) {
-	    return (code >= 48 && code <= 57) || // 0 .. 9
-	           (code >= 65 && code <= 70) || // A .. F
-	           (code >= 97 && code <= 102);  // a .. f
-	}
-
-	function isNumber(code) {
-	    return code >= 48 && code <= 57;
-	}
-
-	function isWhiteSpace(code) {
-	    return code === SPACE$1 || code === TAB$1 || isNewline(code);
-	}
-
-	function isNewline(code) {
-	    return code === R$1 || code === N$1 || code === F$1;
-	}
-
-	function getNewlineLength(source, offset, code) {
-	    if (isNewline(code)) {
-	        if (code === R$1 && offset + 1 < source.length && source.charCodeAt(offset + 1) === N$1) {
-	            return 2;
-	        }
-
-	        return 1;
-	    }
-
-	    return 0;
-	}
-
-	function cmpChar(testStr, offset, referenceCode) {
-	    var code = testStr.charCodeAt(offset);
-
-	    // code.toLowerCase() for A..Z
-	    if (code >= 65 && code <= 90) {
-	        code = code | 32;
-	    }
-
-	    return code === referenceCode;
-	}
-
-	function cmpStr(testStr, start, end, referenceStr) {
-	    if (end - start !== referenceStr.length) {
-	        return false;
-	    }
-
-	    if (start < 0 || end > testStr.length) {
-	        return false;
-	    }
-
-	    for (var i = start; i < end; i++) {
-	        var testCode = testStr.charCodeAt(i);
-	        var refCode = referenceStr.charCodeAt(i - start);
-
-	        // testCode.toLowerCase() for A..Z
-	        if (testCode >= 65 && testCode <= 90) {
-	            testCode = testCode | 32;
-	        }
-
-	        if (testCode !== refCode) {
-	            return false;
-	        }
-	    }
-
-	    return true;
-	}
-
-	function findWhiteSpaceStart(source, offset) {
-	    while (offset >= 0 && isWhiteSpace(source.charCodeAt(offset))) {
-	        offset--;
-	    }
-
-	    return offset + 1;
-	}
-
-	function findWhiteSpaceEnd(source, offset) {
-	    while (offset < source.length && isWhiteSpace(source.charCodeAt(offset))) {
-	        offset++;
-	    }
-
-	    return offset;
-	}
-
-	function findCommentEnd(source, offset) {
-	    var commentEnd = source.indexOf('*/', offset);
-
-	    if (commentEnd === -1) {
-	        return source.length;
-	    }
-
-	    return commentEnd + 2;
-	}
-
-	function findStringEnd(source, offset, quote) {
-	    for (; offset < source.length; offset++) {
-	        var code = source.charCodeAt(offset);
-
-	        // TODO: bad string
-	        if (code === BACK_SLASH) {
-	            offset++;
-	        } else if (code === quote) {
-	            offset++;
-	            break;
-	        }
-	    }
-
-	    return offset;
-	}
-
-	function findDecimalNumberEnd(source, offset) {
-	    while (offset < source.length && isNumber(source.charCodeAt(offset))) {
-	        offset++;
-	    }
-
-	    return offset;
-	}
-
-	function findNumberEnd(source, offset, allowFraction) {
-	    var code;
-
-	    offset = findDecimalNumberEnd(source, offset);
-
-	    // fraction: .\d+
-	    if (allowFraction && offset + 1 < source.length && source.charCodeAt(offset) === FULLSTOP) {
-	        code = source.charCodeAt(offset + 1);
-
-	        if (isNumber(code)) {
-	            offset = findDecimalNumberEnd(source, offset + 1);
-	        }
-	    }
-
-	    // exponent: e[+-]\d+
-	    if (offset + 1 < source.length) {
-	        if ((source.charCodeAt(offset) | 32) === E) { // case insensitive check for `e`
-	            code = source.charCodeAt(offset + 1);
-
-	            if (code === PLUSSIGN || code === HYPHENMINUS) {
-	                if (offset + 2 < source.length) {
-	                    code = source.charCodeAt(offset + 2);
-	                }
-	            }
-
-	            if (isNumber(code)) {
-	                offset = findDecimalNumberEnd(source, offset + 2);
-	            }
-	        }
-	    }
-
-	    return offset;
-	}
-
-	// skip escaped unicode sequence that can ends with space
-	// [0-9a-f]{1,6}(\r\n|[ \n\r\t\f])?
-	function findEscapeEnd(source, offset) {
-	    for (var i = 0; i < 7 && offset + i < source.length; i++) {
-	        var code = source.charCodeAt(offset + i);
-
-	        if (i !== 6 && isHex(code)) {
-	            continue;
-	        }
-
-	        if (i > 0) {
-	            offset += i - 1 + getNewlineLength(source, offset + i, code);
-	            if (code === SPACE$1 || code === TAB$1) {
-	                offset++;
-	            }
-	        }
-
-	        break;
-	    }
-
-	    return offset;
-	}
-
-	function findIdentifierEnd(source, offset) {
-	    for (; offset < source.length; offset++) {
-	        var code = source.charCodeAt(offset);
-
-	        if (code === BACK_SLASH) {
-	            offset = findEscapeEnd(source, offset + 1);
-	        } else if (code < 0x80 && PUNCTUATION$1[code] === PUNCTUATOR$1) {
-	            break;
-	        }
-	    }
-
-	    return offset;
-	}
-
-	function findUrlRawEnd(source, offset) {
-	    for (; offset < source.length; offset++) {
-	        var code = source.charCodeAt(offset);
-
-	        if (code === BACK_SLASH) {
-	            offset = findEscapeEnd(source, offset + 1);
-	        } else if (code < 0x80 && STOP_URL_RAW$1[code] === 1) {
-	            break;
-	        }
-	    }
-
-	    return offset;
-	}
-
-	var utils = {
-	    firstCharOffset: firstCharOffset,
-
-	    isHex: isHex,
-	    isNumber: isNumber,
-	    isWhiteSpace: isWhiteSpace,
-	    isNewline: isNewline,
-	    getNewlineLength: getNewlineLength,
-
-	    cmpChar: cmpChar,
-	    cmpStr: cmpStr,
-
-	    findWhiteSpaceStart: findWhiteSpaceStart,
-	    findWhiteSpaceEnd: findWhiteSpaceEnd,
-	    findCommentEnd: findCommentEnd,
-	    findStringEnd: findStringEnd,
-	    findDecimalNumberEnd: findDecimalNumberEnd,
-	    findNumberEnd: findNumberEnd,
-	    findEscapeEnd: findEscapeEnd,
-	    findIdentifierEnd: findIdentifierEnd,
-	    findUrlRawEnd: findUrlRawEnd
-	};
-
-	var TYPE$2 = _const.TYPE;
-	var NAME$1 = _const.NAME;
-	var SYMBOL_TYPE$1 = _const.SYMBOL_TYPE;
-
-
-	var firstCharOffset$1 = utils.firstCharOffset;
-	var cmpStr$1 = utils.cmpStr;
-	var isNumber$1 = utils.isNumber;
-	var findWhiteSpaceStart$1 = utils.findWhiteSpaceStart;
-	var findWhiteSpaceEnd$1 = utils.findWhiteSpaceEnd;
-	var findCommentEnd$1 = utils.findCommentEnd;
-	var findStringEnd$1 = utils.findStringEnd;
-	var findNumberEnd$1 = utils.findNumberEnd;
-	var findIdentifierEnd$1 = utils.findIdentifierEnd;
-	var findUrlRawEnd$1 = utils.findUrlRawEnd;
-
-	var NULL = 0;
-	var WHITESPACE$1 = TYPE$2.WhiteSpace;
-	var IDENTIFIER$1 = TYPE$2.Identifier;
-	var NUMBER$1 = TYPE$2.Number;
-	var STRING$1 = TYPE$2.String;
-	var COMMENT$1 = TYPE$2.Comment;
-	var PUNCTUATOR$2 = TYPE$2.Punctuator;
-	var CDO$1 = TYPE$2.CDO;
-	var CDC$1 = TYPE$2.CDC;
-	var ATKEYWORD$1 = TYPE$2.AtKeyword;
-	var FUNCTION$1 = TYPE$2.Function;
-	var URL$2 = TYPE$2.Url;
-	var RAW$1 = TYPE$2.Raw;
-
-	var N$2 = 10;
-	var F$2 = 12;
-	var R$2 = 13;
-	var STAR = TYPE$2.Asterisk;
-	var SLASH = TYPE$2.Solidus;
-	var FULLSTOP$1 = TYPE$2.FullStop;
-	var PLUSSIGN$1 = TYPE$2.PlusSign;
-	var HYPHENMINUS$1 = TYPE$2.HyphenMinus;
-	var GREATERTHANSIGN = TYPE$2.GreaterThanSign;
-	var LESSTHANSIGN = TYPE$2.LessThanSign;
-	var EXCLAMATIONMARK = TYPE$2.ExclamationMark;
-	var COMMERCIALAT = TYPE$2.CommercialAt;
-	var QUOTATIONMARK = TYPE$2.QuotationMark;
-	var APOSTROPHE = TYPE$2.Apostrophe;
-	var LEFTPARENTHESIS = TYPE$2.LeftParenthesis;
-	var RIGHTPARENTHESIS = TYPE$2.RightParenthesis;
-	var LEFTCURLYBRACKET = TYPE$2.LeftCurlyBracket;
-	var RIGHTCURLYBRACKET = TYPE$2.RightCurlyBracket;
-	var LEFTSQUAREBRACKET = TYPE$2.LeftSquareBracket;
-	var RIGHTSQUAREBRACKET = TYPE$2.RightSquareBracket;
-
-	var MIN_BUFFER_SIZE = 16 * 1024;
-	var OFFSET_MASK = 0x00FFFFFF;
-	var TYPE_SHIFT = 24;
-	var SafeUint32Array$1 = typeof Uint32Array !== 'undefined' ? Uint32Array : Array; // fallback on Array when TypedArray is not supported
-
-	function computeLinesAndColumns(tokenizer, source) {
-	    var sourceLength = source.length;
-	    var start = firstCharOffset$1(source);
-	    var lines = tokenizer.lines;
-	    var line = tokenizer.startLine;
-	    var columns = tokenizer.columns;
-	    var column = tokenizer.startColumn;
-
-	    if (lines === null || lines.length < sourceLength + 1) {
-	        lines = new SafeUint32Array$1(Math.max(sourceLength + 1024, MIN_BUFFER_SIZE));
-	        columns = new SafeUint32Array$1(lines.length);
-	    }
-
-	    for (var i = start; i < sourceLength; i++) {
-	        var code = source.charCodeAt(i);
-
-	        lines[i] = line;
-	        columns[i] = column++;
-
-	        if (code === N$2 || code === R$2 || code === F$2) {
-	            if (code === R$2 && i + 1 < sourceLength && source.charCodeAt(i + 1) === N$2) {
-	                i++;
-	                lines[i] = line;
-	                columns[i] = column;
-	            }
-
-	            line++;
-	            column = 1;
-	        }
-	    }
-
-	    lines[i] = line;
-	    columns[i] = column;
-
-	    tokenizer.linesAnsColumnsComputed = true;
-	    tokenizer.lines = lines;
-	    tokenizer.columns = columns;
-	}
-
-	function tokenLayout(tokenizer, source, startPos) {
-	    var sourceLength = source.length;
-	    var offsetAndType = tokenizer.offsetAndType;
-	    var balance = tokenizer.balance;
-	    var tokenCount = 0;
-	    var prevType = 0;
-	    var offset = startPos;
-	    var anchor = 0;
-	    var balanceCloseCode = 0;
-	    var balanceStart = 0;
-	    var balancePrev = 0;
-
-	    if (offsetAndType === null || offsetAndType.length < sourceLength + 1) {
-	        offsetAndType = new SafeUint32Array$1(sourceLength + 1024);
-	        balance = new SafeUint32Array$1(sourceLength + 1024);
-	    }
-
-	    while (offset < sourceLength) {
-	        var code = source.charCodeAt(offset);
-	        var type = code < 0x80 ? SYMBOL_TYPE$1[code] : IDENTIFIER$1;
-
-	        balance[tokenCount] = sourceLength;
-
-	        switch (type) {
-	            case WHITESPACE$1:
-	                offset = findWhiteSpaceEnd$1(source, offset + 1);
-	                break;
-
-	            case PUNCTUATOR$2:
-	                switch (code) {
-	                    case balanceCloseCode:
-	                        balancePrev = balanceStart & OFFSET_MASK;
-	                        balanceStart = balance[balancePrev];
-	                        balanceCloseCode = balanceStart >> TYPE_SHIFT;
-	                        balance[tokenCount] = balancePrev;
-	                        balance[balancePrev++] = tokenCount;
-	                        for (; balancePrev < tokenCount; balancePrev++) {
-	                            if (balance[balancePrev] === sourceLength) {
-	                                balance[balancePrev] = tokenCount;
-	                            }
-	                        }
-	                        break;
-
-	                    case LEFTSQUAREBRACKET:
-	                        balance[tokenCount] = balanceStart;
-	                        balanceCloseCode = RIGHTSQUAREBRACKET;
-	                        balanceStart = (balanceCloseCode << TYPE_SHIFT) | tokenCount;
-	                        break;
-
-	                    case LEFTCURLYBRACKET:
-	                        balance[tokenCount] = balanceStart;
-	                        balanceCloseCode = RIGHTCURLYBRACKET;
-	                        balanceStart = (balanceCloseCode << TYPE_SHIFT) | tokenCount;
-	                        break;
-
-	                    case LEFTPARENTHESIS:
-	                        balance[tokenCount] = balanceStart;
-	                        balanceCloseCode = RIGHTPARENTHESIS;
-	                        balanceStart = (balanceCloseCode << TYPE_SHIFT) | tokenCount;
-	                        break;
-	                }
-
-	                // /*
-	                if (code === STAR && prevType === SLASH) {
-	                    type = COMMENT$1;
-	                    offset = findCommentEnd$1(source, offset + 1);
-	                    tokenCount--; // rewrite prev token
-	                    break;
-	                }
-
-	                // edge case for -.123 and +.123
-	                if (code === FULLSTOP$1 && (prevType === PLUSSIGN$1 || prevType === HYPHENMINUS$1)) {
-	                    if (offset + 1 < sourceLength && isNumber$1(source.charCodeAt(offset + 1))) {
-	                        type = NUMBER$1;
-	                        offset = findNumberEnd$1(source, offset + 2, false);
-	                        tokenCount--; // rewrite prev token
-	                        break;
-	                    }
-	                }
-
-	                // <!--
-	                if (code === EXCLAMATIONMARK && prevType === LESSTHANSIGN) {
-	                    if (offset + 2 < sourceLength &&
-	                        source.charCodeAt(offset + 1) === HYPHENMINUS$1 &&
-	                        source.charCodeAt(offset + 2) === HYPHENMINUS$1) {
-	                        type = CDO$1;
-	                        offset = offset + 3;
-	                        tokenCount--; // rewrite prev token
-	                        break;
-	                    }
-	                }
-
-	                // -->
-	                if (code === HYPHENMINUS$1 && prevType === HYPHENMINUS$1) {
-	                    if (offset + 1 < sourceLength && source.charCodeAt(offset + 1) === GREATERTHANSIGN) {
-	                        type = CDC$1;
-	                        offset = offset + 2;
-	                        tokenCount--; // rewrite prev token
-	                        break;
-	                    }
-	                }
-
-	                // ident(
-	                if (code === LEFTPARENTHESIS && prevType === IDENTIFIER$1) {
-	                    offset = offset + 1;
-	                    tokenCount--; // rewrite prev token
-	                    balance[tokenCount] = balance[tokenCount + 1];
-	                    balanceStart--;
-
-	                    // 4 char length identifier and equal to `url(` (case insensitive)
-	                    if (offset - anchor === 4 && cmpStr$1(source, anchor, offset, 'url(')) {
-	                        // special case for url() because it can contain any symbols sequence with few exceptions
-	                        anchor = findWhiteSpaceEnd$1(source, offset);
-	                        code = source.charCodeAt(anchor);
-	                        if (code !== LEFTPARENTHESIS &&
-	                            code !== RIGHTPARENTHESIS &&
-	                            code !== QUOTATIONMARK &&
-	                            code !== APOSTROPHE) {
-	                            // url(
-	                            offsetAndType[tokenCount++] = (URL$2 << TYPE_SHIFT) | offset;
-	                            balance[tokenCount] = sourceLength;
-
-	                            // ws*
-	                            if (anchor !== offset) {
-	                                offsetAndType[tokenCount++] = (WHITESPACE$1 << TYPE_SHIFT) | anchor;
-	                                balance[tokenCount] = sourceLength;
-	                            }
-
-	                            // raw
-	                            type = RAW$1;
-	                            offset = findUrlRawEnd$1(source, anchor);
-	                        } else {
-	                            type = URL$2;
-	                        }
-	                    } else {
-	                        type = FUNCTION$1;
-	                    }
-	                    break;
-	                }
-
-	                type = code;
-	                offset = offset + 1;
-	                break;
-
-	            case NUMBER$1:
-	                offset = findNumberEnd$1(source, offset + 1, prevType !== FULLSTOP$1);
-
-	                // merge number with a preceding dot, dash or plus
-	                if (prevType === FULLSTOP$1 ||
-	                    prevType === HYPHENMINUS$1 ||
-	                    prevType === PLUSSIGN$1) {
-	                    tokenCount--; // rewrite prev token
-	                }
-
-	                break;
-
-	            case STRING$1:
-	                offset = findStringEnd$1(source, offset + 1, code);
-	                break;
-
-	            default:
-	                anchor = offset;
-	                offset = findIdentifierEnd$1(source, offset);
-
-	                // merge identifier with a preceding dash
-	                if (prevType === HYPHENMINUS$1) {
-	                    // rewrite prev token
-	                    tokenCount--;
-	                    // restore prev prev token type
-	                    // for case @-prefix-ident
-	                    prevType = tokenCount === 0 ? 0 : offsetAndType[tokenCount - 1] >> TYPE_SHIFT;
-	                }
-
-	                if (prevType === COMMERCIALAT) {
-	                    // rewrite prev token and change type to <at-keyword-token>
-	                    tokenCount--;
-	                    type = ATKEYWORD$1;
-	                }
-	        }
-
-	        offsetAndType[tokenCount++] = (type << TYPE_SHIFT) | offset;
-	        prevType = type;
-	    }
-
-	    // finalize arrays
-	    offsetAndType[tokenCount] = offset;
-	    balance[tokenCount] = sourceLength;
-	    balance[sourceLength] = sourceLength; // prevents false positive balance match with any token
-	    while (balanceStart !== 0) {
-	        balancePrev = balanceStart & OFFSET_MASK;
-	        balanceStart = balance[balancePrev];
-	        balance[balancePrev] = sourceLength;
-	    }
-
-	    tokenizer.offsetAndType = offsetAndType;
-	    tokenizer.tokenCount = tokenCount;
-	    tokenizer.balance = balance;
-	}
-
-	//
-	// tokenizer
-	//
-
-	var Tokenizer = function(source, startOffset, startLine, startColumn) {
-	    this.offsetAndType = null;
-	    this.balance = null;
-	    this.lines = null;
-	    this.columns = null;
-
-	    this.setSource(source, startOffset, startLine, startColumn);
-	};
-
-	Tokenizer.prototype = {
-	    setSource: function(source, startOffset, startLine, startColumn) {
-	        var safeSource = String(source || '');
-	        var start = firstCharOffset$1(safeSource);
-
-	        this.source = safeSource;
-	        this.firstCharOffset = start;
-	        this.startOffset = typeof startOffset === 'undefined' ? 0 : startOffset;
-	        this.startLine = typeof startLine === 'undefined' ? 1 : startLine;
-	        this.startColumn = typeof startColumn === 'undefined' ? 1 : startColumn;
-	        this.linesAnsColumnsComputed = false;
-
-	        this.eof = false;
-	        this.currentToken = -1;
-	        this.tokenType = 0;
-	        this.tokenStart = start;
-	        this.tokenEnd = start;
-
-	        tokenLayout(this, safeSource, start);
-	        this.next();
-	    },
-
-	    lookupType: function(offset) {
-	        offset += this.currentToken;
-
-	        if (offset < this.tokenCount) {
-	            return this.offsetAndType[offset] >> TYPE_SHIFT;
-	        }
-
-	        return NULL;
-	    },
-	    lookupNonWSType: function(offset) {
-	        offset += this.currentToken;
-
-	        for (var type; offset < this.tokenCount; offset++) {
-	            type = this.offsetAndType[offset] >> TYPE_SHIFT;
-
-	            if (type !== WHITESPACE$1) {
-	                return type;
-	            }
-	        }
-
-	        return NULL;
-	    },
-	    lookupValue: function(offset, referenceStr) {
-	        offset += this.currentToken;
-
-	        if (offset < this.tokenCount) {
-	            return cmpStr$1(
-	                this.source,
-	                this.offsetAndType[offset - 1] & OFFSET_MASK,
-	                this.offsetAndType[offset] & OFFSET_MASK,
-	                referenceStr
-	            );
-	        }
-
-	        return false;
-	    },
-	    getTokenStart: function(tokenNum) {
-	        if (tokenNum === this.currentToken) {
-	            return this.tokenStart;
-	        }
-
-	        if (tokenNum > 0) {
-	            return tokenNum < this.tokenCount
-	                ? this.offsetAndType[tokenNum - 1] & OFFSET_MASK
-	                : this.offsetAndType[this.tokenCount] & OFFSET_MASK;
-	        }
-
-	        return this.firstCharOffset;
-	    },
-	    getOffsetExcludeWS: function() {
-	        if (this.currentToken > 0) {
-	            if ((this.offsetAndType[this.currentToken - 1] >> TYPE_SHIFT) === WHITESPACE$1) {
-	                return this.currentToken > 1
-	                    ? this.offsetAndType[this.currentToken - 2] & OFFSET_MASK
-	                    : this.firstCharOffset;
-	            }
-	        }
-	        return this.tokenStart;
-	    },
-	    getRawLength: function(startToken, endTokenType1, endTokenType2, includeTokenType2) {
-	        var cursor = startToken;
-	        var balanceEnd;
-
-	        loop:
-	        for (; cursor < this.tokenCount; cursor++) {
-	            balanceEnd = this.balance[cursor];
-
-	            // belance end points to offset before start
-	            if (balanceEnd < startToken) {
-	                break loop;
-	            }
-
-	            // check token is stop type
-	            switch (this.offsetAndType[cursor] >> TYPE_SHIFT) {
-	                case endTokenType1:
-	                    break loop;
-
-	                case endTokenType2:
-	                    if (includeTokenType2) {
-	                        cursor++;
-	                    }
-	                    break loop;
-
-	                default:
-	                    // fast forward to the end of balanced block
-	                    if (this.balance[balanceEnd] === cursor) {
-	                        cursor = balanceEnd;
-	                    }
-	            }
-
-	        }
-
-	        return cursor - this.currentToken;
-	    },
-	    isBalanceEdge: function(pos) {
-	        var balanceStart = this.balance[this.currentToken];
-	        return balanceStart < pos;
-	    },
-
-	    getTokenValue: function() {
-	        return this.source.substring(this.tokenStart, this.tokenEnd);
-	    },
-	    substrToCursor: function(start) {
-	        return this.source.substring(start, this.tokenStart);
-	    },
-
-	    skipWS: function() {
-	        for (var i = this.currentToken, skipTokenCount = 0; i < this.tokenCount; i++, skipTokenCount++) {
-	            if ((this.offsetAndType[i] >> TYPE_SHIFT) !== WHITESPACE$1) {
-	                break;
-	            }
-	        }
-
-	        if (skipTokenCount > 0) {
-	            this.skip(skipTokenCount);
-	        }
-	    },
-	    skipSC: function() {
-	        while (this.tokenType === WHITESPACE$1 || this.tokenType === COMMENT$1) {
-	            this.next();
-	        }
-	    },
-	    skip: function(tokenCount) {
-	        var next = this.currentToken + tokenCount;
-
-	        if (next < this.tokenCount) {
-	            this.currentToken = next;
-	            this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;
-	            next = this.offsetAndType[next];
-	            this.tokenType = next >> TYPE_SHIFT;
-	            this.tokenEnd = next & OFFSET_MASK;
-	        } else {
-	            this.currentToken = this.tokenCount;
-	            this.next();
-	        }
-	    },
-	    next: function() {
-	        var next = this.currentToken + 1;
-
-	        if (next < this.tokenCount) {
-	            this.currentToken = next;
-	            this.tokenStart = this.tokenEnd;
-	            next = this.offsetAndType[next];
-	            this.tokenType = next >> TYPE_SHIFT;
-	            this.tokenEnd = next & OFFSET_MASK;
-	        } else {
-	            this.currentToken = this.tokenCount;
-	            this.eof = true;
-	            this.tokenType = NULL;
-	            this.tokenStart = this.tokenEnd = this.source.length;
-	        }
-	    },
-
-	    eat: function(tokenType) {
-	        if (this.tokenType !== tokenType) {
-	            var offset = this.tokenStart;
-	            var message = NAME$1[tokenType] + ' is expected';
-
-	            // tweak message and offset
-	            if (tokenType === IDENTIFIER$1) {
-	                // when identifier is expected but there is a function or url
-	                if (this.tokenType === FUNCTION$1 || this.tokenType === URL$2) {
-	                    offset = this.tokenEnd - 1;
-	                    message += ' but function found';
-	                }
-	            } else {
-	                // when test type is part of another token show error for current position + 1
-	                // e.g. eat(HYPHENMINUS) will fail on "-foo", but pointing on "-" is odd
-	                if (this.source.charCodeAt(this.tokenStart) === tokenType) {
-	                    offset = offset + 1;
-	                }
-	            }
-
-	            this.error(message, offset);
-	        }
-
-	        this.next();
-	    },
-	    eatNonWS: function(tokenType) {
-	        this.skipWS();
-	        this.eat(tokenType);
-	    },
-
-	    consume: function(tokenType) {
-	        var value = this.getTokenValue();
-
-	        this.eat(tokenType);
-
-	        return value;
-	    },
-	    consumeFunctionName: function() {
-	        var name = this.source.substring(this.tokenStart, this.tokenEnd - 1);
-
-	        this.eat(FUNCTION$1);
-
-	        return name;
-	    },
-	    consumeNonWS: function(tokenType) {
-	        this.skipWS();
-
-	        return this.consume(tokenType);
-	    },
-
-	    expectIdentifier: function(name) {
-	        if (this.tokenType !== IDENTIFIER$1 || cmpStr$1(this.source, this.tokenStart, this.tokenEnd, name) === false) {
-	            this.error('Identifier `' + name + '` is expected');
-	        }
-
-	        this.next();
-	    },
-
-	    getLocation: function(offset, filename) {
-	        if (!this.linesAnsColumnsComputed) {
-	            computeLinesAndColumns(this, this.source);
-	        }
-
-	        return {
-	            source: filename,
-	            offset: this.startOffset + offset,
-	            line: this.lines[offset],
-	            column: this.columns[offset]
-	        };
-	    },
-
-	    getLocationRange: function(start, end, filename) {
-	        if (!this.linesAnsColumnsComputed) {
-	            computeLinesAndColumns(this, this.source);
-	        }
-
-	        return {
-	            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]
-	            }
-	        };
-	    },
-
-	    error: function(message, offset) {
-	        var location = typeof offset !== 'undefined' && offset < this.source.length
-	            ? this.getLocation(offset)
-	            : this.eof
-	                ? this.getLocation(findWhiteSpaceStart$1(this.source, this.source.length - 1))
-	                : this.getLocation(this.tokenStart);
-
-	        throw new error(
-	            message || 'Unexpected input',
-	            this.source,
-	            location.offset,
-	            location.line,
-	            location.column
-	        );
-	    },
-
-	    dump: function() {
-	        var offset = 0;
-
-	        return Array.prototype.slice.call(this.offsetAndType, 0, this.tokenCount).map(function(item, idx) {
-	            var start = offset;
-	            var end = item & OFFSET_MASK;
-
-	            offset = end;
-
-	            return {
-	                idx: idx,
-	                type: NAME$1[item >> TYPE_SHIFT],
-	                chunk: this.source.substring(start, end),
-	                balance: this.balance[idx]
-	            };
-	        }, this);
-	    }
-	};
-
-	// extend with error class
-	Tokenizer.CssSyntaxError = error;
-
-	// extend tokenizer with constants
-	Object.keys(_const).forEach(function(key) {
-	    Tokenizer[key] = _const[key];
-	});
-
-	// extend tokenizer with static methods from utils
-	Object.keys(utils).forEach(function(key) {
-	    Tokenizer[key] = utils[key];
-	});
-
-	// warm up tokenizer to elimitate code branches that never execute
-	// fix soft deoptimizations (insufficient type feedback)
-	new Tokenizer('\n\r\r\n\f<!---->//""\'\'/*\r\n\f*/1a;.\\31\t\+2{url(a);func();+1.2e3 -.4e-5 .6e+7}').getLocation();
-
-	var Tokenizer_1 = Tokenizer;
-
-	var tokenizer = Tokenizer_1;
-
-	function noop$1(value) {
-	    return value;
-	}
-
-	function generateMultiplier(multiplier) {
-	    if (multiplier.min === 0 && multiplier.max === 0) {
-	        return '*';
-	    }
-
-	    if (multiplier.min === 0 && multiplier.max === 1) {
-	        return '?';
-	    }
-
-	    if (multiplier.min === 1 && multiplier.max === 0) {
-	        return multiplier.comma ? '#' : '+';
-	    }
-
-	    if (multiplier.min === 1 && multiplier.max === 1) {
-	        return '';
-	    }
-
-	    return (
-	        (multiplier.comma ? '#' : '') +
-	        (multiplier.min === multiplier.max
-	            ? '{' + multiplier.min + '}'
-	            : '{' + multiplier.min + ',' + (multiplier.max !== 0 ? multiplier.max : '') + '}'
-	        )
-	    );
-	}
-
-	function generateSequence(node, forceBraces, decorate) {
-	    var result = node.terms.map(function(term) {
-	        return generate(term, forceBraces, decorate);
-	    }).join(node.combinator === ' ' ? ' ' : ' ' + node.combinator + ' ');
-
-	    if (node.explicit || forceBraces) {
-	        result = (result[0] !== ',' ? '[ ' : '[') + result + ' ]';
-	    }
-
-	    return result;
-	}
-
-	function generate(node, forceBraces, decorate) {
-	    var result;
-
-	    switch (node.type) {
-	        case 'Group':
-	            result =
-	                generateSequence(node, forceBraces, decorate) +
-	                (node.disallowEmpty ? '!' : '');
-	            break;
-
-	        case 'Multiplier':
-	            // return since node is a composition
-	            return (
-	                generate(node.term, forceBraces, decorate) +
-	                decorate(generateMultiplier(node), node)
-	            );
-
-	        case 'Type':
-	            result = '<' + node.name + '>';
-	            break;
-
-	        case 'Property':
-	            result = '<\'' + node.name + '\'>';
-	            break;
-
-	        case 'Keyword':
-	            result = node.name;
-	            break;
-
-	        case 'AtKeyword':
-	            result = '@' + node.name;
-	            break;
-
-	        case 'Function':
-	            result = node.name + '(';
-	            break;
-
-	        case 'String':
-	        case 'Token':
-	            result = node.value;
-	            break;
-
-	        case 'Comma':
-	            result = ',';
-	            break;
-
-	        default:
-	            throw new Error('Unknown node type `' + node.type + '`');
-	    }
-
-	    return decorate(result, node);
-	}
-
-	var generate_1 = function(node, options) {
-	    var decorate = noop$1;
-	    var forceBraces = false;
-
-	    if (typeof options === 'function') {
-	        decorate = options;
-	    } else if (options) {
-	        forceBraces = Boolean(options.forceBraces);
-	        if (typeof options.decorate === 'function') {
-	            decorate = options.decorate;
-	        }
-	    }
-
-	    return generate(node, forceBraces, decorate);
-	};
-
-	function fromMatchResult(matchResult) {
-	    var tokens = matchResult.tokens;
-	    var longestMatch = matchResult.longestMatch;
-	    var node = longestMatch < tokens.length ? tokens[longestMatch].node : null;
-	    var mismatchOffset = 0;
-	    var entries = 0;
-	    var css = '';
-
-	    for (var i = 0; i < tokens.length; i++) {
-	        if (i === longestMatch) {
-	            mismatchOffset = css.length;
-	        }
-
-	        if (node !== null && tokens[i].node === node) {
-	            if (i <= longestMatch) {
-	                entries++;
-	            } else {
-	                entries = 0;
-	            }
-	        }
-
-	        css += tokens[i].value;
-	    }
-
-	    if (node === null) {
-	        mismatchOffset = css.length;
-	    }
-
-	    return {
-	        node: node,
-	        css: css,
-	        mismatchOffset: mismatchOffset,
-	        last: node === null || entries > 1
-	    };
-	}
-
-	function getLocation(node, point) {
-	    var loc = node && node.loc && node.loc[point];
-
-	    if (loc) {
-	        return {
-	            offset: loc.offset,
-	            line: loc.line,
-	            column: loc.column
-	        };
-	    }
-
-	    return null;
-	}
-
-	var SyntaxReferenceError = function(type, referenceName) {
-	    var error = createCustomError(
-	        'SyntaxReferenceError',
-	        type + (referenceName ? ' `' + referenceName + '`' : '')
-	    );
-
-	    error.reference = referenceName;
-
-	    return error;
-	};
-
-	var MatchError = function(message, lexer, syntax, node, matchResult) {
-	    var error = createCustomError('SyntaxMatchError', message);
-	    var details = fromMatchResult(matchResult);
-	    var mismatchOffset = details.mismatchOffset || 0;
-	    var badNode = details.node || node;
-	    var end = getLocation(badNode, 'end');
-	    var start = details.last ? end : getLocation(badNode, 'start');
-	    var css = details.css;
-
-	    error.rawMessage = message;
-	    error.syntax = syntax ? generate_1(syntax) : '<generic>';
-	    error.css = css;
-	    error.mismatchOffset = mismatchOffset;
-	    error.loc = {
-	        source: (badNode && badNode.loc && badNode.loc.source) || '<unknown>',
-	        start: start,
-	        end: end
-	    };
-	    error.line = start ? start.line : undefined;
-	    error.column = start ? start.column : undefined;
-	    error.offset = start ? start.offset : undefined;
-	    error.message = message + '\n' +
-	        '  syntax: ' + error.syntax + '\n' +
-	        '   value: ' + (error.css || '<empty string>') + '\n' +
-	        '  --------' + new Array(error.mismatchOffset + 1).join('-') + '^';
-
-	    return error;
-	};
-
-	var error$1 = {
-	    SyntaxReferenceError: SyntaxReferenceError,
-	    MatchError: MatchError
-	};
-
-	var hasOwnProperty = Object.prototype.hasOwnProperty;
-	var keywords = Object.create(null);
-	var properties = Object.create(null);
-	var HYPHENMINUS$2 = 45; // '-'.charCodeAt()
-
-	function isCustomProperty(str, offset) {
-	    offset = offset || 0;
-
-	    return str.length - offset >= 2 &&
-	           str.charCodeAt(offset) === HYPHENMINUS$2 &&
-	           str.charCodeAt(offset + 1) === HYPHENMINUS$2;
-	}
-
-	function getVendorPrefix(str, offset) {
-	    offset = offset || 0;
-
-	    // verdor prefix should be at least 3 chars length
-	    if (str.length - offset >= 3) {
-	        // vendor prefix starts with hyper minus following non-hyper minus
-	        if (str.charCodeAt(offset) === HYPHENMINUS$2 &&
-	            str.charCodeAt(offset + 1) !== HYPHENMINUS$2) {
-	            // vendor prefix should contain a hyper minus at the ending
-	            var secondDashIndex = str.indexOf('-', offset + 2);
-
-	            if (secondDashIndex !== -1) {
-	                return str.substring(offset, secondDashIndex + 1);
-	            }
-	        }
-	    }
-
-	    return '';
-	}
-
-	function getKeywordDescriptor(keyword) {
-	    if (hasOwnProperty.call(keywords, keyword)) {
-	        return keywords[keyword];
-	    }
-
-	    var name = keyword.toLowerCase();
-
-	    if (hasOwnProperty.call(keywords, name)) {
-	        return keywords[keyword] = keywords[name];
-	    }
-
-	    var custom = isCustomProperty(name, 0);
-	    var vendor = !custom ? getVendorPrefix(name, 0) : '';
-
-	    return keywords[keyword] = Object.freeze({
-	        basename: name.substr(vendor.length),
-	        name: name,
-	        vendor: vendor,
-	        prefix: vendor,
-	        custom: custom
-	    });
-	}
-
-	function getPropertyDescriptor(property) {
-	    if (hasOwnProperty.call(properties, property)) {
-	        return properties[property];
-	    }
-
-	    var name = property;
-	    var hack = property[0];
-
-	    if (hack === '/') {
-	        hack = property[1] === '/' ? '//' : '/';
-	    } else if (hack !== '_' &&
-	               hack !== '*' &&
-	               hack !== '$' &&
-	               hack !== '#' &&
-	               hack !== '+') {
-	        hack = '';
-	    }
-
-	    var custom = isCustomProperty(name, hack.length);
-
-	    // re-use result when possible (the same as for lower case)
-	    if (!custom) {
-	        name = name.toLowerCase();
-	        if (hasOwnProperty.call(properties, name)) {
-	            return properties[property] = properties[name];
-	        }
-	    }
-
-	    var vendor = !custom ? getVendorPrefix(name, hack.length) : '';
-	    var prefix = name.substr(0, hack.length + vendor.length);
-
-	    return properties[property] = Object.freeze({
-	        basename: name.substr(prefix.length),
-	        name: name.substr(hack.length),
-	        hack: hack,
-	        vendor: vendor,
-	        prefix: prefix,
-	        custom: custom
-	    });
-	}
-
-	var names = {
-	    keyword: getKeywordDescriptor,
-	    property: getPropertyDescriptor,
-	    isCustomProperty: isCustomProperty,
-	    vendorPrefix: getVendorPrefix
-	};
-
-	var findIdentifierEnd$2 = utils.findIdentifierEnd;
-	var findNumberEnd$2 = utils.findNumberEnd;
-	var findDecimalNumberEnd$1 = utils.findDecimalNumberEnd;
-	var isHex$1 = utils.isHex;
-
-	var SYMBOL_TYPE$2 = _const.SYMBOL_TYPE;
-	var IDENTIFIER$2 = _const.TYPE.Identifier;
-	var PLUSSIGN$2 = _const.TYPE.PlusSign;
-	var HYPHENMINUS$3 = _const.TYPE.HyphenMinus;
-	var NUMBERSIGN = _const.TYPE.NumberSign;
-
-	var PERCENTAGE = {
-	    '%': true
-	};
-
-	// https://www.w3.org/TR/css-values-3/#lengths
-	var LENGTH = {
-	    // absolute length units
-	    'px': true,
-	    'mm': true,
-	    'cm': true,
-	    'in': true,
-	    'pt': true,
-	    'pc': true,
-	    'q': true,
-
-	    // relative length units
-	    'em': true,
-	    'ex': true,
-	    'ch': true,
-	    'rem': true,
-
-	    // viewport-percentage lengths
-	    'vh': true,
-	    'vw': true,
-	    'vmin': true,
-	    'vmax': true,
-	    'vm': true
-	};
-
-	var ANGLE = {
-	    'deg': true,
-	    'grad': true,
-	    'rad': true,
-	    'turn': true
-	};
-
-	var TIME = {
-	    's': true,
-	    'ms': true
-	};
-
-	var FREQUENCY = {
-	    'hz': true,
-	    'khz': true
-	};
-
-	// https://www.w3.org/TR/css-values-3/#resolution (https://drafts.csswg.org/css-values/#resolution)
-	var RESOLUTION = {
-	    'dpi': true,
-	    'dpcm': true,
-	    'dppx': true,
-	    'x': true      // https://github.com/w3c/csswg-drafts/issues/461
-	};
-
-	// https://drafts.csswg.org/css-grid/#fr-unit
-	var FLEX = {
-	    'fr': true
-	};
-
-	// https://www.w3.org/TR/css3-speech/#mixing-props-voice-volume
-	var DECIBEL = {
-	    'db': true
-	};
-
-	// https://www.w3.org/TR/css3-speech/#voice-props-voice-pitch
-	var SEMITONES = {
-	    'st': true
-	};
-
-	function consumeFunction(token, addTokenToMatch, getNextToken) {
-	    var length = 1;
-	    var cursor;
-
-	    do {
-	        cursor = getNextToken(length++);
-	    } while (cursor !== null && cursor.node !== token.node);
-
-	    if (cursor === null) {
-	        return false;
-	    }
-
-	    while (true) {
-	        // consume tokens until cursor
-	        if (addTokenToMatch() === cursor) {
-	            break;
-	        }
-	    }
-
-	    return true;
-	}
-
-	// TODO: implement
-	// can be used wherever <length>, <frequency>, <angle>, <time>, <percentage>, <number>, or <integer> values are allowed
-	// https://drafts.csswg.org/css-values/#calc-notation
-	function calc(token, addTokenToMatch, getNextToken) {
-	    if (token === null) {
-	        return false;
-	    }
-
-	    var name = token.value.toLowerCase();
-	    if (name !== 'calc(' &&
-	        name !== '-moz-calc(' &&
-	        name !== '-webkit-calc(') {
-	        return false;
-	    }
-
-	    return consumeFunction(token, addTokenToMatch, getNextToken);
-	}
-
-	function attr$1(token, addTokenToMatch, getNextToken) {
-	    if (token === null || token.value.toLowerCase() !== 'attr(') {
-	        return false;
-	    }
-
-	    return consumeFunction(token, addTokenToMatch, getNextToken);
-	}
-
-	function expression(token, addTokenToMatch, getNextToken) {
-	    if (token === null || token.value.toLowerCase() !== 'expression(') {
-	        return false;
-	    }
-
-	    return consumeFunction(token, addTokenToMatch, getNextToken);
-	}
-
-	function url(token, addTokenToMatch, getNextToken) {
-	    if (token === null || token.value.toLowerCase() !== 'url(') {
-	        return false;
-	    }
-
-	    return consumeFunction(token, addTokenToMatch, getNextToken);
-	}
-
-	function idSelector(token, addTokenToMatch) {
-	    if (token === null) {
-	        return false;
-	    }
-
-	    if (token.value.charCodeAt(0) !== NUMBERSIGN) {
-	        return false;
-	    }
-
-	    if (consumeIdentifier(token.value, 1) !== token.value.length) {
-	        return false;
-	    }
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	function isNumber$2(str) {
-	    return /^[-+]?(\d+|\d*\.\d+)([eE][-+]?\d+)?$/.test(str);
-	}
-
-	function consumeNumber(str, allowFraction) {
-	    var code = str.charCodeAt(0);
-
-	    return findNumberEnd$2(str, code === PLUSSIGN$2 || code === HYPHENMINUS$3 ? 1 : 0, allowFraction);
-	}
-
-	function consumeIdentifier(str, offset) {
-	    var code = str.charCodeAt(offset);
-
-	    if (code < 0x80 && SYMBOL_TYPE$2[code] !== IDENTIFIER$2 && code !== HYPHENMINUS$3) {
-	        return offset;
-	    }
-
-	    return findIdentifierEnd$2(str, offset + 1);
-	}
-
-	function astNode(type) {
-	    return function(token, addTokenToMatch) {
-	        if (token === null || token.node.type !== type) {
-	            return false;
-	        }
-
-	        addTokenToMatch();
-	        return true;
-	    };
-	}
-
-	function dimension(type) {
-	    return function(token, addTokenToMatch, getNextToken) {
-	        if (calc(token, addTokenToMatch, getNextToken)) {
-	            return true;
-	        }
-
-	        if (token === null) {
-	            return false;
-	        }
-
-	        var numberEnd = consumeNumber(token.value, true);
-	        if (numberEnd === 0) {
-	            return false;
-	        }
-
-	        if (type) {
-	            if (!type.hasOwnProperty(token.value.substr(numberEnd).toLowerCase())) {
-	                return false;
-	            }
-	        } else {
-	            var unitEnd = consumeIdentifier(token.value, numberEnd);
-	            if (unitEnd === numberEnd || unitEnd !== token.value.length) {
-	                return false;
-	            }
-	        }
-
-	        addTokenToMatch();
-	        return true;
-	    };
-	}
-
-	function zeroUnitlessDimension(type) {
-	    var isDimension = dimension(type);
-
-	    return function(token, addTokenToMatch, getNextToken) {
-	        if (isDimension(token, addTokenToMatch, getNextToken)) {
-	            return true;
-	        }
-
-	        if (token === null || Number(token.value) !== 0) {
-	            return false;
-	        }
-
-	        addTokenToMatch();
-	        return true;
-	    };
-	}
-
-	function number(token, addTokenToMatch, getNextToken) {
-	    if (calc(token, addTokenToMatch, getNextToken)) {
-	        return true;
-	    }
-
-	    if (token === null) {
-	        return false;
-	    }
-
-	    var numberEnd = consumeNumber(token.value, true);
-	    if (numberEnd !== token.value.length) {
-	        return false;
-	    }
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	function numberZeroOne(token, addTokenToMatch, getNextToken) {
-	    if (calc(token, addTokenToMatch, getNextToken)) {
-	        return true;
-	    }
-
-	    if (token === null || !isNumber$2(token.value)) {
-	        return false;
-	    }
-
-	    var value = Number(token.value);
-	    if (value < 0 || value > 1) {
-	        return false;
-	    }
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	function numberOneOrGreater(token, addTokenToMatch, getNextToken) {
-	    if (calc(token, addTokenToMatch, getNextToken)) {
-	        return true;
-	    }
-
-	    if (token === null || !isNumber$2(token.value)) {
-	        return false;
-	    }
-
-	    var value = Number(token.value);
-	    if (value < 1) {
-	        return false;
-	    }
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	// TODO: fail on 10e-2
-	function integer(token, addTokenToMatch, getNextToken) {
-	    if (calc(token, addTokenToMatch, getNextToken)) {
-	        return true;
-	    }
-
-	    if (token === null) {
-	        return false;
-	    }
-
-	    var numberEnd = consumeNumber(token.value, false);
-	    if (numberEnd !== token.value.length) {
-	        return false;
-	    }
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	// TODO: fail on 10e-2
-	function positiveInteger(token, addTokenToMatch, getNextToken) {
-	    if (calc(token, addTokenToMatch, getNextToken)) {
-	        return true;
-	    }
-
-	    if (token === null) {
-	        return false;
-	    }
-
-	    var numberEnd = findDecimalNumberEnd$1(token.value, 0);
-	    if (numberEnd !== token.value.length || token.value.charCodeAt(0) === HYPHENMINUS$3) {
-	        return false;
-	    }
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	function hexColor(token, addTokenToMatch) {
-	    if (token === null || token.value.charCodeAt(0) !== NUMBERSIGN) {
-	        return false;
-	    }
-
-	    var length = token.value.length - 1;
-
-	    // valid length is 3, 4, 6 and 8 (+1 for #)
-	    if (length !== 3 && length !== 4 && length !== 6 && length !== 8) {
-	        return false;
-	    }
-
-	    for (var i = 1; i < length; i++) {
-	        if (!isHex$1(token.value.charCodeAt(i))) {
-	            return false;
-	        }
-	    }
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	// https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident
-	// https://drafts.csswg.org/css-values-4/#identifier-value
-	function customIdent(token, addTokenToMatch) {
-	    if (token === null) {
-	        return false;
-	    }
-
-	    var identEnd = consumeIdentifier(token.value, 0);
-	    if (identEnd !== token.value.length) {
-	        return false;
-	    }
-
-	    var name = token.value.toLowerCase();
-
-	    // § 3.2. Author-defined Identifiers: the <custom-ident> type
-	    // The CSS-wide keywords are not valid <custom-ident>s
-	    if (name === 'unset' || name === 'initial' || name === 'inherit') {
-	        return false;
-	    }
-
-	    // The default keyword is reserved and is also not a valid <custom-ident>
-	    if (name === 'default') {
-	        return false;
-	    }
-
-	    // TODO: ignore property specific keywords (as described https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident)
-
-	    addTokenToMatch();
-	    return true;
-	}
-
-	var generic = {
-	    'angle': zeroUnitlessDimension(ANGLE),
-	    'attr()': attr$1,
-	    'custom-ident': customIdent,
-	    'decibel': dimension(DECIBEL),
-	    'dimension': dimension(),
-	    'frequency': dimension(FREQUENCY),
-	    'flex': dimension(FLEX),
-	    'hex-color': hexColor,
-	    'id-selector': idSelector, // element( <id-selector> )
-	    'ident': astNode('Identifier'),
-	    'integer': integer,
-	    'length': zeroUnitlessDimension(LENGTH),
-	    'number': number,
-	    'number-zero-one': numberZeroOne,
-	    'number-one-or-greater': numberOneOrGreater,
-	    'percentage': dimension(PERCENTAGE),
-	    'positive-integer': positiveInteger,
-	    'resolution': dimension(RESOLUTION),
-	    'semitones': dimension(SEMITONES),
-	    'string': astNode('String'),
-	    'time': dimension(TIME),
-	    'unicode-range': astNode('UnicodeRange'),
-	    'url': url,
-
-	    // old IE stuff
-	    'progid': astNode('Raw'),
-	    'expression': expression
-	};
-
-	var SyntaxParseError = function(message, input, offset) {
-	    var error = createCustomError('SyntaxParseError', message);
-
-	    error.input = input;
-	    error.offset = offset;
-	    error.rawMessage = message;
-	    error.message = error.rawMessage + '\n' +
-	        '  ' + error.input + '\n' +
-	        '--' + new Array((error.offset || error.input.length) + 1).join('-') + '^';
-
-	    return error;
-	};
-
-	var error$2 = {
-	    SyntaxParseError: SyntaxParseError
-	};
-
-	var SyntaxParseError$1 = error$2.SyntaxParseError;
-
-	var TAB$2 = 9;
-	var N$3 = 10;
-	var F$3 = 12;
-	var R$3 = 13;
-	var SPACE$2 = 32;
-
-	var Tokenizer$1 = function(str) {
-	    this.str = str;
-	    this.pos = 0;
-	};
-
-	Tokenizer$1.prototype = {
-	    charCodeAt: function(pos) {
-	        return pos < this.str.length ? this.str.charCodeAt(pos) : 0;
-	    },
-	    charCode: function() {
-	        return this.charCodeAt(this.pos);
-	    },
-	    nextCharCode: function() {
-	        return this.charCodeAt(this.pos + 1);
-	    },
-	    nextNonWsCode: function(pos) {
-	        return this.charCodeAt(this.findWsEnd(pos));
-	    },
-	    findWsEnd: function(pos) {
-	        for (; pos < this.str.length; pos++) {
-	            var code = this.str.charCodeAt(pos);
-	            if (code !== R$3 && code !== N$3 && code !== F$3 && code !== SPACE$2 && code !== TAB$2) {
-	                break;
-	            }
-	        }
-
-	        return pos;
-	    },
-	    substringToPos: function(end) {
-	        return this.str.substring(this.pos, this.pos = end);
-	    },
-	    eat: function(code) {
-	        if (this.charCode() !== code) {
-	            this.error('Expect `' + String.fromCharCode(code) + '`');
-	        }
-
-	        this.pos++;
-	    },
-	    peek: function() {
-	        return this.pos < this.str.length ? this.str.charAt(this.pos++) : '';
-	    },
-	    error: function(message) {
-	        throw new SyntaxParseError$1(message, this.str, this.pos);
-	    }
-	};
-
-	var tokenizer$1 = Tokenizer$1;
-
-	var TAB$3 = 9;
-	var N$4 = 10;
-	var F$4 = 12;
-	var R$4 = 13;
-	var SPACE$3 = 32;
-	var EXCLAMATIONMARK$1 = 33;    // !
-	var NUMBERSIGN$1 = 35;         // #
-	var AMPERSAND = 38;          // &
-	var APOSTROPHE$1 = 39;         // '
-	var LEFTPARENTHESIS$1 = 40;    // (
-	var RIGHTPARENTHESIS$1 = 41;   // )
-	var ASTERISK = 42;           // *
-	var PLUSSIGN$3 = 43;           // +
-	var COMMA = 44;              // ,
-	var LESSTHANSIGN$1 = 60;       // <
-	var GREATERTHANSIGN$1 = 62;    // >
-	var QUESTIONMARK = 63;       // ?
-	var COMMERCIALAT$1 = 64;       // @
-	var LEFTSQUAREBRACKET$1 = 91;  // [
-	var RIGHTSQUAREBRACKET$1 = 93; // ]
-	var LEFTCURLYBRACKET$1 = 123;  // {
-	var VERTICALLINE = 124;      // |
-	var RIGHTCURLYBRACKET$1 = 125; // }
-	var NAME_CHAR = createCharMap(function(ch) {
-	    return /[a-zA-Z0-9\-]/.test(ch);
-	});
-	var COMBINATOR_PRECEDENCE = {
-	    ' ': 1,
-	    '&&': 2,
-	    '||': 3,
-	    '|': 4
-	};
-
-	function createCharMap(fn) {
-	    var array = typeof Uint32Array === 'function' ? new Uint32Array(128) : new Array(128);
-	    for (var i = 0; i < 128; i++) {
-	        array[i] = fn(String.fromCharCode(i)) ? 1 : 0;
-	    }
-	    return array;
-	}
-
-	function scanSpaces(tokenizer) {
-	    return tokenizer.substringToPos(
-	        tokenizer.findWsEnd(tokenizer.pos + 1)
-	    );
-	}
-
-	function scanWord(tokenizer) {
-	    var end = tokenizer.pos;
-
-	    for (; end < tokenizer.str.length; end++) {
-	        var code = tokenizer.str.charCodeAt(end);
-	        if (code >= 128 || NAME_CHAR[code] === 0) {
-	            break;
-	        }
-	    }
-
-	    if (tokenizer.pos === end) {
-	        tokenizer.error('Expect a keyword');
-	    }
-
-	    return tokenizer.substringToPos(end);
-	}
-
-	function scanNumber(tokenizer) {
-	    var end = tokenizer.pos;
-
-	    for (; end < tokenizer.str.length; end++) {
-	        var code = tokenizer.str.charCodeAt(end);
-	        if (code < 48 || code > 57) {
-	            break;
-	        }
-	    }
-
-	    if (tokenizer.pos === end) {
-	        tokenizer.error('Expect a number');
-	    }
-
-	    return tokenizer.substringToPos(end);
-	}
-
-	function scanString(tokenizer) {
-	    var end = tokenizer.str.indexOf('\'', tokenizer.pos + 1);
-
-	    if (end === -1) {
-	        tokenizer.pos = tokenizer.str.length;
-	        tokenizer.error('Expect an apostrophe');
-	    }
-
-	    return tokenizer.substringToPos(end + 1);
-	}
-
-	function readMultiplierRange(tokenizer) {
-	    var min = null;
-	    var max = null;
-
-	    tokenizer.eat(LEFTCURLYBRACKET$1);
-
-	    min = scanNumber(tokenizer);
-
-	    if (tokenizer.charCode() === COMMA) {
-	        tokenizer.pos++;
-	        if (tokenizer.charCode() !== RIGHTCURLYBRACKET$1) {
-	            max = scanNumber(tokenizer);
-	        }
-	    } else {
-	        max = min;
-	    }
-
-	    tokenizer.eat(RIGHTCURLYBRACKET$1);
-
-	    return {
-	        min: Number(min),
-	        max: max ? Number(max) : 0
-	    };
-	}
-
-	function readMultiplier(tokenizer) {
-	    var range = null;
-	    var comma = false;
-
-	    switch (tokenizer.charCode()) {
-	        case ASTERISK:
-	            tokenizer.pos++;
-
-	            range = {
-	                min: 0,
-	                max: 0
-	            };
-
-	            break;
-
-	        case PLUSSIGN$3:
-	            tokenizer.pos++;
-
-	            range = {
-	                min: 1,
-	                max: 0
-	            };
-
-	            break;
-
-	        case QUESTIONMARK:
-	            tokenizer.pos++;
-
-	            range = {
-	                min: 0,
-	                max: 1
-	            };
-
-	            break;
-
-	        case NUMBERSIGN$1:
-	            tokenizer.pos++;
-
-	            comma = true;
-
-	            if (tokenizer.charCode() === LEFTCURLYBRACKET$1) {
-	                range = readMultiplierRange(tokenizer);
-	            } else {
-	                range = {
-	                    min: 1,
-	                    max: 0
-	                };
-	            }
-
-	            break;
-
-	        case LEFTCURLYBRACKET$1:
-	            range = readMultiplierRange(tokenizer);
-	            break;
-
-	        default:
-	            return null;
-	    }
-
-	    return {
-	        type: 'Multiplier',
-	        comma: comma,
-	        min: range.min,
-	        max: range.max,
-	        term: null
-	    };
-	}
-
-	function maybeMultiplied(tokenizer, node) {
-	    var multiplier = readMultiplier(tokenizer);
-
-	    if (multiplier !== null) {
-	        multiplier.term = node;
-	        return multiplier;
-	    }
-
-	    return node;
-	}
-
-	function maybeToken(tokenizer) {
-	    var ch = tokenizer.peek();
-
-	    if (ch === '') {
-	        return null;
-	    }
-
-	    return {
-	        type: 'Token',
-	        value: ch
-	    };
-	}
-
-	function readProperty(tokenizer) {
-	    var name;
-
-	    tokenizer.eat(LESSTHANSIGN$1);
-	    tokenizer.eat(APOSTROPHE$1);
-
-	    name = scanWord(tokenizer);
-
-	    tokenizer.eat(APOSTROPHE$1);
-	    tokenizer.eat(GREATERTHANSIGN$1);
-
-	    return maybeMultiplied(tokenizer, {
-	        type: 'Property',
-	        name: name
-	    });
-	}
-
-	function readType(tokenizer) {
-	    var name;
-
-	    tokenizer.eat(LESSTHANSIGN$1);
-	    name = scanWord(tokenizer);
-
-	    if (tokenizer.charCode() === LEFTPARENTHESIS$1 &&
-	        tokenizer.nextCharCode() === RIGHTPARENTHESIS$1) {
-	        tokenizer.pos += 2;
-	        name += '()';
-	    }
-
-	    tokenizer.eat(GREATERTHANSIGN$1);
-
-	    return maybeMultiplied(tokenizer, {
-	        type: 'Type',
-	        name: name
-	    });
-	}
-
-	function readKeywordOrFunction(tokenizer) {
-	    var name;
-
-	    name = scanWord(tokenizer);
-
-	    if (tokenizer.charCode() === LEFTPARENTHESIS$1) {
-	        tokenizer.pos++;
-
-	        return {
-	            type: 'Function',
-	            name: name
-	        };
-	    }
-
-	    return maybeMultiplied(tokenizer, {
-	        type: 'Keyword',
-	        name: name
-	    });
-	}
-
-	function regroupTerms(terms, combinators) {
-	    function createGroup(terms, combinator) {
-	        return {
-	            type: 'Group',
-	            terms: terms,
-	            combinator: combinator,
-	            disallowEmpty: false,
-	            explicit: false
-	        };
-	    }
-
-	    combinators = Object.keys(combinators).sort(function(a, b) {
-	        return COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b];
-	    });
-
-	    while (combinators.length > 0) {
-	        var combinator = combinators.shift();
-	        for (var i = 0, subgroupStart = 0; i < terms.length; i++) {
-	            var term = terms[i];
-	            if (term.type === 'Combinator') {
-	                if (term.value === combinator) {
-	                    if (subgroupStart === -1) {
-	                        subgroupStart = i - 1;
-	                    }
-	                    terms.splice(i, 1);
-	                    i--;
-	                } else {
-	                    if (subgroupStart !== -1 && i - subgroupStart > 1) {
-	                        terms.splice(
-	                            subgroupStart,
-	                            i - subgroupStart,
-	                            createGroup(terms.slice(subgroupStart, i), combinator)
-	                        );
-	                        i = subgroupStart + 1;
-	                    }
-	                    subgroupStart = -1;
-	                }
-	            }
-	        }
-
-	        if (subgroupStart !== -1 && combinators.length) {
-	            terms.splice(
-	                subgroupStart,
-	                i - subgroupStart,
-	                createGroup(terms.slice(subgroupStart, i), combinator)
-	            );
-	        }
-	    }
-
-	    return combinator;
-	}
-
-	function readImplicitGroup(tokenizer) {
-	    var terms = [];
-	    var combinators = {};
-	    var token;
-	    var prevToken = null;
-	    var prevTokenPos = tokenizer.pos;
-
-	    while (token = peek(tokenizer)) {
-	        if (token.type !== 'Spaces') {
-	            if (token.type === 'Combinator') {
-	                // check for combinator in group beginning and double combinator sequence
-	                if (prevToken === null || prevToken.type === 'Combinator') {
-	                    tokenizer.pos = prevTokenPos;
-	                    tokenizer.error('Unexpected combinator');
-	                }
-
-	                combinators[token.value] = true;
-	            } else if (prevToken !== null && prevToken.type !== 'Combinator') {
-	                combinators[' '] = true;  // a b
-	                terms.push({
-	                    type: 'Combinator',
-	                    value: ' '
-	                });
-	            }
-
-	            terms.push(token);
-	            prevToken = token;
-	            prevTokenPos = tokenizer.pos;
-	        }
-	    }
-
-	    // check for combinator in group ending
-	    if (prevToken !== null && prevToken.type === 'Combinator') {
-	        tokenizer.pos -= prevTokenPos;
-	        tokenizer.error('Unexpected combinator');
-	    }
-
-	    return {
-	        type: 'Group',
-	        terms: terms,
-	        combinator: regroupTerms(terms, combinators) || ' ',
-	        disallowEmpty: false,
-	        explicit: false
-	    };
-	}
-
-	function readGroup(tokenizer) {
-	    var result;
-
-	    tokenizer.eat(LEFTSQUAREBRACKET$1);
-	    result = readImplicitGroup(tokenizer);
-	    tokenizer.eat(RIGHTSQUAREBRACKET$1);
-
-	    result.explicit = true;
-
-	    if (tokenizer.charCode() === EXCLAMATIONMARK$1) {
-	        tokenizer.pos++;
-	        result.disallowEmpty = true;
-	    }
-
-	    return result;
-	}
-
-	function peek(tokenizer) {
-	    var code = tokenizer.charCode();
-
-	    if (code < 128 && NAME_CHAR[code] === 1) {
-	        return readKeywordOrFunction(tokenizer);
-	    }
-
-	    switch (code) {
-	        case RIGHTSQUAREBRACKET$1:
-	            // don't eat, stop scan a group
-	            break;
-
-	        case LEFTSQUAREBRACKET$1:
-	            return maybeMultiplied(tokenizer, readGroup(tokenizer));
-
-	        case LESSTHANSIGN$1:
-	            return tokenizer.nextCharCode() === APOSTROPHE$1
-	                ? readProperty(tokenizer)
-	                : readType(tokenizer);
-
-	        case VERTICALLINE:
-	            return {
-	                type: 'Combinator',
-	                value: tokenizer.substringToPos(
-	                    tokenizer.nextCharCode() === VERTICALLINE
-	                        ? tokenizer.pos + 2
-	                        : tokenizer.pos + 1
-	                )
-	            };
-
-	        case AMPERSAND:
-	            tokenizer.pos++;
-	            tokenizer.eat(AMPERSAND);
-
-	            return {
-	                type: 'Combinator',
-	                value: '&&'
-	            };
-
-	        case COMMA:
-	            tokenizer.pos++;
-	            return {
-	                type: 'Comma'
-	            };
-
-	        case APOSTROPHE$1:
-	            return maybeMultiplied(tokenizer, {
-	                type: 'String',
-	                value: scanString(tokenizer)
-	            });
-
-	        case SPACE$3:
-	        case TAB$3:
-	        case N$4:
-	        case R$4:
-	        case F$4:
-	            return {
-	                type: 'Spaces',
-	                value: scanSpaces(tokenizer)
-	            };
-
-	        case COMMERCIALAT$1:
-	            code = tokenizer.nextCharCode();
-
-	            if (code < 128 && NAME_CHAR[code] === 1) {
-	                tokenizer.pos++;
-	                return {
-	                    type: 'AtKeyword',
-	                    name: scanWord(tokenizer)
-	                };
-	            }
-
-	            return maybeToken(tokenizer);
-
-	        case ASTERISK:
-	        case PLUSSIGN$3:
-	        case QUESTIONMARK:
-	        case NUMBERSIGN$1:
-	        case EXCLAMATIONMARK$1:
-	            // prohibited tokens (used as a multiplier start)
-	            break;
-
-	        case LEFTCURLYBRACKET$1:
-	            // LEFTCURLYBRACKET is allowed since mdn/data uses it w/o quoting
-	            // check next char isn't a number, because it's likely a disjoined multiplier
-	            code = tokenizer.nextCharCode();
-
-	            if (code < 48 || code > 57) {
-	                return maybeToken(tokenizer);
-	            }
-
-	            break;
-
-	        default:
-	            return maybeToken(tokenizer);
-	    }
-	}
-
-	function parse(str) {
-	    var tokenizer = new tokenizer$1(str);
-	    var result = readImplicitGroup(tokenizer);
-
-	    if (tokenizer.pos !== str.length) {
-	        tokenizer.error('Unexpected input');
-	    }
-
-	    // reduce redundant groups with single group term
-	    if (result.terms.length === 1 && result.terms[0].type === 'Group') {
-	        result = result.terms[0];
-	    }
-
-	    return result;
-	}
-
-	// warm up parse to elimitate code branches that never execute
-	// fix soft deoptimizations (insufficient type feedback)
-	parse('[a&&<b>#|<\'c\'>*||e() f{2} /,(% g#{1,2} h{2,})]!');
-
-	var parse_1 = parse;
-
-	var noop$2 = function() {};
-
-	function ensureFunction(value) {
-	    return typeof value === 'function' ? value : noop$2;
-	}
-
-	var walk$1 = function(node, options, context) {
-	    function walk(node) {
-	        enter.call(context, node);
-
-	        switch (node.type) {
-	            case 'Group':
-	                node.terms.forEach(walk);
-	                break;
-
-	            case 'Multiplier':
-	                walk(node.term);
-	                break;
-
-	            case 'Type':
-	            case 'Property':
-	            case 'Keyword':
-	            case 'AtKeyword':
-	            case 'Function':
-	            case 'String':
-	            case 'Token':
-	            case 'Comma':
-	                break;
-
-	            default:
-	                throw new Error('Unknown type: ' + node.type);
-	        }
-
-	        leave.call(context, node);
-	    }
-
-	    var enter = noop$2;
-	    var leave = noop$2;
-
-	    if (typeof options === 'function') {
-	        enter = options;
-	    } else if (options) {
-	        enter = ensureFunction(options.enter);
-	        leave = ensureFunction(options.leave);
-	    }
-
-	    if (enter === noop$2 && leave === noop$2) {
-	        throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
-	    }
-
-	    walk(node, context);
-	};
-
-	var astToTokens = {
-	    decorator: function(handlers) {
-	        var curNode = null;
-	        var prev = null;
-	        var tokens = [];
-
-	        return {
-	            children: handlers.children,
-	            node: function(node) {
-	                var tmp = curNode;
-	                curNode = node;
-	                handlers.node.call(this, node);
-	                curNode = tmp;
-	            },
-	            chunk: function(chunk) {
-	                if (tokens.length > 0) {
-	                    switch (curNode.type) {
-	                        case 'Dimension':
-	                        case 'HexColor':
-	                        case 'IdSelector':
-	                        case 'Percentage':
-	                            if (prev.node === curNode) {
-	                                prev.value += chunk;
-	                                return;
-	                            }
-	                            break;
-
-	                        case 'Function':
-	                        case 'PseudoClassSelector':
-	                        case 'PseudoElementSelector':
-	                        case 'Url':
-	                            if (chunk === '(') {
-	                                prev.value += chunk;
-	                                return;
-	                            }
-	                            break;
-
-	                        case 'Atrule':
-	                            if (prev.node === curNode && prev.value === '@') {
-	                                prev.value += chunk;
-	                                return;
-	                            }
-	                            break;
-	                    }
-	                }
-
-	                tokens.push(prev = {
-	                    value: chunk,
-	                    node: curNode
-	                });
-	            },
-	            result: function() {
-	                return tokens;
-	            }
-	        };
-	    }
-	};
-
-	var MATCH = { type: 'Match' };
-	var MISMATCH = { type: 'Mismatch' };
-	var DISALLOW_EMPTY = { type: 'DisallowEmpty' };
-	var LEFTPARENTHESIS$2 = 40;  // (
-	var RIGHTPARENTHESIS$2 = 41; // )
-
-	function createCondition(match, thenBranch, elseBranch) {
-	    // reduce node count
-	    if (thenBranch === MATCH && elseBranch === MISMATCH) {
-	        return match;
-	    }
-
-	    if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) {
-	        return match;
-	    }
-
-	    if (match.type === 'If' && match.else === MISMATCH && thenBranch === MATCH) {
-	        thenBranch = match.then;
-	        match = match.match;
-	    }
-
-	    return {
-	        type: 'If',
-	        match: match,
-	        then: thenBranch,
-	        else: elseBranch
-	    };
-	}
-
-	function isFunctionType(name) {
-	    return (
-	        name.length > 2 &&
-	        name.charCodeAt(name.length - 2) === LEFTPARENTHESIS$2 &&
-	        name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS$2
-	    );
-	}
-
-	function isEnumCapatible(term) {
-	    return (
-	        term.type === 'Keyword' ||
-	        term.type === 'AtKeyword' ||
-	        term.type === 'Function' ||
-	        term.type === 'Type' && isFunctionType(term.name)
-	    );
-	}
-
-	function buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) {
-	    switch (combinator) {
-	        case ' ':
-	            // Juxtaposing components means that all of them must occur, in the given order.
-	            //
-	            // a b c
-	            // =
-	            // match a
-	            //   then match b
-	            //     then match c
-	            //       then MATCH
-	            //       else MISMATCH
-	            //     else MISMATCH
-	            //   else MISMATCH
-	            var result = MATCH;
-
-	            for (var i = terms.length - 1; i >= 0; i--) {
-	                var term = terms[i];
-
-	                result = createCondition(
-	                    term,
-	                    result,
-	                    MISMATCH
-	                );
-	            }
-	            return result;
-
-	        case '|':
-	            // A bar (|) separates two or more alternatives: exactly one of them must occur.
-	            //
-	            // a | b | c
-	            // =
-	            // match a
-	            //   then MATCH
-	            //   else match b
-	            //     then MATCH
-	            //     else match c
-	            //       then MATCH
-	            //       else MISMATCH
-
-	            var result = MISMATCH;
-	            var map = null;
-
-	            for (var i = terms.length - 1; i >= 0; i--) {
-	                var term = terms[i];
-
-	                // reduce sequence of keywords into a Enum
-	                if (isEnumCapatible(term)) {
-	                    if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) {
-	                        map = Object.create(null);
-	                        result = createCondition(
-	                            {
-	                                type: 'Enum',
-	                                map: map
-	                            },
-	                            MATCH,
-	                            result
-	                        );
-	                    }
-
-	                    if (map !== null) {
-	                        var key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase();
-	                        if (key in map === false) {
-	                            map[key] = term;
-	                            continue;
-	                        }
-	                    }
-	                }
-
-	                map = null;
-
-	                // create a new conditonal node
-	                result = createCondition(
-	                    term,
-	                    MATCH,
-	                    result
-	                );
-	            }
-	            return result;
-
-	        case '&&':
-	            // A double ampersand (&&) separates two or more components,
-	            // all of which must occur, in any order.
-
-	            // Use MatchOnce for groups with a large number of terms,
-	            // since &&-groups produces at least N!-node trees
-	            if (terms.length > 5) {
-	                return {
-	                    type: 'MatchOnce',
-	                    terms: terms,
-	                    all: true
-	                };
-	            }
-
-	            // Use a combination tree for groups with small number of terms
-	            //
-	            // a && b && c
-	            // =
-	            // match a
-	            //   then [b && c]
-	            //   else match b
-	            //     then [a && c]
-	            //     else match c
-	            //       then [a && b]
-	            //       else MISMATCH
-	            //
-	            // a && b
-	            // =
-	            // match a
-	            //   then match b
-	            //     then MATCH
-	            //     else MISMATCH
-	            //   else match b
-	            //     then match a
-	            //       then MATCH
-	            //       else MISMATCH
-	            //     else MISMATCH
-	            var result = MISMATCH;
-
-	            for (var i = terms.length - 1; i >= 0; i--) {
-	                var term = terms[i];
-	                var thenClause;
-
-	                if (terms.length > 1) {
-	                    thenClause = buildGroupMatchGraph(
-	                        combinator,
-	                        terms.filter(function(newGroupTerm) {
-	                            return newGroupTerm !== term;
-	                        }),
-	                        false
-	                    );
-	                } else {
-	                    thenClause = MATCH;
-	                }
-
-	                result = createCondition(
-	                    term,
-	                    thenClause,
-	                    result
-	                );
-	            }
-	            return result;
-
-	        case '||':
-	            // A double bar (||) separates two or more options:
-	            // one or more of them must occur, in any order.
-
-	            // Use MatchOnce for groups with a large number of terms,
-	            // since ||-groups produces at least N!-node trees
-	            if (terms.length > 5) {
-	                return {
-	                    type: 'MatchOnce',
-	                    terms: terms,
-	                    all: false
-	                };            }
-
-	            // Use a combination tree for groups with small number of terms
-	            //
-	            // a || b || c
-	            // =
-	            // match a
-	            //   then [b || c]
-	            //   else match b
-	            //     then [a || c]
-	            //     else match c
-	            //       then [a || b]
-	            //       else MISMATCH
-	            //
-	            // a || b
-	            // =
-	            // match a
-	            //   then match b
-	            //     then MATCH
-	            //     else MATCH
-	            //   else match b
-	            //     then match a
-	            //       then MATCH
-	            //       else MATCH
-	            //     else MISMATCH
-	            var result = atLeastOneTermMatched ? MATCH : MISMATCH;
-
-	            for (var i = terms.length - 1; i >= 0; i--) {
-	                var term = terms[i];
-	                var thenClause;
-
-	                if (terms.length > 1) {
-	                    thenClause = buildGroupMatchGraph(
-	                        combinator,
-	                        terms.filter(function(newGroupTerm) {
-	                            return newGroupTerm !== term;
-	                        }),
-	                        true
-	                    );
-	                } else {
-	                    thenClause = MATCH;
-	                }
-
-	                result = createCondition(
-	                    term,
-	                    thenClause,
-	                    result
-	                );
-	            }
-	            return result;
-	    }
-	}
-
-	function buildMultiplierMatchGraph(node) {
-	    var result = MATCH;
-	    var matchTerm = buildMatchGraph(node.term);
-
-	    if (node.max === 0) {
-	        // disable repeating of empty match to prevent infinite loop
-	        matchTerm = createCondition(
-	            matchTerm,
-	            DISALLOW_EMPTY,
-	            MISMATCH
-	        );
-
-	        // an occurrence count is not limited, make a cycle;
-	        // to collect more terms on each following matching mismatch
-	        result = createCondition(
-	            matchTerm,
-	            null, // will be a loop
-	            MISMATCH
-	        );
-
-	        result.then = createCondition(
-	            MATCH,
-	            MATCH,
-	            result // make a loop
-	        );
-
-	        if (node.comma) {
-	            result.then.else = createCondition(
-	                { type: 'Comma', syntax: node },
-	                result,
-	                MISMATCH
-	            );
-	        }
-	    } else {
-	        // create a match node chain for [min .. max] interval with optional matches
-	        for (var i = node.min || 1; i <= node.max; i++) {
-	            if (node.comma && result !== MATCH) {
-	                result = createCondition(
-	                    { type: 'Comma', syntax: node },
-	                    result,
-	                    MISMATCH
-	                );
-	            }
-
-	            result = createCondition(
-	                matchTerm,
-	                createCondition(
-	                    MATCH,
-	                    MATCH,
-	                    result
-	                ),
-	                MISMATCH
-	            );
-	        }
-	    }
-
-	    if (node.min === 0) {
-	        // allow zero match
-	        result = createCondition(
-	            MATCH,
-	            MATCH,
-	            result
-	        );
-	    } else {
-	        // create a match node chain to collect [0 ... min - 1] required matches
-	        for (var i = 0; i < node.min - 1; i++) {
-	            if (node.comma && result !== MATCH) {
-	                result = createCondition(
-	                    { type: 'Comma', syntax: node },
-	                    result,
-	                    MISMATCH
-	                );
-	            }
-
-	            result = createCondition(
-	                matchTerm,
-	                result,
-	                MISMATCH
-	            );
-	        }
-	    }
-
-	    return result;
-	}
-
-	function buildMatchGraph(node) {
-	    if (typeof node === 'function') {
-	        return {
-	            type: 'Generic',
-	            fn: node
-	        };
-	    }
-
-	    switch (node.type) {
-	        case 'Group':
-	            var result = buildGroupMatchGraph(
-	                node.combinator,
-	                node.terms.map(buildMatchGraph),
-	                false
-	            );
-
-	            if (node.disallowEmpty) {
-	                result = createCondition(
-	                    result,
-	                    DISALLOW_EMPTY,
-	                    MISMATCH
-	                );
-	            }
-
-	            return result;
-
-	        case 'Multiplier':
-	            return buildMultiplierMatchGraph(node);
-
-	        case 'Type':
-	        case 'Property':
-	            return {
-	                type: node.type,
-	                name: node.name,
-	                syntax: node
-	            };
-
-	        case 'Keyword':
-	            return {
-	                type: node.type,
-	                name: node.name.toLowerCase(),
-	                syntax: node
-	            };
-
-	        case 'AtKeyword':
-	            return {
-	                type: node.type,
-	                name: '@' + node.name.toLowerCase(),
-	                syntax: node
-	            };
-
-	        case 'Function':
-	            return {
-	                type: node.type,
-	                name: node.name.toLowerCase() + '(',
-	                syntax: node
-	            };
-
-	        case 'String':
-	            // convert a one char length String to a Token
-	            if (node.value.length === 3) {
-	                return {
-	                    type: 'Token',
-	                    value: node.value.charAt(1),
-	                    syntax: node
-	                };
-	            }
-
-	            // otherwise use it as is
-	            return {
-	                type: node.type,
-	                value: node.value,
-	                syntax: node
-	            };
-
-	        case 'Token':
-	            return {
-	                type: node.type,
-	                value: node.value,
-	                syntax: node
-	            };
-
-	        case 'Comma':
-	            return {
-	                type: node.type,
-	                syntax: node
-	            };
-
-	        default:
-	            throw new Error('Unknown node type:', node.type);
-	    }
-	}
-
-	var matchGraph = {
-	    MATCH: MATCH,
-	    MISMATCH: MISMATCH,
-	    DISALLOW_EMPTY: DISALLOW_EMPTY,
-	    buildMatchGraph: function(syntaxTree, ref) {
-	        if (typeof syntaxTree === 'string') {
-	            syntaxTree = parse_1(syntaxTree);
-	        }
-
-	        return {
-	            type: 'MatchGraph',
-	            match: buildMatchGraph(syntaxTree),
-	            syntax: ref || null,
-	            source: syntaxTree
-	        };
-	    }
-	};
-
-	var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-
-	var MATCH$1 = matchGraph.MATCH;
-	var MISMATCH$1 = matchGraph.MISMATCH;
-	var DISALLOW_EMPTY$1 = matchGraph.DISALLOW_EMPTY;
-
-	var TOKEN = 1;
-	var OPEN_SYNTAX = 2;
-	var CLOSE_SYNTAX = 3;
-
-	var EXIT_REASON_MATCH = 'Match';
-	var EXIT_REASON_MISMATCH = 'Mismatch';
-	var EXIT_REASON_ITERATION_LIMIT = 'Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)';
-
-	var ITERATION_LIMIT = 10000;
-	var totalIterationCount = 0;
-
-	function mapList(list, fn) {
-	    var result = [];
-
-	    while (list) {
-	        result.unshift(fn(list));
-	        list = list.prev;
-	    }
-
-	    return result;
-	}
-
-	function isCommaContextStart(token) {
-	    if (token === null) {
-	        return true;
-	    }
-
-	    token = token.value.charAt(token.value.length - 1);
-
-	    return (
-	        token === ',' ||
-	        token === '(' ||
-	        token === '[' ||
-	        token === '/'
-	    );
-	}
-
-	function isCommaContextEnd(token) {
-	    if (token === null) {
-	        return true;
-	    }
-
-	    token = token.value.charAt(0);
-
-	    return (
-	        token === ')' ||
-	        token === ']' ||
-	        token === '/'
-	    );
-	}
-
-	function internalMatch(tokens, syntax, syntaxes) {
-	    function moveToNextToken() {
-	        do {
-	            tokenCursor++;
-	            token = tokenCursor < tokens.length ? tokens[tokenCursor] : null;
-	        } while (token !== null && !/\S/.test(token.value));
-	    }
-
-	    function getNextToken(offset) {
-	        var nextIndex = tokenCursor + offset;
-
-	        return nextIndex < tokens.length ? tokens[nextIndex] : null;
-	    }
-
-	    function pushThenStack(nextSyntax) {
-	        thenStack = {
-	            nextSyntax: nextSyntax,
-	            matchStack: matchStack,
-	            syntaxStack: syntaxStack,
-	            prev: thenStack
-	        };
-	    }
-
-	    function pushElseStack(nextSyntax) {
-	        elseStack = {
-	            nextSyntax: nextSyntax,
-	            matchStack: matchStack,
-	            syntaxStack: syntaxStack,
-	            thenStack: thenStack,
-	            tokenCursor: tokenCursor,
-	            token: token,
-	            prev: elseStack
-	        };
-	    }
-
-	    function addTokenToMatch() {
-	        matchStack = {
-	            type: TOKEN,
-	            syntax: syntax.syntax,
-	            token: token,
-	            prev: matchStack
-	        };
-
-	        moveToNextToken();
-
-	        if (tokenCursor > longestMatch) {
-	            longestMatch = tokenCursor;
-	        }
-
-	        return matchStack.token;
-	    }
-
-	    function openSyntax() {
-	        syntaxStack = {
-	            syntax: syntax,
-	            prev: syntaxStack
-	        };
-
-	        matchStack = {
-	            type: OPEN_SYNTAX,
-	            syntax: syntax.syntax,
-	            token: matchStack.token,
-	            prev: matchStack
-	        };
-	    }
-
-	    function closeSyntax() {
-	        if (matchStack.type === OPEN_SYNTAX) {
-	            matchStack = matchStack.prev;
-	        } else {
-	            matchStack = {
-	                type: CLOSE_SYNTAX,
-	                syntax: syntaxStack.syntax,
-	                token: matchStack.token,
-	                prev: matchStack
-	            };
-	        }
-
-	        syntaxStack = syntaxStack.prev;
-	    }
-
-	    var syntaxStack = null;
-	    var thenStack = null;
-	    var elseStack = null;
-
-	    var iterationCount = 0;
-	    var exitReason = EXIT_REASON_MATCH;
-
-	    var matchStack = { type: 'Stub', syntax: null, token: null, tokenCursor: -1, prev: null };
-	    var longestMatch = 0;
-	    var tokenCursor = -1;
-	    var token = null;
-
-	    moveToNextToken();
-
-	    while (true) {
-	        // console.log('--\n',
-	        //     '#' + iterationCount,
-	        //     require('util').inspect({
-	        //         match: mapList(matchStack, x => x.type === TOKEN ? x.token && x.token.value : x.syntax ? x.type + '!' + x.syntax.name : null),
-	        //         elseStack: mapList(elseStack, x => x.id),
-	        //         thenStack: mapList(thenStack, x => x.id),
-	        //         token: token && token.value,
-	        //         tokenCursor,
-	        //         syntax
-	        //     }, { depth: null })
-	        // );
-
-	        // prevent infinite loop
-	        if (++iterationCount === ITERATION_LIMIT) {
-	            console.warn('[csstree-match] BREAK after ' + ITERATION_LIMIT + ' iterations');
-	            exitReason = EXIT_REASON_ITERATION_LIMIT;
-	            break;
-	        }
-
-	        if (syntax === MATCH$1) {
-	            if (thenStack === null) {
-	                // turn to MISMATCH when some tokens left unmatched
-	                if (token !== null) {
-	                    // doesn't mismatch if just one token left and it's an IE hack
-	                    if (tokenCursor !== tokens.length - 1 || (token.value !== '\\0' && token.value !== '\\9')) {
-	                        syntax = MISMATCH$1;
-	                        continue;
-	                    }
-	                }
-
-	                // break the main loop, return a result - MATCH
-	                exitReason = EXIT_REASON_MATCH;
-	                break;
-	            }
-
-	            // go to next syntax (`then` branch)
-	            syntax = thenStack.nextSyntax;
-
-	            // check match is not empty
-	            if (syntax === DISALLOW_EMPTY$1) {
-	                if (thenStack.matchStack.token === matchStack.token) {
-	                    syntax = MISMATCH$1;
-	                    continue;
-	                } else {
-	                    syntax = MATCH$1;
-	                }
-	            }
-
-	            // close syntax if needed
-	            while (syntaxStack !== null && thenStack.syntaxStack !== syntaxStack) {
-	                closeSyntax();
-	            }
-
-	            // pop stack
-	            thenStack = thenStack.prev;
-	            continue;
-	        }
-
-	        if (syntax === MISMATCH$1) {
-	            if (elseStack === null) {
-	                // break the main loop, return a result - MISMATCH
-	                exitReason = EXIT_REASON_MISMATCH;
-	                break;
-	            }
-
-	            // go to next syntax (`else` branch)
-	            syntax = elseStack.nextSyntax;
-
-	            // restore all the rest stack states
-	            thenStack = elseStack.thenStack;
-	            syntaxStack = elseStack.syntaxStack;
-	            matchStack = elseStack.matchStack;
-	            tokenCursor = elseStack.tokenCursor;
-	            token = elseStack.token;
-
-	            // pop stack
-	            elseStack = elseStack.prev;
-	            continue;
-	        }
-
-	        switch (syntax.type) {
-	            case 'MatchGraph':
-	                syntax = syntax.match;
-	                break;
-
-	            case 'If':
-	                // IMPORTANT: else stack push must go first,
-	                // since it stores the state of thenStack before changes
-	                if (syntax.else !== MISMATCH$1) {
-	                    pushElseStack(syntax.else);
-	                }
-
-	                if (syntax.then !== MATCH$1) {
-	                    pushThenStack(syntax.then);
-	                }
-
-	                syntax = syntax.match;
-	                break;
-
-	            case 'MatchOnce':
-	                syntax = {
-	                    type: 'MatchOnceBuffer',
-	                    terms: syntax.terms,
-	                    all: syntax.all,
-	                    matchStack: matchStack,
-	                    index: 0,
-	                    mask: 0
-	                };
-	                break;
-
-	            case 'MatchOnceBuffer':
-	                if (syntax.index === syntax.terms.length) {
-	                    // if no matches during a cycle
-	                    if (syntax.matchStack === matchStack) {
-	                        // no matches at all or it's required all terms to be matched
-	                        if (syntax.mask === 0 || syntax.all) {
-	                            syntax = MISMATCH$1;
-	                            break;
-	                        }
-
-	                        // a partial match is ok
-	                        syntax = MATCH$1;
-	                        break;
-	                    } else {
-	                        // start trying to match from the start
-	                        syntax.index = 0;
-	                        syntax.matchStack = matchStack;
-	                    }
-	                }
-
-	                for (; syntax.index < syntax.terms.length; syntax.index++) {
-	                    if ((syntax.mask & (1 << syntax.index)) === 0) {
-	                        // IMPORTANT: else stack push must go first,
-	                        // since it stores the state of thenStack before changes
-	                        pushElseStack(syntax);
-	                        pushThenStack({
-	                            type: 'AddMatchOnce',
-	                            buffer: syntax
-	                        });
-
-	                        // match
-	                        syntax = syntax.terms[syntax.index++];
-	                        break;
-	                    }
-	                }
-	                break;
-
-	            case 'AddMatchOnce':
-	                syntax = syntax.buffer;
-
-	                var newMask = syntax.mask | (1 << (syntax.index - 1));
-
-	                // all terms are matched
-	                if (newMask === (1 << syntax.terms.length) - 1) {
-	                    syntax = MATCH$1;
-	                    continue;
-	                }
-
-	                syntax = {
-	                    type: 'MatchOnceBuffer',
-	                    terms: syntax.terms,
-	                    all: syntax.all,
-	                    matchStack: syntax.matchStack,
-	                    index: syntax.index,
-	                    mask: newMask
-	                };
-
-	                break;
-
-	            case 'Enum':
-	                var name = token !== null ? token.value.toLowerCase() : '';
-
-	                // drop \0 and \9 hack from keyword name
-	                if (name.indexOf('\\') !== -1) {
-	                    name = name.replace(/\\[09].*$/, '');
-	                }
-
-	                if (hasOwnProperty$1.call(syntax.map, name)) {
-	                    syntax = syntax.map[name];
-	                } else {
-	                    syntax = MISMATCH$1;
-	                }
-
-	                break;
-
-	            case 'Generic':
-	                syntax = syntax.fn(token, addTokenToMatch, getNextToken) ? MATCH$1 : MISMATCH$1;
-	                break;
-
-	            case 'Type':
-	            case 'Property':
-	                openSyntax();
-
-	                var syntaxDict = syntax.type === 'Type' ? 'types' : 'properties';
-
-	                if (hasOwnProperty$1.call(syntaxes, syntaxDict) && syntaxes[syntaxDict][syntax.name]) {
-	                    syntax = syntaxes[syntaxDict][syntax.name].match;
-	                } else {
-	                    syntax = undefined;
-	                }
-
-	                if (!syntax) {
-	                    throw new Error(
-	                        'Bad syntax reference: ' +
-	                        (syntaxStack.syntax.type === 'Type'
-	                            ? '<' + syntaxStack.syntax.name + '>'
-	                            : '<\'' + syntaxStack.syntax.name + '\'>')
-	                    );
-	                }
-
-	                break;
-
-	            case 'Keyword':
-	                var name = syntax.name;
-
-	                if (token !== null) {
-	                    var keywordName = token.value;
-
-	                    // drop \0 and \9 hack from keyword name
-	                    if (keywordName.indexOf('\\') !== -1) {
-	                        keywordName = keywordName.replace(/\\[09].*$/, '');
-	                    }
-
-	                    if (keywordName.toLowerCase() === name) {
-	                        addTokenToMatch();
-
-	                        syntax = MATCH$1;
-	                        break;
-	                    }
-	                }
-
-	                syntax = MISMATCH$1;
-	                break;
-
-	            case 'AtKeyword':
-	            case 'Function':
-	                if (token !== null && token.value.toLowerCase() === syntax.name) {
-	                    addTokenToMatch();
-
-	                    syntax = MATCH$1;
-	                    break;
-	                }
-
-	                syntax = MISMATCH$1;
-	                break;
-
-	            case 'Token':
-	                if (token !== null && token.value === syntax.value) {
-	                    addTokenToMatch();
-
-	                    syntax = MATCH$1;
-	                    break;
-	                }
-
-	                syntax = MISMATCH$1;
-	                break;
-
-	            case 'Comma':
-	                if (token !== null && token.value === ',') {
-	                    if (isCommaContextStart(matchStack.token)) {
-	                        syntax = MISMATCH$1;
-	                    } else {
-	                        addTokenToMatch();
-	                        syntax = isCommaContextEnd(token) ? MISMATCH$1 : MATCH$1;
-	                    }
-	                } else {
-	                    syntax = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH$1 : MISMATCH$1;
-	                }
-
-	                break;
-
-	            // case 'String':
-	            // TODO: strings with length other than 1 char
-
-	            default:
-	                throw new Error('Unknown node type: ' + syntax.type);
-	        }
-	    }
-
-	    totalIterationCount += iterationCount;
-
-	    if (exitReason === EXIT_REASON_MATCH) {
-	        while (syntaxStack !== null) {
-	            closeSyntax();
-	        }
-	    } else {
-	        matchStack = null;
-	    }
-
-	    return {
-	        tokens: tokens,
-	        reason: exitReason,
-	        iterations: iterationCount,
-	        match: matchStack,
-	        longestMatch: longestMatch
-	    };
-	}
-
-	function matchAsList(tokens, matchGraph$$1, syntaxes) {
-	    var matchResult = internalMatch(tokens, matchGraph$$1, syntaxes || {});
-
-	    if (matchResult.match !== null) {
-	        matchResult.match = mapList(matchResult.match, function(item) {
-	            if (item.type === OPEN_SYNTAX || item.type === CLOSE_SYNTAX) {
-	                return { type: item.type, syntax: item.syntax };
-	            }
-
-	            return {
-	                syntax: item.syntax,
-	                token: item.token && item.token.value,
-	                node: item.token && item.token.node
-	            };
-	        }).slice(1);
-	    }
-
-	    return matchResult;
-	}
-
-	function matchAsTree(tokens, matchGraph$$1, syntaxes) {
-	    var matchResult = internalMatch(tokens, matchGraph$$1, syntaxes || {});
-
-	    if (matchResult.match === null) {
-	        return matchResult;
-	    }
-
-	    var cursor = matchResult.match;
-	    var host = matchResult.match = {
-	        syntax: matchGraph$$1.syntax || null,
-	        match: []
-	    };
-	    var stack = [host];
-
-	    // revert a list
-	    var prev = null;
-	    var next = null;
-	    while (cursor !== null) {
-	        next = cursor.prev;
-	        cursor.prev = prev;
-	        prev = cursor;
-	        cursor = next;
-	    }
-
-	    // init the cursor to start with 2nd item since 1st is a stub item
-	    cursor = prev.prev;
-
-	    // build a tree
-	    while (cursor !== null && cursor.syntax !== null) {
-	        var entry = cursor;
-
-	        switch (entry.type) {
-	            case OPEN_SYNTAX:
-	                host.match.push(host = {
-	                    syntax: entry.syntax,
-	                    match: []
-	                });
-	                stack.push(host);
-	                break;
-
-	            case CLOSE_SYNTAX:
-	                stack.pop();
-	                host = stack[stack.length - 1];
-	                break;
-
-	            default:
-	                host.match.push({
-	                    syntax: entry.syntax || null,
-	                    token: entry.token.value,
-	                    node: entry.token.node
-	                });
-	        }
-
-	        cursor = cursor.prev;
-	    }
-
-	    return matchResult;
-	}
-
-	var match = {
-	    matchAsList: matchAsList,
-	    matchAsTree: matchAsTree,
-	    getTotalIterationCount: function() {
-	        return totalIterationCount;
-	    }
-	};
-
-	function getTrace(node) {
-	    function shouldPutToTrace(syntax) {
-	        if (syntax === null) {
-	            return false;
-	        }
-
-	        return (
-	            syntax.type === 'Type' ||
-	            syntax.type === 'Property' ||
-	            syntax.type === 'Keyword'
-	        );
-	    }
-
-	    function hasMatch(matchNode) {
-	        if (Array.isArray(matchNode.match)) {
-	            // use for-loop for better perfomance
-	            for (var i = 0; i < matchNode.match.length; i++) {
-	                if (hasMatch(matchNode.match[i])) {
-	                    if (shouldPutToTrace(matchNode.syntax)) {
-	                        result.unshift(matchNode.syntax);
-	                    }
-
-	                    return true;
-	                }
-	            }
-	        } else if (matchNode.node === node) {
-	            result = shouldPutToTrace(matchNode.syntax)
-	                ? [matchNode.syntax]
-	                : [];
-
-	            return true;
-	        }
-
-	        return false;
-	    }
-
-	    var result = null;
-
-	    if (this.matched !== null) {
-	        hasMatch(this.matched);
-	    }
-
-	    return result;
-	}
-
-	function testNode(match, node, fn) {
-	    var trace = getTrace.call(match, node);
-
-	    if (trace === null) {
-	        return false;
-	    }
-
-	    return trace.some(fn);
-	}
-
-	function isType(node, type) {
-	    return testNode(this, node, function(matchNode) {
-	        return matchNode.type === 'Type' && matchNode.name === type;
-	    });
-	}
-
-	function isProperty(node, property) {
-	    return testNode(this, node, function(matchNode) {
-	        return matchNode.type === 'Property' && matchNode.name === property;
-	    });
-	}
-
-	function isKeyword(node) {
-	    return testNode(this, node, function(matchNode) {
-	        return matchNode.type === 'Keyword';
-	    });
-	}
-
-	var trace = {
-	    getTrace: getTrace,
-	    isType: isType,
-	    isProperty: isProperty,
-	    isKeyword: isKeyword
-	};
-
-	function getFirstMatchNode(matchNode) {
-	    if ('node' in matchNode) {
-	        return matchNode.node;
-	    }
-
-	    return getFirstMatchNode(matchNode.match[0]);
-	}
-
-	function getLastMatchNode(matchNode) {
-	    if ('node' in matchNode) {
-	        return matchNode.node;
-	    }
-
-	    return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);
-	}
-
-	function matchFragments(lexer, ast, match, type, name) {
-	    function findFragments(matchNode) {
-	        if (matchNode.syntax !== null &&
-	            matchNode.syntax.type === type &&
-	            matchNode.syntax.name === name) {
-	            var start = getFirstMatchNode(matchNode);
-	            var end = getLastMatchNode(matchNode);
-
-	            lexer.syntax.walk(ast, function(node, item, list$$1) {
-	                if (node === start) {
-	                    var nodes = new list();
-
-	                    do {
-	                        nodes.appendData(item.data);
-
-	                        if (item.data === end) {
-	                            break;
-	                        }
-
-	                        item = item.next;
-	                    } while (item !== null);
-
-	                    fragments.push({
-	                        parent: list$$1,
-	                        nodes: nodes
-	                    });
-	                }
-	            });
-	        }
-
-	        if (Array.isArray(matchNode.match)) {
-	            matchNode.match.forEach(findFragments);
-	        }
-	    }
-
-	    var fragments = [];
-
-	    if (match.matched !== null) {
-	        findFragments(match.matched);
-	    }
-
-	    return fragments;
-	}
-
-	var search = {
-	    matchFragments: matchFragments
-	};
-
-	var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-
-	function isValidNumber(value) {
-	    // Number.isInteger(value) && value >= 0
-	    return (
-	        typeof value === 'number' &&
-	        isFinite(value) &&
-	        Math.floor(value) === value &&
-	        value >= 0
-	    );
-	}
-
-	function isValidLocation(loc) {
-	    return (
-	        Boolean(loc) &&
-	        isValidNumber(loc.offset) &&
-	        isValidNumber(loc.line) &&
-	        isValidNumber(loc.column)
-	    );
-	}
-
-	function createNodeStructureChecker(type, fields) {
-	    return function checkNode(node, warn) {
-	        if (!node || node.constructor !== Object) {
-	            return warn(node, 'Type of node should be an Object');
-	        }
-
-	        for (var key in node) {
-	            var valid = true;
-
-	            if (hasOwnProperty$2.call(node, key) === false) {
-	                continue;
-	            }
-
-	            if (key === 'type') {
-	                if (node.type !== type) {
-	                    warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');
-	                }
-	            } else if (key === 'loc') {
-	                if (node.loc === null) {
-	                    continue;
-	                } else if (node.loc && node.loc.constructor === Object) {
-	                    if (typeof node.loc.source !== 'string') {
-	                        key += '.source';
-	                    } else if (!isValidLocation(node.loc.start)) {
-	                        key += '.start';
-	                    } else if (!isValidLocation(node.loc.end)) {
-	                        key += '.end';
-	                    } else {
-	                        continue;
-	                    }
-	                }
-
-	                valid = false;
-	            } else if (fields.hasOwnProperty(key)) {
-	                for (var i = 0, valid = false; !valid && i < fields[key].length; i++) {
-	                    var fieldType = fields[key][i];
-
-	                    switch (fieldType) {
-	                        case String:
-	                            valid = typeof node[key] === 'string';
-	                            break;
-
-	                        case Boolean:
-	                            valid = typeof node[key] === 'boolean';
-	                            break;
-
-	                        case null:
-	                            valid = node[key] === null;
-	                            break;
-
-	                        default:
-	                            if (typeof fieldType === 'string') {
-	                                valid = node[key] && node[key].type === fieldType;
-	                            } else if (Array.isArray(fieldType)) {
-	                                valid = node[key] instanceof list;
-	                            }
-	                    }
-	                }
-	            } else {
-	                warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');
-	            }
-
-	            if (!valid) {
-	                warn(node, 'Bad value for `' + type + '.' + key + '`');
-	            }
-	        }
-
-	        for (var key in fields) {
-	            if (hasOwnProperty$2.call(fields, key) &&
-	                hasOwnProperty$2.call(node, key) === false) {
-	                warn(node, 'Field `' + type + '.' + key + '` is missed');
-	            }
-	        }
-	    };
-	}
-
-	function processStructure(name, nodeType) {
-	    var structure = nodeType.structure;
-	    var fields = {
-	        type: String,
-	        loc: true
-	    };
-	    var docs = {
-	        type: '"' + name + '"'
-	    };
-
-	    for (var key in structure) {
-	        if (hasOwnProperty$2.call(structure, key) === false) {
-	            continue;
-	        }
-
-	        var docsTypes = [];
-	        var fieldTypes = fields[key] = Array.isArray(structure[key])
-	            ? structure[key].slice()
-	            : [structure[key]];
-
-	        for (var i = 0; i < fieldTypes.length; i++) {
-	            var fieldType = fieldTypes[i];
-	            if (fieldType === String || fieldType === Boolean) {
-	                docsTypes.push(fieldType.name);
-	            } else if (fieldType === null) {
-	                docsTypes.push('null');
-	            } else if (typeof fieldType === 'string') {
-	                docsTypes.push('<' + fieldType + '>');
-	            } else if (Array.isArray(fieldType)) {
-	                docsTypes.push('List'); // TODO: use type enum
-	            } else {
-	                throw new Error('Wrong value `' + fieldType + '` in `' + name + '.' + key + '` structure definition');
-	            }
-	        }
-
-	        docs[key] = docsTypes.join(' | ');
-	    }
-
-	    return {
-	        docs: docs,
-	        check: createNodeStructureChecker(name, fields)
-	    };
-	}
-
-	var structure = {
-	    getStructureFromConfig: function(config) {
-	        var structure = {};
-
-	        if (config.node) {
-	            for (var name in config.node) {
-	                if (hasOwnProperty$2.call(config.node, name)) {
-	                    var nodeType = config.node[name];
-
-	                    if (nodeType.structure) {
-	                        structure[name] = processStructure(name, nodeType);
-	                    } else {
-	                        throw new Error('Missed `structure` field in `' + name + '` node type definition');
-	                    }
-	                }
-	            }
-	        }
-
-	        return structure;
-	    }
-	};
-
-	var SyntaxReferenceError$1 = error$1.SyntaxReferenceError;
-	var MatchError$1 = error$1.MatchError;
-
-
-
-
-
-
-	var buildMatchGraph$1 = matchGraph.buildMatchGraph;
-	var matchAsTree$1 = match.matchAsTree;
-
-
-	var getStructureFromConfig = structure.getStructureFromConfig;
-	var cssWideKeywords = buildMatchGraph$1(parse_1('inherit | initial | unset'));
-	var cssWideKeywordsWithExpression = buildMatchGraph$1(parse_1('inherit | initial | unset | <expression>'));
-
-	function dumpMapSyntax(map, syntaxAsAst) {
-	    var result = {};
-
-	    for (var name in map) {
-	        if (map[name].syntax) {
-	            result[name] = syntaxAsAst ? map[name].syntax : generate_1(map[name].syntax);
-	        }
-	    }
-
-	    return result;
-	}
-
-	function valueHasVar(value) {
-	    var hasVar = false;
-
-	    this.syntax.walk(value, function(node) {
-	        if (node.type === 'Function' && node.name.toLowerCase() === 'var') {
-	            hasVar = true;
-	        }
-	    });
-
-	    return hasVar;
-	}
-
-	function buildMatchResult(match$$1, error, iterations) {
-	    return {
-	        matched: match$$1,
-	        iterations: iterations,
-	        error: error,
-	        getTrace: trace.getTrace,
-	        isType: trace.isType,
-	        isProperty: trace.isProperty,
-	        isKeyword: trace.isKeyword
-	    };
-	}
-
-	function matchSyntax(lexer, syntax, node, useCommon) {
-	    if (!node) {
-	        return buildMatchResult(null, new Error('Node is undefined'));
-	    }
-
-	    if (valueHasVar.call(lexer, node)) {
-	        return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));
-	    }
-
-	    var tokens = lexer.syntax.generate(node, astToTokens);
-	    var result;
-
-	    if (useCommon) {
-	        result = matchAsTree$1(tokens, lexer.valueCommonSyntax, lexer);
-	    }
-
-	    if (!useCommon || !result.match) {
-	        result = matchAsTree$1(tokens, syntax.match, lexer);
-	        if (!result.match) {
-	            return buildMatchResult(
-	                null,
-	                new MatchError$1(result.reason, lexer, syntax.syntax, node, result),
-	                result.iterations
-	            );
-	        }
-	    }
-
-	    return buildMatchResult(result.match, null, result.iterations);
-	}
-
-	var Lexer = function(config, syntax, structure$$1) {
-	    this.valueCommonSyntax = cssWideKeywords;
-	    this.syntax = syntax;
-	    this.generic = false;
-	    this.properties = {};
-	    this.types = {};
-	    this.structure = structure$$1 || getStructureFromConfig(config);
-
-	    if (config) {
-	        if (config.generic) {
-	            this.generic = true;
-	            for (var name in generic) {
-	                this.addType_(name, generic[name]);
-	            }
-	        }
-
-	        if (config.types) {
-	            for (var name in config.types) {
-	                this.addType_(name, config.types[name]);
-	            }
-	        }
-
-	        if (config.properties) {
-	            for (var name in config.properties) {
-	                this.addProperty_(name, config.properties[name]);
-	            }
-	        }
-	    }
-	};
-
-	Lexer.prototype = {
-	    structure: {},
-	    checkStructure: function(ast) {
-	        function collectWarning(node, message) {
-	            warns.push({
-	                node: node,
-	                message: message
-	            });
-	        }
-
-	        var structure$$1 = this.structure;
-	        var warns = [];
-
-	        this.syntax.walk(ast, function(node) {
-	            if (structure$$1.hasOwnProperty(node.type)) {
-	                structure$$1[node.type].check(node, collectWarning);
-	            } else {
-	                collectWarning(node, 'Unknown node type `' + node.type + '`');
-	            }
-	        });
-
-	        return warns.length ? warns : false;
-	    },
-
-	    createDescriptor: function(syntax, type, name) {
-	        var ref = {
-	            type: type,
-	            name: name
-	        };
-	        var descriptor = {
-	            type: type,
-	            name: name,
-	            syntax: null,
-	            match: null
-	        };
-
-	        if (typeof syntax === 'function') {
-	            descriptor.match = buildMatchGraph$1(syntax, ref);
-	        } else {
-	            if (typeof syntax === 'string') {
-	                // lazy parsing on first access
-	                Object.defineProperty(descriptor, 'syntax', {
-	                    get: function() {
-	                        Object.defineProperty(descriptor, 'syntax', {
-	                            value: parse_1(syntax)
-	                        });
-
-	                        return descriptor.syntax;
-	                    }
-	                });
-	            } else {
-	                descriptor.syntax = syntax;
-	            }
-
-	            Object.defineProperty(descriptor, 'match', {
-	                get: function() {
-	                    Object.defineProperty(descriptor, 'match', {
-	                        value: buildMatchGraph$1(descriptor.syntax, ref)
-	                    });
-
-	                    return descriptor.match;
-	                }
-	            });
-	        }
-
-	        return descriptor;
-	    },
-	    addProperty_: function(name, syntax) {
-	        this.properties[name] = this.createDescriptor(syntax, 'Property', name);
-	    },
-	    addType_: function(name, syntax) {
-	        this.types[name] = this.createDescriptor(syntax, 'Type', name);
-
-	        if (syntax === generic.expression) {
-	            this.valueCommonSyntax = cssWideKeywordsWithExpression;
-	        }
-	    },
-
-	    matchDeclaration: function(node) {
-	        if (node.type !== 'Declaration') {
-	            return buildMatchResult(null, new Error('Not a Declaration node'));
-	        }
-
-	        return this.matchProperty(node.property, node.value);
-	    },
-	    matchProperty: function(propertyName, value) {
-	        var property = names.property(propertyName);
-
-	        // don't match syntax for a custom property
-	        if (property.custom) {
-	            return buildMatchResult(null, new Error('Lexer matching doesn\'t applicable for custom properties'));
-	        }
-
-	        var propertySyntax = property.vendor
-	            ? this.getProperty(property.name) || this.getProperty(property.basename)
-	            : this.getProperty(property.name);
-
-	        if (!propertySyntax) {
-	            return buildMatchResult(null, new SyntaxReferenceError$1('Unknown property', propertyName));
-	        }
-
-	        return matchSyntax(this, propertySyntax, value, true);
-	    },
-	    matchType: function(typeName, value) {
-	        var typeSyntax = this.getType(typeName);
-
-	        if (!typeSyntax) {
-	            return buildMatchResult(null, new SyntaxReferenceError$1('Unknown type', typeName));
-	        }
-
-	        return matchSyntax(this, typeSyntax, value, false);
-	    },
-	    match: function(syntax, value) {
-	        if (!syntax || !syntax.type) {
-	            return buildMatchResult(null, new SyntaxReferenceError$1('Bad syntax'));
-	        }
-
-	        if (!syntax.match) {
-	            syntax = this.createDescriptor(syntax);
-	        }
-
-	        return matchSyntax(this, syntax, value, false);
-	    },
-
-	    findValueFragments: function(propertyName, value, type, name) {
-	        return search.matchFragments(this, value, this.matchProperty(propertyName, value), type, name);
-	    },
-	    findDeclarationValueFragments: function(declaration, type, name) {
-	        return search.matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);
-	    },
-	    findAllFragments: function(ast, type, name) {
-	        var result = [];
-
-	        this.syntax.walk(ast, {
-	            visit: 'Declaration',
-	            enter: function(declaration) {
-	                result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));
-	            }.bind(this)
-	        });
-
-	        return result;
-	    },
-
-	    getProperty: function(name) {
-	        return this.properties.hasOwnProperty(name) ? this.properties[name] : null;
-	    },
-	    getType: function(name) {
-	        return this.types.hasOwnProperty(name) ? this.types[name] : null;
-	    },
-
-	    validate: function() {
-	        function validate(syntax, name, broken, descriptor) {
-	            if (broken.hasOwnProperty(name)) {
-	                return broken[name];
-	            }
-
-	            broken[name] = false;
-	            if (descriptor.syntax !== null) {
-	                walk$1(descriptor.syntax, function(node) {
-	                    if (node.type !== 'Type' && node.type !== 'Property') {
-	                        return;
-	                    }
-
-	                    var map = node.type === 'Type' ? syntax.types : syntax.properties;
-	                    var brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;
-
-	                    if (!map.hasOwnProperty(node.name) || validate(syntax, node.name, brokenMap, map[node.name])) {
-	                        broken[name] = true;
-	                    }
-	                }, this);
-	            }
-	        }
-
-	        var brokenTypes = {};
-	        var brokenProperties = {};
-
-	        for (var key in this.types) {
-	            validate(this, key, brokenTypes, this.types[key]);
-	        }
-
-	        for (var key in this.properties) {
-	            validate(this, key, brokenProperties, this.properties[key]);
-	        }
-
-	        brokenTypes = Object.keys(brokenTypes).filter(function(name) {
-	            return brokenTypes[name];
-	        });
-	        brokenProperties = Object.keys(brokenProperties).filter(function(name) {
-	            return brokenProperties[name];
-	        });
-
-	        if (brokenTypes.length || brokenProperties.length) {
-	            return {
-	                types: brokenTypes,
-	                properties: brokenProperties
-	            };
-	        }
-
-	        return null;
-	    },
-	    dump: function(syntaxAsAst) {
-	        return {
-	            generic: this.generic,
-	            types: dumpMapSyntax(this.types, syntaxAsAst),
-	            properties: dumpMapSyntax(this.properties, syntaxAsAst)
-	        };
-	    },
-	    toString: function() {
-	        return JSON.stringify(this.dump());
-	    }
-	};
-
-	var Lexer_1 = Lexer;
-
-	var grammar = {
-	    SyntaxParseError: error$2.SyntaxParseError,
-	    parse: parse_1,
-	    generate: generate_1,
-	    walk: walk$1
-	};
-
-	var TYPE$3 = tokenizer.TYPE;
-	var WHITESPACE$2 = TYPE$3.WhiteSpace;
-	var COMMENT$2 = TYPE$3.Comment;
-
-	var sequence = function readSequence(recognizer) {
-	    var children = this.createList();
-	    var child = null;
-	    var context = {
-	        recognizer: recognizer,
-	        space: null,
-	        ignoreWS: false,
-	        ignoreWSAfter: false
-	    };
-
-	    this.scanner.skipSC();
-
-	    while (!this.scanner.eof) {
-	        switch (this.scanner.tokenType) {
-	            case COMMENT$2:
-	                this.scanner.next();
-	                continue;
-
-	            case WHITESPACE$2:
-	                if (context.ignoreWS) {
-	                    this.scanner.next();
-	                } else {
-	                    context.space = this.WhiteSpace();
-	                }
-	                continue;
-	        }
-
-	        child = recognizer.getNode.call(this, context);
-
-	        if (child === undefined) {
-	            break;
-	        }
-
-	        if (context.space !== null) {
-	            children.push(context.space);
-	            context.space = null;
-	        }
-
-	        children.push(child);
-
-	        if (context.ignoreWSAfter) {
-	            context.ignoreWSAfter = false;
-	            context.ignoreWS = true;
-	        } else {
-	            context.ignoreWS = false;
-	        }
-	    }
-
-	    return children;
-	};
-
-	var noop$3 = function() {};
-
-	function createParseContext(name) {
-	    return function() {
-	        return this[name]();
-	    };
-	}
-
-	function processConfig(config) {
-	    var parserConfig = {
-	        context: {},
-	        scope: {},
-	        atrule: {},
-	        pseudo: {}
-	    };
-
-	    if (config.parseContext) {
-	        for (var name in config.parseContext) {
-	            switch (typeof config.parseContext[name]) {
-	                case 'function':
-	                    parserConfig.context[name] = config.parseContext[name];
-	                    break;
-
-	                case 'string':
-	                    parserConfig.context[name] = createParseContext(config.parseContext[name]);
-	                    break;
-	            }
-	        }
-	    }
-
-	    if (config.scope) {
-	        for (var name in config.scope) {
-	            parserConfig.scope[name] = config.scope[name];
-	        }
-	    }
-
-	    if (config.atrule) {
-	        for (var name in config.atrule) {
-	            var atrule = config.atrule[name];
-
-	            if (atrule.parse) {
-	                parserConfig.atrule[name] = atrule.parse;
-	            }
-	        }
-	    }
-
-	    if (config.pseudo) {
-	        for (var name in config.pseudo) {
-	            var pseudo = config.pseudo[name];
-
-	            if (pseudo.parse) {
-	                parserConfig.pseudo[name] = pseudo.parse;
-	            }
-	        }
-	    }
-
-	    if (config.node) {
-	        for (var name in config.node) {
-	            parserConfig[name] = config.node[name].parse;
-	        }
-	    }
-
-	    return parserConfig;
-	}
-
-	var create$1 = function createParser(config) {
-	    var parser = {
-	        scanner: new tokenizer(),
-	        filename: '<unknown>',
-	        needPositions: false,
-	        onParseError: noop$3,
-	        onParseErrorThrow: false,
-	        parseAtrulePrelude: true,
-	        parseRulePrelude: true,
-	        parseValue: true,
-	        parseCustomProperty: false,
-
-	        readSequence: sequence,
-
-	        createList: function() {
-	            return new list();
-	        },
-	        createSingleNodeList: function(node) {
-	            return new list().appendData(node);
-	        },
-	        getFirstListNode: function(list$$1) {
-	            return list$$1 && list$$1.first();
-	        },
-	        getLastListNode: function(list$$1) {
-	            return list$$1.last();
-	        },
-
-	        parseWithFallback: function(consumer, fallback) {
-	            var startToken = this.scanner.currentToken;
-
-	            try {
-	                return consumer.call(this);
-	            } catch (e) {
-	                if (this.onParseErrorThrow) {
-	                    throw e;
-	                }
-
-	                var fallbackNode = fallback.call(this, startToken);
-
-	                this.onParseErrorThrow = true;
-	                this.onParseError(e, fallbackNode);
-	                this.onParseErrorThrow = false;
-
-	                return fallbackNode;
-	            }
-	        },
-
-	        getLocation: function(start, end) {
-	            if (this.needPositions) {
-	                return this.scanner.getLocationRange(
-	                    start,
-	                    end,
-	                    this.filename
-	                );
-	            }
-
-	            return null;
-	        },
-	        getLocationFromList: function(list$$1) {
-	            if (this.needPositions) {
-	                var head = this.getFirstListNode(list$$1);
-	                var tail = this.getLastListNode(list$$1);
-	                return this.scanner.getLocationRange(
-	                    head !== null ? head.loc.start.offset - this.scanner.startOffset : this.scanner.tokenStart,
-	                    tail !== null ? tail.loc.end.offset - this.scanner.startOffset : this.scanner.tokenStart,
-	                    this.filename
-	                );
-	            }
-
-	            return null;
-	        }
-	    };
-
-	    config = processConfig(config || {});
-	    for (var key in config) {
-	        parser[key] = config[key];
-	    }
-
-	    return function(source, options) {
-	        options = options || {};
-
-	        var context = options.context || 'default';
-	        var ast;
-
-	        parser.scanner.setSource(source, options.offset, options.line, options.column);
-	        parser.filename = options.filename || '<unknown>';
-	        parser.needPositions = Boolean(options.positions);
-	        parser.onParseError = typeof options.onParseError === 'function' ? options.onParseError : noop$3;
-	        parser.onParseErrorThrow = false;
-	        parser.parseAtrulePrelude = 'parseAtrulePrelude' in options ? Boolean(options.parseAtrulePrelude) : true;
-	        parser.parseRulePrelude = 'parseRulePrelude' in options ? Boolean(options.parseRulePrelude) : true;
-	        parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;
-	        parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;
-
-	        if (!parser.context.hasOwnProperty(context)) {
-	            throw new Error('Unknown context `' + context + '`');
-	        }
-
-	        ast = parser.context[context].call(parser, options);
-
-	        if (!parser.scanner.eof) {
-	            parser.scanner.error();
-	        }
-
-	        return ast;
-	    };
-	};
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-	var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
-
-	/**
-	 * Encode an integer in the range of 0 to 63 to a single base 64 digit.
-	 */
-	var encode = function (number) {
-	  if (0 <= number && number < intToCharMap.length) {
-	    return intToCharMap[number];
-	  }
-	  throw new TypeError("Must be between 0 and 63: " + number);
-	};
-
-	/**
-	 * Decode a single base 64 character code digit to an integer. Returns -1 on
-	 * failure.
-	 */
-	var decode = function (charCode) {
-	  var bigA = 65;     // 'A'
-	  var bigZ = 90;     // 'Z'
-
-	  var littleA = 97;  // 'a'
-	  var littleZ = 122; // 'z'
-
-	  var zero = 48;     // '0'
-	  var nine = 57;     // '9'
-
-	  var plus = 43;     // '+'
-	  var slash = 47;    // '/'
-
-	  var littleOffset = 26;
-	  var numberOffset = 52;
-
-	  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
-	  if (bigA <= charCode && charCode <= bigZ) {
-	    return (charCode - bigA);
-	  }
-
-	  // 26 - 51: abcdefghijklmnopqrstuvwxyz
-	  if (littleA <= charCode && charCode <= littleZ) {
-	    return (charCode - littleA + littleOffset);
-	  }
-
-	  // 52 - 61: 0123456789
-	  if (zero <= charCode && charCode <= nine) {
-	    return (charCode - zero + numberOffset);
-	  }
-
-	  // 62: +
-	  if (charCode == plus) {
-	    return 62;
-	  }
-
-	  // 63: /
-	  if (charCode == slash) {
-	    return 63;
-	  }
-
-	  // Invalid base64 digit.
-	  return -1;
-	};
-
-	var base64 = {
-		encode: encode,
-		decode: decode
-	};
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 *
-	 * Based on the Base 64 VLQ implementation in Closure Compiler:
-	 * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
-	 *
-	 * Copyright 2011 The Closure Compiler Authors. All rights reserved.
-	 * Redistribution and use in source and binary forms, with or without
-	 * modification, are permitted provided that the following conditions are
-	 * met:
-	 *
-	 *  * Redistributions of source code must retain the above copyright
-	 *    notice, this list of conditions and the following disclaimer.
-	 *  * Redistributions in binary form must reproduce the above
-	 *    copyright notice, this list of conditions and the following
-	 *    disclaimer in the documentation and/or other materials provided
-	 *    with the distribution.
-	 *  * Neither the name of Google Inc. nor the names of its
-	 *    contributors may be used to endorse or promote products derived
-	 *    from this software without specific prior written permission.
-	 *
-	 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-	 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-	 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-	 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-	 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-	 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-	 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-	 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-	 */
-
-
-
-	// A single base 64 digit can contain 6 bits of data. For the base 64 variable
-	// length quantities we use in the source map spec, the first bit is the sign,
-	// the next four bits are the actual value, and the 6th bit is the
-	// continuation bit. The continuation bit tells us whether there are more
-	// digits in this value following this digit.
-	//
-	//   Continuation
-	//   |    Sign
-	//   |    |
-	//   V    V
-	//   101011
-
-	var VLQ_BASE_SHIFT = 5;
-
-	// binary: 100000
-	var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
-
-	// binary: 011111
-	var VLQ_BASE_MASK = VLQ_BASE - 1;
-
-	// binary: 100000
-	var VLQ_CONTINUATION_BIT = VLQ_BASE;
-
-	/**
-	 * Converts from a two-complement value to a value where the sign bit is
-	 * placed in the least significant bit.  For example, as decimals:
-	 *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
-	 *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
-	 */
-	function toVLQSigned(aValue) {
-	  return aValue < 0
-	    ? ((-aValue) << 1) + 1
-	    : (aValue << 1) + 0;
-	}
-
-	/**
-	 * Converts to a two-complement value from a value where the sign bit is
-	 * placed in the least significant bit.  For example, as decimals:
-	 *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
-	 *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
-	 */
-	function fromVLQSigned(aValue) {
-	  var isNegative = (aValue & 1) === 1;
-	  var shifted = aValue >> 1;
-	  return isNegative
-	    ? -shifted
-	    : shifted;
-	}
-
-	/**
-	 * Returns the base 64 VLQ encoded value.
-	 */
-	var encode$1 = function base64VLQ_encode(aValue) {
-	  var encoded = "";
-	  var digit;
-
-	  var vlq = toVLQSigned(aValue);
-
-	  do {
-	    digit = vlq & VLQ_BASE_MASK;
-	    vlq >>>= VLQ_BASE_SHIFT;
-	    if (vlq > 0) {
-	      // There are still more digits in this value, so we must make sure the
-	      // continuation bit is marked.
-	      digit |= VLQ_CONTINUATION_BIT;
-	    }
-	    encoded += base64.encode(digit);
-	  } while (vlq > 0);
-
-	  return encoded;
-	};
-
-	/**
-	 * Decodes the next base 64 VLQ value from the given string and returns the
-	 * value and the rest of the string via the out parameter.
-	 */
-	var decode$1 = function base64VLQ_decode(aStr, aIndex, aOutParam) {
-	  var strLen = aStr.length;
-	  var result = 0;
-	  var shift = 0;
-	  var continuation, digit;
-
-	  do {
-	    if (aIndex >= strLen) {
-	      throw new Error("Expected more digits in base 64 VLQ value.");
-	    }
-
-	    digit = base64.decode(aStr.charCodeAt(aIndex++));
-	    if (digit === -1) {
-	      throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
-	    }
-
-	    continuation = !!(digit & VLQ_CONTINUATION_BIT);
-	    digit &= VLQ_BASE_MASK;
-	    result = result + (digit << shift);
-	    shift += VLQ_BASE_SHIFT;
-	  } while (continuation);
-
-	  aOutParam.value = fromVLQSigned(result);
-	  aOutParam.rest = aIndex;
-	};
-
-	var base64Vlq = {
-		encode: encode$1,
-		decode: decode$1
-	};
-
-	var util = createCommonjsModule(function (module, exports) {
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-	/**
-	 * This is a helper function for getting values from parameter/options
-	 * objects.
-	 *
-	 * @param args The object we are extracting values from
-	 * @param name The name of the property we are getting.
-	 * @param defaultValue An optional value to return if the property is missing
-	 * from the object. If this is not specified and the property is missing, an
-	 * error will be thrown.
-	 */
-	function getArg(aArgs, aName, aDefaultValue) {
-	  if (aName in aArgs) {
-	    return aArgs[aName];
-	  } else if (arguments.length === 3) {
-	    return aDefaultValue;
-	  } else {
-	    throw new Error('"' + aName + '" is a required argument.');
-	  }
-	}
-	exports.getArg = getArg;
-
-	var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
-	var dataUrlRegexp = /^data:.+\,.+$/;
-
-	function urlParse(aUrl) {
-	  var match = aUrl.match(urlRegexp);
-	  if (!match) {
-	    return null;
-	  }
-	  return {
-	    scheme: match[1],
-	    auth: match[2],
-	    host: match[3],
-	    port: match[4],
-	    path: match[5]
-	  };
-	}
-	exports.urlParse = urlParse;
-
-	function urlGenerate(aParsedUrl) {
-	  var url = '';
-	  if (aParsedUrl.scheme) {
-	    url += aParsedUrl.scheme + ':';
-	  }
-	  url += '//';
-	  if (aParsedUrl.auth) {
-	    url += aParsedUrl.auth + '@';
-	  }
-	  if (aParsedUrl.host) {
-	    url += aParsedUrl.host;
-	  }
-	  if (aParsedUrl.port) {
-	    url += ":" + aParsedUrl.port;
-	  }
-	  if (aParsedUrl.path) {
-	    url += aParsedUrl.path;
-	  }
-	  return url;
-	}
-	exports.urlGenerate = urlGenerate;
-
-	/**
-	 * Normalizes a path, or the path portion of a URL:
-	 *
-	 * - Replaces consecutive slashes with one slash.
-	 * - Removes unnecessary '.' parts.
-	 * - Removes unnecessary '<dir>/..' parts.
-	 *
-	 * Based on code in the Node.js 'path' core module.
-	 *
-	 * @param aPath The path or url to normalize.
-	 */
-	function normalize(aPath) {
-	  var path = aPath;
-	  var url = urlParse(aPath);
-	  if (url) {
-	    if (!url.path) {
-	      return aPath;
-	    }
-	    path = url.path;
-	  }
-	  var isAbsolute = exports.isAbsolute(path);
-
-	  var parts = path.split(/\/+/);
-	  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
-	    part = parts[i];
-	    if (part === '.') {
-	      parts.splice(i, 1);
-	    } else if (part === '..') {
-	      up++;
-	    } else if (up > 0) {
-	      if (part === '') {
-	        // The first part is blank if the path is absolute. Trying to go
-	        // above the root is a no-op. Therefore we can remove all '..' parts
-	        // directly after the root.
-	        parts.splice(i + 1, up);
-	        up = 0;
-	      } else {
-	        parts.splice(i, 2);
-	        up--;
-	      }
-	    }
-	  }
-	  path = parts.join('/');
-
-	  if (path === '') {
-	    path = isAbsolute ? '/' : '.';
-	  }
-
-	  if (url) {
-	    url.path = path;
-	    return urlGenerate(url);
-	  }
-	  return path;
-	}
-	exports.normalize = normalize;
-
-	/**
-	 * Joins two paths/URLs.
-	 *
-	 * @param aRoot The root path or URL.
-	 * @param aPath The path or URL to be joined with the root.
-	 *
-	 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
-	 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
-	 *   first.
-	 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
-	 *   is updated with the result and aRoot is returned. Otherwise the result
-	 *   is returned.
-	 *   - If aPath is absolute, the result is aPath.
-	 *   - Otherwise the two paths are joined with a slash.
-	 * - Joining for example 'http://' and 'www.example.com' is also supported.
-	 */
-	function join(aRoot, aPath) {
-	  if (aRoot === "") {
-	    aRoot = ".";
-	  }
-	  if (aPath === "") {
-	    aPath = ".";
-	  }
-	  var aPathUrl = urlParse(aPath);
-	  var aRootUrl = urlParse(aRoot);
-	  if (aRootUrl) {
-	    aRoot = aRootUrl.path || '/';
-	  }
-
-	  // `join(foo, '//www.example.org')`
-	  if (aPathUrl && !aPathUrl.scheme) {
-	    if (aRootUrl) {
-	      aPathUrl.scheme = aRootUrl.scheme;
-	    }
-	    return urlGenerate(aPathUrl);
-	  }
-
-	  if (aPathUrl || aPath.match(dataUrlRegexp)) {
-	    return aPath;
-	  }
-
-	  // `join('http://', 'www.example.com')`
-	  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
-	    aRootUrl.host = aPath;
-	    return urlGenerate(aRootUrl);
-	  }
-
-	  var joined = aPath.charAt(0) === '/'
-	    ? aPath
-	    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
-
-	  if (aRootUrl) {
-	    aRootUrl.path = joined;
-	    return urlGenerate(aRootUrl);
-	  }
-	  return joined;
-	}
-	exports.join = join;
-
-	exports.isAbsolute = function (aPath) {
-	  return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);
-	};
-
-	/**
-	 * Make a path relative to a URL or another path.
-	 *
-	 * @param aRoot The root path or URL.
-	 * @param aPath The path or URL to be made relative to aRoot.
-	 */
-	function relative(aRoot, aPath) {
-	  if (aRoot === "") {
-	    aRoot = ".";
-	  }
-
-	  aRoot = aRoot.replace(/\/$/, '');
-
-	  // It is possible for the path to be above the root. In this case, simply
-	  // checking whether the root is a prefix of the path won't work. Instead, we
-	  // need to remove components from the root one by one, until either we find
-	  // a prefix that fits, or we run out of components to remove.
-	  var level = 0;
-	  while (aPath.indexOf(aRoot + '/') !== 0) {
-	    var index = aRoot.lastIndexOf("/");
-	    if (index < 0) {
-	      return aPath;
-	    }
-
-	    // If the only part of the root that is left is the scheme (i.e. http://,
-	    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
-	    // have exhausted all components, so the path is not relative to the root.
-	    aRoot = aRoot.slice(0, index);
-	    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
-	      return aPath;
-	    }
-
-	    ++level;
-	  }
-
-	  // Make sure we add a "../" for each component we removed from the root.
-	  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
-	}
-	exports.relative = relative;
-
-	var supportsNullProto = (function () {
-	  var obj = Object.create(null);
-	  return !('__proto__' in obj);
-	}());
-
-	function identity (s) {
-	  return s;
-	}
-
-	/**
-	 * Because behavior goes wacky when you set `__proto__` on objects, we
-	 * have to prefix all the strings in our set with an arbitrary character.
-	 *
-	 * See https://github.com/mozilla/source-map/pull/31 and
-	 * https://github.com/mozilla/source-map/issues/30
-	 *
-	 * @param String aStr
-	 */
-	function toSetString(aStr) {
-	  if (isProtoString(aStr)) {
-	    return '$' + aStr;
-	  }
-
-	  return aStr;
-	}
-	exports.toSetString = supportsNullProto ? identity : toSetString;
-
-	function fromSetString(aStr) {
-	  if (isProtoString(aStr)) {
-	    return aStr.slice(1);
-	  }
-
-	  return aStr;
-	}
-	exports.fromSetString = supportsNullProto ? identity : fromSetString;
-
-	function isProtoString(s) {
-	  if (!s) {
-	    return false;
-	  }
-
-	  var length = s.length;
-
-	  if (length < 9 /* "__proto__".length */) {
-	    return false;
-	  }
-
-	  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
-	      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
-	      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
-	      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
-	      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
-	      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
-	      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
-	      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
-	      s.charCodeAt(length - 9) !== 95  /* '_' */) {
-	    return false;
-	  }
-
-	  for (var i = length - 10; i >= 0; i--) {
-	    if (s.charCodeAt(i) !== 36 /* '$' */) {
-	      return false;
-	    }
-	  }
-
-	  return true;
-	}
-
-	/**
-	 * Comparator between two mappings where the original positions are compared.
-	 *
-	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
-	 * mappings with the same original source/line/column, but different generated
-	 * line and column the same. Useful when searching for a mapping with a
-	 * stubbed out mapping.
-	 */
-	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
-	  var cmp = mappingA.source - mappingB.source;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.originalLine - mappingB.originalLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.originalColumn - mappingB.originalColumn;
-	  if (cmp !== 0 || onlyCompareOriginal) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.generatedLine - mappingB.generatedLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  return mappingA.name - mappingB.name;
-	}
-	exports.compareByOriginalPositions = compareByOriginalPositions;
-
-	/**
-	 * Comparator between two mappings with deflated source and name indices where
-	 * the generated positions are compared.
-	 *
-	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
-	 * mappings with the same generated line and column, but different
-	 * source/name/original line and column the same. Useful when searching for a
-	 * mapping with a stubbed out mapping.
-	 */
-	function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
-	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-	  if (cmp !== 0 || onlyCompareGenerated) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.source - mappingB.source;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.originalLine - mappingB.originalLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.originalColumn - mappingB.originalColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  return mappingA.name - mappingB.name;
-	}
-	exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
-
-	function strcmp(aStr1, aStr2) {
-	  if (aStr1 === aStr2) {
-	    return 0;
-	  }
-
-	  if (aStr1 > aStr2) {
-	    return 1;
-	  }
-
-	  return -1;
-	}
-
-	/**
-	 * Comparator between two mappings with inflated source and name strings where
-	 * the generated positions are compared.
-	 */
-	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
-	  var cmp = mappingA.generatedLine - mappingB.generatedLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = strcmp(mappingA.source, mappingB.source);
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.originalLine - mappingB.originalLine;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  cmp = mappingA.originalColumn - mappingB.originalColumn;
-	  if (cmp !== 0) {
-	    return cmp;
-	  }
-
-	  return strcmp(mappingA.name, mappingB.name);
-	}
-	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
-	});
-	var util_1 = util.getArg;
-	var util_2 = util.urlParse;
-	var util_3 = util.urlGenerate;
-	var util_4 = util.normalize;
-	var util_5 = util.join;
-	var util_6 = util.isAbsolute;
-	var util_7 = util.relative;
-	var util_8 = util.toSetString;
-	var util_9 = util.fromSetString;
-	var util_10 = util.compareByOriginalPositions;
-	var util_11 = util.compareByGeneratedPositionsDeflated;
-	var util_12 = util.compareByGeneratedPositionsInflated;
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-
-	var has = Object.prototype.hasOwnProperty;
-	var hasNativeMap = typeof Map !== "undefined";
-
-	/**
-	 * A data structure which is a combination of an array and a set. Adding a new
-	 * member is O(1), testing for membership is O(1), and finding the index of an
-	 * element is O(1). Removing elements from the set is not supported. Only
-	 * strings are supported for membership.
-	 */
-	function ArraySet() {
-	  this._array = [];
-	  this._set = hasNativeMap ? new Map() : Object.create(null);
-	}
-
-	/**
-	 * Static method for creating ArraySet instances from an existing array.
-	 */
-	ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
-	  var set = new ArraySet();
-	  for (var i = 0, len = aArray.length; i < len; i++) {
-	    set.add(aArray[i], aAllowDuplicates);
-	  }
-	  return set;
-	};
-
-	/**
-	 * Return how many unique items are in this ArraySet. If duplicates have been
-	 * added, than those do not count towards the size.
-	 *
-	 * @returns Number
-	 */
-	ArraySet.prototype.size = function ArraySet_size() {
-	  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
-	};
-
-	/**
-	 * Add the given string to this set.
-	 *
-	 * @param String aStr
-	 */
-	ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
-	  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
-	  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
-	  var idx = this._array.length;
-	  if (!isDuplicate || aAllowDuplicates) {
-	    this._array.push(aStr);
-	  }
-	  if (!isDuplicate) {
-	    if (hasNativeMap) {
-	      this._set.set(aStr, idx);
-	    } else {
-	      this._set[sStr] = idx;
-	    }
-	  }
-	};
-
-	/**
-	 * Is the given string a member of this set?
-	 *
-	 * @param String aStr
-	 */
-	ArraySet.prototype.has = function ArraySet_has(aStr) {
-	  if (hasNativeMap) {
-	    return this._set.has(aStr);
-	  } else {
-	    var sStr = util.toSetString(aStr);
-	    return has.call(this._set, sStr);
-	  }
-	};
-
-	/**
-	 * What is the index of the given string in the array?
-	 *
-	 * @param String aStr
-	 */
-	ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
-	  if (hasNativeMap) {
-	    var idx = this._set.get(aStr);
-	    if (idx >= 0) {
-	        return idx;
-	    }
-	  } else {
-	    var sStr = util.toSetString(aStr);
-	    if (has.call(this._set, sStr)) {
-	      return this._set[sStr];
-	    }
-	  }
-
-	  throw new Error('"' + aStr + '" is not in the set.');
-	};
-
-	/**
-	 * What is the element at the given index?
-	 *
-	 * @param Number aIdx
-	 */
-	ArraySet.prototype.at = function ArraySet_at(aIdx) {
-	  if (aIdx >= 0 && aIdx < this._array.length) {
-	    return this._array[aIdx];
-	  }
-	  throw new Error('No element indexed by ' + aIdx);
-	};
-
-	/**
-	 * Returns the array representation of this set (which has the proper indices
-	 * indicated by indexOf). Note that this is a copy of the internal array used
-	 * for storing the members so that no one can mess with internal state.
-	 */
-	ArraySet.prototype.toArray = function ArraySet_toArray() {
-	  return this._array.slice();
-	};
-
-	var ArraySet_1 = ArraySet;
-
-	var arraySet = {
-		ArraySet: ArraySet_1
-	};
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2014 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-
-
-	/**
-	 * Determine whether mappingB is after mappingA with respect to generated
-	 * position.
-	 */
-	function generatedPositionAfter(mappingA, mappingB) {
-	  // Optimized for most common case
-	  var lineA = mappingA.generatedLine;
-	  var lineB = mappingB.generatedLine;
-	  var columnA = mappingA.generatedColumn;
-	  var columnB = mappingB.generatedColumn;
-	  return lineB > lineA || lineB == lineA && columnB >= columnA ||
-	         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
-	}
-
-	/**
-	 * A data structure to provide a sorted view of accumulated mappings in a
-	 * performance conscious manner. It trades a neglibable overhead in general
-	 * case for a large speedup in case of mappings being added in order.
-	 */
-	function MappingList() {
-	  this._array = [];
-	  this._sorted = true;
-	  // Serves as infimum
-	  this._last = {generatedLine: -1, generatedColumn: 0};
-	}
-
-	/**
-	 * Iterate through internal items. This method takes the same arguments that
-	 * `Array.prototype.forEach` takes.
-	 *
-	 * NOTE: The order of the mappings is NOT guaranteed.
-	 */
-	MappingList.prototype.unsortedForEach =
-	  function MappingList_forEach(aCallback, aThisArg) {
-	    this._array.forEach(aCallback, aThisArg);
-	  };
-
-	/**
-	 * Add the given source mapping.
-	 *
-	 * @param Object aMapping
-	 */
-	MappingList.prototype.add = function MappingList_add(aMapping) {
-	  if (generatedPositionAfter(this._last, aMapping)) {
-	    this._last = aMapping;
-	    this._array.push(aMapping);
-	  } else {
-	    this._sorted = false;
-	    this._array.push(aMapping);
-	  }
-	};
-
-	/**
-	 * Returns the flat, sorted array of mappings. The mappings are sorted by
-	 * generated position.
-	 *
-	 * WARNING: This method returns internal data without copying, for
-	 * performance. The return value must NOT be mutated, and should be treated as
-	 * an immutable borrow. If you want to take ownership, you must make your own
-	 * copy.
-	 */
-	MappingList.prototype.toArray = function MappingList_toArray() {
-	  if (!this._sorted) {
-	    this._array.sort(util.compareByGeneratedPositionsInflated);
-	    this._sorted = true;
-	  }
-	  return this._array;
-	};
-
-	var MappingList_1 = MappingList;
-
-	var mappingList = {
-		MappingList: MappingList_1
-	};
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-
-
-	var ArraySet$1 = arraySet.ArraySet;
-	var MappingList$1 = mappingList.MappingList;
-
-	/**
-	 * An instance of the SourceMapGenerator represents a source map which is
-	 * being built incrementally. You may pass an object with the following
-	 * properties:
-	 *
-	 *   - file: The filename of the generated source.
-	 *   - sourceRoot: A root for all relative URLs in this source map.
-	 */
-	function SourceMapGenerator(aArgs) {
-	  if (!aArgs) {
-	    aArgs = {};
-	  }
-	  this._file = util.getArg(aArgs, 'file', null);
-	  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
-	  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
-	  this._sources = new ArraySet$1();
-	  this._names = new ArraySet$1();
-	  this._mappings = new MappingList$1();
-	  this._sourcesContents = null;
-	}
-
-	SourceMapGenerator.prototype._version = 3;
-
-	/**
-	 * Creates a new SourceMapGenerator based on a SourceMapConsumer
-	 *
-	 * @param aSourceMapConsumer The SourceMap.
-	 */
-	SourceMapGenerator.fromSourceMap =
-	  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
-	    var sourceRoot = aSourceMapConsumer.sourceRoot;
-	    var generator = new SourceMapGenerator({
-	      file: aSourceMapConsumer.file,
-	      sourceRoot: sourceRoot
-	    });
-	    aSourceMapConsumer.eachMapping(function (mapping) {
-	      var newMapping = {
-	        generated: {
-	          line: mapping.generatedLine,
-	          column: mapping.generatedColumn
-	        }
-	      };
-
-	      if (mapping.source != null) {
-	        newMapping.source = mapping.source;
-	        if (sourceRoot != null) {
-	          newMapping.source = util.relative(sourceRoot, newMapping.source);
-	        }
-
-	        newMapping.original = {
-	          line: mapping.originalLine,
-	          column: mapping.originalColumn
-	        };
-
-	        if (mapping.name != null) {
-	          newMapping.name = mapping.name;
-	        }
-	      }
-
-	      generator.addMapping(newMapping);
-	    });
-	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
-	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
-	      if (content != null) {
-	        generator.setSourceContent(sourceFile, content);
-	      }
-	    });
-	    return generator;
-	  };
-
-	/**
-	 * Add a single mapping from original source line and column to the generated
-	 * source's line and column for this source map being created. The mapping
-	 * object should have the following properties:
-	 *
-	 *   - generated: An object with the generated line and column positions.
-	 *   - original: An object with the original line and column positions.
-	 *   - source: The original source file (relative to the sourceRoot).
-	 *   - name: An optional original token name for this mapping.
-	 */
-	SourceMapGenerator.prototype.addMapping =
-	  function SourceMapGenerator_addMapping(aArgs) {
-	    var generated = util.getArg(aArgs, 'generated');
-	    var original = util.getArg(aArgs, 'original', null);
-	    var source = util.getArg(aArgs, 'source', null);
-	    var name = util.getArg(aArgs, 'name', null);
-
-	    if (!this._skipValidation) {
-	      this._validateMapping(generated, original, source, name);
-	    }
-
-	    if (source != null) {
-	      source = String(source);
-	      if (!this._sources.has(source)) {
-	        this._sources.add(source);
-	      }
-	    }
-
-	    if (name != null) {
-	      name = String(name);
-	      if (!this._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
-	    });
-	  };
-
-	/**
-	 * Set the source content for a source file.
-	 */
-	SourceMapGenerator.prototype.setSourceContent =
-	  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
-	    var source = aSourceFile;
-	    if (this._sourceRoot != null) {
-	      source = util.relative(this._sourceRoot, source);
-	    }
-
-	    if (aSourceContent != null) {
-	      // Add the source content to the _sourcesContents map.
-	      // Create a new _sourcesContents map if the property is null.
-	      if (!this._sourcesContents) {
-	        this._sourcesContents = Object.create(null);
-	      }
-	      this._sourcesContents[util.toSetString(source)] = aSourceContent;
-	    } else if (this._sourcesContents) {
-	      // Remove the source file from the _sourcesContents map.
-	      // If the _sourcesContents map is empty, set the property to null.
-	      delete this._sourcesContents[util.toSetString(source)];
-	      if (Object.keys(this._sourcesContents).length === 0) {
-	        this._sourcesContents = null;
-	      }
-	    }
-	  };
-
-	/**
-	 * Applies the mappings of a sub-source-map for a specific source file to the
-	 * source map being generated. Each mapping to the supplied source file is
-	 * rewritten using the supplied source map. Note: The resolution for the
-	 * resulting mappings is the minimium of this map and the supplied map.
-	 *
-	 * @param aSourceMapConsumer The source map to be applied.
-	 * @param aSourceFile Optional. The filename of the source file.
-	 *        If omitted, SourceMapConsumer's file property will be used.
-	 * @param aSourceMapPath Optional. The dirname of the path to the source map
-	 *        to be applied. If relative, it is relative to the SourceMapConsumer.
-	 *        This parameter is needed when the two source maps aren't in the same
-	 *        directory, and the source map to be applied contains relative source
-	 *        paths. If so, those relative source paths need to be rewritten
-	 *        relative to the SourceMapGenerator.
-	 */
-	SourceMapGenerator.prototype.applySourceMap =
-	  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
-	    var sourceFile = aSourceFile;
-	    // If aSourceFile is omitted, we will use the file property of the SourceMap
-	    if (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.'
-	        );
-	      }
-	      sourceFile = aSourceMapConsumer.file;
-	    }
-	    var sourceRoot = this._sourceRoot;
-	    // Make "sourceFile" relative if an absolute Url is passed.
-	    if (sourceRoot != null) {
-	      sourceFile = util.relative(sourceRoot, sourceFile);
-	    }
-	    // Applying the SourceMap can add and remove items from the sources and
-	    // the names array.
-	    var newSources = new ArraySet$1();
-	    var newNames = new ArraySet$1();
-
-	    // Find mappings for the "sourceFile"
-	    this._mappings.unsortedForEach(function (mapping) {
-	      if (mapping.source === sourceFile && mapping.originalLine != null) {
-	        // Check if it can be mapped by the source map, then update the mapping.
-	        var original = aSourceMapConsumer.originalPositionFor({
-	          line: mapping.originalLine,
-	          column: mapping.originalColumn
-	        });
-	        if (original.source != null) {
-	          // Copy mapping
-	          mapping.source = original.source;
-	          if (aSourceMapPath != null) {
-	            mapping.source = util.join(aSourceMapPath, mapping.source);
-	          }
-	          if (sourceRoot != null) {
-	            mapping.source = util.relative(sourceRoot, mapping.source);
-	          }
-	          mapping.originalLine = original.line;
-	          mapping.originalColumn = original.column;
-	          if (original.name != null) {
-	            mapping.name = original.name;
-	          }
-	        }
-	      }
-
-	      var source = mapping.source;
-	      if (source != null && !newSources.has(source)) {
-	        newSources.add(source);
-	      }
-
-	      var name = mapping.name;
-	      if (name != null && !newNames.has(name)) {
-	        newNames.add(name);
-	      }
-
-	    }, this);
-	    this._sources = newSources;
-	    this._names = newNames;
-
-	    // Copy sourcesContents of applied map.
-	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
-	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
-	      if (content != null) {
-	        if (aSourceMapPath != null) {
-	          sourceFile = util.join(aSourceMapPath, sourceFile);
-	        }
-	        if (sourceRoot != null) {
-	          sourceFile = util.relative(sourceRoot, sourceFile);
-	        }
-	        this.setSourceContent(sourceFile, content);
-	      }
-	    }, this);
-	  };
-
-	/**
-	 * A mapping can have one of the three levels of data:
-	 *
-	 *   1. Just the generated position.
-	 *   2. The Generated position, original position, and original source.
-	 *   3. Generated and original position, original source, as well as a name
-	 *      token.
-	 *
-	 * To maintain consistency, we validate that any new mapping being added falls
-	 * in to one of these categories.
-	 */
-	SourceMapGenerator.prototype._validateMapping =
-	  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
-	                                              aName) {
-	    // When aOriginal is truthy but has empty values for .line and .column,
-	    // it is most likely a programmer error. In this case we throw a very
-	    // specific error message to try to guide them the right way.
-	    // For example: https://github.com/Polymer/polymer-bundler/pull/519
-	    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
-	        throw new Error(
-	            '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.'
-	        );
-	    }
-
-	    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
-	        && aGenerated.line > 0 && aGenerated.column >= 0
-	        && !aOriginal && !aSource && !aName) {
-	      // Case 1.
-	      return;
-	    }
-	    else if (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) {
-	      // Cases 2 and 3.
-	      return;
-	    }
-	    else {
-	      throw new Error('Invalid mapping: ' + JSON.stringify({
-	        generated: aGenerated,
-	        source: aSource,
-	        original: aOriginal,
-	        name: aName
-	      }));
-	    }
-	  };
-
-	/**
-	 * Serialize the accumulated mappings in to the stream of base 64 VLQs
-	 * specified by the source map format.
-	 */
-	SourceMapGenerator.prototype._serializeMappings =
-	  function SourceMapGenerator_serializeMappings() {
-	    var previousGeneratedColumn = 0;
-	    var previousGeneratedLine = 1;
-	    var previousOriginalColumn = 0;
-	    var previousOriginalLine = 0;
-	    var previousName = 0;
-	    var previousSource = 0;
-	    var result = '';
-	    var next;
-	    var mapping;
-	    var nameIdx;
-	    var sourceIdx;
-
-	    var mappings = this._mappings.toArray();
-	    for (var i = 0, len = mappings.length; i < len; i++) {
-	      mapping = mappings[i];
-	      next = '';
-
-	      if (mapping.generatedLine !== previousGeneratedLine) {
-	        previousGeneratedColumn = 0;
-	        while (mapping.generatedLine !== previousGeneratedLine) {
-	          next += ';';
-	          previousGeneratedLine++;
-	        }
-	      }
-	      else {
-	        if (i > 0) {
-	          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
-	            continue;
-	          }
-	          next += ',';
-	        }
-	      }
-
-	      next += base64Vlq.encode(mapping.generatedColumn
-	                                 - previousGeneratedColumn);
-	      previousGeneratedColumn = mapping.generatedColumn;
-
-	      if (mapping.source != null) {
-	        sourceIdx = this._sources.indexOf(mapping.source);
-	        next += base64Vlq.encode(sourceIdx - previousSource);
-	        previousSource = sourceIdx;
-
-	        // lines are stored 0-based in SourceMap spec version 3
-	        next += base64Vlq.encode(mapping.originalLine - 1
-	                                   - previousOriginalLine);
-	        previousOriginalLine = mapping.originalLine - 1;
-
-	        next += base64Vlq.encode(mapping.originalColumn
-	                                   - previousOriginalColumn);
-	        previousOriginalColumn = mapping.originalColumn;
-
-	        if (mapping.name != null) {
-	          nameIdx = this._names.indexOf(mapping.name);
-	          next += base64Vlq.encode(nameIdx - previousName);
-	          previousName = nameIdx;
-	        }
-	      }
-
-	      result += next;
-	    }
-
-	    return result;
-	  };
-
-	SourceMapGenerator.prototype._generateSourcesContent =
-	  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
-	    return aSources.map(function (source) {
-	      if (!this._sourcesContents) {
-	        return null;
-	      }
-	      if (aSourceRoot != null) {
-	        source = util.relative(aSourceRoot, source);
-	      }
-	      var key = util.toSetString(source);
-	      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
-	        ? this._sourcesContents[key]
-	        : null;
-	    }, this);
-	  };
-
-	/**
-	 * Externalize the source map.
-	 */
-	SourceMapGenerator.prototype.toJSON =
-	  function SourceMapGenerator_toJSON() {
-	    var map = {
-	      version: this._version,
-	      sources: this._sources.toArray(),
-	      names: this._names.toArray(),
-	      mappings: this._serializeMappings()
-	    };
-	    if (this._file != null) {
-	      map.file = this._file;
-	    }
-	    if (this._sourceRoot != null) {
-	      map.sourceRoot = this._sourceRoot;
-	    }
-	    if (this._sourcesContents) {
-	      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
-	    }
-
-	    return map;
-	  };
-
-	/**
-	 * Render the source map being generated to a string.
-	 */
-	SourceMapGenerator.prototype.toString =
-	  function SourceMapGenerator_toString() {
-	    return JSON.stringify(this.toJSON());
-	  };
-
-	var SourceMapGenerator_1 = SourceMapGenerator;
-
-	var sourceMapGenerator = {
-		SourceMapGenerator: SourceMapGenerator_1
-	};
-
-	var binarySearch = createCommonjsModule(function (module, exports) {
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-	exports.GREATEST_LOWER_BOUND = 1;
-	exports.LEAST_UPPER_BOUND = 2;
-
-	/**
-	 * Recursive implementation of binary search.
-	 *
-	 * @param aLow Indices here and lower do not contain the needle.
-	 * @param aHigh Indices here and higher do not contain the needle.
-	 * @param aNeedle The element being searched for.
-	 * @param aHaystack The non-empty array being searched.
-	 * @param aCompare Function which takes two elements and returns -1, 0, or 1.
-	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
-	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
-	 *     closest element that is smaller than or greater than the one we are
-	 *     searching for, respectively, if the exact element cannot be found.
-	 */
-	function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
-	  // This function terminates when one of the following is true:
-	  //
-	  //   1. We find the exact element we are looking for.
-	  //
-	  //   2. We did not find the exact element, but we can return the index of
-	  //      the next-closest element.
-	  //
-	  //   3. We did not find the exact element, and there is no next-closest
-	  //      element than the one we are searching for, so we return -1.
-	  var mid = Math.floor((aHigh - aLow) / 2) + aLow;
-	  var cmp = aCompare(aNeedle, aHaystack[mid], true);
-	  if (cmp === 0) {
-	    // Found the element we are looking for.
-	    return mid;
-	  }
-	  else if (cmp > 0) {
-	    // Our needle is greater than aHaystack[mid].
-	    if (aHigh - mid > 1) {
-	      // The element is in the upper half.
-	      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
-	    }
-
-	    // The exact needle element was not found in this haystack. Determine if
-	    // we are in termination case (3) or (2) and return the appropriate thing.
-	    if (aBias == exports.LEAST_UPPER_BOUND) {
-	      return aHigh < aHaystack.length ? aHigh : -1;
-	    } else {
-	      return mid;
-	    }
-	  }
-	  else {
-	    // Our needle is less than aHaystack[mid].
-	    if (mid - aLow > 1) {
-	      // The element is in the lower half.
-	      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
-	    }
-
-	    // we are in termination case (3) or (2) and return the appropriate thing.
-	    if (aBias == exports.LEAST_UPPER_BOUND) {
-	      return mid;
-	    } else {
-	      return aLow < 0 ? -1 : aLow;
-	    }
-	  }
-	}
-
-	/**
-	 * This is an implementation of binary search which will always try and return
-	 * the index of the closest element if there is no exact hit. This is because
-	 * mappings between original and generated line/col pairs are single points,
-	 * and there is an implicit region between each of them, so a miss just means
-	 * that you aren't on the very start of a region.
-	 *
-	 * @param aNeedle The element you are looking for.
-	 * @param aHaystack The array that is being searched.
-	 * @param aCompare A function which takes the needle and an element in the
-	 *     array and returns -1, 0, or 1 depending on whether the needle is less
-	 *     than, equal to, or greater than the element, respectively.
-	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
-	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
-	 *     closest element that is smaller than or greater than the one we are
-	 *     searching for, respectively, if the exact element cannot be found.
-	 *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
-	 */
-	exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
-	  if (aHaystack.length === 0) {
-	    return -1;
-	  }
-
-	  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
-	                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
-	  if (index < 0) {
-	    return -1;
-	  }
-
-	  // We have found either the exact element, or the next-closest element than
-	  // the one we are searching for. However, there may be more than one such
-	  // element. Make sure we always return the smallest of these.
-	  while (index - 1 >= 0) {
-	    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
-	      break;
-	    }
-	    --index;
-	  }
-
-	  return index;
-	};
-	});
-	var binarySearch_1 = binarySearch.GREATEST_LOWER_BOUND;
-	var binarySearch_2 = binarySearch.LEAST_UPPER_BOUND;
-	var binarySearch_3 = binarySearch.search;
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-	// It turns out that some (most?) JavaScript engines don't self-host
-	// `Array.prototype.sort`. This makes sense because C++ will likely remain
-	// faster than JS when doing raw CPU-intensive sorting. However, when using a
-	// custom comparator function, calling back and forth between the VM's C++ and
-	// JIT'd JS is rather slow *and* loses JIT type information, resulting in
-	// worse generated code for the comparator function than would be optimal. In
-	// fact, when sorting with a comparator, these costs outweigh the benefits of
-	// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
-	// a ~3500ms mean speed-up in `bench/bench.html`.
-
-	/**
-	 * Swap the elements indexed by `x` and `y` in the array `ary`.
-	 *
-	 * @param {Array} ary
-	 *        The array.
-	 * @param {Number} x
-	 *        The index of the first item.
-	 * @param {Number} y
-	 *        The index of the second item.
-	 */
-	function swap(ary, x, y) {
-	  var temp = ary[x];
-	  ary[x] = ary[y];
-	  ary[y] = temp;
-	}
-
-	/**
-	 * Returns a random integer within the range `low .. high` inclusive.
-	 *
-	 * @param {Number} low
-	 *        The lower bound on the range.
-	 * @param {Number} high
-	 *        The upper bound on the range.
-	 */
-	function randomIntInRange(low, high) {
-	  return Math.round(low + (Math.random() * (high - low)));
-	}
-
-	/**
-	 * The Quick Sort algorithm.
-	 *
-	 * @param {Array} ary
-	 *        An array to sort.
-	 * @param {function} comparator
-	 *        Function to use to compare two items.
-	 * @param {Number} p
-	 *        Start index of the array
-	 * @param {Number} r
-	 *        End index of the array
-	 */
-	function doQuickSort(ary, comparator, p, r) {
-	  // If our lower bound is less than our upper bound, we (1) partition the
-	  // array into two pieces and (2) recurse on each half. If it is not, this is
-	  // the empty array and our base case.
-
-	  if (p < r) {
-	    // (1) Partitioning.
-	    //
-	    // The partitioning chooses a pivot between `p` and `r` and moves all
-	    // elements that are less than or equal to the pivot to the before it, and
-	    // all the elements that are greater than it after it. The effect is that
-	    // once partition is done, the pivot is in the exact place it will be when
-	    // the array is put in sorted order, and it will not need to be moved
-	    // again. This runs in O(n) time.
-
-	    // Always choose a random pivot so that an input array which is reverse
-	    // sorted does not cause O(n^2) running time.
-	    var pivotIndex = randomIntInRange(p, r);
-	    var i = p - 1;
-
-	    swap(ary, pivotIndex, r);
-	    var pivot = ary[r];
-
-	    // Immediately after `j` is incremented in this loop, the following hold
-	    // true:
-	    //
-	    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
-	    //
-	    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
-	    for (var j = p; j < r; j++) {
-	      if (comparator(ary[j], pivot) <= 0) {
-	        i += 1;
-	        swap(ary, i, j);
-	      }
-	    }
-
-	    swap(ary, i + 1, j);
-	    var q = i + 1;
-
-	    // (2) Recurse on each half.
-
-	    doQuickSort(ary, comparator, p, q - 1);
-	    doQuickSort(ary, comparator, q + 1, r);
-	  }
-	}
-
-	/**
-	 * Sort the given array in-place with the given comparator function.
-	 *
-	 * @param {Array} ary
-	 *        An array to sort.
-	 * @param {function} comparator
-	 *        Function to use to compare two items.
-	 */
-	var quickSort_1 = function (ary, comparator) {
-	  doQuickSort(ary, comparator, 0, ary.length - 1);
-	};
-
-	var quickSort = {
-		quickSort: quickSort_1
-	};
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-
-
-	var ArraySet$2 = arraySet.ArraySet;
-
-	var quickSort$1 = quickSort.quickSort;
-
-	function SourceMapConsumer(aSourceMap) {
-	  var sourceMap = aSourceMap;
-	  if (typeof aSourceMap === 'string') {
-	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
-	  }
-
-	  return sourceMap.sections != null
-	    ? new IndexedSourceMapConsumer(sourceMap)
-	    : new BasicSourceMapConsumer(sourceMap);
-	}
-
-	SourceMapConsumer.fromSourceMap = function(aSourceMap) {
-	  return BasicSourceMapConsumer.fromSourceMap(aSourceMap);
-	};
-
-	/**
-	 * The version of the source mapping spec that we are consuming.
-	 */
-	SourceMapConsumer.prototype._version = 3;
-
-	// `__generatedMappings` and `__originalMappings` are arrays that hold the
-	// parsed mapping coordinates from the source map's "mappings" attribute. They
-	// are lazily instantiated, accessed via the `_generatedMappings` and
-	// `_originalMappings` getters respectively, and we only parse the mappings
-	// and create these arrays once queried for a source location. We jump through
-	// these hoops because there can be many thousands of mappings, and parsing
-	// them is expensive, so we only want to do it if we must.
-	//
-	// Each object in the arrays is of the form:
-	//
-	//     {
-	//       generatedLine: The line number in the generated code,
-	//       generatedColumn: The column number in the generated code,
-	//       source: The path to the original source file that generated this
-	//               chunk of code,
-	//       originalLine: The line number in the original source that
-	//                     corresponds to this chunk of generated code,
-	//       originalColumn: The column number in the original source that
-	//                       corresponds to this chunk of generated code,
-	//       name: The name of the original symbol which generated this chunk of
-	//             code.
-	//     }
-	//
-	// All properties except for `generatedLine` and `generatedColumn` can be
-	// `null`.
-	//
-	// `_generatedMappings` is ordered by the generated positions.
-	//
-	// `_originalMappings` is ordered by the original positions.
-
-	SourceMapConsumer.prototype.__generatedMappings = null;
-	Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
-	  get: function () {
-	    if (!this.__generatedMappings) {
-	      this._parseMappings(this._mappings, this.sourceRoot);
-	    }
-
-	    return this.__generatedMappings;
-	  }
-	});
-
-	SourceMapConsumer.prototype.__originalMappings = null;
-	Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
-	  get: function () {
-	    if (!this.__originalMappings) {
-	      this._parseMappings(this._mappings, this.sourceRoot);
-	    }
-
-	    return this.__originalMappings;
-	  }
-	});
-
-	SourceMapConsumer.prototype._charIsMappingSeparator =
-	  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
-	    var c = aStr.charAt(index);
-	    return c === ";" || c === ",";
-	  };
-
-	/**
-	 * Parse the mappings in a string in to a data structure which we can easily
-	 * query (the ordered arrays in the `this.__generatedMappings` and
-	 * `this.__originalMappings` properties).
-	 */
-	SourceMapConsumer.prototype._parseMappings =
-	  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
-	    throw new Error("Subclasses must implement _parseMappings");
-	  };
-
-	SourceMapConsumer.GENERATED_ORDER = 1;
-	SourceMapConsumer.ORIGINAL_ORDER = 2;
-
-	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
-	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
-
-	/**
-	 * Iterate over each mapping between an original source/line/column and a
-	 * generated line/column in this source map.
-	 *
-	 * @param Function aCallback
-	 *        The function that is called with each mapping.
-	 * @param Object aContext
-	 *        Optional. If specified, this object will be the value of `this` every
-	 *        time that `aCallback` is called.
-	 * @param aOrder
-	 *        Either `SourceMapConsumer.GENERATED_ORDER` or
-	 *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
-	 *        iterate over the mappings sorted by the generated file's line/column
-	 *        order or the original's source/line/column order, respectively. Defaults to
-	 *        `SourceMapConsumer.GENERATED_ORDER`.
-	 */
-	SourceMapConsumer.prototype.eachMapping =
-	  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
-	    var context = aContext || null;
-	    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
-
-	    var mappings;
-	    switch (order) {
-	    case SourceMapConsumer.GENERATED_ORDER:
-	      mappings = this._generatedMappings;
-	      break;
-	    case SourceMapConsumer.ORIGINAL_ORDER:
-	      mappings = this._originalMappings;
-	      break;
-	    default:
-	      throw new Error("Unknown order of iteration.");
-	    }
-
-	    var sourceRoot = this.sourceRoot;
-	    mappings.map(function (mapping) {
-	      var source = mapping.source === null ? null : this._sources.at(mapping.source);
-	      if (source != null && sourceRoot != null) {
-	        source = util.join(sourceRoot, source);
-	      }
-	      return {
-	        source: source,
-	        generatedLine: mapping.generatedLine,
-	        generatedColumn: mapping.generatedColumn,
-	        originalLine: mapping.originalLine,
-	        originalColumn: mapping.originalColumn,
-	        name: mapping.name === null ? null : this._names.at(mapping.name)
-	      };
-	    }, this).forEach(aCallback, context);
-	  };
-
-	/**
-	 * Returns all generated line and column information for the original source,
-	 * line, and column provided. If no column is provided, returns all mappings
-	 * corresponding to a either the line we are searching for or the next
-	 * closest line that has any mappings. Otherwise, returns all mappings
-	 * corresponding to the given line and either the column we are searching for
-	 * or the next closest column that has any offsets.
-	 *
-	 * The only argument is an object with the following properties:
-	 *
-	 *   - source: The filename of the original source.
-	 *   - line: The line number in the original source.
-	 *   - column: Optional. the column number in the original source.
-	 *
-	 * and an array of objects is returned, each with the following properties:
-	 *
-	 *   - line: The line number in the generated source, or null.
-	 *   - column: The column number in the generated source, or null.
-	 */
-	SourceMapConsumer.prototype.allGeneratedPositionsFor =
-	  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
-	    var line = util.getArg(aArgs, 'line');
-
-	    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
-	    // returns the index of the closest mapping less than the needle. By
-	    // setting needle.originalColumn to 0, we thus find the last mapping for
-	    // the given line, provided such a mapping exists.
-	    var needle = {
-	      source: util.getArg(aArgs, 'source'),
-	      originalLine: line,
-	      originalColumn: util.getArg(aArgs, 'column', 0)
-	    };
-
-	    if (this.sourceRoot != null) {
-	      needle.source = util.relative(this.sourceRoot, needle.source);
-	    }
-	    if (!this._sources.has(needle.source)) {
-	      return [];
-	    }
-	    needle.source = this._sources.indexOf(needle.source);
-
-	    var mappings = [];
-
-	    var index = this._findMapping(needle,
-	                                  this._originalMappings,
-	                                  "originalLine",
-	                                  "originalColumn",
-	                                  util.compareByOriginalPositions,
-	                                  binarySearch.LEAST_UPPER_BOUND);
-	    if (index >= 0) {
-	      var mapping = this._originalMappings[index];
-
-	      if (aArgs.column === undefined) {
-	        var originalLine = mapping.originalLine;
-
-	        // Iterate until either we run out of mappings, or we run into
-	        // a mapping for a different line than the one we found. Since
-	        // mappings are sorted, this is guaranteed to find all mappings for
-	        // the line we found.
-	        while (mapping && mapping.originalLine === originalLine) {
-	          mappings.push({
-	            line: util.getArg(mapping, 'generatedLine', null),
-	            column: util.getArg(mapping, 'generatedColumn', null),
-	            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
-	          });
-
-	          mapping = this._originalMappings[++index];
-	        }
-	      } else {
-	        var originalColumn = mapping.originalColumn;
-
-	        // Iterate until either we run out of mappings, or we run into
-	        // a mapping for a different line than the one we were searching for.
-	        // Since mappings are sorted, this is guaranteed to find all mappings for
-	        // the line we are searching for.
-	        while (mapping &&
-	               mapping.originalLine === line &&
-	               mapping.originalColumn == originalColumn) {
-	          mappings.push({
-	            line: util.getArg(mapping, 'generatedLine', null),
-	            column: util.getArg(mapping, 'generatedColumn', null),
-	            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
-	          });
-
-	          mapping = this._originalMappings[++index];
-	        }
-	      }
-	    }
-
-	    return mappings;
-	  };
-
-	var SourceMapConsumer_1 = SourceMapConsumer;
-
-	/**
-	 * A BasicSourceMapConsumer instance represents a parsed source map which we can
-	 * query for information about the original file positions by giving it a file
-	 * position in the generated source.
-	 *
-	 * The only parameter is the raw source map (either as a JSON string, or
-	 * already parsed to an object). According to the spec, source maps have the
-	 * following attributes:
-	 *
-	 *   - version: Which version of the source map spec this map is following.
-	 *   - sources: An array of URLs to the original source files.
-	 *   - names: An array of identifiers which can be referrenced by individual mappings.
-	 *   - sourceRoot: Optional. The URL root from which all sources are relative.
-	 *   - sourcesContent: Optional. An array of contents of the original source files.
-	 *   - mappings: A string of base64 VLQs which contain the actual mappings.
-	 *   - file: Optional. The generated file this source map is associated with.
-	 *
-	 * Here is an example source map, taken from the source map spec[0]:
-	 *
-	 *     {
-	 *       version : 3,
-	 *       file: "out.js",
-	 *       sourceRoot : "",
-	 *       sources: ["foo.js", "bar.js"],
-	 *       names: ["src", "maps", "are", "fun"],
-	 *       mappings: "AA,AB;;ABCDE;"
-	 *     }
-	 *
-	 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
-	 */
-	function BasicSourceMapConsumer(aSourceMap) {
-	  var sourceMap = aSourceMap;
-	  if (typeof aSourceMap === 'string') {
-	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
-	  }
-
-	  var version = util.getArg(sourceMap, 'version');
-	  var sources = util.getArg(sourceMap, 'sources');
-	  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
-	  // requires the array) to play nice here.
-	  var names = util.getArg(sourceMap, 'names', []);
-	  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
-	  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
-	  var mappings = util.getArg(sourceMap, 'mappings');
-	  var file = util.getArg(sourceMap, 'file', null);
-
-	  // Once again, Sass deviates from the spec and supplies the version as a
-	  // string rather than a number, so we use loose equality checking here.
-	  if (version != this._version) {
-	    throw new Error('Unsupported version: ' + version);
-	  }
-
-	  sources = sources
-	    .map(String)
-	    // Some source maps produce relative source paths like "./foo.js" instead of
-	    // "foo.js".  Normalize these first so that future comparisons will succeed.
-	    // See bugzil.la/1090768.
-	    .map(util.normalize)
-	    // Always ensure that absolute sources are internally stored relative to
-	    // the source root, if the source root is absolute. Not doing this would
-	    // be particularly problematic when the source root is a prefix of the
-	    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
-	    .map(function (source) {
-	      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
-	        ? util.relative(sourceRoot, source)
-	        : source;
-	    });
-
-	  // Pass `true` below to allow duplicate names and sources. While source maps
-	  // are intended to be compressed and deduplicated, the TypeScript compiler
-	  // sometimes generates source maps with duplicates in them. See Github issue
-	  // #72 and bugzil.la/889492.
-	  this._names = ArraySet$2.fromArray(names.map(String), true);
-	  this._sources = ArraySet$2.fromArray(sources, true);
-
-	  this.sourceRoot = sourceRoot;
-	  this.sourcesContent = sourcesContent;
-	  this._mappings = mappings;
-	  this.file = file;
-	}
-
-	BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
-	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
-
-	/**
-	 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
-	 *
-	 * @param SourceMapGenerator aSourceMap
-	 *        The source map that will be consumed.
-	 * @returns BasicSourceMapConsumer
-	 */
-	BasicSourceMapConsumer.fromSourceMap =
-	  function SourceMapConsumer_fromSourceMap(aSourceMap) {
-	    var smc = Object.create(BasicSourceMapConsumer.prototype);
-
-	    var names = smc._names = ArraySet$2.fromArray(aSourceMap._names.toArray(), true);
-	    var sources = smc._sources = ArraySet$2.fromArray(aSourceMap._sources.toArray(), true);
-	    smc.sourceRoot = aSourceMap._sourceRoot;
-	    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
-	                                                            smc.sourceRoot);
-	    smc.file = aSourceMap._file;
-
-	    // Because we are modifying the entries (by converting string sources and
-	    // names to indices into the sources and names ArraySets), we have to make
-	    // a copy of the entry or else bad things happen. Shared mutable state
-	    // strikes again! See github issue #191.
-
-	    var generatedMappings = aSourceMap._mappings.toArray().slice();
-	    var destGeneratedMappings = smc.__generatedMappings = [];
-	    var destOriginalMappings = smc.__originalMappings = [];
-
-	    for (var i = 0, length = generatedMappings.length; i < length; i++) {
-	      var srcMapping = generatedMappings[i];
-	      var destMapping = new Mapping;
-	      destMapping.generatedLine = srcMapping.generatedLine;
-	      destMapping.generatedColumn = srcMapping.generatedColumn;
-
-	      if (srcMapping.source) {
-	        destMapping.source = sources.indexOf(srcMapping.source);
-	        destMapping.originalLine = srcMapping.originalLine;
-	        destMapping.originalColumn = srcMapping.originalColumn;
-
-	        if (srcMapping.name) {
-	          destMapping.name = names.indexOf(srcMapping.name);
-	        }
-
-	        destOriginalMappings.push(destMapping);
-	      }
-
-	      destGeneratedMappings.push(destMapping);
-	    }
-
-	    quickSort$1(smc.__originalMappings, util.compareByOriginalPositions);
-
-	    return smc;
-	  };
-
-	/**
-	 * The version of the source mapping spec that we are consuming.
-	 */
-	BasicSourceMapConsumer.prototype._version = 3;
-
-	/**
-	 * The list of original sources.
-	 */
-	Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
-	  get: function () {
-	    return this._sources.toArray().map(function (s) {
-	      return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
-	    }, this);
-	  }
-	});
-
-	/**
-	 * Provide the JIT with a nice shape / hidden class.
-	 */
-	function Mapping() {
-	  this.generatedLine = 0;
-	  this.generatedColumn = 0;
-	  this.source = null;
-	  this.originalLine = null;
-	  this.originalColumn = null;
-	  this.name = null;
-	}
-
-	/**
-	 * Parse the mappings in a string in to a data structure which we can easily
-	 * query (the ordered arrays in the `this.__generatedMappings` and
-	 * `this.__originalMappings` properties).
-	 */
-	BasicSourceMapConsumer.prototype._parseMappings =
-	  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
-	    var generatedLine = 1;
-	    var previousGeneratedColumn = 0;
-	    var previousOriginalLine = 0;
-	    var previousOriginalColumn = 0;
-	    var previousSource = 0;
-	    var previousName = 0;
-	    var length = aStr.length;
-	    var index = 0;
-	    var cachedSegments = {};
-	    var temp = {};
-	    var originalMappings = [];
-	    var generatedMappings = [];
-	    var mapping, str, segment, end, value;
-
-	    while (index < length) {
-	      if (aStr.charAt(index) === ';') {
-	        generatedLine++;
-	        index++;
-	        previousGeneratedColumn = 0;
-	      }
-	      else if (aStr.charAt(index) === ',') {
-	        index++;
-	      }
-	      else {
-	        mapping = new Mapping();
-	        mapping.generatedLine = generatedLine;
-
-	        // Because each offset is encoded relative to the previous one,
-	        // many segments often have the same encoding. We can exploit this
-	        // fact by caching the parsed variable length fields of each segment,
-	        // allowing us to avoid a second parse if we encounter the same
-	        // segment again.
-	        for (end = index; end < length; end++) {
-	          if (this._charIsMappingSeparator(aStr, end)) {
-	            break;
-	          }
-	        }
-	        str = aStr.slice(index, end);
-
-	        segment = cachedSegments[str];
-	        if (segment) {
-	          index += str.length;
-	        } else {
-	          segment = [];
-	          while (index < end) {
-	            base64Vlq.decode(aStr, index, temp);
-	            value = temp.value;
-	            index = temp.rest;
-	            segment.push(value);
-	          }
-
-	          if (segment.length === 2) {
-	            throw new Error('Found a source, but no line and column');
-	          }
-
-	          if (segment.length === 3) {
-	            throw new Error('Found a source and line, but no column');
-	          }
-
-	          cachedSegments[str] = segment;
-	        }
-
-	        // Generated column.
-	        mapping.generatedColumn = previousGeneratedColumn + segment[0];
-	        previousGeneratedColumn = mapping.generatedColumn;
-
-	        if (segment.length > 1) {
-	          // Original source.
-	          mapping.source = previousSource + segment[1];
-	          previousSource += segment[1];
-
-	          // Original line.
-	          mapping.originalLine = previousOriginalLine + segment[2];
-	          previousOriginalLine = mapping.originalLine;
-	          // Lines are stored 0-based
-	          mapping.originalLine += 1;
-
-	          // Original column.
-	          mapping.originalColumn = previousOriginalColumn + segment[3];
-	          previousOriginalColumn = mapping.originalColumn;
-
-	          if (segment.length > 4) {
-	            // Original name.
-	            mapping.name = previousName + segment[4];
-	            previousName += segment[4];
-	          }
-	        }
-
-	        generatedMappings.push(mapping);
-	        if (typeof mapping.originalLine === 'number') {
-	          originalMappings.push(mapping);
-	        }
-	      }
-	    }
-
-	    quickSort$1(generatedMappings, util.compareByGeneratedPositionsDeflated);
-	    this.__generatedMappings = generatedMappings;
-
-	    quickSort$1(originalMappings, util.compareByOriginalPositions);
-	    this.__originalMappings = originalMappings;
-	  };
-
-	/**
-	 * Find the mapping that best matches the hypothetical "needle" mapping that
-	 * we are searching for in the given "haystack" of mappings.
-	 */
-	BasicSourceMapConsumer.prototype._findMapping =
-	  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
-	                                         aColumnName, aComparator, aBias) {
-	    // To return the position we are searching for, we must first find the
-	    // mapping for the given position and then return the opposite position it
-	    // points to. Because the mappings are sorted, we can use binary search to
-	    // find the best mapping.
-
-	    if (aNeedle[aLineName] <= 0) {
-	      throw new TypeError('Line must be greater than or equal to 1, got '
-	                          + aNeedle[aLineName]);
-	    }
-	    if (aNeedle[aColumnName] < 0) {
-	      throw new TypeError('Column must be greater than or equal to 0, got '
-	                          + aNeedle[aColumnName]);
-	    }
-
-	    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
-	  };
-
-	/**
-	 * Compute the last column for each generated mapping. The last column is
-	 * inclusive.
-	 */
-	BasicSourceMapConsumer.prototype.computeColumnSpans =
-	  function SourceMapConsumer_computeColumnSpans() {
-	    for (var index = 0; index < this._generatedMappings.length; ++index) {
-	      var mapping = this._generatedMappings[index];
-
-	      // Mappings do not contain a field for the last generated columnt. We
-	      // can come up with an optimistic estimate, however, by assuming that
-	      // mappings are contiguous (i.e. given two consecutive mappings, the
-	      // first mapping ends where the second one starts).
-	      if (index + 1 < this._generatedMappings.length) {
-	        var nextMapping = this._generatedMappings[index + 1];
-
-	        if (mapping.generatedLine === nextMapping.generatedLine) {
-	          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
-	          continue;
-	        }
-	      }
-
-	      // The last mapping for each line spans the entire line.
-	      mapping.lastGeneratedColumn = Infinity;
-	    }
-	  };
-
-	/**
-	 * Returns the original source, line, and column information for the generated
-	 * source's line and column positions provided. The only argument is an object
-	 * with the following properties:
-	 *
-	 *   - line: The line number in the generated source.
-	 *   - column: The column number in the generated source.
-	 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
-	 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
-	 *     closest element that is smaller than or greater than the one we are
-	 *     searching for, respectively, if the exact element cannot be found.
-	 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
-	 *
-	 * and an object is returned with the following properties:
-	 *
-	 *   - source: The original source file, or null.
-	 *   - line: The line number in the original source, or null.
-	 *   - column: The column number in the original source, or null.
-	 *   - name: The original identifier, or null.
-	 */
-	BasicSourceMapConsumer.prototype.originalPositionFor =
-	  function SourceMapConsumer_originalPositionFor(aArgs) {
-	    var needle = {
-	      generatedLine: util.getArg(aArgs, 'line'),
-	      generatedColumn: util.getArg(aArgs, 'column')
-	    };
-
-	    var index = this._findMapping(
-	      needle,
-	      this._generatedMappings,
-	      "generatedLine",
-	      "generatedColumn",
-	      util.compareByGeneratedPositionsDeflated,
-	      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
-	    );
-
-	    if (index >= 0) {
-	      var mapping = this._generatedMappings[index];
-
-	      if (mapping.generatedLine === needle.generatedLine) {
-	        var source = util.getArg(mapping, 'source', null);
-	        if (source !== null) {
-	          source = this._sources.at(source);
-	          if (this.sourceRoot != null) {
-	            source = util.join(this.sourceRoot, source);
-	          }
-	        }
-	        var name = util.getArg(mapping, 'name', null);
-	        if (name !== null) {
-	          name = this._names.at(name);
-	        }
-	        return {
-	          source: source,
-	          line: util.getArg(mapping, 'originalLine', null),
-	          column: util.getArg(mapping, 'originalColumn', null),
-	          name: name
-	        };
-	      }
-	    }
-
-	    return {
-	      source: null,
-	      line: null,
-	      column: null,
-	      name: null
-	    };
-	  };
-
-	/**
-	 * Return true if we have the source content for every source in the source
-	 * map, false otherwise.
-	 */
-	BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
-	  function BasicSourceMapConsumer_hasContentsOfAllSources() {
-	    if (!this.sourcesContent) {
-	      return false;
-	    }
-	    return this.sourcesContent.length >= this._sources.size() &&
-	      !this.sourcesContent.some(function (sc) { return sc == null; });
-	  };
-
-	/**
-	 * Returns the original source content. The only argument is the url of the
-	 * original source file. Returns null if no original source content is
-	 * available.
-	 */
-	BasicSourceMapConsumer.prototype.sourceContentFor =
-	  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
-	    if (!this.sourcesContent) {
-	      return null;
-	    }
-
-	    if (this.sourceRoot != null) {
-	      aSource = util.relative(this.sourceRoot, aSource);
-	    }
-
-	    if (this._sources.has(aSource)) {
-	      return this.sourcesContent[this._sources.indexOf(aSource)];
-	    }
-
-	    var url;
-	    if (this.sourceRoot != null
-	        && (url = util.urlParse(this.sourceRoot))) {
-	      // XXX: file:// URIs and absolute paths lead to unexpected behavior for
-	      // many users. We can help them out when they expect file:// URIs to
-	      // behave like it would if they were running a local HTTP server. See
-	      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
-	      var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
-	      if (url.scheme == "file"
-	          && this._sources.has(fileUriAbsPath)) {
-	        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
-	      }
-
-	      if ((!url.path || url.path == "/")
-	          && this._sources.has("/" + aSource)) {
-	        return this.sourcesContent[this._sources.indexOf("/" + aSource)];
-	      }
-	    }
-
-	    // This function is used recursively from
-	    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
-	    // don't want to throw if we can't find the source - we just want to
-	    // return null, so we provide a flag to exit gracefully.
-	    if (nullOnMissing) {
-	      return null;
-	    }
-	    else {
-	      throw new Error('"' + aSource + '" is not in the SourceMap.');
-	    }
-	  };
-
-	/**
-	 * Returns the generated line and column information for the original source,
-	 * line, and column positions provided. The only argument is an object with
-	 * the following properties:
-	 *
-	 *   - source: The filename of the original source.
-	 *   - line: The line number in the original source.
-	 *   - column: The column number in the original source.
-	 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
-	 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
-	 *     closest element that is smaller than or greater than the one we are
-	 *     searching for, respectively, if the exact element cannot be found.
-	 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
-	 *
-	 * and an object is returned with the following properties:
-	 *
-	 *   - line: The line number in the generated source, or null.
-	 *   - column: The column number in the generated source, or null.
-	 */
-	BasicSourceMapConsumer.prototype.generatedPositionFor =
-	  function SourceMapConsumer_generatedPositionFor(aArgs) {
-	    var source = util.getArg(aArgs, 'source');
-	    if (this.sourceRoot != null) {
-	      source = util.relative(this.sourceRoot, source);
-	    }
-	    if (!this._sources.has(source)) {
-	      return {
-	        line: null,
-	        column: null,
-	        lastColumn: null
-	      };
-	    }
-	    source = this._sources.indexOf(source);
-
-	    var needle = {
-	      source: source,
-	      originalLine: util.getArg(aArgs, 'line'),
-	      originalColumn: util.getArg(aArgs, 'column')
-	    };
-
-	    var index = this._findMapping(
-	      needle,
-	      this._originalMappings,
-	      "originalLine",
-	      "originalColumn",
-	      util.compareByOriginalPositions,
-	      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
-	    );
-
-	    if (index >= 0) {
-	      var mapping = this._originalMappings[index];
-
-	      if (mapping.source === needle.source) {
-	        return {
-	          line: util.getArg(mapping, 'generatedLine', null),
-	          column: util.getArg(mapping, 'generatedColumn', null),
-	          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
-	        };
-	      }
-	    }
-
-	    return {
-	      line: null,
-	      column: null,
-	      lastColumn: null
-	    };
-	  };
-
-	var BasicSourceMapConsumer_1 = BasicSourceMapConsumer;
-
-	/**
-	 * An IndexedSourceMapConsumer instance represents a parsed source map which
-	 * we can query for information. It differs from BasicSourceMapConsumer in
-	 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
-	 * input.
-	 *
-	 * The only parameter is a raw source map (either as a JSON string, or already
-	 * parsed to an object). According to the spec for indexed source maps, they
-	 * have the following attributes:
-	 *
-	 *   - version: Which version of the source map spec this map is following.
-	 *   - file: Optional. The generated file this source map is associated with.
-	 *   - sections: A list of section definitions.
-	 *
-	 * Each value under the "sections" field has two fields:
-	 *   - offset: The offset into the original specified at which this section
-	 *       begins to apply, defined as an object with a "line" and "column"
-	 *       field.
-	 *   - map: A source map definition. This source map could also be indexed,
-	 *       but doesn't have to be.
-	 *
-	 * Instead of the "map" field, it's also possible to have a "url" field
-	 * specifying a URL to retrieve a source map from, but that's currently
-	 * unsupported.
-	 *
-	 * Here's an example source map, taken from the source map spec[0], but
-	 * modified to omit a section which uses the "url" field.
-	 *
-	 *  {
-	 *    version : 3,
-	 *    file: "app.js",
-	 *    sections: [{
-	 *      offset: {line:100, column:10},
-	 *      map: {
-	 *        version : 3,
-	 *        file: "section.js",
-	 *        sources: ["foo.js", "bar.js"],
-	 *        names: ["src", "maps", "are", "fun"],
-	 *        mappings: "AAAA,E;;ABCDE;"
-	 *      }
-	 *    }],
-	 *  }
-	 *
-	 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
-	 */
-	function IndexedSourceMapConsumer(aSourceMap) {
-	  var sourceMap = aSourceMap;
-	  if (typeof aSourceMap === 'string') {
-	    sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
-	  }
-
-	  var version = util.getArg(sourceMap, 'version');
-	  var sections = util.getArg(sourceMap, 'sections');
-
-	  if (version != this._version) {
-	    throw new Error('Unsupported version: ' + version);
-	  }
-
-	  this._sources = new ArraySet$2();
-	  this._names = new ArraySet$2();
-
-	  var lastOffset = {
-	    line: -1,
-	    column: 0
-	  };
-	  this._sections = sections.map(function (s) {
-	    if (s.url) {
-	      // The url field will require support for asynchronicity.
-	      // See https://github.com/mozilla/source-map/issues/16
-	      throw new Error('Support for url field in sections not implemented.');
-	    }
-	    var offset = util.getArg(s, 'offset');
-	    var offsetLine = util.getArg(offset, 'line');
-	    var offsetColumn = util.getArg(offset, 'column');
-
-	    if (offsetLine < lastOffset.line ||
-	        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
-	      throw new Error('Section offsets must be ordered and non-overlapping.');
-	    }
-	    lastOffset = offset;
-
-	    return {
-	      generatedOffset: {
-	        // The offset fields are 0-based, but we use 1-based indices when
-	        // encoding/decoding from VLQ.
-	        generatedLine: offsetLine + 1,
-	        generatedColumn: offsetColumn + 1
-	      },
-	      consumer: new SourceMapConsumer(util.getArg(s, 'map'))
-	    }
-	  });
-	}
-
-	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
-	IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
-
-	/**
-	 * The version of the source mapping spec that we are consuming.
-	 */
-	IndexedSourceMapConsumer.prototype._version = 3;
-
-	/**
-	 * The list of original sources.
-	 */
-	Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
-	  get: function () {
-	    var sources = [];
-	    for (var i = 0; i < this._sections.length; i++) {
-	      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
-	        sources.push(this._sections[i].consumer.sources[j]);
-	      }
-	    }
-	    return sources;
-	  }
-	});
-
-	/**
-	 * Returns the original source, line, and column information for the generated
-	 * source's line and column positions provided. The only argument is an object
-	 * with the following properties:
-	 *
-	 *   - line: The line number in the generated source.
-	 *   - column: The column number in the generated source.
-	 *
-	 * and an object is returned with the following properties:
-	 *
-	 *   - source: The original source file, or null.
-	 *   - line: The line number in the original source, or null.
-	 *   - column: The column number in the original source, or null.
-	 *   - name: The original identifier, or null.
-	 */
-	IndexedSourceMapConsumer.prototype.originalPositionFor =
-	  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
-	    var needle = {
-	      generatedLine: util.getArg(aArgs, 'line'),
-	      generatedColumn: util.getArg(aArgs, 'column')
-	    };
-
-	    // Find the section containing the generated position we're trying to map
-	    // to an original position.
-	    var sectionIndex = binarySearch.search(needle, this._sections,
-	      function(needle, section) {
-	        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
-	        if (cmp) {
-	          return cmp;
-	        }
-
-	        return (needle.generatedColumn -
-	                section.generatedOffset.generatedColumn);
-	      });
-	    var section = this._sections[sectionIndex];
-
-	    if (!section) {
-	      return {
-	        source: null,
-	        line: null,
-	        column: null,
-	        name: null
-	      };
-	    }
-
-	    return section.consumer.originalPositionFor({
-	      line: needle.generatedLine -
-	        (section.generatedOffset.generatedLine - 1),
-	      column: needle.generatedColumn -
-	        (section.generatedOffset.generatedLine === needle.generatedLine
-	         ? section.generatedOffset.generatedColumn - 1
-	         : 0),
-	      bias: aArgs.bias
-	    });
-	  };
-
-	/**
-	 * Return true if we have the source content for every source in the source
-	 * map, false otherwise.
-	 */
-	IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
-	  function IndexedSourceMapConsumer_hasContentsOfAllSources() {
-	    return this._sections.every(function (s) {
-	      return s.consumer.hasContentsOfAllSources();
-	    });
-	  };
-
-	/**
-	 * Returns the original source content. The only argument is the url of the
-	 * original source file. Returns null if no original source content is
-	 * available.
-	 */
-	IndexedSourceMapConsumer.prototype.sourceContentFor =
-	  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
-	    for (var i = 0; i < this._sections.length; i++) {
-	      var section = this._sections[i];
-
-	      var content = section.consumer.sourceContentFor(aSource, true);
-	      if (content) {
-	        return content;
-	      }
-	    }
-	    if (nullOnMissing) {
-	      return null;
-	    }
-	    else {
-	      throw new Error('"' + aSource + '" is not in the SourceMap.');
-	    }
-	  };
-
-	/**
-	 * Returns the generated line and column information for the original source,
-	 * line, and column positions provided. The only argument is an object with
-	 * the following properties:
-	 *
-	 *   - source: The filename of the original source.
-	 *   - line: The line number in the original source.
-	 *   - column: The column number in the original source.
-	 *
-	 * and an object is returned with the following properties:
-	 *
-	 *   - line: The line number in the generated source, or null.
-	 *   - column: The column number in the generated source, or null.
-	 */
-	IndexedSourceMapConsumer.prototype.generatedPositionFor =
-	  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
-	    for (var i = 0; i < this._sections.length; i++) {
-	      var section = this._sections[i];
-
-	      // Only consider this section if the requested source is in the list of
-	      // sources of the consumer.
-	      if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {
-	        continue;
-	      }
-	      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
-	      if (generatedPosition) {
-	        var ret = {
-	          line: generatedPosition.line +
-	            (section.generatedOffset.generatedLine - 1),
-	          column: generatedPosition.column +
-	            (section.generatedOffset.generatedLine === generatedPosition.line
-	             ? section.generatedOffset.generatedColumn - 1
-	             : 0)
-	        };
-	        return ret;
-	      }
-	    }
-
-	    return {
-	      line: null,
-	      column: null
-	    };
-	  };
-
-	/**
-	 * Parse the mappings in a string in to a data structure which we can easily
-	 * query (the ordered arrays in the `this.__generatedMappings` and
-	 * `this.__originalMappings` properties).
-	 */
-	IndexedSourceMapConsumer.prototype._parseMappings =
-	  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
-	    this.__generatedMappings = [];
-	    this.__originalMappings = [];
-	    for (var i = 0; i < this._sections.length; i++) {
-	      var section = this._sections[i];
-	      var sectionMappings = section.consumer._generatedMappings;
-	      for (var j = 0; j < sectionMappings.length; j++) {
-	        var mapping = sectionMappings[j];
-
-	        var source = section.consumer._sources.at(mapping.source);
-	        if (section.consumer.sourceRoot !== null) {
-	          source = util.join(section.consumer.sourceRoot, source);
-	        }
-	        this._sources.add(source);
-	        source = this._sources.indexOf(source);
-
-	        var name = section.consumer._names.at(mapping.name);
-	        this._names.add(name);
-	        name = this._names.indexOf(name);
-
-	        // The mappings coming from the consumer for the section have
-	        // generated positions relative to the start of the section, so we
-	        // need to offset them to be relative to the start of the concatenated
-	        // generated file.
-	        var adjustedMapping = {
-	          source: source,
-	          generatedLine: mapping.generatedLine +
-	            (section.generatedOffset.generatedLine - 1),
-	          generatedColumn: mapping.generatedColumn +
-	            (section.generatedOffset.generatedLine === mapping.generatedLine
-	            ? section.generatedOffset.generatedColumn - 1
-	            : 0),
-	          originalLine: mapping.originalLine,
-	          originalColumn: mapping.originalColumn,
-	          name: name
-	        };
-
-	        this.__generatedMappings.push(adjustedMapping);
-	        if (typeof adjustedMapping.originalLine === 'number') {
-	          this.__originalMappings.push(adjustedMapping);
-	        }
-	      }
-	    }
-
-	    quickSort$1(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
-	    quickSort$1(this.__originalMappings, util.compareByOriginalPositions);
-	  };
-
-	var IndexedSourceMapConsumer_1 = IndexedSourceMapConsumer;
-
-	var sourceMapConsumer = {
-		SourceMapConsumer: SourceMapConsumer_1,
-		BasicSourceMapConsumer: BasicSourceMapConsumer_1,
-		IndexedSourceMapConsumer: IndexedSourceMapConsumer_1
-	};
-
-	/* -*- Mode: js; js-indent-level: 2; -*- */
-	/*
-	 * Copyright 2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-
-	var SourceMapGenerator$1 = sourceMapGenerator.SourceMapGenerator;
-
-
-	// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
-	// operating systems these days (capturing the result).
-	var REGEX_NEWLINE = /(\r?\n)/;
-
-	// Newline character code for charCodeAt() comparisons
-	var NEWLINE_CODE = 10;
-
-	// Private symbol for identifying `SourceNode`s when multiple versions of
-	// the source-map library are loaded. This MUST NOT CHANGE across
-	// versions!
-	var isSourceNode = "$$$isSourceNode$$$";
-
-	/**
-	 * SourceNodes provide a way to abstract over interpolating/concatenating
-	 * snippets of generated JavaScript source code while maintaining the line and
-	 * column information associated with the original source code.
-	 *
-	 * @param aLine The original line number.
-	 * @param aColumn The original column number.
-	 * @param aSource The original source's filename.
-	 * @param aChunks Optional. An array of strings which are snippets of
-	 *        generated JS, or other SourceNodes.
-	 * @param aName The original identifier.
-	 */
-	function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
-	  this.children = [];
-	  this.sourceContents = {};
-	  this.line = aLine == null ? null : aLine;
-	  this.column = aColumn == null ? null : aColumn;
-	  this.source = aSource == null ? null : aSource;
-	  this.name = aName == null ? null : aName;
-	  this[isSourceNode] = true;
-	  if (aChunks != null) this.add(aChunks);
-	}
-
-	/**
-	 * Creates a SourceNode from generated code and a SourceMapConsumer.
-	 *
-	 * @param aGeneratedCode The generated code
-	 * @param aSourceMapConsumer The SourceMap for the generated code
-	 * @param aRelativePath Optional. The path that relative sources in the
-	 *        SourceMapConsumer should be relative to.
-	 */
-	SourceNode.fromStringWithSourceMap =
-	  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
-	    // The SourceNode we want to fill with the generated code
-	    // and the SourceMap
-	    var node = new SourceNode();
-
-	    // All even indices of this array are one line of the generated code,
-	    // while all odd indices are the newlines between two adjacent lines
-	    // (since `REGEX_NEWLINE` captures its match).
-	    // Processed fragments are accessed by calling `shiftNextLine`.
-	    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
-	    var remainingLinesIndex = 0;
-	    var shiftNextLine = function() {
-	      var lineContents = getNextLine();
-	      // The last line of a file might not have a newline.
-	      var newLine = getNextLine() || "";
-	      return lineContents + newLine;
-
-	      function getNextLine() {
-	        return remainingLinesIndex < remainingLines.length ?
-	            remainingLines[remainingLinesIndex++] : undefined;
-	      }
-	    };
-
-	    // We need to remember the position of "remainingLines"
-	    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
-
-	    // The generate SourceNodes we need a code range.
-	    // To extract it current and last mapping is used.
-	    // Here we store the last mapping.
-	    var lastMapping = null;
-
-	    aSourceMapConsumer.eachMapping(function (mapping) {
-	      if (lastMapping !== null) {
-	        // We add the code from "lastMapping" to "mapping":
-	        // First check if there is a new line in between.
-	        if (lastGeneratedLine < mapping.generatedLine) {
-	          // Associate first line with "lastMapping"
-	          addMappingWithCode(lastMapping, shiftNextLine());
-	          lastGeneratedLine++;
-	          lastGeneratedColumn = 0;
-	          // The remaining code is added without mapping
-	        } else {
-	          // There is no new line in between.
-	          // Associate the code between "lastGeneratedColumn" and
-	          // "mapping.generatedColumn" with "lastMapping"
-	          var nextLine = remainingLines[remainingLinesIndex];
-	          var code = nextLine.substr(0, mapping.generatedColumn -
-	                                        lastGeneratedColumn);
-	          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
-	                                              lastGeneratedColumn);
-	          lastGeneratedColumn = mapping.generatedColumn;
-	          addMappingWithCode(lastMapping, code);
-	          // No more remaining code, continue
-	          lastMapping = mapping;
-	          return;
-	        }
-	      }
-	      // We add the generated code until the first mapping
-	      // to the SourceNode without any mapping.
-	      // Each line is added as separate string.
-	      while (lastGeneratedLine < mapping.generatedLine) {
-	        node.add(shiftNextLine());
-	        lastGeneratedLine++;
-	      }
-	      if (lastGeneratedColumn < mapping.generatedColumn) {
-	        var nextLine = remainingLines[remainingLinesIndex];
-	        node.add(nextLine.substr(0, mapping.generatedColumn));
-	        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
-	        lastGeneratedColumn = mapping.generatedColumn;
-	      }
-	      lastMapping = mapping;
-	    }, this);
-	    // We have processed all mappings.
-	    if (remainingLinesIndex < remainingLines.length) {
-	      if (lastMapping) {
-	        // Associate the remaining code in the current line with "lastMapping"
-	        addMappingWithCode(lastMapping, shiftNextLine());
-	      }
-	      // and add the remaining lines without any mapping
-	      node.add(remainingLines.splice(remainingLinesIndex).join(""));
-	    }
-
-	    // Copy sourcesContent into SourceNode
-	    aSourceMapConsumer.sources.forEach(function (sourceFile) {
-	      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
-	      if (content != null) {
-	        if (aRelativePath != null) {
-	          sourceFile = util.join(aRelativePath, sourceFile);
-	        }
-	        node.setSourceContent(sourceFile, content);
-	      }
-	    });
-
-	    return node;
-
-	    function addMappingWithCode(mapping, code) {
-	      if (mapping === null || mapping.source === undefined) {
-	        node.add(code);
-	      } else {
-	        var source = aRelativePath
-	          ? util.join(aRelativePath, mapping.source)
-	          : mapping.source;
-	        node.add(new SourceNode(mapping.originalLine,
-	                                mapping.originalColumn,
-	                                source,
-	                                code,
-	                                mapping.name));
-	      }
-	    }
-	  };
-
-	/**
-	 * Add a chunk of generated JS to this source node.
-	 *
-	 * @param aChunk A string snippet of generated JS code, another instance of
-	 *        SourceNode, or an array where each member is one of those things.
-	 */
-	SourceNode.prototype.add = function SourceNode_add(aChunk) {
-	  if (Array.isArray(aChunk)) {
-	    aChunk.forEach(function (chunk) {
-	      this.add(chunk);
-	    }, this);
-	  }
-	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
-	    if (aChunk) {
-	      this.children.push(aChunk);
-	    }
-	  }
-	  else {
-	    throw new TypeError(
-	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
-	    );
-	  }
-	  return this;
-	};
-
-	/**
-	 * Add a chunk of generated JS to the beginning of this source node.
-	 *
-	 * @param aChunk A string snippet of generated JS code, another instance of
-	 *        SourceNode, or an array where each member is one of those things.
-	 */
-	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
-	  if (Array.isArray(aChunk)) {
-	    for (var i = aChunk.length-1; i >= 0; i--) {
-	      this.prepend(aChunk[i]);
-	    }
-	  }
-	  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
-	    this.children.unshift(aChunk);
-	  }
-	  else {
-	    throw new TypeError(
-	      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
-	    );
-	  }
-	  return this;
-	};
-
-	/**
-	 * Walk over the tree of JS snippets in this node and its children. The
-	 * walking function is called once for each snippet of JS and is passed that
-	 * snippet and the its original associated source's line/column location.
-	 *
-	 * @param aFn The traversal function.
-	 */
-	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
-	  var chunk;
-	  for (var i = 0, len = this.children.length; i < len; i++) {
-	    chunk = this.children[i];
-	    if (chunk[isSourceNode]) {
-	      chunk.walk(aFn);
-	    }
-	    else {
-	      if (chunk !== '') {
-	        aFn(chunk, { source: this.source,
-	                     line: this.line,
-	                     column: this.column,
-	                     name: this.name });
-	      }
-	    }
-	  }
-	};
-
-	/**
-	 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
-	 * each of `this.children`.
-	 *
-	 * @param aSep The separator.
-	 */
-	SourceNode.prototype.join = function SourceNode_join(aSep) {
-	  var newChildren;
-	  var i;
-	  var len = this.children.length;
-	  if (len > 0) {
-	    newChildren = [];
-	    for (i = 0; i < len-1; i++) {
-	      newChildren.push(this.children[i]);
-	      newChildren.push(aSep);
-	    }
-	    newChildren.push(this.children[i]);
-	    this.children = newChildren;
-	  }
-	  return this;
-	};
-
-	/**
-	 * Call String.prototype.replace on the very right-most source snippet. Useful
-	 * for trimming whitespace from the end of a source node, etc.
-	 *
-	 * @param aPattern The pattern to replace.
-	 * @param aReplacement The thing to replace the pattern with.
-	 */
-	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
-	  var lastChild = this.children[this.children.length - 1];
-	  if (lastChild[isSourceNode]) {
-	    lastChild.replaceRight(aPattern, aReplacement);
-	  }
-	  else if (typeof lastChild === 'string') {
-	    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
-	  }
-	  else {
-	    this.children.push(''.replace(aPattern, aReplacement));
-	  }
-	  return this;
-	};
-
-	/**
-	 * Set the source content for a source file. This will be added to the SourceMapGenerator
-	 * in the sourcesContent field.
-	 *
-	 * @param aSourceFile The filename of the source file
-	 * @param aSourceContent The content of the source file
-	 */
-	SourceNode.prototype.setSourceContent =
-	  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
-	    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
-	  };
-
-	/**
-	 * Walk over the tree of SourceNodes. The walking function is called for each
-	 * source file content and is passed the filename and source content.
-	 *
-	 * @param aFn The traversal function.
-	 */
-	SourceNode.prototype.walkSourceContents =
-	  function SourceNode_walkSourceContents(aFn) {
-	    for (var i = 0, len = this.children.length; i < len; i++) {
-	      if (this.children[i][isSourceNode]) {
-	        this.children[i].walkSourceContents(aFn);
-	      }
-	    }
-
-	    var sources = Object.keys(this.sourceContents);
-	    for (var i = 0, len = sources.length; i < len; i++) {
-	      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
-	    }
-	  };
-
-	/**
-	 * Return the string representation of this source node. Walks over the tree
-	 * and concatenates all the various snippets together to one string.
-	 */
-	SourceNode.prototype.toString = function SourceNode_toString() {
-	  var str = "";
-	  this.walk(function (chunk) {
-	    str += chunk;
-	  });
-	  return str;
-	};
-
-	/**
-	 * Returns the string representation of this source node along with a source
-	 * map.
-	 */
-	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
-	  var generated = {
-	    code: "",
-	    line: 1,
-	    column: 0
-	  };
-	  var map = new SourceMapGenerator$1(aArgs);
-	  var sourceMappingActive = false;
-	  var lastOriginalSource = null;
-	  var lastOriginalLine = null;
-	  var lastOriginalColumn = null;
-	  var lastOriginalName = null;
-	  this.walk(function (chunk, original) {
-	    generated.code += chunk;
-	    if (original.source !== null
-	        && original.line !== null
-	        && original.column !== null) {
-	      if(lastOriginalSource !== original.source
-	         || lastOriginalLine !== original.line
-	         || lastOriginalColumn !== original.column
-	         || lastOriginalName !== original.name) {
-	        map.addMapping({
-	          source: original.source,
-	          original: {
-	            line: original.line,
-	            column: original.column
-	          },
-	          generated: {
-	            line: generated.line,
-	            column: generated.column
-	          },
-	          name: original.name
-	        });
-	      }
-	      lastOriginalSource = original.source;
-	      lastOriginalLine = original.line;
-	      lastOriginalColumn = original.column;
-	      lastOriginalName = original.name;
-	      sourceMappingActive = true;
-	    } else if (sourceMappingActive) {
-	      map.addMapping({
-	        generated: {
-	          line: generated.line,
-	          column: generated.column
-	        }
-	      });
-	      lastOriginalSource = null;
-	      sourceMappingActive = false;
-	    }
-	    for (var idx = 0, length = chunk.length; idx < length; idx++) {
-	      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
-	        generated.line++;
-	        generated.column = 0;
-	        // Mappings end at eol
-	        if (idx + 1 === length) {
-	          lastOriginalSource = null;
-	          sourceMappingActive = false;
-	        } else if (sourceMappingActive) {
-	          map.addMapping({
-	            source: original.source,
-	            original: {
-	              line: original.line,
-	              column: original.column
-	            },
-	            generated: {
-	              line: generated.line,
-	              column: generated.column
-	            },
-	            name: original.name
-	          });
-	        }
-	      } else {
-	        generated.column++;
-	      }
-	    }
-	  });
-	  this.walkSourceContents(function (sourceFile, sourceContent) {
-	    map.setSourceContent(sourceFile, sourceContent);
-	  });
-
-	  return { code: generated.code, map: map };
-	};
-
-	var SourceNode_1 = SourceNode;
-
-	var sourceNode = {
-		SourceNode: SourceNode_1
-	};
-
-	/*
-	 * Copyright 2009-2011 Mozilla Foundation and contributors
-	 * Licensed under the New BSD license. See LICENSE.txt or:
-	 * http://opensource.org/licenses/BSD-3-Clause
-	 */
-	var SourceMapGenerator$2 = sourceMapGenerator.SourceMapGenerator;
-	var SourceMapConsumer$1 = sourceMapConsumer.SourceMapConsumer;
-	var SourceNode$1 = sourceNode.SourceNode;
-
-	var sourceMap = {
-		SourceMapGenerator: SourceMapGenerator$2,
-		SourceMapConsumer: SourceMapConsumer$1,
-		SourceNode: SourceNode$1
-	};
-
-	var SourceMapGenerator$3 = sourceMap.SourceMapGenerator;
-	var trackNodes = {
-	    Atrule: true,
-	    Selector: true,
-	    Declaration: true
-	};
-
-	var sourceMap$1 = function generateSourceMap(handlers) {
-	    var map = new SourceMapGenerator$3();
-	    var line = 1;
-	    var column = 0;
-	    var generated = {
-	        line: 1,
-	        column: 0
-	    };
-	    var original = {
-	        line: 0, // should be zero to add first mapping
-	        column: 0
-	    };
-	    var sourceMappingActive = false;
-	    var activatedGenerated = {
-	        line: 1,
-	        column: 0
-	    };
-	    var activatedMapping = {
-	        generated: activatedGenerated
-	    };
-
-	    var handlersNode = handlers.node;
-	    handlers.node = function(node) {
-	        if (node.loc && node.loc.start && trackNodes.hasOwnProperty(node.type)) {
-	            var nodeLine = node.loc.start.line;
-	            var nodeColumn = node.loc.start.column - 1;
-
-	            if (original.line !== nodeLine ||
-	                original.column !== nodeColumn) {
-	                original.line = nodeLine;
-	                original.column = nodeColumn;
-
-	                generated.line = line;
-	                generated.column = column;
-
-	                if (sourceMappingActive) {
-	                    sourceMappingActive = false;
-	                    if (generated.line !== activatedGenerated.line ||
-	                        generated.column !== activatedGenerated.column) {
-	                        map.addMapping(activatedMapping);
-	                    }
-	                }
-
-	                sourceMappingActive = true;
-	                map.addMapping({
-	                    source: node.loc.source,
-	                    original: original,
-	                    generated: generated
-	                });
-	            }
-	        }
-
-	        handlersNode.call(this, node);
-
-	        if (sourceMappingActive && trackNodes.hasOwnProperty(node.type)) {
-	            activatedGenerated.line = line;
-	            activatedGenerated.column = column;
-	        }
-	    };
-
-	    var handlersChunk = handlers.chunk;
-	    handlers.chunk = function(chunk) {
-	        for (var i = 0; i < chunk.length; i++) {
-	            if (chunk.charCodeAt(i) === 10) { // \n
-	                line++;
-	                column = 0;
-	            } else {
-	                column++;
-	            }
-	        }
-
-	        handlersChunk(chunk);
-	    };
-
-	    var handlersResult = handlers.result;
-	    handlers.result = function() {
-	        if (sourceMappingActive) {
-	            map.addMapping(activatedMapping);
-	        }
-
-	        return {
-	            css: handlersResult(),
-	            map: map
-	        };
-	    };
-
-	    return handlers;
-	};
-
-	var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
-
-	function processChildren(node, delimeter) {
-	    var list = node.children;
-	    var prev = null;
-
-	    if (typeof delimeter !== 'function') {
-	        list.forEach(this.node, this);
-	    } else {
-	        list.forEach(function(node) {
-	            if (prev !== null) {
-	                delimeter.call(this, prev);
-	            }
-
-	            this.node(node);
-	            prev = node;
-	        }, this);
-	    }
-	}
-
-	var create$2 = function createGenerator(config) {
-	    function processNode(node) {
-	        if (hasOwnProperty$3.call(types, node.type)) {
-	            types[node.type].call(this, node);
-	        } else {
-	            throw new Error('Unknown node type: ' + node.type);
-	        }
-	    }
-
-	    var types = {};
-
-	    if (config.node) {
-	        for (var name in config.node) {
-	            types[name] = config.node[name].generate;
-	        }
-	    }
-
-	    return function(node, options) {
-	        var buffer = '';
-	        var handlers = {
-	            children: processChildren,
-	            node: processNode,
-	            chunk: function(chunk) {
-	                buffer += chunk;
-	            },
-	            result: function() {
-	                return buffer;
-	            }
-	        };
-
-	        if (options) {
-	            if (typeof options.decorator === 'function') {
-	                handlers = options.decorator(handlers);
-	            }
-
-	            if (options.sourceMap) {
-	                handlers = sourceMap$1(handlers);
-	            }
-	        }
-
-	        handlers.node(node);
-
-	        return handlers.result();
-	    };
-	};
-
-	var create$3 = function createConvertors(walk) {
-	    return {
-	        fromPlainObject: function(ast) {
-	            walk(ast, {
-	                enter: function(node) {
-	                    if (node.children && node.children instanceof list === false) {
-	                        node.children = new list().fromArray(node.children);
-	                    }
-	                }
-	            });
-
-	            return ast;
-	        },
-	        toPlainObject: function(ast) {
-	            walk(ast, {
-	                leave: function(node) {
-	                    if (node.children && node.children instanceof list) {
-	                        node.children = node.children.toArray();
-	                    }
-	                }
-	            });
-
-	            return ast;
-	        }
-	    };
-	};
-
-	var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
-	var noop$4 = function() {};
-
-	function ensureFunction$1(value) {
-	    return typeof value === 'function' ? value : noop$4;
-	}
-
-	function invokeForType(fn, type) {
-	    return function(node, item, list) {
-	        if (node.type === type) {
-	            fn.call(this, node, item, list);
-	        }
-	    };
-	}
-
-	function getWalkersFromStructure(name, nodeType) {
-	    var structure = nodeType.structure;
-	    var walkers = [];
-
-	    for (var key in structure) {
-	        if (hasOwnProperty$4.call(structure, key) === false) {
-	            continue;
-	        }
-
-	        var fieldTypes = structure[key];
-	        var walker = {
-	            name: key,
-	            type: false,
-	            nullable: false
-	        };
-
-	        if (!Array.isArray(structure[key])) {
-	            fieldTypes = [structure[key]];
-	        }
-
-	        for (var i = 0; i < fieldTypes.length; i++) {
-	            var fieldType = fieldTypes[i];
-	            if (fieldType === null) {
-	                walker.nullable = true;
-	            } else if (typeof fieldType === 'string') {
-	                walker.type = 'node';
-	            } else if (Array.isArray(fieldType)) {
-	                walker.type = 'list';
-	            }
-	        }
-
-	        if (walker.type) {
-	            walkers.push(walker);
-	        }
-	    }
-
-	    if (walkers.length) {
-	        return {
-	            context: nodeType.walkContext,
-	            fields: walkers
-	        };
-	    }
-
-	    return null;
-	}
-
-	function getTypesFromConfig(config) {
-	    var types = {};
-
-	    for (var name in config.node) {
-	        if (hasOwnProperty$4.call(config.node, name)) {
-	            var nodeType = config.node[name];
-
-	            if (!nodeType.structure) {
-	                throw new Error('Missed `structure` field in `' + name + '` node type definition');
-	            }
-
-	            types[name] = getWalkersFromStructure(name, nodeType);
-	        }
-	    }
-
-	    return types;
-	}
-
-	function createTypeIterator(config, reverse) {
-	    var fields = reverse ? config.fields.slice().reverse() : config.fields;
-	    var body = fields.map(function(field) {
-	        var ref = 'node.' + field.name;
-	        var line;
-
-	        if (field.type === 'list') {
-	            line = reverse
-	                ? ref + '.forEachRight(walk);'
-	                : ref + '.forEach(walk);';
-	        } else {
-	            line = 'walk(' + ref + ');';
-	        }
-
-	        if (field.nullable) {
-	            line = 'if (' + ref + ') {\n    ' + line + '}';
-	        }
-
-	        return line;
-	    });
-
-	    if (config.context) {
-	        body = [].concat(
-	            'var old = context.' + config.context + ';',
-	            'context.' + config.context + ' = node;',
-	            body,
-	            'context.' + config.context + ' = old;'
-	        );
-	    }
-
-	    return new Function('node', 'context', 'walk', body.join('\n'));
-	}
-
-	function createFastTraveralMap(iterators) {
-	    return {
-	        Atrule: {
-	            StyleSheet: iterators.StyleSheet,
-	            Atrule: iterators.Atrule,
-	            Rule: iterators.Rule,
-	            Block: iterators.Block
-	        },
-	        Rule: {
-	            StyleSheet: iterators.StyleSheet,
-	            Atrule: iterators.Atrule,
-	            Rule: iterators.Rule,
-	            Block: iterators.Block
-	        },
-	        Declaration: {
-	            StyleSheet: iterators.StyleSheet,
-	            Atrule: iterators.Atrule,
-	            Rule: iterators.Rule,
-	            Block: iterators.Block
-	        }
-	    };
-	}
-
-	var create$4 = function createWalker(config) {
-	    var types = getTypesFromConfig(config);
-	    var iteratorsNatural = {};
-	    var iteratorsReverse = {};
-
-	    for (var name in types) {
-	        if (hasOwnProperty$4.call(types, name) && types[name] !== null) {
-	            iteratorsNatural[name] = createTypeIterator(types[name], false);
-	            iteratorsReverse[name] = createTypeIterator(types[name], true);
-	        }
-	    }
-
-	    var fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);
-	    var fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);
-
-	    return function walk(root, options) {
-	        function walkNode(node, item, list) {
-	            enter.call(context, node, item, list);
-
-	            if (iterators.hasOwnProperty(node.type)) {
-	                iterators[node.type](node, context, walkNode);
-	            }
-
-	            leave.call(context, node, item, list);
-	        }
-
-	        var enter = noop$4;
-	        var leave = noop$4;
-	        var iterators = iteratorsNatural;
-	        var context = {
-	            root: root,
-	            stylesheet: null,
-	            atrule: null,
-	            atrulePrelude: null,
-	            rule: null,
-	            selector: null,
-	            block: null,
-	            declaration: null,
-	            function: null
-	        };
-
-	        if (typeof options === 'function') {
-	            enter = options;
-	        } else if (options) {
-	            enter = ensureFunction$1(options.enter);
-	            leave = ensureFunction$1(options.leave);
-
-	            if (options.reverse) {
-	                iterators = iteratorsReverse;
-	            }
-
-	            if (options.visit) {
-	                if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {
-	                    iterators = options.reverse
-	                        ? fastTraversalIteratorsReverse[options.visit]
-	                        : fastTraversalIteratorsNatural[options.visit];
-	                } else if (!types.hasOwnProperty(options.visit)) {
-	                    throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).join(', ') + ')');
-	                }
-
-	                enter = invokeForType(enter, options.visit);
-	                leave = invokeForType(leave, options.visit);
-	            }
-	        }
-
-	        if (enter === noop$4 && leave === noop$4) {
-	            throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
-	        }
-
-	        // swap handlers in reverse mode to invert visit order
-	        if (options.reverse) {
-	            var tmp = enter;
-	            enter = leave;
-	            leave = tmp;
-	        }
-
-	        walkNode(root);
-	    };
-	};
-
-	var clone = function clone(node) {
-	    var result = {};
-
-	    for (var key in node) {
-	        var value = node[key];
-
-	        if (value) {
-	            if (Array.isArray(value) || value instanceof list) {
-	                value = value.map(clone);
-	            } else if (value.constructor === Object) {
-	                value = clone(value);
-	            }
-	        }
-
-	        result[key] = value;
-	    }
-
-	    return result;
-	};
-
-	var hasOwnProperty$5 = Object.prototype.hasOwnProperty;
-	var shape = {
-	    generic: true,
-	    types: {},
-	    properties: {},
-	    parseContext: {},
-	    scope: {},
-	    atrule: ['parse'],
-	    pseudo: ['parse'],
-	    node: ['name', 'structure', 'parse', 'generate', 'walkContext']
-	};
-
-	function isObject(value) {
-	    return value && value.constructor === Object;
-	}
-
-	function copy(value) {
-	    if (isObject(value)) {
-	        var res = {};
-	        for (var key in value) {
-	            if (hasOwnProperty$5.call(value, key)) {
-	                res[key] = value[key];
-	            }
-	        }
-	        return res;
-	    } else {
-	        return value;
-	    }
-	}
-
-	function extend(dest, src) {
-	    for (var key in src) {
-	        if (hasOwnProperty$5.call(src, key)) {
-	            if (isObject(dest[key])) {
-	                extend(dest[key], copy(src[key]));
-	            } else {
-	                dest[key] = copy(src[key]);
-	            }
-	        }
-	    }
-	}
-
-	function mix(dest, src, shape) {
-	    for (var key in shape) {
-	        if (hasOwnProperty$5.call(shape, key) === false) {
-	            continue;
-	        }
-
-	        if (shape[key] === true) {
-	            if (key in src) {
-	                if (hasOwnProperty$5.call(src, key)) {
-	                    dest[key] = copy(src[key]);
-	                }
-	            }
-	        } else if (shape[key]) {
-	            if (isObject(shape[key])) {
-	                var res = {};
-	                extend(res, dest[key]);
-	                extend(res, src[key]);
-	                dest[key] = res;
-	            } else if (Array.isArray(shape[key])) {
-	                var res = {};
-	                var innerShape = shape[key].reduce(function(s, k) {
-	                    s[k] = true;
-	                    return s;
-	                }, {});
-	                for (var name in dest[key]) {
-	                    if (hasOwnProperty$5.call(dest[key], name)) {
-	                        res[name] = {};
-	                        if (dest[key] && dest[key][name]) {
-	                            mix(res[name], dest[key][name], innerShape);
-	                        }
-	                    }
-	                }
-	                for (var name in src[key]) {
-	                    if (hasOwnProperty$5.call(src[key], name)) {
-	                        if (!res[name]) {
-	                            res[name] = {};
-	                        }
-	                        if (src[key] && src[key][name]) {
-	                            mix(res[name], src[key][name], innerShape);
-	                        }
-	                    }
-	                }
-	                dest[key] = res;
-	            }
-	        }
-	    }
-	    return dest;
-	}
-
-	var mix_1 = function(dest, src) {
-	    return mix(dest, src, shape);
-	};
-
-	function assign$1(dest, src) {
-	    for (var key in src) {
-	        dest[key] = src[key];
-	    }
-
-	    return dest;
-	}
-
-	function createSyntax(config) {
-	    var parse = create$1(config);
-	    var walk = create$4(config);
-	    var generate = create$2(config);
-	    var convert = create$3(walk);
-
-	    var syntax = {
-	        List: list,
-	        Tokenizer: tokenizer,
-	        Lexer: Lexer_1,
-
-	        vendorPrefix: names.vendorPrefix,
-	        keyword: names.keyword,
-	        property: names.property,
-	        isCustomProperty: names.isCustomProperty,
-
-	        grammar: grammar,
-	        lexer: null,
-	        createLexer: function(config) {
-	            return new Lexer_1(config, syntax, syntax.lexer.structure);
-	        },
-
-	        parse: parse,
-	        walk: walk,
-	        generate: generate,
-
-	        clone: clone,
-	        fromPlainObject: convert.fromPlainObject,
-	        toPlainObject: convert.toPlainObject,
-
-	        createSyntax: function(config) {
-	            return createSyntax(mix_1({}, config));
-	        },
-	        fork: function(extension) {
-	            var base = mix_1({}, config); // copy of config
-	            return createSyntax(
-	                typeof extension === 'function'
-	                    ? extension(base, assign$1)
-	                    : mix_1(base, extension)
-	            );
-	        }
-	    };
-
-	    syntax.lexer = new Lexer_1({
-	        generic: true,
-	        types: config.types,
-	        properties: config.properties,
-	        node: config.node
-	    }, syntax);
-
-	    return syntax;
-	}
-	var create_1 = function(config) {
-	    return createSyntax(mix_1({}, config));
-	};
-
-	var create$5 = {
-		create: create_1
-	};
-
-	var all = {
-		syntax: "initial | inherit | unset | revert",
-		media: "noPracticalMedia",
-		inherited: false,
-		animationType: "eachOfShorthandPropertiesExceptUnicodeBiDiAndDirection",
-		percentages: "no",
-		groups: [
-			"CSS Miscellaneous"
-		],
-		initial: "noPracticalInitialValue",
-		appliesto: "allElements",
-		computed: "asSpecifiedAppliesToEachProperty",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var animation = {
-		syntax: "<single-animation>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: [
-			"animation-name",
-			"animation-duration",
-			"animation-timing-function",
-			"animation-delay",
-			"animation-iteration-count",
-			"animation-direction",
-			"animation-fill-mode",
-			"animation-play-state"
-		],
-		appliesto: "allElementsAndPseudos",
-		computed: [
-			"animation-name",
-			"animation-duration",
-			"animation-timing-function",
-			"animation-delay",
-			"animation-direction",
-			"animation-iteration-count",
-			"animation-fill-mode",
-			"animation-play-state"
-		],
-		order: "orderOfAppearance",
-		status: "standard"
-	};
-	var appearance = {
-		syntax: "auto | none",
-		media: "all",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	};
-	var azimuth = {
-		syntax: "<angle> | [ [ left-side | far-left | left | center-left | center | center-right | right | far-right | right-side ] || behind ] | leftwards | rightwards",
-		media: "aural",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Speech"
-		],
-		initial: "center",
-		appliesto: "allElements",
-		computed: "normalizedAngle",
-		order: "orderOfAppearance",
-		status: "obsolete"
-	};
-	var background = {
-		syntax: "[ <bg-layer> , ]* <final-bg-layer>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"background-color",
-			"background-image",
-			"background-clip",
-			"background-position",
-			"background-size",
-			"background-repeat",
-			"background-attachment"
-		],
-		percentages: [
-			"background-position",
-			"background-size"
-		],
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"background-image",
-			"background-position",
-			"background-size",
-			"background-repeat",
-			"background-origin",
-			"background-clip",
-			"background-attachment",
-			"background-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"background-image",
-			"background-position",
-			"background-size",
-			"background-repeat",
-			"background-origin",
-			"background-clip",
-			"background-attachment",
-			"background-color"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	};
-	var border = {
-		syntax: "<br-width> || <br-style> || <color>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-color",
-			"border-style",
-			"border-width"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-width",
-			"border-style",
-			"border-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-width",
-			"border-style",
-			"border-color"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	};
-	var bottom = {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToContainingBlockHeight",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var clear = {
-		syntax: "none | left | right | both | inline-start | inline-end",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "none",
-		appliesto: "blockLevelElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var clip = {
-		syntax: "<shape> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "rectangle",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "auto",
-		appliesto: "absolutelyPositionedElements",
-		computed: "autoOrRectangle",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var color = {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Color"
-		],
-		initial: "variesFromBrowserToBrowser",
-		appliesto: "allElements",
-		computed: "translucentValuesRGBAOtherwiseRGB",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	};
-	var columns = {
-		syntax: "<'column-width'> || <'column-count'>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"column-width",
-			"column-count"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: [
-			"column-width",
-			"column-count"
-		],
-		appliesto: "blockContainersExceptTableWrappers",
-		computed: [
-			"column-width",
-			"column-count"
-		],
-		order: "perGrammar",
-		status: "standard"
-	};
-	var contain = {
-		syntax: "none | strict | content | [ size || layout || style || paint ]",
-		media: "all",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Containment"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	};
-	var content = {
-		syntax: "normal | none | [ <content-replacement> | <content-list> ] [/ <string> ]?",
-		media: "all",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Generated Content"
-		],
-		initial: "normal",
-		appliesto: "beforeAndAfterPseudos",
-		computed: "normalOnElementsForPseudosNoneAbsoluteURIStringOrAsSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var cursor = {
-		syntax: "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing ] ]",
-		media: [
-			"visual",
-			"interactive"
-		],
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecifiedURLsAbsolute",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var direction = {
-		syntax: "ltr | rtl",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Writing Modes"
-		],
-		initial: "ltr",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var display = {
-		syntax: "[ <display-outside> || <display-inside> ] | <display-listitem> | <display-internal> | <display-box> | <display-legacy>",
-		media: "all",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Display"
-		],
-		initial: "inline",
-		appliesto: "allElements",
-		computed: "asSpecifiedExceptPositionedFloatingAndRootElementsKeywordMaybeDifferent",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var filter = {
-		syntax: "none | <filter-function-list>",
-		media: "visual",
-		inherited: false,
-		animationType: "filterList",
-		percentages: "no",
-		groups: [
-			"Filter Effects"
-		],
-		initial: "none",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var flex = {
-		syntax: "none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"flex-grow",
-			"flex-shrink",
-			"flex-basis"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: [
-			"flex-grow",
-			"flex-shrink",
-			"flex-basis"
-		],
-		appliesto: "flexItemsAndInFlowPseudos",
-		computed: [
-			"flex-grow",
-			"flex-shrink",
-			"flex-basis"
-		],
-		order: "orderOfAppearance",
-		status: "standard"
-	};
-	var float = {
-		syntax: "left | right | none | inline-start | inline-end",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "none",
-		appliesto: "allElementsNoEffectIfDisplayNone",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var font = {
-		syntax: "[ [ <'font-style'> || <font-variant-css21> || <'font-weight'> || <'font-stretch'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ] | caption | icon | menu | message-box | small-caption | status-bar",
-		media: "visual",
-		inherited: true,
-		animationType: [
-			"font-style",
-			"font-variant",
-			"font-weight",
-			"font-stretch",
-			"font-size",
-			"line-height",
-			"font-family"
-		],
-		percentages: [
-			"font-size",
-			"line-height"
-		],
-		groups: [
-			"CSS Fonts"
-		],
-		initial: [
-			"font-style",
-			"font-variant",
-			"font-weight",
-			"font-stretch",
-			"font-size",
-			"line-height",
-			"font-family"
-		],
-		appliesto: "allElements",
-		computed: [
-			"font-style",
-			"font-variant",
-			"font-weight",
-			"font-stretch",
-			"font-size",
-			"line-height",
-			"font-family"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	};
-	var gap = {
-		syntax: "<'row-gap'> <'column-gap'>?",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"row-gap",
-			"column-gap"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Box Alignment"
-		],
-		initial: [
-			"row-gap",
-			"column-gap"
-		],
-		appliesto: "gridContainers",
-		computed: [
-			"row-gap",
-			"column-gap"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var grid = {
-		syntax: "<'grid-template'> | <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? | [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: [
-			"grid-template-rows",
-			"grid-template-columns",
-			"grid-auto-rows",
-			"grid-auto-columns"
-		],
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: [
-			"grid-template-rows",
-			"grid-template-columns",
-			"grid-template-areas",
-			"grid-auto-rows",
-			"grid-auto-columns",
-			"grid-auto-flow",
-			"grid-column-gap",
-			"grid-row-gap",
-			"column-gap",
-			"row-gap"
-		],
-		appliesto: "gridContainers",
-		computed: [
-			"grid-template-rows",
-			"grid-template-columns",
-			"grid-template-areas",
-			"grid-auto-rows",
-			"grid-auto-columns",
-			"grid-auto-flow",
-			"grid-column-gap",
-			"grid-row-gap",
-			"column-gap",
-			"row-gap"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var height = {
-		syntax: "[ <length> | <percentage> ] && [ border-box | content-box ]? | available | min-content | max-content | fit-content | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentagesRelativeToContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "auto",
-		appliesto: "allElementsButNonReplacedAndTableColumns",
-		computed: "percentageAutoOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var hyphens = {
-		syntax: "none | manual | auto",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "manual",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var isolation = {
-		syntax: "auto | isolate",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Compositing and Blending"
-		],
-		initial: "auto",
-		appliesto: "allElementsSVGContainerGraphicsAndGraphicsReferencingElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var left = {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var margin = {
-		syntax: "[ <length> | <percentage> | auto ]{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: [
-			"margin-bottom",
-			"margin-left",
-			"margin-right",
-			"margin-top"
-		],
-		appliesto: "allElementsExceptTableDisplayTypes",
-		computed: [
-			"margin-bottom",
-			"margin-left",
-			"margin-right",
-			"margin-top"
-		],
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	};
-	var mask = {
-		syntax: "<mask-layer>#",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"mask-image",
-			"mask-mode",
-			"mask-repeat",
-			"mask-position",
-			"mask-clip",
-			"mask-origin",
-			"mask-size",
-			"mask-composite"
-		],
-		percentages: [
-			"mask-position"
-		],
-		groups: [
-			"CSS Masking"
-		],
-		initial: [
-			"mask-image",
-			"mask-mode",
-			"mask-repeat",
-			"mask-position",
-			"mask-clip",
-			"mask-origin",
-			"mask-size",
-			"mask-composite"
-		],
-		appliesto: "allElementsSVGContainerElements",
-		computed: [
-			"mask-image",
-			"mask-mode",
-			"mask-repeat",
-			"mask-position",
-			"mask-clip",
-			"mask-origin",
-			"mask-size",
-			"mask-composite"
-		],
-		order: "perGrammar",
-		stacking: true,
-		status: "standard"
-	};
-	var offset = {
-		syntax: "[ <'offset-position'>? [ <'offset-path'> [ <'offset-distance'> || <'offset-rotate'> ]? ]? ]! [ / <'offset-anchor'> ]?",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"offset-position",
-			"offset-path",
-			"offset-distance",
-			"offset-anchor",
-			"offset-rotate"
-		],
-		percentages: [
-			"offset-position",
-			"offset-distance",
-			"offset-anchor"
-		],
-		groups: [
-			"CSS Motion"
-		],
-		initial: [
-			"offset-position",
-			"offset-path",
-			"offset-distance",
-			"offset-anchor",
-			"offset-rotate"
-		],
-		appliesto: "transformableElements",
-		computed: [
-			"offset-position",
-			"offset-path",
-			"offset-distance",
-			"offset-anchor",
-			"offset-rotate"
-		],
-		order: "perGrammar",
-		stacking: true,
-		status: "experimental"
-	};
-	var opacity = {
-		syntax: "<number>",
-		media: "visual",
-		inherited: false,
-		animationType: "number",
-		percentages: "no",
-		groups: [
-			"CSS Color"
-		],
-		initial: "1.0",
-		appliesto: "allElements",
-		computed: "specifiedValueClipped0To1",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::placeholder"
-		],
-		status: "standard"
-	};
-	var order = {
-		syntax: "<integer>",
-		media: "visual",
-		inherited: false,
-		animationType: "integer",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "0",
-		appliesto: "flexItemsAndAbsolutelyPositionedFlexContainerChildren",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var orphans = {
-		syntax: "<integer>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fragmentation"
-		],
-		initial: "2",
-		appliesto: "blockContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	};
-	var outline = {
-		syntax: "[ <'outline-color'> || <'outline-style'> || <'outline-width'> ]",
-		media: [
-			"visual",
-			"interactive"
-		],
-		inherited: false,
-		animationType: [
-			"outline-color",
-			"outline-width",
-			"outline-style"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: [
-			"outline-color",
-			"outline-style",
-			"outline-width"
-		],
-		appliesto: "allElements",
-		computed: [
-			"outline-color",
-			"outline-width",
-			"outline-style"
-		],
-		order: "orderOfAppearance",
-		status: "standard"
-	};
-	var overflow = {
-		syntax: "[ visible | hidden | clip | scroll | auto ]{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "visible",
-		appliesto: "blockContainersFlexContainersGridContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var padding = {
-		syntax: "[ <length> | <percentage> ]{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: [
-			"padding-bottom",
-			"padding-left",
-			"padding-right",
-			"padding-top"
-		],
-		appliesto: "allElementsExceptInternalTableDisplayTypes",
-		computed: [
-			"padding-bottom",
-			"padding-left",
-			"padding-right",
-			"padding-top"
-		],
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	};
-	var perspective = {
-		syntax: "none | <length>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "none",
-		appliesto: "transformableElements",
-		computed: "absoluteLengthOrNone",
-		order: "uniqueOrder",
-		stacking: true,
-		status: "standard"
-	};
-	var position = {
-		syntax: "static | relative | absolute | sticky | fixed",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "static",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		stacking: true,
-		status: "standard"
-	};
-	var quotes = {
-		syntax: "none | [ <string> <string> ]+",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Generated Content"
-		],
-		initial: "dependsOnUserAgent",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var resize = {
-		syntax: "none | both | horizontal | vertical",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "none",
-		appliesto: "elementsWithOverflowNotVisibleAndReplacedElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var right = {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var rotate = {
-		syntax: "none | [ x | y | z | <number>{3} ]? && <angle>",
-		media: "visual",
-		inherited: false,
-		animationType: "transform",
-		percentages: "no",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "none",
-		appliesto: "transformableElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		stacking: true,
-		status: "standard"
-	};
-	var scale = {
-		syntax: "none | <number>{1,3}",
-		media: "visual",
-		inherited: false,
-		animationType: "transform",
-		percentages: "no",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "none",
-		appliesto: "transformableElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		stacking: true,
-		status: "standard"
-	};
-	var top = {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToContainingBlockHeight",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var transform = {
-		syntax: "none | <transform-list>",
-		media: "visual",
-		inherited: false,
-		animationType: "transform",
-		percentages: "referToSizeOfBoundingBox",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "none",
-		appliesto: "transformableElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		stacking: true,
-		status: "standard"
-	};
-	var transition = {
-		syntax: "<single-transition>#",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transitions"
-		],
-		initial: [
-			"transition-delay",
-			"transition-duration",
-			"transition-property",
-			"transition-timing-function"
-		],
-		appliesto: "allElementsAndPseudos",
-		computed: [
-			"transition-delay",
-			"transition-duration",
-			"transition-property",
-			"transition-timing-function"
-		],
-		order: "orderOfAppearance",
-		status: "standard"
-	};
-	var translate = {
-		syntax: "none | <length-percentage> [ <length-percentage> <length>? ]?",
-		media: "visual",
-		inherited: false,
-		animationType: "transform",
-		percentages: "referToSizeOfBoundingBox",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "none",
-		appliesto: "transformableElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "perGrammar",
-		stacking: true,
-		status: "standard"
-	};
-	var visibility = {
-		syntax: "visible | hidden | collapse",
-		media: "visual",
-		inherited: true,
-		animationType: "visibility",
-		percentages: "no",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "visible",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	};
-	var widows = {
-		syntax: "<integer>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fragmentation"
-		],
-		initial: "2",
-		appliesto: "blockContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	};
-	var width = {
-		syntax: "[ <length> | <percentage> ] && [ border-box | content-box ]? | available | min-content | max-content | fit-content | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "auto",
-		appliesto: "allElementsButNonReplacedAndTableRows",
-		computed: "percentageAutoOrAbsoluteLength",
-		order: "lengthOrPercentageBeforeKeywordIfBothPresent",
-		status: "standard"
-	};
-	var zoom = {
-		syntax: "normal | reset | <number> | <percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "integer",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	};
-	var properties$1 = {
-		"--*": {
-		syntax: "<declaration-value>",
-		media: "all",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Variables"
-		],
-		initial: "seeProse",
-		appliesto: "allElements",
-		computed: "asSpecifiedWithVarsSubstituted",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"-ms-accelerator": {
-		syntax: "false | true",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "false",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-block-progression": {
-		syntax: "tb | rl | bt | lr",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "tb",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zoom-chaining": {
-		syntax: "none | chained",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "none",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zooming": {
-		syntax: "none | zoom",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "zoomForTheTopLevelNoneForTheRest",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zoom-limit": {
-		syntax: "<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: [
-			"-ms-content-zoom-limit-max",
-			"-ms-content-zoom-limit-min"
-		],
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: [
-			"-ms-content-zoom-limit-max",
-			"-ms-content-zoom-limit-min"
-		],
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: [
-			"-ms-content-zoom-limit-max",
-			"-ms-content-zoom-limit-min"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zoom-limit-max": {
-		syntax: "<percentage>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "maxZoomFactor",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "400%",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zoom-limit-min": {
-		syntax: "<percentage>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "minZoomFactor",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "100%",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zoom-snap": {
-		syntax: "<'-ms-content-zoom-snap-type'> || <'-ms-content-zoom-snap-points'>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: [
-			"-ms-content-zoom-snap-type",
-			"-ms-content-zoom-snap-points"
-		],
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: [
-			"-ms-content-zoom-snap-type",
-			"-ms-content-zoom-snap-points"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zoom-snap-points": {
-		syntax: "snapInterval( <percentage>, <percentage> ) | snapList( <percentage># )",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "snapInterval(0%, 100%)",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-content-zoom-snap-type": {
-		syntax: "none | proximity | mandatory",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "none",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-filter": {
-		syntax: "<string>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "\"\"",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-flow-from": {
-		syntax: "[ none | <custom-ident> ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "none",
-		appliesto: "nonReplacedElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-flow-into": {
-		syntax: "[ none | <custom-ident> ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "none",
-		appliesto: "iframeElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-high-contrast-adjust": {
-		syntax: "auto | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-hyphenate-limit-chars": {
-		syntax: "auto | <integer>{1,3}",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-hyphenate-limit-lines": {
-		syntax: "no-limit | <integer>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "no-limit",
-		appliesto: "blockContainerElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-hyphenate-limit-zone": {
-		syntax: "<percentage> | <length>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "referToLineBoxWidth",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "0",
-		appliesto: "blockContainerElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-ime-align": {
-		syntax: "auto | after",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-overflow-style": {
-		syntax: "auto | none | scrollbar | -ms-autohiding-scrollbar",
-		media: "interactive",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "auto",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-3dlight-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "dependsOnUserAgent",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-arrow-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "ButtonText",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-base-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "dependsOnUserAgent",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-darkshadow-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "ThreeDDarkShadow",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-face-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "ThreeDFace",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-highlight-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "ThreeDHighlight",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-shadow-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "ThreeDDarkShadow",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scrollbar-track-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "Scrollbar",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-chaining": {
-		syntax: "chained | none",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "chained",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-limit": {
-		syntax: "<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: [
-			"-ms-scroll-limit-x-min",
-			"-ms-scroll-limit-y-min",
-			"-ms-scroll-limit-x-max",
-			"-ms-scroll-limit-y-max"
-		],
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: [
-			"-ms-scroll-limit-x-min",
-			"-ms-scroll-limit-y-min",
-			"-ms-scroll-limit-x-max",
-			"-ms-scroll-limit-y-max"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-limit-x-max": {
-		syntax: "auto | <length>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "auto",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-limit-x-min": {
-		syntax: "<length>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "0",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-limit-y-max": {
-		syntax: "auto | <length>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "auto",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-limit-y-min": {
-		syntax: "<length>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "0",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-rails": {
-		syntax: "none | railed",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "railed",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-snap-points-x": {
-		syntax: "snapInterval( <length-percentage>, <length-percentage> ) | snapList( <length-percentage># )",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "snapInterval(0px, 100%)",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-snap-points-y": {
-		syntax: "snapInterval( <length-percentage>, <length-percentage> ) | snapList( <length-percentage># )",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "snapInterval(0px, 100%)",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-snap-type": {
-		syntax: "none | proximity | mandatory",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "none",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-snap-x": {
-		syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: [
-			"-ms-scroll-snap-type",
-			"-ms-scroll-snap-points-x"
-		],
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: [
-			"-ms-scroll-snap-type",
-			"-ms-scroll-snap-points-x"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-snap-y": {
-		syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: [
-			"-ms-scroll-snap-type",
-			"-ms-scroll-snap-points-y"
-		],
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: [
-			"-ms-scroll-snap-type",
-			"-ms-scroll-snap-points-y"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-scroll-translation": {
-		syntax: "none | vertical-to-horizontal",
-		media: "interactive",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-text-autospace": {
-		syntax: "none | ideograph-alpha | ideograph-numeric | ideograph-parenthesis | ideograph-space",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-touch-select": {
-		syntax: "grippers | none",
-		media: "interactive",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "grippers",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-user-select": {
-		syntax: "none | element | text",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "text",
-		appliesto: "nonReplacedElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-wrap-flow": {
-		syntax: "auto | both | start | end | maximum | clear",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "auto",
-		appliesto: "blockLevelElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-wrap-margin": {
-		syntax: "<length>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "0",
-		appliesto: "exclusionElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-ms-wrap-through": {
-		syntax: "wrap | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Microsoft Extensions"
-		],
-		initial: "wrap",
-		appliesto: "blockLevelElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-appearance": {
-		syntax: "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",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "noneButOverriddenInUserAgentCSS",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-binding": {
-		syntax: "<url> | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElementsExceptGeneratedContentOrPseudoElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-border-bottom-colors": {
-		syntax: "<color>+ | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-border-left-colors": {
-		syntax: "<color>+ | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-border-right-colors": {
-		syntax: "<color>+ | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-border-top-colors": {
-		syntax: "<color>+ | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-context-properties": {
-		syntax: "none | [ fill | fill-opacity | stroke | stroke-opacity ]#",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElementsThatCanReferenceImages",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-float-edge": {
-		syntax: "border-box | content-box | margin-box | padding-box",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "content-box",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-force-broken-image-icon": {
-		syntax: "<integer>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "0",
-		appliesto: "images",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-image-region": {
-		syntax: "<shape> | auto",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "auto",
-		appliesto: "xulImageElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-orient": {
-		syntax: "inline | block | horizontal | vertical",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "inline",
-		appliesto: "anyElementEffectOnProgressAndMeter",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-outline-radius": {
-		syntax: "<outline-radius>{1,4} [ / <outline-radius>{1,4} ]?",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"-moz-outline-radius-topleft",
-			"-moz-outline-radius-topright",
-			"-moz-outline-radius-bottomright",
-			"-moz-outline-radius-bottomleft"
-		],
-		percentages: [
-			"-moz-outline-radius-topleft",
-			"-moz-outline-radius-topright",
-			"-moz-outline-radius-bottomright",
-			"-moz-outline-radius-bottomleft"
-		],
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: [
-			"-moz-outline-radius-topleft",
-			"-moz-outline-radius-topright",
-			"-moz-outline-radius-bottomright",
-			"-moz-outline-radius-bottomleft"
-		],
-		appliesto: "allElements",
-		computed: [
-			"-moz-outline-radius-topleft",
-			"-moz-outline-radius-topright",
-			"-moz-outline-radius-bottomright",
-			"-moz-outline-radius-bottomleft"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-outline-radius-bottomleft": {
-		syntax: "<outline-radius>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-outline-radius-bottomright": {
-		syntax: "<outline-radius>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-outline-radius-topleft": {
-		syntax: "<outline-radius>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-outline-radius-topright": {
-		syntax: "<outline-radius>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-stack-sizing": {
-		syntax: "ignore | stretch-to-fit",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "stretch-to-fit",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-text-blink": {
-		syntax: "none | blink",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-user-focus": {
-		syntax: "ignore | normal | select-after | select-before | select-menu | select-same | select-all | none",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-user-input": {
-		syntax: "auto | none | enabled | disabled",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-user-modify": {
-		syntax: "read-only | read-write | write-only",
-		media: "interactive",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "read-only",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-window-dragging": {
-		syntax: "drag | no-drag",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "drag",
-		appliesto: "allElementsCreatingNativeWindows",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-moz-window-shadow": {
-		syntax: "default | menu | tooltip | sheet | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "default",
-		appliesto: "allElementsCreatingNativeWindows",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-appearance": {
-		syntax: "none | button | button-bevel | 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 | searchfield | searchfield-cancel-button | searchfield-decoration | searchfield-results-button | searchfield-results-decoration | slider-horizontal | slider-vertical | sliderthumb-horizontal | sliderthumb-vertical | square-button | textarea | textfield",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "noneButOverriddenInUserAgentCSS",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-border-before": {
-		syntax: "<'border-width'> || <'border-style'> || <'color'>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: [
-			"-webkit-border-before-width"
-		],
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: [
-			"border-width",
-			"border-style",
-			"color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-width",
-			"border-style",
-			"color"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-border-before-color": {
-		syntax: "<'color'>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-border-before-style": {
-		syntax: "<'border-style'>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-border-before-width": {
-		syntax: "<'border-width'>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-box-reflect": {
-		syntax: "[ above | below | right | left ]? <length>? <image>?",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-mask": {
-		syntax: "[ <mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || [ <box> | border | padding | content | text ] || [ <box> | border | padding | content ] ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: [
-			"-webkit-mask-image",
-			"-webkit-mask-repeat",
-			"-webkit-mask-attachment",
-			"-webkit-mask-position",
-			"-webkit-mask-origin",
-			"-webkit-mask-clip"
-		],
-		appliesto: "allElements",
-		computed: [
-			"-webkit-mask-image",
-			"-webkit-mask-repeat",
-			"-webkit-mask-attachment",
-			"-webkit-mask-position",
-			"-webkit-mask-origin",
-			"-webkit-mask-clip"
-		],
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-mask-attachment": {
-		syntax: "<attachment>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "scroll",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-clip": {
-		syntax: "[ <box> | border | padding | content | text ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "border",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-composite": {
-		syntax: "<composite-style>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "source-over",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-image": {
-		syntax: "<mask-reference>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "absoluteURIOrNone",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-origin": {
-		syntax: "[ <box> | border | padding | content ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "padding",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-position": {
-		syntax: "<position>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToSizeOfElement",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "0% 0%",
-		appliesto: "allElements",
-		computed: "absoluteLengthOrPercentage",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-position-x": {
-		syntax: "[ <length-percentage> | left | center | right ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToSizeOfElement",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "0%",
-		appliesto: "allElements",
-		computed: "absoluteLengthOrPercentage",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-position-y": {
-		syntax: "[ <length-percentage> | top | center | bottom ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToSizeOfElement",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "0%",
-		appliesto: "allElements",
-		computed: "absoluteLengthOrPercentage",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-repeat": {
-		syntax: "<repeat-style>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "repeat",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-repeat-x": {
-		syntax: "repeat | no-repeat | space | round",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "repeat",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-repeat-y": {
-		syntax: "repeat | no-repeat | space | round",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "repeat",
-		appliesto: "allElements",
-		computed: "absoluteLengthOrPercentage",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-mask-size": {
-		syntax: "<bg-size>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "relativeToBackgroundPositioningArea",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "auto auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-overflow-scrolling": {
-		syntax: "auto | touch",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "auto",
-		appliesto: "scrollingBoxes",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "nonstandard"
-	},
-		"-webkit-tap-highlight-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "black",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-text-fill-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-text-stroke": {
-		syntax: "<length> || <color>",
-		media: "visual",
-		inherited: true,
-		animationType: [
-			"-webkit-text-stroke-width",
-			"-webkit-text-stroke-color"
-		],
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: [
-			"-webkit-text-stroke-width",
-			"-webkit-text-stroke-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"-webkit-text-stroke-width",
-			"-webkit-text-stroke-color"
-		],
-		order: "canonicalOrder",
-		status: "nonstandard"
-	},
-		"-webkit-text-stroke-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: true,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-text-stroke-width": {
-		syntax: "<length>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "absoluteLength",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-touch-callout": {
-		syntax: "default | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "default",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"-webkit-user-modify": {
-		syntax: "read-only | read-write | read-write-plaintext-only",
-		media: "interactive",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"WebKit Extensions"
-		],
-		initial: "read-only",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"align-content": {
-		syntax: "normal | <baseline-position> | <content-distribution> | <overflow-position>? <content-position>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "normal",
-		appliesto: "multilineFlexContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"align-items": {
-		syntax: "normal | stretch | <baseline-position> | [ <overflow-position>? <self-position> ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"align-self": {
-		syntax: "auto | normal | stretch | <baseline-position> | <overflow-position>? <self-position>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "auto",
-		appliesto: "flexItemsGridItemsAndAbsolutelyPositionedBoxes",
-		computed: "autoOnAbsolutelyPositionedElementsValueOfAlignItemsOnParent",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		all: all,
-		animation: animation,
-		"animation-delay": {
-		syntax: "<time>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "0s",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"animation-direction": {
-		syntax: "<single-animation-direction>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "normal",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"animation-duration": {
-		syntax: "<time>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "0s",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"animation-fill-mode": {
-		syntax: "<single-animation-fill-mode>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "none",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"animation-iteration-count": {
-		syntax: "<single-animation-iteration-count>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "1",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"animation-name": {
-		syntax: "[ none | <keyframes-name> ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "none",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"animation-play-state": {
-		syntax: "<single-animation-play-state>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "running",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"animation-timing-function": {
-		syntax: "<single-timing-function>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Animations"
-		],
-		initial: "ease",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		appearance: appearance,
-		azimuth: azimuth,
-		"backdrop-filter": {
-		syntax: "none | <filter-function-list>",
-		media: "visual",
-		inherited: false,
-		animationType: "filterList",
-		percentages: "no",
-		groups: [
-			"Filter Effects"
-		],
-		initial: "none",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"backface-visibility": {
-		syntax: "visible | hidden",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "visible",
-		appliesto: "transformableElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		background: background,
-		"background-attachment": {
-		syntax: "<attachment>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "scroll",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-blend-mode": {
-		syntax: "<blend-mode>#",
-		media: "none",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Compositing and Blending"
-		],
-		initial: "normal",
-		appliesto: "allElementsSVGContainerGraphicsAndGraphicsReferencingElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-clip": {
-		syntax: "<box>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "border-box",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "transparent",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-image": {
-		syntax: "<bg-image>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecifiedURLsAbsolute",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-origin": {
-		syntax: "<box>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "padding-box",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-position": {
-		syntax: "<bg-position>#",
-		media: "visual",
-		inherited: false,
-		animationType: "repeatableListOfSimpleListOfLpc",
-		percentages: "referToSizeOfBackgroundPositioningAreaMinusBackgroundImageSize",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "0% 0%",
-		appliesto: "allElements",
-		computed: "listEachItemTwoKeywordsOriginOffsets",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-position-x": {
-		syntax: "[ center | [ left | right | x-start | x-end ]? <length-percentage>? ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToWidthOfBackgroundPositioningAreaMinusBackgroundImageHeight",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "left",
-		appliesto: "allElements",
-		computed: "listEachItemConsistingOfAbsoluteLengthPercentageAndOrigin",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"background-position-y": {
-		syntax: "[ center | [ top | bottom | y-start | y-end ]? <length-percentage>? ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToHeightOfBackgroundPositioningAreaMinusBackgroundImageHeight",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "top",
-		appliesto: "allElements",
-		computed: "listEachItemConsistingOfAbsoluteLengthPercentageAndOrigin",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"background-repeat": {
-		syntax: "<repeat-style>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "repeat",
-		appliesto: "allElements",
-		computed: "listEachItemHasTwoKeywordsOnePerDimension",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"background-size": {
-		syntax: "<bg-size>#",
-		media: "visual",
-		inherited: false,
-		animationType: "repeatableListOfSimpleListOfLpc",
-		percentages: "relativeToBackgroundPositioningArea",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "auto auto",
-		appliesto: "allElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"block-overflow": {
-		syntax: "clip | ellipsis | <string>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "clip",
-		appliesto: "blockContainers",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"block-size": {
-		syntax: "<'width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "blockSizeOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "auto",
-		appliesto: "sameAsWidthAndHeight",
-		computed: "sameAsWidthAndHeight",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		border: border,
-		"border-block-end": {
-		syntax: "<'border-width'> || <'border-style'> || <'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: [
-			"border-width",
-			"border-style",
-			"color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-width",
-			"border-style",
-			"border-block-end-color"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-block-end-color": {
-		syntax: "<'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-block-end-style": {
-		syntax: "<'border-style'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-block-end-width": {
-		syntax: "<'border-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-block-start": {
-		syntax: "<'border-width'> || <'border-style'> || <'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: [
-			"border-width",
-			"border-style",
-			"color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-width",
-			"border-style",
-			"border-block-start-color"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-block-start-color": {
-		syntax: "<'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-block-start-style": {
-		syntax: "<'border-style'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-block-start-width": {
-		syntax: "<'border-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-bottom": {
-		syntax: "<br-width> || <br-style> || <color>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-bottom-color",
-			"border-bottom-style",
-			"border-bottom-width"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-bottom-width",
-			"border-bottom-style",
-			"border-bottom-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-bottom-width",
-			"border-bottom-style",
-			"border-bottom-color"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-bottom-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-bottom-left-radius": {
-		syntax: "<length-percentage>{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "0",
-		appliesto: "allElementsUAsNotRequiredWhenCollapse",
-		computed: "twoAbsoluteLengthOrPercentages",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-bottom-right-radius": {
-		syntax: "<length-percentage>{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "0",
-		appliesto: "allElementsUAsNotRequiredWhenCollapse",
-		computed: "twoAbsoluteLengthOrPercentages",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-bottom-style": {
-		syntax: "<br-style>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-bottom-width": {
-		syntax: "<br-width>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthOr0IfBorderBottomStyleNoneOrHidden",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-collapse": {
-		syntax: "collapse | separate",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Table"
-		],
-		initial: "separate",
-		appliesto: "tableElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-color": {
-		syntax: "<color>{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-bottom-color",
-			"border-left-color",
-			"border-right-color",
-			"border-top-color"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-top-color",
-			"border-right-color",
-			"border-bottom-color",
-			"border-left-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-bottom-color",
-			"border-left-color",
-			"border-right-color",
-			"border-top-color"
-		],
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-image": {
-		syntax: "<'border-image-source'> || <'border-image-slice'> [ / <'border-image-width'> | / <'border-image-width'>? / <'border-image-outset'> ]? || <'border-image-repeat'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: [
-			"border-image-slice",
-			"border-image-width"
-		],
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-image-source",
-			"border-image-slice",
-			"border-image-width",
-			"border-image-outset",
-			"border-image-repeat"
-		],
-		appliesto: "allElementsExceptTableElementsWhenCollapse",
-		computed: [
-			"border-image-outset",
-			"border-image-repeat",
-			"border-image-slice",
-			"border-image-source",
-			"border-image-width"
-		],
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-image-outset": {
-		syntax: "[ <length> | <number> ]{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptTableElementsWhenCollapse",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-image-repeat": {
-		syntax: "[ stretch | repeat | round | space ]{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "stretch",
-		appliesto: "allElementsExceptTableElementsWhenCollapse",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-image-slice": {
-		syntax: "<number-percentage>{1,4} && fill?",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToSizeOfBorderImage",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "100%",
-		appliesto: "allElementsExceptTableElementsWhenCollapse",
-		computed: "oneToFourPercentagesOrAbsoluteLengthsPlusFill",
-		order: "percentagesOrLengthsFollowedByFill",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-image-source": {
-		syntax: "none | <image>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "none",
-		appliesto: "allElementsExceptTableElementsWhenCollapse",
-		computed: "noneOrImageWithAbsoluteURI",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-image-width": {
-		syntax: "[ <length-percentage> | <number> | auto ]{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToWidthOrHeightOfBorderImageArea",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "1",
-		appliesto: "allElementsExceptTableElementsWhenCollapse",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-inline-end": {
-		syntax: "<'border-width'> || <'border-style'> || <'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: [
-			"border-width",
-			"border-style",
-			"color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-width",
-			"border-style",
-			"border-inline-end-color"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-inline-end-color": {
-		syntax: "<'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-inline-end-style": {
-		syntax: "<'border-style'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-inline-end-width": {
-		syntax: "<'border-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-inline-start": {
-		syntax: "<'border-width'> || <'border-style'> || <'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: [
-			"border-width",
-			"border-style",
-			"color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-width",
-			"border-style",
-			"border-inline-start-color"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-inline-start-color": {
-		syntax: "<'color'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-inline-start-style": {
-		syntax: "<'border-style'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-inline-start-width": {
-		syntax: "<'border-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-left": {
-		syntax: "<br-width> || <br-style> || <color>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-left-color",
-			"border-left-style",
-			"border-left-width"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-left-width",
-			"border-left-style",
-			"border-left-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-left-width",
-			"border-left-style",
-			"border-left-color"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-left-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-left-style": {
-		syntax: "<br-style>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-left-width": {
-		syntax: "<br-width>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthOr0IfBorderLeftStyleNoneOrHidden",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-radius": {
-		syntax: "<length-percentage>{1,4} [ / <length-percentage>{1,4} ]?",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-top-left-radius",
-			"border-top-right-radius",
-			"border-bottom-right-radius",
-			"border-bottom-left-radius"
-		],
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-top-left-radius",
-			"border-top-right-radius",
-			"border-bottom-right-radius",
-			"border-bottom-left-radius"
-		],
-		appliesto: "allElementsUAsNotRequiredWhenCollapse",
-		computed: [
-			"border-bottom-left-radius",
-			"border-bottom-right-radius",
-			"border-top-left-radius",
-			"border-top-right-radius"
-		],
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-right": {
-		syntax: "<br-width> || <br-style> || <color>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-right-color",
-			"border-right-style",
-			"border-right-width"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-right-width",
-			"border-right-style",
-			"border-right-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-right-width",
-			"border-right-style",
-			"border-right-color"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-right-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-right-style": {
-		syntax: "<br-style>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-right-width": {
-		syntax: "<br-width>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthOr0IfBorderRightStyleNoneOrHidden",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-spacing": {
-		syntax: "<length> <length>?",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Table"
-		],
-		initial: "0",
-		appliesto: "tableElements",
-		computed: "twoAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"border-style": {
-		syntax: "<br-style>{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-top-style",
-			"border-right-style",
-			"border-bottom-style",
-			"border-left-style"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-bottom-style",
-			"border-left-style",
-			"border-right-style",
-			"border-top-style"
-		],
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-top": {
-		syntax: "<br-width> || <br-style> || <color>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-top-color",
-			"border-top-style",
-			"border-top-width"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-top-width",
-			"border-top-style",
-			"border-top-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-top-width",
-			"border-top-style",
-			"border-top-color"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-top-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-top-left-radius": {
-		syntax: "<length-percentage>{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "0",
-		appliesto: "allElementsUAsNotRequiredWhenCollapse",
-		computed: "twoAbsoluteLengthOrPercentages",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-top-right-radius": {
-		syntax: "<length-percentage>{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfBorderBox",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "0",
-		appliesto: "allElementsUAsNotRequiredWhenCollapse",
-		computed: "twoAbsoluteLengthOrPercentages",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-top-style": {
-		syntax: "<br-style>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-top-width": {
-		syntax: "<br-width>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLengthOr0IfBorderTopStyleNoneOrHidden",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"border-width": {
-		syntax: "<br-width>{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"border-bottom-width",
-			"border-left-width",
-			"border-right-width",
-			"border-top-width"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: [
-			"border-top-width",
-			"border-right-width",
-			"border-bottom-width",
-			"border-left-width"
-		],
-		appliesto: "allElements",
-		computed: [
-			"border-bottom-width",
-			"border-left-width",
-			"border-right-width",
-			"border-top-width"
-		],
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		bottom: bottom,
-		"box-align": {
-		syntax: "start | center | end | baseline | stretch",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "stretch",
-		appliesto: "elementsWithDisplayBoxOrInlineBox",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-decoration-break": {
-		syntax: "slice | clone",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fragmentation"
-		],
-		initial: "slice",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"box-direction": {
-		syntax: "normal | reverse | inherit",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "normal",
-		appliesto: "elementsWithDisplayBoxOrInlineBox",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-flex": {
-		syntax: "<number>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "0",
-		appliesto: "directChildrenOfElementsWithDisplayMozBoxMozInlineBox",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-flex-group": {
-		syntax: "<integer>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "1",
-		appliesto: "inFlowChildrenOfBoxElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-lines": {
-		syntax: "single | multiple",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "single",
-		appliesto: "boxElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-ordinal-group": {
-		syntax: "<integer>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "1",
-		appliesto: "childrenOfBoxElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-orient": {
-		syntax: "horizontal | vertical | inline-axis | block-axis | inherit",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "inlineAxisHorizontalInXUL",
-		appliesto: "elementsWithDisplayBoxOrInlineBox",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-pack": {
-		syntax: "start | center | end | justify",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions",
-			"WebKit Extensions"
-		],
-		initial: "start",
-		appliesto: "elementsWithDisplayMozBoxMozInlineBox",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"box-shadow": {
-		syntax: "none | <shadow>#",
-		media: "visual",
-		inherited: false,
-		animationType: "shadowList",
-		percentages: "no",
-		groups: [
-			"CSS Backgrounds and Borders"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "absoluteLengthsSpecifiedColorAsSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"box-sizing": {
-		syntax: "content-box | border-box",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "content-box",
-		appliesto: "allElementsAcceptingWidthOrHeight",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"break-after": {
-		syntax: "auto | avoid | avoid-page | page | left | right | recto | verso | avoid-column | column | avoid-region | region",
-		media: "paged",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fragmentation"
-		],
-		initial: "auto",
-		appliesto: "blockLevelElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"break-before": {
-		syntax: "auto | avoid | avoid-page | page | left | right | recto | verso | avoid-column | column | avoid-region | region",
-		media: "paged",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fragmentation"
-		],
-		initial: "auto",
-		appliesto: "blockLevelElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"break-inside": {
-		syntax: "auto | avoid | avoid-page | avoid-column | avoid-region",
-		media: "paged",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fragmentation"
-		],
-		initial: "auto",
-		appliesto: "blockLevelElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"caption-side": {
-		syntax: "top | bottom | block-start | block-end | inline-start | inline-end",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Table"
-		],
-		initial: "top",
-		appliesto: "tableCaptionElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"caret-color": {
-		syntax: "auto | <color>",
-		media: "interactive",
-		inherited: true,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asAutoOrColor",
-		order: "perGrammar",
-		status: "standard"
-	},
-		clear: clear,
-		clip: clip,
-		"clip-path": {
-		syntax: "<clip-source> | [ <basic-shape> || <geometry-box> ] | none",
-		media: "visual",
-		inherited: false,
-		animationType: "basicShapeOtherwiseNo",
-		percentages: "referToReferenceBoxWhenSpecifiedOtherwiseBorderBox",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "none",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecifiedURLsAbsolute",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		color: color,
-		"color-adjust": {
-		syntax: "economy | exact",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Color"
-		],
-		initial: "economy",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-count": {
-		syntax: "<integer> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "integer",
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: "auto",
-		appliesto: "blockContainersExceptTableWrappers",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-fill": {
-		syntax: "auto | balance | balance-all",
-		media: "visualInContinuousMediaNoEffectInOverflowColumns",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: "balance",
-		appliesto: "multicolElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-gap": {
-		syntax: "normal | <length-percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Box Alignment"
-		],
-		initial: "normal",
-		appliesto: "multiColumnElementsFlexContainersGridContainers",
-		computed: "asSpecifiedWithLengthsAbsoluteAndNormalComputingToZeroExceptMultiColumn",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-rule": {
-		syntax: "<'column-rule-width'> || <'column-rule-style'> || <'column-rule-color'>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"column-rule-color",
-			"column-rule-style",
-			"column-rule-width"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: [
-			"column-rule-width",
-			"column-rule-style",
-			"column-rule-color"
-		],
-		appliesto: "multicolElements",
-		computed: [
-			"column-rule-color",
-			"column-rule-style",
-			"column-rule-width"
-		],
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-rule-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: "currentcolor",
-		appliesto: "multicolElements",
-		computed: "computedColor",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-rule-style": {
-		syntax: "<'border-style'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: "none",
-		appliesto: "multicolElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-rule-width": {
-		syntax: "<'border-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: "medium",
-		appliesto: "multicolElements",
-		computed: "absoluteLength0IfColumnRuleStyleNoneOrHidden",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-span": {
-		syntax: "none | all",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: "none",
-		appliesto: "inFlowBlockLevelElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"column-width": {
-		syntax: "<length> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Columns"
-		],
-		initial: "auto",
-		appliesto: "blockContainersExceptTableWrappers",
-		computed: "absoluteLengthZeroOrLarger",
-		order: "perGrammar",
-		status: "standard"
-	},
-		columns: columns,
-		contain: contain,
-		content: content,
-		"counter-increment": {
-		syntax: "[ <custom-ident> <integer>? ]+ | none",
-		media: "all",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Counter Styles"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"counter-reset": {
-		syntax: "[ <custom-ident> <integer>? ]+ | none",
-		media: "all",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Counter Styles"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		cursor: cursor,
-		direction: direction,
-		display: display,
-		"empty-cells": {
-		syntax: "show | hide",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Table"
-		],
-		initial: "show",
-		appliesto: "tableCellElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		filter: filter,
-		flex: flex,
-		"flex-basis": {
-		syntax: "content | <'width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToFlexContainersInnerMainSize",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "auto",
-		appliesto: "flexItemsAndInFlowPseudos",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "lengthOrPercentageBeforeKeywordIfBothPresent",
-		status: "standard"
-	},
-		"flex-direction": {
-		syntax: "row | row-reverse | column | column-reverse",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "row",
-		appliesto: "flexContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"flex-flow": {
-		syntax: "<'flex-direction'> || <'flex-wrap'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: [
-			"flex-direction",
-			"flex-wrap"
-		],
-		appliesto: "flexContainers",
-		computed: [
-			"flex-direction",
-			"flex-wrap"
-		],
-		order: "orderOfAppearance",
-		status: "standard"
-	},
-		"flex-grow": {
-		syntax: "<number>",
-		media: "visual",
-		inherited: false,
-		animationType: "number",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "0",
-		appliesto: "flexItemsAndInFlowPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"flex-shrink": {
-		syntax: "<number>",
-		media: "visual",
-		inherited: false,
-		animationType: "number",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "1",
-		appliesto: "flexItemsAndInFlowPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"flex-wrap": {
-		syntax: "nowrap | wrap | wrap-reverse",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "nowrap",
-		appliesto: "flexContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		float: float,
-		font: font,
-		"font-family": {
-		syntax: "[ <family-name> | <generic-family> ]#",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "dependsOnUserAgent",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-feature-settings": {
-		syntax: "normal | <feature-tag-value>#",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-kerning": {
-		syntax: "auto | normal | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-language-override": {
-		syntax: "normal | <string>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-optical-sizing": {
-		syntax: "auto | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variation-settings": {
-		syntax: "normal | [ <string> <number> ]#",
-		media: "visual",
-		inherited: true,
-		animationType: "transform",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "experimental"
-	},
-		"font-size": {
-		syntax: "<absolute-size> | <relative-size> | <length-percentage>",
-		media: "visual",
-		inherited: true,
-		animationType: "length",
-		percentages: "referToParentElementsFontSize",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-size-adjust": {
-		syntax: "none | <number>",
-		media: "visual",
-		inherited: true,
-		animationType: "number",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-stretch": {
-		syntax: "<font-stretch-absolute>",
-		media: "visual",
-		inherited: true,
-		animationType: "fontStretch",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-style": {
-		syntax: "normal | italic | oblique <angle>?",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-synthesis": {
-		syntax: "none | [ weight || style ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "weight style",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variant": {
-		syntax: "normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> || stylistic( <feature-value-name> ) || historical-forms || styleset( <feature-value-name># ) || character-variant( <feature-value-name># ) || swash( <feature-value-name> ) || ornaments( <feature-value-name> ) || annotation( <feature-value-name> ) || [ small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps ] || <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero || <east-asian-variant-values> || <east-asian-width-values> || ruby ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variant-alternates": {
-		syntax: "normal | [ stylistic( <feature-value-name> ) || historical-forms || styleset( <feature-value-name># ) || character-variant( <feature-value-name># ) || swash( <feature-value-name> ) || ornaments( <feature-value-name> ) || annotation( <feature-value-name> ) ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variant-caps": {
-		syntax: "normal | small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variant-east-asian": {
-		syntax: "normal | [ <east-asian-variant-values> || <east-asian-width-values> || ruby ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variant-ligatures": {
-		syntax: "normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variant-numeric": {
-		syntax: "normal | [ <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-variant-position": {
-		syntax: "normal | sub | super",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"font-weight": {
-		syntax: "<font-weight-absolute> | bolder | lighter",
-		media: "visual",
-		inherited: true,
-		animationType: "fontWeight",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "keywordOrNumericalValueBolderLighterTransformedToRealValue",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		gap: gap,
-		grid: grid,
-		"grid-area": {
-		syntax: "<grid-line> [ / <grid-line> ]{0,3}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: [
-			"grid-row-start",
-			"grid-column-start",
-			"grid-row-end",
-			"grid-column-end"
-		],
-		appliesto: "gridItemsAndBoxesWithinGridContainer",
-		computed: [
-			"grid-row-start",
-			"grid-column-start",
-			"grid-row-end",
-			"grid-column-end"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-auto-columns": {
-		syntax: "<track-size>+",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "auto",
-		appliesto: "gridContainers",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-auto-flow": {
-		syntax: "[ row | column ] || dense",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "row",
-		appliesto: "gridContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-auto-rows": {
-		syntax: "<track-size>+",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "auto",
-		appliesto: "gridContainers",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-column": {
-		syntax: "<grid-line> [ / <grid-line> ]?",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: [
-			"grid-column-start",
-			"grid-column-end"
-		],
-		appliesto: "gridItemsAndBoxesWithinGridContainer",
-		computed: [
-			"grid-column-start",
-			"grid-column-end"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-column-end": {
-		syntax: "<grid-line>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "auto",
-		appliesto: "gridItemsAndBoxesWithinGridContainer",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-column-gap": {
-		syntax: "<length-percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "0",
-		appliesto: "gridContainers",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "obsolete"
-	},
-		"grid-column-start": {
-		syntax: "<grid-line>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "auto",
-		appliesto: "gridItemsAndBoxesWithinGridContainer",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-gap": {
-		syntax: "<'grid-row-gap'> <'grid-column-gap'>?",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"grid-row-gap",
-			"grid-column-gap"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: [
-			"grid-row-gap",
-			"grid-column-gap"
-		],
-		appliesto: "gridContainers",
-		computed: [
-			"grid-row-gap",
-			"grid-column-gap"
-		],
-		order: "uniqueOrder",
-		status: "obsolete"
-	},
-		"grid-row": {
-		syntax: "<grid-line> [ / <grid-line> ]?",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: [
-			"grid-row-start",
-			"grid-row-end"
-		],
-		appliesto: "gridItemsAndBoxesWithinGridContainer",
-		computed: [
-			"grid-row-start",
-			"grid-row-end"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-row-end": {
-		syntax: "<grid-line>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "auto",
-		appliesto: "gridItemsAndBoxesWithinGridContainer",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-row-gap": {
-		syntax: "<length-percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "0",
-		appliesto: "gridContainers",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "obsolete"
-	},
-		"grid-row-start": {
-		syntax: "<grid-line>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "auto",
-		appliesto: "gridItemsAndBoxesWithinGridContainer",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-template": {
-		syntax: "none | [ <'grid-template-rows'> / <'grid-template-columns'> ] | [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: [
-			"grid-template-columns",
-			"grid-template-rows"
-		],
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: [
-			"grid-template-columns",
-			"grid-template-rows",
-			"grid-template-areas"
-		],
-		appliesto: "gridContainers",
-		computed: [
-			"grid-template-columns",
-			"grid-template-rows",
-			"grid-template-areas"
-		],
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-template-areas": {
-		syntax: "none | <string>+",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "none",
-		appliesto: "gridContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-template-columns": {
-		syntax: "none | <track-list> | <auto-track-list>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "none",
-		appliesto: "gridContainers",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"grid-template-rows": {
-		syntax: "none | <track-list> | <auto-track-list>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Grid Layout"
-		],
-		initial: "none",
-		appliesto: "gridContainers",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"hanging-punctuation": {
-		syntax: "none | [ first || [ force-end | allow-end ] || last ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		height: height,
-		hyphens: hyphens,
-		"image-orientation": {
-		syntax: "from-image | <angle> | [ <angle>? flip ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Images"
-		],
-		initial: "0deg",
-		appliesto: "allElements",
-		computed: "angleRoundedToNextQuarter",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"image-rendering": {
-		syntax: "auto | crisp-edges | pixelated",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Images"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"image-resolution": {
-		syntax: "[ from-image || <resolution> ] && snap?",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Images"
-		],
-		initial: "1dppx",
-		appliesto: "allElements",
-		computed: "asSpecifiedWithExceptionOfResolution",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"ime-mode": {
-		syntax: "auto | normal | active | inactive | disabled",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "auto",
-		appliesto: "textFields",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "obsolete"
-	},
-		"initial-letter": {
-		syntax: "normal | [ <number> <integer>? ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Inline"
-		],
-		initial: "normal",
-		appliesto: "firstLetterPseudoElementsAndInlineLevelFirstChildren",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"initial-letter-align": {
-		syntax: "[ auto | alphabetic | hanging | ideographic ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Inline"
-		],
-		initial: "auto",
-		appliesto: "firstLetterPseudoElementsAndInlineLevelFirstChildren",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"inline-size": {
-		syntax: "<'width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "inlineSizeOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "auto",
-		appliesto: "sameAsWidthAndHeight",
-		computed: "sameAsWidthAndHeight",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		isolation: isolation,
-		"justify-content": {
-		syntax: "normal | <content-distribution> | <overflow-position>? [ <content-position> | left | right ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "normal",
-		appliesto: "flexContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"justify-items": {
-		syntax: "normal | stretch | <baseline-position> | <overflow-position>? [ <self-position> | left | right ] | legacy | legacy && [ left | right | center ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Box Alignment"
-		],
-		initial: "legacy",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"justify-self": {
-		syntax: "auto | normal | stretch | <baseline-position> | <overflow-position>? [ <self-position> | left | right ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Box Alignment"
-		],
-		initial: "auto",
-		appliesto: "blockLevelBoxesAndAbsolutelyPositionedBoxesAndGridItems",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		left: left,
-		"letter-spacing": {
-		syntax: "normal | <length>",
-		media: "visual",
-		inherited: true,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "optimumValueOfAbsoluteLengthOrNormal",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line"
-		],
-		status: "standard"
-	},
-		"line-break": {
-		syntax: "auto | loose | normal | strict",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"line-clamp": {
-		syntax: "none | <integer>",
-		media: "visual",
-		inherited: false,
-		animationType: "integer",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "none",
-		appliesto: "blockContainersExceptMultiColumnContainers",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"line-height": {
-		syntax: "normal | <number> | <length> | <percentage>",
-		media: "visual",
-		inherited: true,
-		animationType: "numberOrLength",
-		percentages: "referToElementFontSize",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "absoluteLengthOrAsSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"line-height-step": {
-		syntax: "<length>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Fonts"
-		],
-		initial: "0",
-		appliesto: "blockContainerElements",
-		computed: "absoluteLength",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"list-style": {
-		syntax: "<'list-style-type'> || <'list-style-position'> || <'list-style-image'>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Lists and Counters"
-		],
-		initial: [
-			"list-style-type",
-			"list-style-position",
-			"list-style-image"
-		],
-		appliesto: "listItems",
-		computed: [
-			"list-style-image",
-			"list-style-position",
-			"list-style-type"
-		],
-		order: "orderOfAppearance",
-		status: "standard"
-	},
-		"list-style-image": {
-		syntax: "<url> | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Lists and Counters"
-		],
-		initial: "none",
-		appliesto: "listItems",
-		computed: "noneOrImageWithAbsoluteURI",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"list-style-position": {
-		syntax: "inside | outside",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Lists and Counters"
-		],
-		initial: "outside",
-		appliesto: "listItems",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"list-style-type": {
-		syntax: "<counter-style> | <string> | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Lists and Counters"
-		],
-		initial: "disc",
-		appliesto: "listItems",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		margin: margin,
-		"margin-block-end": {
-		syntax: "<'margin-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "dependsOnLayoutModel",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsMargin",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"margin-block-start": {
-		syntax: "<'margin-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "dependsOnLayoutModel",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsMargin",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"margin-bottom": {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"margin-inline-end": {
-		syntax: "<'margin-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "dependsOnLayoutModel",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsMargin",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"margin-inline-start": {
-		syntax: "<'margin-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "dependsOnLayoutModel",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsMargin",
-		computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"margin-left": {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"margin-right": {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"margin-top": {
-		syntax: "<length> | <percentage> | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		mask: mask,
-		"mask-border": {
-		syntax: "<'mask-border-source'> || <'mask-border-slice'> [ / <'mask-border-width'>? [ / <'mask-border-outset'> ]? ]? || <'mask-border-repeat'> || <'mask-border-mode'>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"mask-border-mode",
-			"mask-border-outset",
-			"mask-border-repeat",
-			"mask-border-slice",
-			"mask-border-source",
-			"mask-border-width"
-		],
-		percentages: [
-			"mask-border-slice",
-			"mask-border-width"
-		],
-		groups: [
-			"CSS Masking"
-		],
-		initial: [
-			"mask-border-mode",
-			"mask-border-outset",
-			"mask-border-repeat",
-			"mask-border-slice",
-			"mask-border-source",
-			"mask-border-width"
-		],
-		appliesto: "allElementsSVGContainerElements",
-		computed: [
-			"mask-border-mode",
-			"mask-border-outset",
-			"mask-border-repeat",
-			"mask-border-slice",
-			"mask-border-source",
-			"mask-border-width"
-		],
-		order: "perGrammar",
-		stacking: true,
-		status: "experimental"
-	},
-		"mask-border-mode": {
-		syntax: "luminance | alpha",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "alpha",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"mask-border-outset": {
-		syntax: "[ <length> | <number> ]{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "0",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"mask-border-repeat": {
-		syntax: "[ stretch | repeat | round | space ]{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "stretch",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"mask-border-slice": {
-		syntax: "<number-percentage>{1,4} fill?",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "referToSizeOfMaskBorderImage",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "0",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"mask-border-source": {
-		syntax: "none | <image>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "none",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecifiedURLsAbsolute",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"mask-border-width": {
-		syntax: "[ <length-percentage> | <number> | auto ]{1,4}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "relativeToMaskBorderImageArea",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "auto",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"mask-clip": {
-		syntax: "[ <geometry-box> | no-clip ]#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "border-box",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-composite": {
-		syntax: "<compositing-operator>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "add",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-image": {
-		syntax: "<mask-reference>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "none",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecifiedURLsAbsolute",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-mode": {
-		syntax: "<masking-mode>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "match-source",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-origin": {
-		syntax: "<geometry-box>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "border-box",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-position": {
-		syntax: "<position>#",
-		media: "visual",
-		inherited: false,
-		animationType: "repeatableListOfSimpleListOfLpc",
-		percentages: "referToSizeOfMaskPaintingArea",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "center",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "consistsOfTwoKeywordsForOriginAndOffsets",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-repeat": {
-		syntax: "<repeat-style>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "no-repeat",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "consistsOfTwoDimensionKeywords",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-size": {
-		syntax: "<bg-size>#",
-		media: "visual",
-		inherited: false,
-		animationType: "repeatableListOfSimpleListOfLpc",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "auto",
-		appliesto: "allElementsSVGContainerElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"mask-type": {
-		syntax: "luminance | alpha",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Masking"
-		],
-		initial: "luminance",
-		appliesto: "maskElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"max-block-size": {
-		syntax: "<'max-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "blockSizeOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsWidthAndHeight",
-		computed: "sameAsMaxWidthAndMaxHeight",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"max-height": {
-		syntax: "<length> | <percentage> | none | max-content | min-content | fit-content | fill-available",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentagesNone",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "none",
-		appliesto: "allElementsButNonReplacedAndTableColumns",
-		computed: "percentageAsSpecifiedAbsoluteLengthOrNone",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"max-inline-size": {
-		syntax: "<'max-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "inlineSizeOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsWidthAndHeight",
-		computed: "sameAsMaxWidthAndMaxHeight",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"max-lines": {
-		syntax: "none | <integer>",
-		media: "visual",
-		inherited: false,
-		animationType: "integer",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "none",
-		appliesto: "blockContainersExceptMultiColumnContainers",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"max-width": {
-		syntax: "<length> | <percentage> | none | max-content | min-content | fit-content | fill-available",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "none",
-		appliesto: "allElementsButNonReplacedAndTableRows",
-		computed: "percentageAsSpecifiedAbsoluteLengthOrNone",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"min-block-size": {
-		syntax: "<'min-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "blockSizeOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsWidthAndHeight",
-		computed: "sameAsMinWidthAndMinHeight",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"min-height": {
-		syntax: "<length> | <percentage> | auto | max-content | min-content | fit-content | fill-available",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentages0",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsButNonReplacedAndTableColumns",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"min-inline-size": {
-		syntax: "<'min-width'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "inlineSizeOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "sameAsWidthAndHeight",
-		computed: "sameAsMinWidthAndMinHeight",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"min-width": {
-		syntax: "<length> | <percentage> | auto | max-content | min-content | fit-content | fill-available",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsButNonReplacedAndTableRows",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"mix-blend-mode": {
-		syntax: "<blend-mode>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Compositing and Blending"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		stacking: true,
-		status: "standard"
-	},
-		"object-fit": {
-		syntax: "fill | contain | cover | none | scale-down",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Images"
-		],
-		initial: "fill",
-		appliesto: "replacedElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"object-position": {
-		syntax: "<position>",
-		media: "visual",
-		inherited: true,
-		animationType: "repeatableListOfSimpleListOfLpc",
-		percentages: "referToWidthAndHeightOfElement",
-		groups: [
-			"CSS Images"
-		],
-		initial: "50% 50%",
-		appliesto: "replacedElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		offset: offset,
-		"offset-anchor": {
-		syntax: "auto | <position>",
-		media: "visual",
-		inherited: false,
-		animationType: "position",
-		percentages: "relativeToWidthAndHeight",
-		groups: [
-			"CSS Motion"
-		],
-		initial: "auto",
-		appliesto: "transformableElements",
-		computed: "forLengthAbsoluteValueOtherwisePercentage",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"offset-block-end": {
-		syntax: "<'left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalHeightOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "sameAsBoxOffsets",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"offset-block-start": {
-		syntax: "<'left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalHeightOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "sameAsBoxOffsets",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"offset-inline-end": {
-		syntax: "<'left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "sameAsBoxOffsets",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"offset-inline-start": {
-		syntax: "<'left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "sameAsBoxOffsets",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"offset-distance": {
-		syntax: "<length-percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToTotalPathLength",
-		groups: [
-			"CSS Motion"
-		],
-		initial: "0",
-		appliesto: "transformableElements",
-		computed: "forLengthAbsoluteValueOtherwisePercentage",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"offset-path": {
-		syntax: "none | ray( [ <angle> && <size>? && contain? ] ) | <path()> | <url> | [ <basic-shape> || <geometry-box> ]",
-		media: "visual",
-		inherited: false,
-		animationType: "angleOrBasicShapeOrPath",
-		percentages: "no",
-		groups: [
-			"CSS Motion"
-		],
-		initial: "none",
-		appliesto: "transformableElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		stacking: true,
-		status: "experimental"
-	},
-		"offset-position": {
-		syntax: "auto | <position>",
-		media: "visual",
-		inherited: false,
-		animationType: "position",
-		percentages: "referToSizeOfContainingBlock",
-		groups: [
-			"CSS Motion"
-		],
-		initial: "auto",
-		appliesto: "transformableElements",
-		computed: "forLengthAbsoluteValueOtherwisePercentage",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"offset-rotate": {
-		syntax: "[ auto | reverse ] || <angle>",
-		media: "visual",
-		inherited: false,
-		animationType: "angle",
-		percentages: "no",
-		groups: [
-			"CSS Motion"
-		],
-		initial: "auto",
-		appliesto: "transformableElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		opacity: opacity,
-		order: order,
-		orphans: orphans,
-		outline: outline,
-		"outline-color": {
-		syntax: "<color> | invert",
-		media: [
-			"visual",
-			"interactive"
-		],
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "invertOrCurrentColor",
-		appliesto: "allElements",
-		computed: "invertForTranslucentColorRGBAOtherwiseRGB",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"outline-offset": {
-		syntax: "<length>",
-		media: [
-			"visual",
-			"interactive"
-		],
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"outline-style": {
-		syntax: "auto | <br-style>",
-		media: [
-			"visual",
-			"interactive"
-		],
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"outline-width": {
-		syntax: "<br-width>",
-		media: [
-			"visual",
-			"interactive"
-		],
-		inherited: false,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "medium",
-		appliesto: "allElements",
-		computed: "absoluteLength0ForNone",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		overflow: overflow,
-		"overflow-anchor": {
-		syntax: "auto | none",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Scroll Anchoring"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"overflow-block": {
-		syntax: "<'overflow'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "auto",
-		appliesto: "blockContainersFlexContainersGridContainers",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"overflow-clip-box": {
-		syntax: "padding-box | content-box",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Mozilla Extensions"
-		],
-		initial: "padding-box",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"overflow-inline": {
-		syntax: "<'overflow'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "auto",
-		appliesto: "blockContainersFlexContainersGridContainers",
-		computed: "asSpecified",
-		order: "perGrammar",
-		status: "experimental"
-	},
-		"overflow-wrap": {
-		syntax: "normal | break-word",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"overflow-x": {
-		syntax: "visible | hidden | clip | scroll | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "visible",
-		appliesto: "blockContainersFlexContainersGridContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"overflow-y": {
-		syntax: "visible | hidden | clip | scroll | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Overflow"
-		],
-		initial: "visible",
-		appliesto: "blockContainersFlexContainersGridContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"overscroll-behavior": {
-		syntax: "[ contain | none | auto ]{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "auto",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"overscroll-behavior-x": {
-		syntax: "contain | none | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "auto",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"overscroll-behavior-y": {
-		syntax: "contain | none | auto",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "auto",
-		appliesto: "nonReplacedBlockAndInlineBlockElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		padding: padding,
-		"padding-block-end": {
-		syntax: "<'padding-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"padding-block-start": {
-		syntax: "<'padding-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"padding-bottom": {
-		syntax: "<length> | <percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptInternalTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"padding-inline-end": {
-		syntax: "<'padding-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"padding-inline-start": {
-		syntax: "<'padding-left'>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "logicalWidthOfContainingBlock",
-		groups: [
-			"CSS Logical Properties"
-		],
-		initial: "0",
-		appliesto: "allElements",
-		computed: "asLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"padding-left": {
-		syntax: "<length> | <percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptInternalTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"padding-right": {
-		syntax: "<length> | <percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptInternalTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"padding-top": {
-		syntax: "<length> | <percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Box Model"
-		],
-		initial: "0",
-		appliesto: "allElementsExceptInternalTableDisplayTypes",
-		computed: "percentageAsSpecifiedOrAbsoluteLength",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter"
-		],
-		status: "standard"
-	},
-		"page-break-after": {
-		syntax: "auto | always | avoid | left | right | recto | verso",
-		media: [
-			"visual",
-			"paged"
-		],
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Pages"
-		],
-		initial: "auto",
-		appliesto: "blockElementsInNormalFlow",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"page-break-before": {
-		syntax: "auto | always | avoid | left | right | recto | verso",
-		media: [
-			"visual",
-			"paged"
-		],
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Pages"
-		],
-		initial: "auto",
-		appliesto: "blockElementsInNormalFlow",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"page-break-inside": {
-		syntax: "auto | avoid",
-		media: [
-			"visual",
-			"paged"
-		],
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Pages"
-		],
-		initial: "auto",
-		appliesto: "blockElementsInNormalFlow",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"paint-order": {
-		syntax: "normal | [ fill || stroke || markers ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "normal",
-		appliesto: "textElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		perspective: perspective,
-		"perspective-origin": {
-		syntax: "<position>",
-		media: "visual",
-		inherited: false,
-		animationType: "simpleListOfLpc",
-		percentages: "referToSizeOfBoundingBox",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "50% 50%",
-		appliesto: "transformableElements",
-		computed: "forLengthAbsoluteValueOtherwisePercentage",
-		order: "oneOrTwoValuesLengthAbsoluteKeywordsPercentages",
-		status: "standard"
-	},
-		"place-content": {
-		syntax: "<'align-content'> <'justify-content'>?",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Flexible Box Layout"
-		],
-		initial: "normal",
-		appliesto: "multilineFlexContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"pointer-events": {
-		syntax: "auto | none | visiblePainted | visibleFill | visibleStroke | visible | painted | fill | stroke | all | inherit",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Pointer Events"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		position: position,
-		quotes: quotes,
-		resize: resize,
-		right: right,
-		rotate: rotate,
-		"row-gap": {
-		syntax: "normal | <length-percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToDimensionOfContentArea",
-		groups: [
-			"CSS Box Alignment"
-		],
-		initial: "normal",
-		appliesto: "multiColumnElementsFlexContainersGridContainers",
-		computed: "asSpecifiedWithLengthsAbsoluteAndNormalComputingToZeroExceptMultiColumn",
-		order: "perGrammar",
-		status: "standard"
-	},
-		"ruby-align": {
-		syntax: "start | center | space-between | space-around",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Ruby"
-		],
-		initial: "space-around",
-		appliesto: "rubyBasesAnnotationsBaseAnnotationContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"ruby-merge": {
-		syntax: "separate | collapse | auto",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Ruby"
-		],
-		initial: "separate",
-		appliesto: "rubyAnnotationsContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"ruby-position": {
-		syntax: "over | under | inter-character",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Ruby"
-		],
-		initial: "over",
-		appliesto: "rubyAnnotationsContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		scale: scale,
-		"scroll-behavior": {
-		syntax: "auto | smooth",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSSOM View"
-		],
-		initial: "auto",
-		appliesto: "scrollingBoxes",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"scroll-snap-coordinate": {
-		syntax: "none | <position>#",
-		media: "interactive",
-		inherited: false,
-		animationType: "position",
-		percentages: "referToBorderBox",
-		groups: [
-			"CSS Scroll Snap"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"scroll-snap-destination": {
-		syntax: "<position>",
-		media: "interactive",
-		inherited: false,
-		animationType: "position",
-		percentages: "relativeToScrollContainerPaddingBoxAxis",
-		groups: [
-			"CSS Scroll Snap"
-		],
-		initial: "0px 0px",
-		appliesto: "scrollContainers",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"scroll-snap-points-x": {
-		syntax: "none | repeat( <length-percentage> )",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "relativeToScrollContainerPaddingBoxAxis",
-		groups: [
-			"CSS Scroll Snap"
-		],
-		initial: "none",
-		appliesto: "scrollContainers",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "obsolete"
-	},
-		"scroll-snap-points-y": {
-		syntax: "none | repeat( <length-percentage> )",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "relativeToScrollContainerPaddingBoxAxis",
-		groups: [
-			"CSS Scroll Snap"
-		],
-		initial: "none",
-		appliesto: "scrollContainers",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "obsolete"
-	},
-		"scroll-snap-type": {
-		syntax: "none | mandatory | proximity",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Scroll Snap"
-		],
-		initial: "none",
-		appliesto: "scrollContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"scroll-snap-type-x": {
-		syntax: "none | mandatory | proximity",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Scroll Snap"
-		],
-		initial: "none",
-		appliesto: "scrollContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"scroll-snap-type-y": {
-		syntax: "none | mandatory | proximity",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Scroll Snap"
-		],
-		initial: "none",
-		appliesto: "scrollContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"shape-image-threshold": {
-		syntax: "<number>",
-		media: "visual",
-		inherited: false,
-		animationType: "number",
-		percentages: "no",
-		groups: [
-			"CSS Shapes"
-		],
-		initial: "0.0",
-		appliesto: "floats",
-		computed: "specifiedValueNumberClipped0To1",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"shape-margin": {
-		syntax: "<length-percentage>",
-		media: "visual",
-		inherited: false,
-		animationType: "lpc",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Shapes"
-		],
-		initial: "0",
-		appliesto: "floats",
-		computed: "asSpecifiedRelativeToAbsoluteLengths",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"shape-outside": {
-		syntax: "none | <shape-box> || <basic-shape> | <image>",
-		media: "visual",
-		inherited: false,
-		animationType: "basicShapeOtherwiseNo",
-		percentages: "no",
-		groups: [
-			"CSS Shapes"
-		],
-		initial: "none",
-		appliesto: "floats",
-		computed: "asDefinedForBasicShapeWithAbsoluteURIOtherwiseAsSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"tab-size": {
-		syntax: "<integer> | <length>",
-		media: "visual",
-		inherited: true,
-		animationType: "length",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "8",
-		appliesto: "blockContainers",
-		computed: "specifiedIntegerOrAbsoluteLength",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"table-layout": {
-		syntax: "auto | fixed",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Table"
-		],
-		initial: "auto",
-		appliesto: "tableElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-align": {
-		syntax: "start | end | left | right | center | justify | match-parent",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "startOrNamelessValueIfLTRRightIfRTL",
-		appliesto: "blockContainers",
-		computed: "asSpecifiedExceptMatchParent",
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-align-last": {
-		syntax: "auto | start | end | left | right | center | justify",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "auto",
-		appliesto: "blockContainers",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-combine-upright": {
-		syntax: "none | all | [ digits <integer>? ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Writing Modes"
-		],
-		initial: "none",
-		appliesto: "nonReplacedInlineElements",
-		computed: "keywordPlusIntegerIfDigits",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-decoration": {
-		syntax: "<'text-decoration-line'> || <'text-decoration-style'> || <'text-decoration-color'>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"text-decoration-color",
-			"text-decoration-style",
-			"text-decoration-line"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: [
-			"text-decoration-color",
-			"text-decoration-style",
-			"text-decoration-line"
-		],
-		appliesto: "allElements",
-		computed: [
-			"text-decoration-line",
-			"text-decoration-style",
-			"text-decoration-color"
-		],
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-decoration-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-decoration-line": {
-		syntax: "none | [ underline || overline || line-through || blink ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-decoration-skip": {
-		syntax: "none | [ objects || [ spaces | [ leading-spaces || trailing-spaces ] ] || edges || box-decoration ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "objects",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "experimental"
-	},
-		"text-decoration-skip-ink": {
-		syntax: "auto | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "experimental"
-	},
-		"text-decoration-style": {
-		syntax: "solid | double | dotted | dashed | wavy",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "solid",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-emphasis": {
-		syntax: "<'text-emphasis-style'> || <'text-emphasis-color'>",
-		media: "visual",
-		inherited: false,
-		animationType: [
-			"text-emphasis-color",
-			"text-emphasis-style"
-		],
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: [
-			"text-emphasis-style",
-			"text-emphasis-color"
-		],
-		appliesto: "allElements",
-		computed: [
-			"text-emphasis-style",
-			"text-emphasis-color"
-		],
-		order: "orderOfAppearance",
-		status: "standard"
-	},
-		"text-emphasis-color": {
-		syntax: "<color>",
-		media: "visual",
-		inherited: false,
-		animationType: "color",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "currentcolor",
-		appliesto: "allElements",
-		computed: "computedColor",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-emphasis-position": {
-		syntax: "[ over | under ] && [ right | left ]",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "over right",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-emphasis-style": {
-		syntax: "none | [ [ filled | open ] || [ dot | circle | double-circle | triangle | sesame ] ] | <string>",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-indent": {
-		syntax: "<length-percentage> && hanging? && each-line?",
-		media: "visual",
-		inherited: true,
-		animationType: "lpc",
-		percentages: "referToWidthOfContainingBlock",
-		groups: [
-			"CSS Text"
-		],
-		initial: "0",
-		appliesto: "blockContainers",
-		computed: "percentageOrAbsoluteLengthPlusKeywords",
-		order: "lengthOrPercentageBeforeKeywords",
-		status: "standard"
-	},
-		"text-justify": {
-		syntax: "auto | inter-character | inter-word | none",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "auto",
-		appliesto: "inlineLevelAndTableCellElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-orientation": {
-		syntax: "mixed | upright | sideways",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Writing Modes"
-		],
-		initial: "mixed",
-		appliesto: "allElementsExceptTableRowGroupsRowsColumnGroupsAndColumns",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-overflow": {
-		syntax: "[ clip | ellipsis | <string> ]{1,2}",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "clip",
-		appliesto: "blockContainerElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-rendering": {
-		syntax: "auto | optimizeSpeed | optimizeLegibility | geometricPrecision",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Miscellaneous"
-		],
-		initial: "auto",
-		appliesto: "textElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"text-shadow": {
-		syntax: "none | <shadow-t>#",
-		media: "visual",
-		inherited: true,
-		animationType: "shadowList",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "colorPlusThreeAbsoluteLengths",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-size-adjust": {
-		syntax: "none | auto | <percentage>",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "referToSizeOfFont",
-		groups: [
-			"CSS Text"
-		],
-		initial: "autoForSmartphoneBrowsersSupportingInflation",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "experimental"
-	},
-		"text-transform": {
-		syntax: "none | capitalize | uppercase | lowercase | full-width",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "none",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"text-underline-position": {
-		syntax: "auto | [ under || [ left | right ] ]",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text Decoration"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "orderOfAppearance",
-		status: "standard"
-	},
-		top: top,
-		"touch-action": {
-		syntax: "auto | none | [ [ pan-x | pan-left | pan-right ] || [ pan-y | pan-up | pan-down ] || pinch-zoom ] | manipulation",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"Pointer Events"
-		],
-		initial: "auto",
-		appliesto: "allElementsExceptNonReplacedInlineElementsTableRowsColumnsRowColumnGroups",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		transform: transform,
-		"transform-box": {
-		syntax: "border-box | fill-box | view-box",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "border-box ",
-		appliesto: "transformableElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"transform-origin": {
-		syntax: "[ <length-percentage> | left | center | right | top | bottom ] | [ [ <length-percentage> | left | center | right ] && [ <length-percentage> | top | center | bottom ] ] <length>?",
-		media: "visual",
-		inherited: false,
-		animationType: "simpleListOfLpc",
-		percentages: "referToSizeOfBoundingBox",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "50% 50% 0",
-		appliesto: "transformableElements",
-		computed: "forLengthAbsoluteValueOtherwisePercentage",
-		order: "oneOrTwoValuesLengthAbsoluteKeywordsPercentages",
-		status: "standard"
-	},
-		"transform-style": {
-		syntax: "flat | preserve-3d",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transforms"
-		],
-		initial: "flat",
-		appliesto: "transformableElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		stacking: true,
-		status: "standard"
-	},
-		transition: transition,
-		"transition-delay": {
-		syntax: "<time>#",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transitions"
-		],
-		initial: "0s",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"transition-duration": {
-		syntax: "<time>#",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transitions"
-		],
-		initial: "0s",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"transition-property": {
-		syntax: "none | <single-transition-property>#",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transitions"
-		],
-		initial: "all",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"transition-timing-function": {
-		syntax: "<single-transition-timing-function>#",
-		media: "interactive",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Transitions"
-		],
-		initial: "ease",
-		appliesto: "allElementsAndPseudos",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		translate: translate,
-		"unicode-bidi": {
-		syntax: "normal | embed | isolate | bidi-override | isolate-override | plaintext",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Writing Modes"
-		],
-		initial: "normal",
-		appliesto: "allElementsSomeValuesNoEffectOnNonInlineElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"user-select": {
-		syntax: "auto | text | none | contain | all",
-		media: "visual",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Basic User Interface"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "nonstandard"
-	},
-		"vertical-align": {
-		syntax: "baseline | sub | super | text-top | text-bottom | middle | top | bottom | <percentage> | <length>",
-		media: "visual",
-		inherited: false,
-		animationType: "length",
-		percentages: "referToLineHeight",
-		groups: [
-			"CSS Table"
-		],
-		initial: "baseline",
-		appliesto: "inlineLevelAndTableCellElements",
-		computed: "absoluteLengthOrKeyword",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		visibility: visibility,
-		"white-space": {
-		syntax: "normal | pre | nowrap | pre-wrap | pre-line",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		widows: widows,
-		width: width,
-		"will-change": {
-		syntax: "auto | <animateable-feature>#",
-		media: "all",
-		inherited: false,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Will Change"
-		],
-		initial: "auto",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"word-break": {
-		syntax: "normal | break-all | keep-all | break-word",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"word-spacing": {
-		syntax: "normal | <length-percentage>",
-		media: "visual",
-		inherited: true,
-		animationType: "length",
-		percentages: "referToWidthOfAffectedGlyph",
-		groups: [
-			"CSS Text"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "optimumMinAndMaxValueOfAbsoluteLengthPercentageOrNormal",
-		order: "uniqueOrder",
-		alsoAppliesTo: [
-			"::first-letter",
-			"::first-line",
-			"::placeholder"
-		],
-		status: "standard"
-	},
-		"word-wrap": {
-		syntax: "normal | break-word",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Text"
-		],
-		initial: "normal",
-		appliesto: "allElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"writing-mode": {
-		syntax: "horizontal-tb | vertical-rl | vertical-lr | sideways-rl | sideways-lr",
-		media: "visual",
-		inherited: true,
-		animationType: "discrete",
-		percentages: "no",
-		groups: [
-			"CSS Writing Modes"
-		],
-		initial: "horizontal-tb",
-		appliesto: "allElementsExceptTableRowColumnGroupsTableRowsColumns",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		status: "standard"
-	},
-		"z-index": {
-		syntax: "auto | <integer>",
-		media: "visual",
-		inherited: false,
-		animationType: "integer",
-		percentages: "no",
-		groups: [
-			"CSS Positioning"
-		],
-		initial: "auto",
-		appliesto: "positionedElements",
-		computed: "asSpecified",
-		order: "uniqueOrder",
-		stacking: true,
-		status: "standard"
-	},
-		zoom: zoom
-	};
-
-	var properties$2 = /*#__PURE__*/Object.freeze({
-		all: all,
-		animation: animation,
-		appearance: appearance,
-		azimuth: azimuth,
-		background: background,
-		border: border,
-		bottom: bottom,
-		clear: clear,
-		clip: clip,
-		color: color,
-		columns: columns,
-		contain: contain,
-		content: content,
-		cursor: cursor,
-		direction: direction,
-		display: display,
-		filter: filter,
-		flex: flex,
-		float: float,
-		font: font,
-		gap: gap,
-		grid: grid,
-		height: height,
-		hyphens: hyphens,
-		isolation: isolation,
-		left: left,
-		margin: margin,
-		mask: mask,
-		offset: offset,
-		opacity: opacity,
-		order: order,
-		orphans: orphans,
-		outline: outline,
-		overflow: overflow,
-		padding: padding,
-		perspective: perspective,
-		position: position,
-		quotes: quotes,
-		resize: resize,
-		right: right,
-		rotate: rotate,
-		scale: scale,
-		top: top,
-		transform: transform,
-		transition: transition,
-		translate: translate,
-		visibility: visibility,
-		widows: widows,
-		width: width,
-		zoom: zoom,
-		default: properties$1
-	});
-
-	var attachment = {
-		syntax: "scroll | fixed | local"
-	};
-	var box = {
-		syntax: "border-box | padding-box | content-box"
-	};
-	var color$1 = {
-		syntax: "<rgb()> | <rgba()> | <hsl()> | <hsla()> | <hex-color> | <named-color> | currentcolor | <deprecated-system-color>"
-	};
-	var gradient = {
-		syntax: "<linear-gradient()> | <repeating-linear-gradient()> | <radial-gradient()> | <repeating-radial-gradient()>"
-	};
-	var hue = {
-		syntax: "<number> | <angle>"
-	};
-	var image = {
-		syntax: "<url> | <image()> | <image-set()> | <element()> | <cross-fade()> | <gradient>"
-	};
-	var nth = {
-		syntax: "<an-plus-b> | even | odd"
-	};
-	var position$1 = {
-		syntax: "[ [ left | center | right ] || [ top | center | bottom ] | [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]? | [ [ left | right ] <length-percentage> ] && [ [ top | bottom ] <length-percentage> ] ]"
-	};
-	var quote = {
-		syntax: "open-quote | close-quote | no-open-quote | no-close-quote"
-	};
-	var shadow = {
-		syntax: "inset? && <length>{2,4} && <color>?"
-	};
-	var shape$1 = {
-		syntax: "rect(<top>, <right>, <bottom>, <left>)"
-	};
-	var size = {
-		syntax: "closest-side | farthest-side | closest-corner | farthest-corner | <length> | <length-percentage>{2}"
-	};
-	var symbol = {
-		syntax: "<string> | <image> | <custom-ident>"
-	};
-	var target = {
-		syntax: "<target-counter()> | <target-counters()> | <target-text()>"
-	};
-	var syntaxes = {
-		"absolute-size": {
-		syntax: "xx-small | x-small | small | medium | large | x-large | xx-large"
-	},
-		"alpha-value": {
-		syntax: "<number> | <percentage>"
-	},
-		"angle-percentage": {
-		syntax: "<angle> | <percentage>"
-	},
-		"animateable-feature": {
-		syntax: "scroll-position | contents | <custom-ident>"
-	},
-		attachment: attachment,
-		"attr()": {
-		syntax: "attr( <attr-name> <type-or-unit>? [, <attr-fallback> ]? )"
-	},
-		"attr-matcher": {
-		syntax: "[ '~' | '|' | '^' | '$' | '*' ]? '='"
-	},
-		"attr-modifier": {
-		syntax: "i"
-	},
-		"attribute-selector": {
-		syntax: "'[' <wq-name> ']' | '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'"
-	},
-		"auto-repeat": {
-		syntax: "repeat( [ auto-fill | auto-fit ] , [ <line-names>? <fixed-size> ]+ <line-names>? )"
-	},
-		"auto-track-list": {
-		syntax: "[ <line-names>? [ <fixed-size> | <fixed-repeat> ] ]* <line-names>? <auto-repeat>\n[ <line-names>? [ <fixed-size> | <fixed-repeat> ] ]* <line-names>?"
-	},
-		"baseline-position": {
-		syntax: "[ first | last ]? baseline"
-	},
-		"basic-shape": {
-		syntax: "<inset()> | <circle()> | <ellipse()> | <polygon()>"
-	},
-		"bg-image": {
-		syntax: "none | <image>"
-	},
-		"bg-layer": {
-		syntax: "<bg-image> || <bg-position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box>"
-	},
-		"bg-position": {
-		syntax: "[ [ left | center | right | top | bottom | <length-percentage> ] | [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ] | [ center | [ left | right ] <length-percentage>? ] && [ center | [ top | bottom ] <length-percentage>? ] ]"
-	},
-		"bg-size": {
-		syntax: "[ <length-percentage> | auto ]{1,2} | cover | contain"
-	},
-		"blur()": {
-		syntax: "blur( <length> )"
-	},
-		"blend-mode": {
-		syntax: "normal | multiply | screen | overlay | darken | lighten | color-dodge | color-burn | hard-light | soft-light | difference | exclusion | hue | saturation | color | luminosity"
-	},
-		box: box,
-		"br-style": {
-		syntax: "none | hidden | dotted | dashed | solid | double | groove | ridge | inset | outset"
-	},
-		"br-width": {
-		syntax: "<length> | thin | medium | thick"
-	},
-		"brightness()": {
-		syntax: "brightness( <number-percentage> )"
-	},
-		"calc()": {
-		syntax: "calc( <calc-sum> )"
-	},
-		"calc-sum": {
-		syntax: "<calc-product> [ [ '+' | '-' ] <calc-product> ]*"
-	},
-		"calc-product": {
-		syntax: "<calc-value> [ '*' <calc-value> | '/' <number> ]*"
-	},
-		"calc-value": {
-		syntax: "<number> | <dimension> | <percentage> | ( <calc-sum> )"
-	},
-		"cf-final-image": {
-		syntax: "<image> | <color>"
-	},
-		"cf-mixing-image": {
-		syntax: "<percentage>? && <image>"
-	},
-		"circle()": {
-		syntax: "circle( [ <shape-radius> ]? [ at <position> ]? )"
-	},
-		"class-selector": {
-		syntax: "'.' <ident-token>"
-	},
-		"clip-source": {
-		syntax: "<url>"
-	},
-		color: color$1,
-		"color-stop": {
-		syntax: "<color> <length-percentage>?"
-	},
-		"color-stop-list": {
-		syntax: "<color-stop>#{2,}"
-	},
-		"common-lig-values": {
-		syntax: "[ common-ligatures | no-common-ligatures ]"
-	},
-		"composite-style": {
-		syntax: "clear | copy | source-over | source-in | source-out | source-atop | destination-over | destination-in | destination-out | destination-atop | xor"
-	},
-		"compositing-operator": {
-		syntax: "add | subtract | intersect | exclude"
-	},
-		"compound-selector": {
-		syntax: "[ <type-selector>? <subclass-selector>* [ <pseudo-element-selector> <pseudo-class-selector>* ]* ]!"
-	},
-		"compound-selector-list": {
-		syntax: "<compound-selector>#"
-	},
-		"contextual-alt-values": {
-		syntax: "[ contextual | no-contextual ]"
-	},
-		"content-distribution": {
-		syntax: "space-between | space-around | space-evenly | stretch"
-	},
-		"content-list": {
-		syntax: "[ <string> | contents | <image> | <quote> | <target> | <leader()> ]+"
-	},
-		"content-position": {
-		syntax: "center | start | end | flex-start | flex-end"
-	},
-		"content-replacement": {
-		syntax: "<image>"
-	},
-		"contrast()": {
-		syntax: "contrast( [ <number-percentage> ] )"
-	},
-		"counter-style": {
-		syntax: "<counter-style-name> | symbols()"
-	},
-		"counter-style-name": {
-		syntax: "<custom-ident>"
-	},
-		"cross-fade()": {
-		syntax: "cross-fade( <cf-mixing-image> , <cf-final-image>? )"
-	},
-		"cubic-bezier-timing-function": {
-		syntax: "ease | ease-in | ease-out | ease-in-out | cubic-bezier(<number>, <number>, <number>, <number>)"
-	},
-		"deprecated-system-color": {
-		syntax: "ActiveBorder | ActiveCaption | AppWorkspace | Background | ButtonFace | ButtonHighlight | ButtonShadow | ButtonText | CaptionText | GrayText | Highlight | HighlightText | InactiveBorder | InactiveCaption | InactiveCaptionText | InfoBackground | InfoText | Menu | MenuText | Scrollbar | ThreeDDarkShadow | ThreeDFace | ThreeDHighlight | ThreeDLightShadow | ThreeDShadow | Window | WindowFrame | WindowText"
-	},
-		"discretionary-lig-values": {
-		syntax: "[ discretionary-ligatures | no-discretionary-ligatures ]"
-	},
-		"display-box": {
-		syntax: "contents | none"
-	},
-		"display-inside": {
-		syntax: "flow | flow-root | table | flex | grid | subgrid | ruby"
-	},
-		"display-internal": {
-		syntax: "table-row-group | table-header-group | table-footer-group | table-row | table-cell | table-column-group | table-column | table-caption | ruby-base | ruby-text | ruby-base-container | ruby-text-container"
-	},
-		"display-legacy": {
-		syntax: "inline-block | inline-list-item | inline-table | inline-flex | inline-grid"
-	},
-		"display-listitem": {
-		syntax: "<display-outside>? && [ flow | flow-root ]? && list-item"
-	},
-		"display-outside": {
-		syntax: "block | inline | run-in"
-	},
-		"drop-shadow()": {
-		syntax: "drop-shadow( <length>{2,3} <color>? )"
-	},
-		"east-asian-variant-values": {
-		syntax: "[ jis78 | jis83 | jis90 | jis04 | simplified | traditional ]"
-	},
-		"east-asian-width-values": {
-		syntax: "[ full-width | proportional-width ]"
-	},
-		"element()": {
-		syntax: "element( <id-selector> )"
-	},
-		"ellipse()": {
-		syntax: "ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )"
-	},
-		"ending-shape": {
-		syntax: "circle | ellipse"
-	},
-		"explicit-track-list": {
-		syntax: "[ <line-names>? <track-size> ]+ <line-names>?"
-	},
-		"family-name": {
-		syntax: "<string> | <custom-ident>+"
-	},
-		"feature-tag-value": {
-		syntax: "<string> [ <integer> | on | off ]?"
-	},
-		"feature-type": {
-		syntax: "@stylistic | @historical-forms | @styleset | @character-variant | @swash | @ornaments | @annotation"
-	},
-		"feature-value-block": {
-		syntax: "<feature-type> {\n  <feature-value-declaration-list>\n}"
-	},
-		"feature-value-block-list": {
-		syntax: "<feature-value-block>+"
-	},
-		"feature-value-declaration": {
-		syntax: "<custom-ident>: <integer>+;"
-	},
-		"feature-value-declaration-list": {
-		syntax: "<feature-value-declaration>"
-	},
-		"feature-value-name": {
-		syntax: "<custom-ident>"
-	},
-		"fill-rule": {
-		syntax: "nonzero | evenodd"
-	},
-		"filter-function": {
-		syntax: "<blur()> | <brightness()> | <contrast()> | <drop-shadow()> | <grayscale()> | <hue-rotate()> | <invert()> | <opacity()> | <saturate()> | <sepia()>"
-	},
-		"filter-function-list": {
-		syntax: "[ <filter-function> | <url> ]+"
-	},
-		"final-bg-layer": {
-		syntax: "<'background-color'> || <bg-image> || <bg-position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box>"
-	},
-		"fit-content()": {
-		syntax: "fit-content( [ <length> | <percentage> ] )"
-	},
-		"fixed-breadth": {
-		syntax: "<length-percentage>"
-	},
-		"fixed-repeat": {
-		syntax: "repeat( [ <positive-integer> ] , [ <line-names>? <fixed-size> ]+ <line-names>? )"
-	},
-		"fixed-size": {
-		syntax: "<fixed-breadth> | minmax( <fixed-breadth> , <track-breadth> ) | minmax( <inflexible-breadth> , <fixed-breadth> )"
-	},
-		"font-stretch-absolute": {
-		syntax: "normal | ultra-condensed | extra-condensed | condensed | semi-condensed | semi-expanded | expanded | extra-expanded | ultra-expanded | <percentage>"
-	},
-		"font-variant-css21": {
-		syntax: "[ normal | small-caps ]"
-	},
-		"font-weight-absolute": {
-		syntax: "normal | bold | <number>"
-	},
-		"frames-timing-function": {
-		syntax: "frames(<integer>)"
-	},
-		"frequency-percentage": {
-		syntax: "<frequency> | <percentage>"
-	},
-		"general-enclosed": {
-		syntax: "[ <function-token> <any-value> ) ] | ( <ident> <any-value> )"
-	},
-		"generic-family": {
-		syntax: "serif | sans-serif | cursive | fantasy | monospace"
-	},
-		"generic-name": {
-		syntax: "serif | sans-serif | cursive | fantasy | monospace"
-	},
-		"geometry-box": {
-		syntax: "<shape-box> | fill-box | stroke-box | view-box"
-	},
-		gradient: gradient,
-		"grayscale()": {
-		syntax: "grayscale( <number-percentage> )"
-	},
-		"grid-line": {
-		syntax: "auto | <custom-ident> | [ <integer> && <custom-ident>? ] | [ span && [ <integer> || <custom-ident> ] ]"
-	},
-		"historical-lig-values": {
-		syntax: "[ historical-ligatures | no-historical-ligatures ]"
-	},
-		"hsl()": {
-		syntax: "hsl( <hue> <percentage> <percentage> [ / <alpha-value> ]? ) | hsl( <hue>, <percentage>, <percentage>, <alpha-value>? )"
-	},
-		"hsla()": {
-		syntax: "hsla( <hue> <percentage> <percentage> [ / <alpha-value> ]? ) | hsla( <hue>, <percentage>, <percentage>, <alpha-value>? )"
-	},
-		hue: hue,
-		"hue-rotate()": {
-		syntax: "hue-rotate( <angle> )"
-	},
-		"id-selector": {
-		syntax: "<hash-token>"
-	},
-		image: image,
-		"image()": {
-		syntax: "image( [ [ <image> | <string> ]? , <color>? ]! )"
-	},
-		"image-set()": {
-		syntax: "image-set( <image-set-option># )"
-	},
-		"image-set-option": {
-		syntax: "[ <image> | <string> ] <resolution>"
-	},
-		"inflexible-breadth": {
-		syntax: "<length> | <percentage> | min-content | max-content | auto"
-	},
-		"inset()": {
-		syntax: "inset( <length-percentage>{1,4} [ round <border-radius> ]? )"
-	},
-		"invert()": {
-		syntax: "invert( <number-percentage> )"
-	},
-		"keyframes-name": {
-		syntax: "<custom-ident> | <string>"
-	},
-		"keyframe-block": {
-		syntax: "<keyframe-selector># {\n  <declaration-list>\n}"
-	},
-		"keyframe-block-list": {
-		syntax: "<keyframe-block>+"
-	},
-		"keyframe-selector": {
-		syntax: "from | to | <percentage>"
-	},
-		"leader()": {
-		syntax: "leader( <leader-type> )"
-	},
-		"leader-type": {
-		syntax: "dotted | solid | space | <string>"
-	},
-		"length-percentage": {
-		syntax: "<length> | <percentage>"
-	},
-		"line-names": {
-		syntax: "'[' <custom-ident>* ']'"
-	},
-		"line-name-list": {
-		syntax: "[ <line-names> | <name-repeat> ]+"
-	},
-		"linear-gradient()": {
-		syntax: "linear-gradient( [ <angle> | to <side-or-corner> ]? , <color-stop-list> )"
-	},
-		"mask-layer": {
-		syntax: "<mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || <geometry-box> || [ <geometry-box> | no-clip ] || <compositing-operator> || <masking-mode>"
-	},
-		"mask-position": {
-		syntax: "[ <length-percentage> | left | center | right ] [ <length-percentage> | top | center | bottom ]?"
-	},
-		"mask-reference": {
-		syntax: "none | <image> | <mask-source>"
-	},
-		"mask-source": {
-		syntax: "<url>"
-	},
-		"masking-mode": {
-		syntax: "alpha | luminance | match-source"
-	},
-		"matrix()": {
-		syntax: "matrix( <number> [, <number> ]{5,5} )"
-	},
-		"matrix3d()": {
-		syntax: "matrix3d( <number> [, <number> ]{15,15} )"
-	},
-		"media-and": {
-		syntax: "<media-in-parens> [ and <media-in-parens> ]+"
-	},
-		"media-condition": {
-		syntax: "<media-not> | <media-and> | <media-or> | <media-in-parens>"
-	},
-		"media-condition-without-or": {
-		syntax: "<media-not> | <media-and> | <media-in-parens>"
-	},
-		"media-feature": {
-		syntax: "( [ <mf-plain> | <mf-boolean> | <mf-range> ] )"
-	},
-		"media-in-parens": {
-		syntax: "( <media-condition> ) | <media-feature> | <general-enclosed>"
-	},
-		"media-not": {
-		syntax: "not <media-in-parens>"
-	},
-		"media-or": {
-		syntax: "<media-in-parens> [ or <media-in-parens> ]+"
-	},
-		"media-query": {
-		syntax: "<media-condition> | [ not | only ]? <media-type> [ and <media-condition-without-or> ]?"
-	},
-		"media-query-list": {
-		syntax: "<media-query>#"
-	},
-		"media-type": {
-		syntax: "<ident>"
-	},
-		"mf-boolean": {
-		syntax: "<mf-name>"
-	},
-		"mf-name": {
-		syntax: "<ident>"
-	},
-		"mf-plain": {
-		syntax: "<mf-name> : <mf-value>"
-	},
-		"mf-range": {
-		syntax: "<mf-name> [ '<' | '>' ]? '='? <mf-value>\n| <mf-value> [ '<' | '>' ]? '='? <mf-name>\n| <mf-value> '<' '='? <mf-name> '<' '='? <mf-value>\n| <mf-value> '>' '='? <mf-name> '>' '='? <mf-value>"
-	},
-		"mf-value": {
-		syntax: "<number> | <dimension> | <ident> | <ratio>"
-	},
-		"minmax()": {
-		syntax: "minmax( [ <length> | <percentage> | <flex> | min-content | max-content | auto ] , [ <length> | <percentage> | <flex> | min-content | max-content | auto ] )"
-	},
-		"named-color": {
-		syntax: "transparent | aliceblue | antiquewhite | aqua | aquamarine | azure | beige | bisque | black | blanchedalmond | blue | blueviolet | brown | burlywood | cadetblue | chartreuse | chocolate | coral | cornflowerblue | cornsilk | crimson | cyan | darkblue | darkcyan | darkgoldenrod | darkgray | darkgreen | darkgrey | darkkhaki | darkmagenta | darkolivegreen | darkorange | darkorchid | darkred | darksalmon | darkseagreen | darkslateblue | darkslategray | darkslategrey | darkturquoise | darkviolet | deeppink | deepskyblue | dimgray | dimgrey | dodgerblue | firebrick | floralwhite | forestgreen | fuchsia | gainsboro | ghostwhite | gold | goldenrod | gray | green | greenyellow | grey | honeydew | hotpink | indianred | indigo | ivory | khaki | lavender | lavenderblush | lawngreen | lemonchiffon | lightblue | lightcoral | lightcyan | lightgoldenrodyellow | lightgray | lightgreen | lightgrey | lightpink | lightsalmon | lightseagreen | lightskyblue | lightslategray | lightslategrey | lightsteelblue | lightyellow | lime | limegreen | linen | magenta | maroon | mediumaquamarine | mediumblue | mediumorchid | mediumpurple | mediumseagreen | mediumslateblue | mediumspringgreen | mediumturquoise | mediumvioletred | midnightblue | mintcream | mistyrose | moccasin | navajowhite | navy | oldlace | olive | olivedrab | orange | orangered | orchid | palegoldenrod | palegreen | paleturquoise | palevioletred | papayawhip | peachpuff | peru | pink | plum | powderblue | purple | rebeccapurple | red | rosybrown | royalblue | saddlebrown | salmon | sandybrown | seagreen | seashell | sienna | silver | skyblue | slateblue | slategray | slategrey | snow | springgreen | steelblue | tan | teal | thistle | tomato | turquoise | violet | wheat | white | whitesmoke | yellow | yellowgreen"
-	},
-		"namespace-prefix": {
-		syntax: "<ident>"
-	},
-		"ns-prefix": {
-		syntax: "[ <ident-token> | '*' ]? '|'"
-	},
-		"number-percentage": {
-		syntax: "<number> | <percentage>"
-	},
-		"numeric-figure-values": {
-		syntax: "[ lining-nums | oldstyle-nums ]"
-	},
-		"numeric-fraction-values": {
-		syntax: "[ diagonal-fractions | stacked-fractions ]"
-	},
-		"numeric-spacing-values": {
-		syntax: "[ proportional-nums | tabular-nums ]"
-	},
-		nth: nth,
-		"opacity()": {
-		syntax: "opacity( [ <number-percentage> ] )"
-	},
-		"overflow-position": {
-		syntax: "unsafe | safe"
-	},
-		"outline-radius": {
-		syntax: "<length> | <percentage>"
-	},
-		"page-body": {
-		syntax: "<declaration>? [ ; <page-body> ]? | <page-margin-box> <page-body>"
-	},
-		"page-margin-box": {
-		syntax: "<page-margin-box-type> {\n  <declaration-list>\n}"
-	},
-		"page-margin-box-type": {
-		syntax: "@top-left-corner | @top-left | @top-center | @top-right | @top-right-corner | @bottom-left-corner | @bottom-left | @bottom-center | @bottom-right | @bottom-right-corner | @left-top | @left-middle | @left-bottom | @right-top | @right-middle | @right-bottom"
-	},
-		"page-selector-list": {
-		syntax: "[ <page-selector># ]?"
-	},
-		"page-selector": {
-		syntax: "<pseudo-page>+ | <ident> <pseudo-page>*"
-	},
-		"perspective()": {
-		syntax: "perspective( <length> )"
-	},
-		"polygon()": {
-		syntax: "polygon( <fill-rule>? , [ <length-percentage> <length-percentage> ]# )"
-	},
-		position: position$1,
-		"pseudo-class-selector": {
-		syntax: "':' <ident-token> | ':' <function-token> <any-value> ')'"
-	},
-		"pseudo-element-selector": {
-		syntax: "':' <pseudo-class-selector>"
-	},
-		"pseudo-page": {
-		syntax: ": [ left | right | first | blank ]"
-	},
-		quote: quote,
-		"radial-gradient()": {
-		syntax: "radial-gradient( [ <ending-shape> || <size> ]? [ at <position> ]? , <color-stop-list> )"
-	},
-		"relative-size": {
-		syntax: "larger | smaller"
-	},
-		"repeat-style": {
-		syntax: "repeat-x | repeat-y | [ repeat | space | round | no-repeat ]{1,2}"
-	},
-		"repeating-linear-gradient()": {
-		syntax: "repeating-linear-gradient( [ <angle> | to <side-or-corner> ]? , <color-stop-list> )"
-	},
-		"repeating-radial-gradient()": {
-		syntax: "repeating-radial-gradient( [ <ending-shape> || <size> ]? [ at <position> ]? , <color-stop-list> )"
-	},
-		"rgb()": {
-		syntax: "rgb( <percentage>{3} [ / <alpha-value> ]? ) | rgb( <number>{3} [ / <alpha-value> ]? ) | rgb( <percentage>#{3} , <alpha-value>? ) | rgb( <number>#{3} , <alpha-value>? )"
-	},
-		"rgba()": {
-		syntax: "rgba( <percentage>{3} [ / <alpha-value> ]? ) | rgba( <number>{3} [ / <alpha-value> ]? ) | rgba( <percentage>#{3} , <alpha-value>? ) | rgba( <number>#{3} , <alpha-value>? )"
-	},
-		"rotate()": {
-		syntax: "rotate( <angle> )"
-	},
-		"rotate3d()": {
-		syntax: "rotate3d( <number> , <number> , <number> , <angle> )"
-	},
-		"rotateX()": {
-		syntax: "rotateX( <angle> )"
-	},
-		"rotateY()": {
-		syntax: "rotateY( <angle> )"
-	},
-		"rotateZ()": {
-		syntax: "rotateZ( <angle> )"
-	},
-		"saturate()": {
-		syntax: "saturate( <number-percentage> )"
-	},
-		"scale()": {
-		syntax: "scale( <number> [, <number> ]? )"
-	},
-		"scale3d()": {
-		syntax: "scale3d( <number> , <number> , <number> )"
-	},
-		"scaleX()": {
-		syntax: "scaleX( <number> )"
-	},
-		"scaleY()": {
-		syntax: "scaleY( <number> )"
-	},
-		"scaleZ()": {
-		syntax: "scaleZ( <number> )"
-	},
-		"self-position": {
-		syntax: "center | start | end | self-start | self-end | flex-start | flex-end"
-	},
-		"shape-radius": {
-		syntax: "<length-percentage> | closest-side | farthest-side"
-	},
-		"skew()": {
-		syntax: "skew( <angle> [, <angle> ]? )"
-	},
-		"skewX()": {
-		syntax: "skewX( <angle> )"
-	},
-		"skewY()": {
-		syntax: "skewY( <angle> )"
-	},
-		"sepia()": {
-		syntax: "sepia( <number-percentage> )"
-	},
-		shadow: shadow,
-		"shadow-t": {
-		syntax: "[ <length>{2,3} && <color>? ]"
-	},
-		shape: shape$1,
-		"shape-box": {
-		syntax: "<box> | margin-box"
-	},
-		"side-or-corner": {
-		syntax: "[ left | right ] || [ top | bottom ]"
-	},
-		"single-animation": {
-		syntax: "<time> || <single-timing-function> || <time> || <single-animation-iteration-count> || <single-animation-direction> || <single-animation-fill-mode> || <single-animation-play-state> || [ none | <keyframes-name> ]"
-	},
-		"single-animation-direction": {
-		syntax: "normal | reverse | alternate | alternate-reverse"
-	},
-		"single-animation-fill-mode": {
-		syntax: "none | forwards | backwards | both"
-	},
-		"single-animation-iteration-count": {
-		syntax: "infinite | <number>"
-	},
-		"single-animation-play-state": {
-		syntax: "running | paused"
-	},
-		"single-timing-function": {
-		syntax: "linear | <cubic-bezier-timing-function> | <step-timing-function> | <frames-timing-function>"
-	},
-		"single-transition": {
-		syntax: "[ none | <single-transition-property> ] || <time> || <single-transition-timing-function> || <time>"
-	},
-		"single-transition-timing-function": {
-		syntax: "<single-timing-function>"
-	},
-		"single-transition-property": {
-		syntax: "all | <custom-ident>"
-	},
-		size: size,
-		"step-timing-function": {
-		syntax: "step-start | step-end | steps(<integer>[, [ start | end ] ]?)"
-	},
-		"subclass-selector": {
-		syntax: "<id-selector> | <class-selector> | <attribute-selector> | <pseudo-class-selector>"
-	},
-		symbol: symbol,
-		target: target,
-		"target-counter()": {
-		syntax: "target-counter( [ <string> | <url> ] , <custom-ident> , <counter-style>? )"
-	},
-		"target-counters()": {
-		syntax: "target-counters( [ <string> | <url> ] , <custom-ident> , <string> , <counter-style>? )"
-	},
-		"target-text()": {
-		syntax: "target-text( [ <string> | <url> ] , [ content | before | after | first-letter ]? )"
-	},
-		"time-percentage": {
-		syntax: "<time> | <percentage>"
-	},
-		"track-breadth": {
-		syntax: "<length-percentage> | <flex> | min-content | max-content | auto"
-	},
-		"track-list": {
-		syntax: "[ <line-names>? [ <track-size> | <track-repeat> ] ]+ <line-names>?"
-	},
-		"track-repeat": {
-		syntax: "repeat( [ <positive-integer> ] , [ <line-names>? <track-size> ]+ <line-names>? )"
-	},
-		"track-size": {
-		syntax: "<track-breadth> | minmax( <inflexible-breadth> , <track-breadth> ) | fit-content( [ <length> | <percentage> ] )"
-	},
-		"transform-function": {
-		syntax: "<matrix()> | <translate()> | <translateX()> | <translateY()> | <scale()> | <scaleX()> | <scaleY()> | <rotate()> | <skew()> | <skewX()> | <skewY()> | <matrix3d()> | <translate3d()> | <translateZ()> | <scale3d()> | <scaleZ()> | <rotate3d()> | <rotateX()> | <rotateY()> | <rotateZ()> | <perspective()>"
-	},
-		"transform-list": {
-		syntax: "<transform-function>+"
-	},
-		"translate()": {
-		syntax: "translate( <length-percentage> [, <length-percentage> ]? )"
-	},
-		"translate3d()": {
-		syntax: "translate3d( <length-percentage> , <length-percentage> , <length> )"
-	},
-		"translateX()": {
-		syntax: "translateX( <length-percentage> )"
-	},
-		"translateY()": {
-		syntax: "translateY( <length-percentage> )"
-	},
-		"translateZ()": {
-		syntax: "translateZ( <length> )"
-	},
-		"type-or-unit": {
-		syntax: "string | integer | color | url | integer | number | length | angle | time | frequency | em | ex | px | rem | vw | vh | vmin | vmax | mm | q | cm | in | pt | pc | deg | grad | rad | ms | s | Hz | kHz | %"
-	},
-		"type-selector": {
-		syntax: "<wq-name> | <ns-prefix>? '*'"
-	},
-		"var()": {
-		syntax: "var( <custom-property-name> [, <declaration-value> ]? )"
-	},
-		"viewport-length": {
-		syntax: "auto | <length-percentage>"
-	},
-		"wq-name": {
-		syntax: "<ns-prefix>? <ident-token>"
-	}
-	};
-
-	var syntaxes$1 = /*#__PURE__*/Object.freeze({
-		attachment: attachment,
-		box: box,
-		color: color$1,
-		gradient: gradient,
-		hue: hue,
-		image: image,
-		nth: nth,
-		position: position$1,
-		quote: quote,
-		shadow: shadow,
-		shape: shape$1,
-		size: size,
-		symbol: symbol,
-		target: target,
-		default: syntaxes
-	});
-
-	var properties$3 = {
-		"--*": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"-moz-background-clip": {
-			comment: "deprecated syntax in old Firefox, https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
-			syntax: "padding | border"
-		},
-		"-moz-border-radius-bottomleft": {
-			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-left-radius",
-			syntax: "<'border-bottom-left-radius'>"
-		},
-		"-moz-border-radius-bottomright": {
-			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
-			syntax: "<'border-bottom-right-radius'>"
-		},
-		"-moz-border-radius-topleft": {
-			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-left-radius",
-			syntax: "<'border-top-left-radius'>"
-		},
-		"-moz-border-radius-topright": {
-			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
-			syntax: "<'border-bottom-right-radius'>"
-		},
-		"-moz-osx-font-smoothing": {
-			comment: "misssed old syntax https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
-			syntax: "auto | grayscale"
-		},
-		"-moz-user-select": {
-			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
-			syntax: "none | text | all | -moz-none"
-		},
-		"-ms-flex-align": {
-			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
-			syntax: "start | end | center | baseline | stretch"
-		},
-		"-ms-flex-item-align": {
-			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
-			syntax: "auto | start | end | center | baseline | stretch"
-		},
-		"-ms-flex-line-pack": {
-			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack",
-			syntax: "start | end | center | justify | distribute | stretch"
-		},
-		"-ms-flex-negative": {
-			comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
-			syntax: "<'flex-shrink'>"
-		},
-		"-ms-flex-pack": {
-			comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack",
-			syntax: "start | end | center | justify | distribute"
-		},
-		"-ms-flex-order": {
-			comment: "misssed old syntax implemented in IE; https://msdn.microsoft.com/en-us/library/jj127303(v=vs.85).aspx",
-			syntax: "<integer>"
-		},
-		"-ms-flex-positive": {
-			comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
-			syntax: "<'flex-grow'>"
-		},
-		"-ms-flex-preferred-size": {
-			comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
-			syntax: "<'flex-basis'>"
-		},
-		"-ms-interpolation-mode": {
-			comment: "https://msdn.microsoft.com/en-us/library/ff521095(v=vs.85).aspx",
-			syntax: "nearest-neighbor | bicubic"
-		},
-		"-ms-grid-column-align": {
-			comment: "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466338.aspx",
-			syntax: "start | end | center | stretch"
-		},
-		"-ms-grid-row-align": {
-			comment: "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466348.aspx",
-			syntax: "start | end | center | stretch"
-		},
-		"-webkit-appearance": {
-			comment: "webkit specific keywords",
-			references: [
-				"http://css-infos.net/property/-webkit-appearance"
-			],
-			syntax: "none | button | button-bevel | caps-lock-indicator | caret | checkbox | default-button | listbox | listitem | media-fullscreen-button | media-mute-button | media-play-button | media-seek-back-button | media-seek-forward-button | media-slider | media-sliderthumb | menulist | menulist-button | menulist-text | menulist-textfield | 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"
-		},
-		"-webkit-background-clip": {
-			comment: "https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
-			syntax: "[ <box> | border | padding | content | text ]#"
-		},
-		"-webkit-column-break-after": {
-			comment: "added, http://help.dottoro.com/lcrthhhv.php",
-			syntax: "always | auto | avoid"
-		},
-		"-webkit-column-break-before": {
-			comment: "added, http://help.dottoro.com/lcxquvkf.php",
-			syntax: "always | auto | avoid"
-		},
-		"-webkit-column-break-inside": {
-			comment: "added, http://help.dottoro.com/lclhnthl.php",
-			syntax: "always | auto | avoid"
-		},
-		"-webkit-font-smoothing": {
-			comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
-			syntax: "auto | none | antialiased | subpixel-antialiased"
-		},
-		"-webkit-line-clamp": {
-			comment: "non-standard and deprecated but may still using by some sites",
-			syntax: "<positive-integer>"
-		},
-		"-webkit-mask-box-image": {
-			comment: "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
-			syntax: "[ <url> | <gradient> | none ] [ <length-percentage>{4} <-webkit-mask-box-repeat>{2} ]?"
-		},
-		"-webkit-mask-clip": {
-			comment: "change type to <-webkit-mask-clip-style> since it differ from <mask-clip>, extra space between [ and ,",
-			syntax: "<-webkit-mask-clip-style> [, <-webkit-mask-clip-style> ]*"
-		},
-		"-webkit-print-color-adjust": {
-			comment: "missed",
-			references: [
-				"https://developer.mozilla.org/en/docs/Web/CSS/-webkit-print-color-adjust"
-			],
-			syntax: "economy | exact"
-		},
-		"-webkit-text-security": {
-			comment: "missed; http://help.dottoro.com/lcbkewgt.php",
-			syntax: "none | circle | disc | square"
-		},
-		"-webkit-user-drag": {
-			comment: "missed; http://help.dottoro.com/lcbixvwm.php",
-			syntax: "none | element | auto"
-		},
-		"-webkit-user-select": {
-			comment: "auto is supported by old webkit, https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
-			syntax: "auto | none | text | all"
-		},
-		"alignment-baseline": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/text.html#AlignmentBaselineProperty"
-			],
-			syntax: "auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge | ideographic | alphabetic | hanging | mathematical"
-		},
-		"baseline-shift": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/text.html#BaselineShiftProperty"
-			],
-			syntax: "baseline | sub | super | <svg-length>"
-		},
-		behavior: {
-			comment: "added old IE property https://msdn.microsoft.com/en-us/library/ms530723(v=vs.85).aspx",
-			syntax: "<url>+"
-		},
-		"clip-rule": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/masking.html#ClipRuleProperty"
-			],
-			syntax: "nonzero | evenodd"
-		},
-		cue: {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<'cue-before'> <'cue-after'>?"
-		},
-		"cue-after": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<url> <decibel>? | none"
-		},
-		"cue-before": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<url> <decibel>? | none"
-		},
-		cursor: {
-			comment: "added legacy keywords: hand, -webkit-grab. -webkit-grabbing, -webkit-zoom-in, -webkit-zoom-out, -moz-grab, -moz-grabbing, -moz-zoom-in, -moz-zoom-out",
-			refenrences: [
-				"https://www.sitepoint.com/css3-cursor-styles/"
-			],
-			syntax: "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing | hand | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out | -moz-grab | -moz-grabbing | -moz-zoom-in | -moz-zoom-out ] ]"
-		},
-		display: {
-			comment: "extended with -ms-flexbox",
-			syntax: "none | inline | block | list-item | inline-list-item | inline-block | inline-table | table | table-cell | table-column | table-column-group | table-footer-group | table-header-group | table-row | table-row-group | flex | inline-flex | grid | inline-grid | run-in | ruby | ruby-base | ruby-text | ruby-base-container | ruby-text-container | contents | -ms-flexbox | -ms-inline-flexbox | -ms-grid | -ms-inline-grid | -webkit-flex | -webkit-inline-flex | -webkit-box | -webkit-inline-box | -moz-inline-stack | -moz-box | -moz-inline-box"
-		},
-		position: {
-			comment: "extended with -webkit-sticky",
-			syntax: "static | relative | absolute | sticky | fixed | -webkit-sticky"
-		},
-		"dominant-baseline": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/text.html#DominantBaselineProperty"
-			],
-			syntax: "auto | use-script | no-change | reset-size | ideographic | alphabetic | hanging | mathematical | central | middle | text-after-edge | text-before-edge"
-		},
-		"image-rendering": {
-			comment: "extended with <-non-standard-image-rendering>, added SVG keywords optimizeSpeed and optimizeQuality",
-			references: [
-				"https://developer.mozilla.org/en/docs/Web/CSS/image-rendering",
-				"https://www.w3.org/TR/SVG/painting.html#ImageRenderingProperty"
-			],
-			syntax: "auto | crisp-edges | pixelated | optimizeSpeed | optimizeQuality | <-non-standard-image-rendering>"
-		},
-		fill: {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#FillProperty"
-			],
-			syntax: "<paint>"
-		},
-		"fill-opacity": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#FillProperty"
-			],
-			syntax: "<number-zero-one>"
-		},
-		"fill-rule": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#FillProperty"
-			],
-			syntax: "nonzero | evenodd"
-		},
-		filter: {
-			comment: "extend with IE legacy syntaxes",
-			syntax: "none | <filter-function-list> | <-ms-filter>"
-		},
-		font: {
-			comment: "extend with non-standard fonts",
-			syntax: "[ [ <'font-style'> || <font-variant-css21> || <'font-weight'> || <'font-stretch'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ] | caption | icon | menu | message-box | small-caption | status-bar | <-non-standard-font>"
-		},
-		"glyph-orientation-horizontal": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/text.html#GlyphOrientationHorizontalProperty"
-			],
-			syntax: "<angle>"
-		},
-		"glyph-orientation-vertical": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/text.html#GlyphOrientationVerticalProperty"
-			],
-			syntax: "<angle>"
-		},
-		kerning: {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/text.html#KerningProperty"
-			],
-			syntax: "auto | <svg-length>"
-		},
-		"letter-spacing": {
-			comment: "fix syntax <length> -> <length-percentage>",
-			references: [
-				"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/letter-spacing"
-			],
-			syntax: "normal | <length-percentage>"
-		},
-		"line-height-step": {
-			comment: "fix extra spaces around",
-			syntax: "none | <length>"
-		},
-		marker: {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
-			],
-			syntax: "none | <url>"
-		},
-		"marker-end": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
-			],
-			syntax: "none | <url>"
-		},
-		"marker-mid": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
-			],
-			syntax: "none | <url>"
-		},
-		"marker-start": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
-			],
-			syntax: "none | <url>"
-		},
-		"max-width": {
-			comment: "extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/max-width",
-			syntax: "<length> | <percentage> | none | max-content | min-content | fit-content | fill-available | <-non-standard-width>"
-		},
-		"min-width": {
-			comment: "extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
-			syntax: "<length> | <percentage> | auto | max-content | min-content | fit-content | fill-available | <-non-standard-width>"
-		},
-		opacity: {
-			comment: "strict to 0..1 <number> -> <number-zero-one>",
-			syntax: "<number-zero-one>"
-		},
-		overflow: {
-			comment: "extend by vendor keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
-			syntax: "visible | hidden | scroll | auto | <-non-standard-overflow>"
-		},
-		pause: {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<'pause-before'> <'pause-after'>?"
-		},
-		"pause-after": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
-		},
-		"pause-before": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
-		},
-		rest: {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<'rest-before'> <'rest-after'>?"
-		},
-		"rest-after": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
-		},
-		"rest-before": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
-		},
-		"shape-rendering": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#ShapeRenderingPropert"
-			],
-			syntax: "auto | optimizeSpeed | crispEdges | geometricPrecision"
-		},
-		src: {
-			comment: "added @font-face's src property https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src",
-			syntax: "[ <url> [ format( <string># ) ]? | local( <family-name> ) ]#"
-		},
-		speak: {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "auto | none | normal"
-		},
-		"speak-as": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "normal | spell-out || digits || [ literal-punctuation | no-punctuation ]"
-		},
-		stroke: {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "<paint>"
-		},
-		"stroke-dasharray": {
-			comment: "added SVG property; a list of comma and/or white space separated <length>s and <percentage>s",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "none | [ <svg-length>+ ]#"
-		},
-		"stroke-dashoffset": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "<svg-length>"
-		},
-		"stroke-linecap": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "butt | round | square"
-		},
-		"stroke-linejoin": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "miter | round | bevel"
-		},
-		"stroke-miterlimit": {
-			comment: "added SVG property (<miterlimit> = <number-one-or-greater>) ",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "<number-one-or-greater>"
-		},
-		"stroke-opacity": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "<number-zero-one>"
-		},
-		"stroke-width": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
-			],
-			syntax: "<svg-length>"
-		},
-		"text-anchor": {
-			comment: "added SVG property",
-			references: [
-				"https://www.w3.org/TR/SVG/text.html#TextAlignmentProperties"
-			],
-			syntax: "start | middle | end"
-		},
-		"transform-origin": {
-			comment: "move first group to the end since less collecting",
-			syntax: "[ [ <length-percentage> | left | center | right ] && [ <length-percentage> | top | center | bottom ] ] <length>? | [ <length-percentage> | left | center | right | top | bottom ]"
-		},
-		"unicode-bidi": {
-			comment: "added prefixed keywords https://developer.mozilla.org/en-US/docs/Web/CSS/unicode-bidi",
-			syntax: "normal | embed | isolate | bidi-override | isolate-override | plaintext | -moz-isolate | -moz-isolate-override | -moz-plaintext | -webkit-isolate"
-		},
-		"unicode-range": {
-			comment: "added missed property https://developer.mozilla.org/en-US/docs/Web/CSS/%40font-face/unicode-range",
-			syntax: "<unicode-range>#"
-		},
-		"voice-balance": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<number> | left | center | right | leftwards | rightwards"
-		},
-		"voice-duration": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "auto | <time>"
-		},
-		"voice-family": {
-			comment: "<name> -> <family-name>, https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "[ [ <family-name> | <generic-voice> ] , ]* [ <family-name> | <generic-voice> ] | preserve"
-		},
-		"voice-pitch": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
-		},
-		"voice-range": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
-		},
-		"voice-rate": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "[ normal | x-slow | slow | medium | fast | x-fast ] || <percentage>"
-		},
-		"voice-stress": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "normal | strong | moderate | none | reduced"
-		},
-		"voice-volume": {
-			comment: "https://www.w3.org/TR/css3-speech/#property-index",
-			syntax: "silent | [ [ x-soft | soft | medium | loud | x-loud ] || <decibel> ]"
-		},
-		"word-break": {
-			comment: "extend with non-standard keywords",
-			syntax: "normal | break-all | keep-all | <-non-standard-word-break>"
-		},
-		"writing-mode": {
-			comment: "extend with SVG keywords",
-			syntax: "horizontal-tb | vertical-rl | vertical-lr | sideways-rl | sideways-lr | <svg-writing-mode>"
-		}
-	};
-	var syntaxes$2 = {
-		"-legacy-gradient": {
-			comment: "added collection of legacy gradient syntaxes",
-			syntax: "<-webkit-gradient()> | <-legacy-linear-gradient> | <-legacy-repeating-linear-gradient> | <-legacy-radial-gradient> | <-legacy-repeating-radial-gradient>"
-		},
-		"-legacy-linear-gradient": {
-			comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
-			syntax: "-moz-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-linear-gradient( <-legacy-linear-gradient-arguments> )"
-		},
-		"-legacy-repeating-linear-gradient": {
-			comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
-			syntax: "-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )"
-		},
-		"-legacy-linear-gradient-arguments": {
-			comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
-			syntax: "[ <angle> | <side-or-corner> ]? , <color-stop-list>"
-		},
-		"-legacy-radial-gradient": {
-			comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
-			syntax: "-moz-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-radial-gradient( <-legacy-radial-gradient-arguments> )"
-		},
-		"-legacy-repeating-radial-gradient": {
-			comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
-			syntax: "-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )"
-		},
-		"-legacy-radial-gradient-arguments": {
-			comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
-			syntax: "[ <position> , ]? [ [ [ <-legacy-radial-gradient-shape> || <-legacy-radial-gradient-size> ] | [ <length> | <percentage> ]{2} ] , ]? <color-stop-list>"
-		},
-		"-legacy-radial-gradient-size": {
-			comment: "before a standard it contains 2 extra keywords (`contain` and `cover`) https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltsize",
-			syntax: "closest-side | closest-corner | farthest-side | farthest-corner | contain | cover"
-		},
-		"-legacy-radial-gradient-shape": {
-			comment: "define to duoble sure it doesn't extends in future https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltshape",
-			syntax: "circle | ellipse"
-		},
-		"-non-standard-font": {
-			comment: "non standard fonts",
-			preferences: [
-				"https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
-			],
-			syntax: "-apple-system-body | -apple-system-headline | -apple-system-subheadline | -apple-system-caption1 | -apple-system-caption2 | -apple-system-footnote | -apple-system-short-body | -apple-system-short-headline | -apple-system-short-subheadline | -apple-system-short-caption1 | -apple-system-short-footnote | -apple-system-tall-body"
-		},
-		"-non-standard-color": {
-			comment: "non standard colors",
-			references: [
-				"http://cssdot.ru/%D0%A1%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%D1%87%D0%BD%D0%B8%D0%BA_CSS/color-i305.html",
-				"https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#Mozilla_Color_Preference_Extensions"
-			],
-			syntax: "-moz-ButtonDefault | -moz-ButtonHoverFace | -moz-ButtonHoverText | -moz-CellHighlight | -moz-CellHighlightText | -moz-Combobox | -moz-ComboboxText | -moz-Dialog | -moz-DialogText | -moz-dragtargetzone | -moz-EvenTreeRow | -moz-Field | -moz-FieldText | -moz-html-CellHighlight | -moz-html-CellHighlightText | -moz-mac-accentdarkestshadow | -moz-mac-accentdarkshadow | -moz-mac-accentface | -moz-mac-accentlightesthighlight | -moz-mac-accentlightshadow | -moz-mac-accentregularhighlight | -moz-mac-accentregularshadow | -moz-mac-chrome-active | -moz-mac-chrome-inactive | -moz-mac-focusring | -moz-mac-menuselect | -moz-mac-menushadow | -moz-mac-menutextselect | -moz-MenuHover | -moz-MenuHoverText | -moz-MenuBarText | -moz-MenuBarHoverText | -moz-nativehyperlinktext | -moz-OddTreeRow | -moz-win-communicationstext | -moz-win-mediatext | -moz-activehyperlinktext | -moz-default-background-color | -moz-default-color | -moz-hyperlinktext | -moz-visitedhyperlinktext | -webkit-activelink | -webkit-focus-ring-color | -webkit-link | -webkit-text"
-		},
-		"-non-standard-image-rendering": {
-			comment: "non-standard keywords http://phrogz.net/tmp/canvas_image_zoom.html",
-			syntax: "optimize-contrast | -moz-crisp-edges | -o-crisp-edges | -webkit-optimize-contrast"
-		},
-		"-non-standard-overflow": {
-			comment: "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
-			syntax: "-moz-scrollbars-none | -moz-scrollbars-horizontal | -moz-scrollbars-vertical | -moz-hidden-unscrollable"
-		},
-		"-non-standard-width": {
-			comment: "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
-			syntax: "min-intrinsic | intrinsic | -moz-min-content | -moz-max-content | -webkit-min-content | -webkit-max-content"
-		},
-		"-non-standard-word-break": {
-			comment: "non-standard keywords https://css-tricks.com/almanac/properties/w/word-break/",
-			syntax: "break-word"
-		},
-		"-webkit-gradient()": {
-			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/ - TODO: simplify when after match algorithm improvement ( [, point, radius | , point] -> [, radius]? , point )",
-			syntax: "-webkit-gradient( <-webkit-gradient-type>, <-webkit-gradient-point> [, <-webkit-gradient-point> | , <-webkit-gradient-radius>, <-webkit-gradient-point> ] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )"
-		},
-		"-webkit-gradient-color-stop": {
-			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
-			syntax: "from( <color> ) | color-stop( [ <number-zero-one> | <percentage> ] , <color> ) | to( <color> )"
-		},
-		"-webkit-gradient-point": {
-			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
-			syntax: "[ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]"
-		},
-		"-webkit-gradient-radius": {
-			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
-			syntax: "<length> | <percentage>"
-		},
-		"-webkit-gradient-type": {
-			comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
-			syntax: "linear | radial"
-		},
-		"-webkit-mask-box-repeat": {
-			comment: "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
-			syntax: "repeat | stretch | round"
-		},
-		"-webkit-mask-clip-style": {
-			comment: "missed; there is no enough information about `-webkit-mask-clip` property, but looks like all those keywords are working",
-			syntax: "border | border-box | padding | padding-box | content | content-box | text"
-		},
-		"-ms-filter": {
-			syntax: "[ <progid> | FlipH | FlipV ]+"
-		},
-		age: {
-			comment: "https://www.w3.org/TR/css3-speech/#voice-family",
-			syntax: "child | young | old"
-		},
-		"attr()": {
-			comment: "drop it since it's a generic",
-			syntax: null
-		},
-		"border-radius": {
-			comment: "missed, https://drafts.csswg.org/css-backgrounds-3/#the-border-radius",
-			syntax: "<length-percentage>{1,2}"
-		},
-		bottom: {
-			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
-			syntax: "<length> | auto"
-		},
-		"content-list": {
-			comment: "missed -> https://drafts.csswg.org/css-content/#typedef-content-list (document-url, <target> and leader() is omitted util stabilization)",
-			syntax: "[ <string> | contents | <url> | <quote> | <attr()> | counter( <ident>, <'list-style-type'>? ) ]+"
-		},
-		"inset()": {
-			comment: "changed <border-radius> to <'border-radius'>",
-			syntax: "inset( <length-percentage>{1,4} [ round <'border-radius'> ]? )"
-		},
-		"generic-voice": {
-			comment: "https://www.w3.org/TR/css3-speech/#voice-family",
-			syntax: "[ <age>? <gender> <integer>? ]"
-		},
-		gender: {
-			comment: "https://www.w3.org/TR/css3-speech/#voice-family",
-			syntax: "male | female | neutral"
-		},
-		"generic-family": {
-			comment: "added -apple-system",
-			references: [
-				"https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
-			],
-			syntax: "serif | sans-serif | cursive | fantasy | monospace | -apple-system"
-		},
-		gradient: {
-			comment: "added -webkit-gradient() since may to be used for legacy support",
-			syntax: "<-legacy-gradient> | <linear-gradient()> | <repeating-linear-gradient()> | <radial-gradient()> | <repeating-radial-gradient()>"
-		},
-		left: {
-			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
-			syntax: "<length> | auto"
-		},
-		"mask-image": {
-			comment: "missed; https://drafts.fxtf.org/css-masking-1/#the-mask-image",
-			syntax: "<mask-reference>#"
-		},
-		"matrix()": {
-			comment: "redundant max",
-			syntax: "matrix( <number> [, <number> ]{5} )"
-		},
-		"matrix3d()": {
-			comment: "redundant max",
-			syntax: "matrix3d( <number> [, <number> ]{15} )"
-		},
-		"name-repeat": {
-			comment: "missed, and looks like obsolete, keep it as is since other property syntaxes should be changed too; https://www.w3.org/TR/2015/WD-css-grid-1-20150917/#typedef-name-repeat",
-			syntax: "repeat( [ <positive-integer> | auto-fill ], <line-names>+)"
-		},
-		"named-color": {
-			comment: "replaced <ident> to list of colors according to https://www.w3.org/TR/css-color-4/#named-colors",
-			syntax: "transparent | aliceblue | antiquewhite | aqua | aquamarine | azure | beige | bisque | black | blanchedalmond | blue | blueviolet | brown | burlywood | cadetblue | chartreuse | chocolate | coral | cornflowerblue | cornsilk | crimson | cyan | darkblue | darkcyan | darkgoldenrod | darkgray | darkgreen | darkgrey | darkkhaki | darkmagenta | darkolivegreen | darkorange | darkorchid | darkred | darksalmon | darkseagreen | darkslateblue | darkslategray | darkslategrey | darkturquoise | darkviolet | deeppink | deepskyblue | dimgray | dimgrey | dodgerblue | firebrick | floralwhite | forestgreen | fuchsia | gainsboro | ghostwhite | gold | goldenrod | gray | green | greenyellow | grey | honeydew | hotpink | indianred | indigo | ivory | khaki | lavender | lavenderblush | lawngreen | lemonchiffon | lightblue | lightcoral | lightcyan | lightgoldenrodyellow | lightgray | lightgreen | lightgrey | lightpink | lightsalmon | lightseagreen | lightskyblue | lightslategray | lightslategrey | lightsteelblue | lightyellow | lime | limegreen | linen | magenta | maroon | mediumaquamarine | mediumblue | mediumorchid | mediumpurple | mediumseagreen | mediumslateblue | mediumspringgreen | mediumturquoise | mediumvioletred | midnightblue | mintcream | mistyrose | moccasin | navajowhite | navy | oldlace | olive | olivedrab | orange | orangered | orchid | palegoldenrod | palegreen | paleturquoise | palevioletred | papayawhip | peachpuff | peru | pink | plum | powderblue | purple | rebeccapurple | red | rosybrown | royalblue | saddlebrown | salmon | sandybrown | seagreen | seashell | sienna | silver | skyblue | slateblue | slategray | slategrey | snow | springgreen | steelblue | tan | teal | thistle | tomato | turquoise | violet | wheat | white | whitesmoke | yellow | yellowgreen | <-non-standard-color>"
-		},
-		"outline-radius": {
-			comment: "missed, looks like it's a similar to <border-radius> https://developer.mozilla.org/en/docs/Web/CSS/-moz-outline-radius",
-			syntax: "<border-radius>"
-		},
-		paint: {
-			comment: "simplified SVG syntax (omit <icccolor>, replace <funciri> for <url>) https://www.w3.org/TR/SVG/painting.html#SpecifyingPaint",
-			syntax: "none | currentColor | <color> | <url> [ none | currentColor | <color> ]?"
-		},
-		"path()": {
-			comment: "missed, `motion` property was renamed, but left it as is for now; path() syntax was get from last draft https://drafts.fxtf.org/motion-1/#funcdef-offset-path-path",
-			syntax: "path( <string> )"
-		},
-		right: {
-			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
-			syntax: "<length> | auto"
-		},
-		shape: {
-			comment: "missed spaces in function body and add backwards compatible syntax",
-			syntax: "rect( [ [ <top>, <right>, <bottom>, <left> ] | [ <top> <right> <bottom> <left> ] ] )"
-		},
-		"single-transition": {
-			comment: "moved <single-transition-timing-function> in the beginning to avoid wrong match to <single-transition-property>",
-			syntax: "<single-transition-timing-function> || [ none | <single-transition-property> ] || <time> || <time>"
-		},
-		"svg-length": {
-			comment: "All coordinates and lengths in SVG can be specified with or without a unit identifier",
-			references: [
-				"https://www.w3.org/TR/SVG11/coords.html#Units"
-			],
-			syntax: "<percentage> | <length> | <number>"
-		},
-		"svg-writing-mode": {
-			comment: "SVG specific keywords (deprecated for CSS)",
-			references: [
-				"https://developer.mozilla.org/en/docs/Web/CSS/writing-mode",
-				"https://www.w3.org/TR/SVG/text.html#WritingModeProperty"
-			],
-			syntax: "lr-tb | rl-tb | tb-rl | lr | rl | tb"
-		},
-		top: {
-			comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
-			syntax: "<length> | auto"
-		},
-		x: {
-			comment: "missed; not sure we should add it, but no others except `cursor` is using it so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
-			syntax: "<number>"
-		},
-		y: {
-			comment: "missed; not sure we should add it, but no others except `cursor` is using so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
-			syntax: "<number>"
-		},
-		"var()": {
-			comment: "drop it since it's a generic (also syntax is incorrect and can't be parsed)",
-			syntax: null
-		},
-		"an-plus-b": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"feature-type": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"feature-value-block": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"feature-value-declaration": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"feature-value-block-list": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"feature-value-declaration-list": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"general-enclosed": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"keyframe-block": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"keyframe-block-list": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"mf-plain": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"mf-range": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"mf-value": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-and": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-condition": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-not": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-or": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-in-parens": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-feature": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-condition-without-or": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-query": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"media-query-list": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		nth: {
-			comment: "syntax has <an-plus-b> that doesn't support currently, drop for now",
-			syntax: null
-		},
-		"page-selector": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"page-selector-list": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"page-body": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"page-margin-box": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"page-margin-box-type": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		},
-		"pseudo-page": {
-			comment: "syntax is incorrect and can't be parsed, drop for now",
-			syntax: null
-		}
-	};
-	var patch = {
-		properties: properties$3,
-		syntaxes: syntaxes$2
-	};
-
-	var patch$1 = /*#__PURE__*/Object.freeze({
-		properties: properties$3,
-		syntaxes: syntaxes$2,
-		default: patch
-	});
-
-	var mdnProperties = getCjsExportFromNamespace(properties$2);
-
-	var mdnSyntaxes = getCjsExportFromNamespace(syntaxes$1);
-
-	var patch$2 = getCjsExportFromNamespace(patch$1);
-
-	function buildDictionary(dict, patchDict) {
-	    var result = {};
-
-	    // copy all syntaxes for an original dict
-	    for (var key in dict) {
-	        result[key] = dict[key].syntax;
-	    }
-
-	    // apply a patch
-	    for (var key in patchDict) {
-	        if (key in dict) {
-	            if (patchDict[key].syntax) {
-	                result[key] = patchDict[key].syntax;
-	            } else {
-	                delete result[key];
-	            }
-	        } else {
-	            if (patchDict[key].syntax) {
-	                result[key] = patchDict[key].syntax;
-	            }
-	        }
-	    }
-
-	    return result;
-	}
-
-	var data = {
-	    properties: buildDictionary(mdnProperties, patch$2.properties),
-	    types: buildDictionary(mdnSyntaxes, patch$2.syntaxes)
-	};
-
-	var cmpChar$1 = tokenizer.cmpChar;
-	var isNumber$3 = tokenizer.isNumber;
-	var TYPE$4 = tokenizer.TYPE;
-
-	var IDENTIFIER$3 = TYPE$4.Identifier;
-	var NUMBER$2 = TYPE$4.Number;
-	var PLUSSIGN$4 = TYPE$4.PlusSign;
-	var HYPHENMINUS$4 = TYPE$4.HyphenMinus;
-	var N$5 = 110; // 'n'.charCodeAt(0)
-	var DISALLOW_SIGN = true;
-	var ALLOW_SIGN = false;
-
-	function checkTokenIsInteger(scanner, disallowSign) {
-	    var pos = scanner.tokenStart;
-
-	    if (scanner.source.charCodeAt(pos) === PLUSSIGN$4 ||
-	        scanner.source.charCodeAt(pos) === HYPHENMINUS$4) {
-	        if (disallowSign) {
-	            scanner.error();
-	        }
-	        pos++;
-	    }
-
-	    for (; pos < scanner.tokenEnd; pos++) {
-	        if (!isNumber$3(scanner.source.charCodeAt(pos))) {
-	            scanner.error('Unexpected input', pos);
-	        }
-	    }
-	}
-
-	// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
-	var AnPlusB = {
-	    name: 'AnPlusB',
-	    structure: {
-	        a: [String, null],
-	        b: [String, null]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var end = start;
-	        var prefix = '';
-	        var a = null;
-	        var b = null;
-
-	        if (this.scanner.tokenType === NUMBER$2 ||
-	            this.scanner.tokenType === PLUSSIGN$4) {
-	            checkTokenIsInteger(this.scanner, ALLOW_SIGN);
-	            prefix = this.scanner.getTokenValue();
-	            this.scanner.next();
-	            end = this.scanner.tokenStart;
-	        }
-
-	        if (this.scanner.tokenType === IDENTIFIER$3) {
-	            var bStart = this.scanner.tokenStart;
-
-	            if (cmpChar$1(this.scanner.source, bStart, HYPHENMINUS$4)) {
-	                if (prefix === '') {
-	                    prefix = '-';
-	                    bStart++;
-	                } else {
-	                    this.scanner.error('Unexpected hyphen minus');
-	                }
-	            }
-
-	            if (!cmpChar$1(this.scanner.source, bStart, N$5)) {
-	                this.scanner.error();
-	            }
-
-	            a = prefix === ''  ? '1'  :
-	                prefix === '+' ? '+1' :
-	                prefix === '-' ? '-1' :
-	                prefix;
-
-	            var len = this.scanner.tokenEnd - bStart;
-	            if (len > 1) {
-	                // ..n-..
-	                if (this.scanner.source.charCodeAt(bStart + 1) !== HYPHENMINUS$4) {
-	                    this.scanner.error('Unexpected input', bStart + 1);
-	                }
-
-	                if (len > 2) {
-	                    // ..n-{number}..
-	                    this.scanner.tokenStart = bStart + 2;
-	                } else {
-	                    // ..n- {number}
-	                    this.scanner.next();
-	                    this.scanner.skipSC();
-	                }
-
-	                checkTokenIsInteger(this.scanner, DISALLOW_SIGN);
-	                b = '-' + this.scanner.getTokenValue();
-	                this.scanner.next();
-	                end = this.scanner.tokenStart;
-	            } else {
-	                prefix = '';
-	                this.scanner.next();
-	                end = this.scanner.tokenStart;
-	                this.scanner.skipSC();
-
-	                if (this.scanner.tokenType === HYPHENMINUS$4 ||
-	                    this.scanner.tokenType === PLUSSIGN$4) {
-	                    prefix = this.scanner.getTokenValue();
-	                    this.scanner.next();
-	                    this.scanner.skipSC();
-	                }
-
-	                if (this.scanner.tokenType === NUMBER$2) {
-	                    checkTokenIsInteger(this.scanner, prefix !== '');
-
-	                    if (!isNumber$3(this.scanner.source.charCodeAt(this.scanner.tokenStart))) {
-	                        prefix = this.scanner.source.charAt(this.scanner.tokenStart);
-	                        this.scanner.tokenStart++;
-	                    }
-
-	                    if (prefix === '') {
-	                        // should be an operator before number
-	                        this.scanner.error();
-	                    } else if (prefix === '+') {
-	                        // plus is using by default
-	                        prefix = '';
-	                    }
-
-	                    b = prefix + this.scanner.getTokenValue();
-
-	                    this.scanner.next();
-	                    end = this.scanner.tokenStart;
-	                } else {
-	                    if (prefix) {
-	                        this.scanner.eat(NUMBER$2);
-	                    }
-	                }
-	            }
-	        } else {
-	            if (prefix === '' || prefix === '+') { // no number
-	                this.scanner.error(
-	                    'Number or identifier is expected',
-	                    this.scanner.tokenStart + (
-	                        this.scanner.tokenType === PLUSSIGN$4 ||
-	                        this.scanner.tokenType === HYPHENMINUS$4
-	                    )
-	                );
-	            }
-
-	            b = prefix;
-	        }
-
-	        return {
-	            type: 'AnPlusB',
-	            loc: this.getLocation(start, end),
-	            a: a,
-	            b: b
-	        };
-	    },
-	    generate: function(node) {
-	        var a = node.a !== null && node.a !== undefined;
-	        var b = node.b !== null && node.b !== undefined;
-
-	        if (a) {
-	            this.chunk(
-	                node.a === '+1' ? '+n' :
-	                node.a ===  '1' ?  'n' :
-	                node.a === '-1' ? '-n' :
-	                node.a + 'n'
-	            );
-
-	            if (b) {
-	                b = String(node.b);
-	                if (b.charAt(0) === '-' || b.charAt(0) === '+') {
-	                    this.chunk(b.charAt(0));
-	                    this.chunk(b.substr(1));
-	                } else {
-	                    this.chunk('+');
-	                    this.chunk(b);
-	                }
-	            }
-	        } else {
-	            this.chunk(String(node.b));
-	        }
-	    }
-	};
-
-	var TYPE$5 = tokenizer.TYPE;
-
-	var ATKEYWORD$2 = TYPE$5.AtKeyword;
-	var SEMICOLON = TYPE$5.Semicolon;
-	var LEFTCURLYBRACKET$2 = TYPE$5.LeftCurlyBracket;
-	var RIGHTCURLYBRACKET$2 = TYPE$5.RightCurlyBracket;
-
-	function consumeRaw(startToken) {
-	    return this.Raw(startToken, SEMICOLON, LEFTCURLYBRACKET$2, false, true);
-	}
-
-	function isDeclarationBlockAtrule() {
-	    for (var offset = 1, type; type = this.scanner.lookupType(offset); offset++) {
-	        if (type === RIGHTCURLYBRACKET$2) {
-	            return true;
-	        }
-
-	        if (type === LEFTCURLYBRACKET$2 ||
-	            type === ATKEYWORD$2) {
-	            return false;
-	        }
-	    }
-
-	    return false;
-	}
-
-	var Atrule = {
-	    name: 'Atrule',
-	    structure: {
-	        name: String,
-	        prelude: ['AtrulePrelude', 'Raw', null],
-	        block: ['Block', null]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var name;
-	        var nameLowerCase;
-	        var prelude = null;
-	        var block = null;
-
-	        this.scanner.eat(ATKEYWORD$2);
-
-	        name = this.scanner.substrToCursor(start + 1);
-	        nameLowerCase = name.toLowerCase();
-	        this.scanner.skipSC();
-
-	        // parse prelude
-	        if (this.scanner.eof === false &&
-	            this.scanner.tokenType !== LEFTCURLYBRACKET$2 &&
-	            this.scanner.tokenType !== SEMICOLON) {
-	            if (this.parseAtrulePrelude) {
-	                prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name), consumeRaw);
-
-	                // turn empty AtrulePrelude into null
-	                if (prelude.type === 'AtrulePrelude' && prelude.children.head === null) {
-	                    prelude = null;
-	                }
-	            } else {
-	                prelude = consumeRaw.call(this, this.scanner.currentToken);
-	            }
-
-	            this.scanner.skipSC();
-	        }
-
-	        switch (this.scanner.tokenType) {
-	            case SEMICOLON:
-	                this.scanner.next();
-	                break;
-
-	            case LEFTCURLYBRACKET$2:
-	                if (this.atrule.hasOwnProperty(nameLowerCase) &&
-	                    typeof this.atrule[nameLowerCase].block === 'function') {
-	                    block = this.atrule[nameLowerCase].block.call(this);
-	                } else {
-	                    // TODO: should consume block content as Raw?
-	                    block = this.Block(isDeclarationBlockAtrule.call(this));
-	                }
-
-	                break;
-	        }
-
-	        return {
-	            type: 'Atrule',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: name,
-	            prelude: prelude,
-	            block: block
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('@');
-	        this.chunk(node.name);
-
-	        if (node.prelude !== null) {
-	            this.chunk(' ');
-	            this.node(node.prelude);
-	        }
-
-	        if (node.block) {
-	            this.node(node.block);
-	        } else {
-	            this.chunk(';');
-	        }
-	    },
-	    walkContext: 'atrule'
-	};
-
-	var TYPE$6 = tokenizer.TYPE;
-
-	var SEMICOLON$1 = TYPE$6.Semicolon;
-	var LEFTCURLYBRACKET$3 = TYPE$6.LeftCurlyBracket;
-
-	var AtrulePrelude = {
-	    name: 'AtrulePrelude',
-	    structure: {
-	        children: [[]]
-	    },
-	    parse: function(name) {
-	        var children = null;
-
-	        if (name !== null) {
-	            name = name.toLowerCase();
-	        }
-
-	        this.scanner.skipSC();
-
-	        if (this.atrule.hasOwnProperty(name) &&
-	            typeof this.atrule[name].prelude === 'function') {
-	            // custom consumer
-	            children = this.atrule[name].prelude.call(this);
-	        } else {
-	            // default consumer
-	            children = this.readSequence(this.scope.AtrulePrelude);
-	        }
-
-	        this.scanner.skipSC();
-
-	        if (this.scanner.eof !== true &&
-	            this.scanner.tokenType !== LEFTCURLYBRACKET$3 &&
-	            this.scanner.tokenType !== SEMICOLON$1) {
-	            this.scanner.error('Semicolon or block is expected');
-	        }
-
-	        if (children === null) {
-	            children = this.createList();
-	        }
-
-	        return {
-	            type: 'AtrulePrelude',
-	            loc: this.getLocationFromList(children),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node);
-	    },
-	    walkContext: 'atrulePrelude'
-	};
-
-	var TYPE$7 = tokenizer.TYPE;
-
-	var IDENTIFIER$4 = TYPE$7.Identifier;
-	var STRING$2 = TYPE$7.String;
-	var DOLLARSIGN = TYPE$7.DollarSign;
-	var ASTERISK$1 = TYPE$7.Asterisk;
-	var COLON = TYPE$7.Colon;
-	var EQUALSSIGN = TYPE$7.EqualsSign;
-	var LEFTSQUAREBRACKET$2 = TYPE$7.LeftSquareBracket;
-	var RIGHTSQUAREBRACKET$2 = TYPE$7.RightSquareBracket;
-	var CIRCUMFLEXACCENT = TYPE$7.CircumflexAccent;
-	var VERTICALLINE$1 = TYPE$7.VerticalLine;
-	var TILDE = TYPE$7.Tilde;
-
-	function getAttributeName() {
-	    if (this.scanner.eof) {
-	        this.scanner.error('Unexpected end of input');
-	    }
-
-	    var start = this.scanner.tokenStart;
-	    var expectIdentifier = false;
-	    var checkColon = true;
-
-	    if (this.scanner.tokenType === ASTERISK$1) {
-	        expectIdentifier = true;
-	        checkColon = false;
-	        this.scanner.next();
-	    } else if (this.scanner.tokenType !== VERTICALLINE$1) {
-	        this.scanner.eat(IDENTIFIER$4);
-	    }
-
-	    if (this.scanner.tokenType === VERTICALLINE$1) {
-	        if (this.scanner.lookupType(1) !== EQUALSSIGN) {
-	            this.scanner.next();
-	            this.scanner.eat(IDENTIFIER$4);
-	        } else if (expectIdentifier) {
-	            this.scanner.error('Identifier is expected', this.scanner.tokenEnd);
-	        }
-	    } else if (expectIdentifier) {
-	        this.scanner.error('Vertical line is expected');
-	    }
-
-	    if (checkColon && this.scanner.tokenType === COLON) {
-	        this.scanner.next();
-	        this.scanner.eat(IDENTIFIER$4);
-	    }
-
-	    return {
-	        type: 'Identifier',
-	        loc: this.getLocation(start, this.scanner.tokenStart),
-	        name: this.scanner.substrToCursor(start)
-	    };
-	}
-
-	function getOperator() {
-	    var start = this.scanner.tokenStart;
-	    var tokenType = this.scanner.tokenType;
-
-	    if (tokenType !== EQUALSSIGN &&        // =
-	        tokenType !== TILDE &&             // ~=
-	        tokenType !== CIRCUMFLEXACCENT &&  // ^=
-	        tokenType !== DOLLARSIGN &&        // $=
-	        tokenType !== ASTERISK$1 &&          // *=
-	        tokenType !== VERTICALLINE$1         // |=
-	    ) {
-	        this.scanner.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');
-	    }
-
-	    if (tokenType === EQUALSSIGN) {
-	        this.scanner.next();
-	    } else {
-	        this.scanner.next();
-	        this.scanner.eat(EQUALSSIGN);
-	    }
-
-	    return this.scanner.substrToCursor(start);
-	}
-
-	// '[' S* attrib_name ']'
-	// '[' S* attrib_name S* attrib_matcher S* [ IDENT | STRING ] S* attrib_flags? S* ']'
-	var AttributeSelector = {
-	    name: 'AttributeSelector',
-	    structure: {
-	        name: 'Identifier',
-	        matcher: [String, null],
-	        value: ['String', 'Identifier', null],
-	        flags: [String, null]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var name;
-	        var matcher = null;
-	        var value = null;
-	        var flags = null;
-
-	        this.scanner.eat(LEFTSQUAREBRACKET$2);
-	        this.scanner.skipSC();
-
-	        name = getAttributeName.call(this);
-	        this.scanner.skipSC();
-
-	        if (this.scanner.tokenType !== RIGHTSQUAREBRACKET$2) {
-	            // avoid case `[name i]`
-	            if (this.scanner.tokenType !== IDENTIFIER$4) {
-	                matcher = getOperator.call(this);
-
-	                this.scanner.skipSC();
-
-	                value = this.scanner.tokenType === STRING$2
-	                    ? this.String()
-	                    : this.Identifier();
-
-	                this.scanner.skipSC();
-	            }
-
-	            // attribute flags
-	            if (this.scanner.tokenType === IDENTIFIER$4) {
-	                flags = this.scanner.getTokenValue();
-	                this.scanner.next();
-
-	                this.scanner.skipSC();
-	            }
-	        }
-
-	        this.scanner.eat(RIGHTSQUAREBRACKET$2);
-
-	        return {
-	            type: 'AttributeSelector',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: name,
-	            matcher: matcher,
-	            value: value,
-	            flags: flags
-	        };
-	    },
-	    generate: function(node) {
-	        var flagsPrefix = ' ';
-
-	        this.chunk('[');
-	        this.node(node.name);
-
-	        if (node.matcher !== null) {
-	            this.chunk(node.matcher);
-
-	            if (node.value !== null) {
-	                this.node(node.value);
-
-	                // space between string and flags is not required
-	                if (node.value.type === 'String') {
-	                    flagsPrefix = '';
-	                }
-	            }
-	        }
-
-	        if (node.flags !== null) {
-	            this.chunk(flagsPrefix);
-	            this.chunk(node.flags);
-	        }
-
-	        this.chunk(']');
-	    }
-	};
-
-	var TYPE$8 = tokenizer.TYPE;
-
-	var WHITESPACE$3 = TYPE$8.WhiteSpace;
-	var COMMENT$3 = TYPE$8.Comment;
-	var SEMICOLON$2 = TYPE$8.Semicolon;
-	var ATKEYWORD$3 = TYPE$8.AtKeyword;
-	var LEFTCURLYBRACKET$4 = TYPE$8.LeftCurlyBracket;
-	var RIGHTCURLYBRACKET$3 = TYPE$8.RightCurlyBracket;
-
-	function consumeRaw$1(startToken) {
-	    return this.Raw(startToken, 0, 0, false, true);
-	}
-	function consumeRule() {
-	    return this.parseWithFallback(this.Rule, consumeRaw$1);
-	}
-	function consumeRawDeclaration(startToken) {
-	    return this.Raw(startToken, 0, SEMICOLON$2, true, true);
-	}
-	function consumeDeclaration() {
-	    if (this.scanner.tokenType === SEMICOLON$2) {
-	        return consumeRawDeclaration.call(this, this.scanner.currentToken);
-	    }
-
-	    var node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);
-
-	    if (this.scanner.tokenType === SEMICOLON$2) {
-	        this.scanner.next();
-	    }
-
-	    return node;
-	}
-
-	var Block = {
-	    name: 'Block',
-	    structure: {
-	        children: [[
-	            'Atrule',
-	            'Rule',
-	            'Declaration'
-	        ]]
-	    },
-	    parse: function(isDeclaration) {
-	        var consumer = isDeclaration ? consumeDeclaration : consumeRule;
-
-	        var start = this.scanner.tokenStart;
-	        var children = this.createList();
-
-	        this.scanner.eat(LEFTCURLYBRACKET$4);
-
-	        scan:
-	        while (!this.scanner.eof) {
-	            switch (this.scanner.tokenType) {
-	                case RIGHTCURLYBRACKET$3:
-	                    break scan;
-
-	                case WHITESPACE$3:
-	                case COMMENT$3:
-	                    this.scanner.next();
-	                    break;
-
-	                case ATKEYWORD$3:
-	                    children.push(this.parseWithFallback(this.Atrule, consumeRaw$1));
-	                    break;
-
-	                default:
-	                    children.push(consumer.call(this));
-	            }
-	        }
-
-	        if (!this.scanner.eof) {
-	            this.scanner.eat(RIGHTCURLYBRACKET$3);
-	        }
-
-	        return {
-	            type: 'Block',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('{');
-	        this.children(node, function(prev) {
-	            if (prev.type === 'Declaration') {
-	                this.chunk(';');
-	            }
-	        });
-	        this.chunk('}');
-	    },
-	    walkContext: 'block'
-	};
-
-	var TYPE$9 = tokenizer.TYPE;
-	var LEFTSQUAREBRACKET$3 = TYPE$9.LeftSquareBracket;
-	var RIGHTSQUAREBRACKET$3 = TYPE$9.RightSquareBracket;
-
-	var Brackets = {
-	    name: 'Brackets',
-	    structure: {
-	        children: [[]]
-	    },
-	    parse: function(readSequence, recognizer) {
-	        var start = this.scanner.tokenStart;
-	        var children = null;
-
-	        this.scanner.eat(LEFTSQUAREBRACKET$3);
-
-	        children = readSequence.call(this, recognizer);
-
-	        if (!this.scanner.eof) {
-	            this.scanner.eat(RIGHTSQUAREBRACKET$3);
-	        }
-
-	        return {
-	            type: 'Brackets',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('[');
-	        this.children(node);
-	        this.chunk(']');
-	    }
-	};
-
-	var CDC$2 = tokenizer.TYPE.CDC;
-
-	var CDC_1 = {
-	    name: 'CDC',
-	    structure: [],
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-
-	        this.scanner.eat(CDC$2); // -->
-
-	        return {
-	            type: 'CDC',
-	            loc: this.getLocation(start, this.scanner.tokenStart)
-	        };
-	    },
-	    generate: function() {
-	        this.chunk('-->');
-	    }
-	};
-
-	var CDO$2 = tokenizer.TYPE.CDO;
-
-	var CDO_1 = {
-	    name: 'CDO',
-	    structure: [],
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-
-	        this.scanner.eat(CDO$2); // <!--
-
-	        return {
-	            type: 'CDO',
-	            loc: this.getLocation(start, this.scanner.tokenStart)
-	        };
-	    },
-	    generate: function() {
-	        this.chunk('<!--');
-	    }
-	};
-
-	var TYPE$a = tokenizer.TYPE;
-	var IDENTIFIER$5 = TYPE$a.Identifier;
-	var FULLSTOP$2 = TYPE$a.FullStop;
-
-	// '.' ident
-	var ClassSelector = {
-	    name: 'ClassSelector',
-	    structure: {
-	        name: String
-	    },
-	    parse: function() {
-	        this.scanner.eat(FULLSTOP$2);
-
-	        return {
-	            type: 'ClassSelector',
-	            loc: this.getLocation(this.scanner.tokenStart - 1, this.scanner.tokenEnd),
-	            name: this.scanner.consume(IDENTIFIER$5)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('.');
-	        this.chunk(node.name);
-	    }
-	};
-
-	var TYPE$b = tokenizer.TYPE;
-
-	var PLUSSIGN$5 = TYPE$b.PlusSign;
-	var SOLIDUS = TYPE$b.Solidus;
-	var GREATERTHANSIGN$2 = TYPE$b.GreaterThanSign;
-	var TILDE$1 = TYPE$b.Tilde;
-
-	// + | > | ~ | /deep/
-	var Combinator = {
-	    name: 'Combinator',
-	    structure: {
-	        name: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-
-	        switch (this.scanner.tokenType) {
-	            case GREATERTHANSIGN$2:
-	            case PLUSSIGN$5:
-	            case TILDE$1:
-	                this.scanner.next();
-	                break;
-
-	            case SOLIDUS:
-	                this.scanner.next();
-	                this.scanner.expectIdentifier('deep');
-	                this.scanner.eat(SOLIDUS);
-	                break;
-
-	            default:
-	                this.scanner.error('Combinator is expected');
-	        }
-
-	        return {
-	            type: 'Combinator',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: this.scanner.substrToCursor(start)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.name);
-	    }
-	};
-
-	var TYPE$c = tokenizer.TYPE;
-
-	var ASTERISK$2 = TYPE$c.Asterisk;
-	var SOLIDUS$1 = TYPE$c.Solidus;
-
-	// '/*' .* '*/'
-	var Comment = {
-	    name: 'Comment',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var end = this.scanner.tokenEnd;
-
-	        if ((end - start + 2) >= 2 &&
-	            this.scanner.source.charCodeAt(end - 2) === ASTERISK$2 &&
-	            this.scanner.source.charCodeAt(end - 1) === SOLIDUS$1) {
-	            end -= 2;
-	        }
-
-	        this.scanner.next();
-
-	        return {
-	            type: 'Comment',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            value: this.scanner.source.substring(start + 2, end)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('/*');
-	        this.chunk(node.value);
-	        this.chunk('*/');
-	    }
-	};
-
-	var isCustomProperty$1 = names.isCustomProperty;
-	var TYPE$d = tokenizer.TYPE;
-
-	var IDENTIFIER$6 = TYPE$d.Identifier;
-	var COLON$1 = TYPE$d.Colon;
-	var EXCLAMATIONMARK$2 = TYPE$d.ExclamationMark;
-	var SOLIDUS$2 = TYPE$d.Solidus;
-	var ASTERISK$3 = TYPE$d.Asterisk;
-	var DOLLARSIGN$1 = TYPE$d.DollarSign;
-	var HYPHENMINUS$5 = TYPE$d.HyphenMinus;
-	var SEMICOLON$3 = TYPE$d.Semicolon;
-	var PLUSSIGN$6 = TYPE$d.PlusSign;
-	var NUMBERSIGN$2 = TYPE$d.NumberSign;
-
-	function consumeValueRaw(startToken) {
-	    return this.Raw(startToken, EXCLAMATIONMARK$2, SEMICOLON$3, false, true);
-	}
-
-	function consumeCustomPropertyRaw(startToken) {
-	    return this.Raw(startToken, EXCLAMATIONMARK$2, SEMICOLON$3, false, false);
-	}
-
-	function consumeValue() {
-	    var startValueToken = this.scanner.currentToken;
-	    var value = this.Value();
-
-	    if (value.type !== 'Raw' &&
-	        this.scanner.eof === false &&
-	        this.scanner.tokenType !== SEMICOLON$3 &&
-	        this.scanner.tokenType !== EXCLAMATIONMARK$2 &&
-	        this.scanner.isBalanceEdge(startValueToken) === false) {
-	        this.scanner.error();
-	    }
-
-	    return value;
-	}
-
-	var Declaration = {
-	    name: 'Declaration',
-	    structure: {
-	        important: [Boolean, String],
-	        property: String,
-	        value: ['Value', 'Raw']
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var startToken = this.scanner.currentToken;
-	        var property = readProperty$1.call(this);
-	        var customProperty = isCustomProperty$1(property);
-	        var parseValue = customProperty ? this.parseCustomProperty : this.parseValue;
-	        var consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;
-	        var important = false;
-	        var value;
-
-	        this.scanner.skipSC();
-	        this.scanner.eat(COLON$1);
-
-	        if (!customProperty) {
-	            this.scanner.skipSC();
-	        }
-
-	        if (parseValue) {
-	            value = this.parseWithFallback(consumeValue, consumeRaw);
-	        } else {
-	            value = consumeRaw.call(this, this.scanner.currentToken);
-	        }
-
-	        if (this.scanner.tokenType === EXCLAMATIONMARK$2) {
-	            important = getImportant(this.scanner);
-	            this.scanner.skipSC();
-	        }
-
-	        // Do not include semicolon to range per spec
-	        // https://drafts.csswg.org/css-syntax/#declaration-diagram
-
-	        if (this.scanner.eof === false &&
-	            this.scanner.tokenType !== SEMICOLON$3 &&
-	            this.scanner.isBalanceEdge(startToken) === false) {
-	            this.scanner.error();
-	        }
-
-	        return {
-	            type: 'Declaration',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            important: important,
-	            property: property,
-	            value: value
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.property);
-	        this.chunk(':');
-	        this.node(node.value);
-
-	        if (node.important) {
-	            this.chunk(node.important === true ? '!important' : '!' + node.important);
-	        }
-	    },
-	    walkContext: 'declaration'
-	};
-
-	function readProperty$1() {
-	    var start = this.scanner.tokenStart;
-	    var prefix = 0;
-
-	    // hacks
-	    switch (this.scanner.tokenType) {
-	        case ASTERISK$3:
-	        case DOLLARSIGN$1:
-	        case PLUSSIGN$6:
-	        case NUMBERSIGN$2:
-	            prefix = 1;
-	            break;
-
-	        // TODO: not sure we should support this hack
-	        case SOLIDUS$2:
-	            prefix = this.scanner.lookupType(1) === SOLIDUS$2 ? 2 : 1;
-	            break;
-	    }
-
-	    if (this.scanner.lookupType(prefix) === HYPHENMINUS$5) {
-	        prefix++;
-	    }
-
-	    if (prefix) {
-	        this.scanner.skip(prefix);
-	    }
-
-	    this.scanner.eat(IDENTIFIER$6);
-
-	    return this.scanner.substrToCursor(start);
-	}
-
-	// ! ws* important
-	function getImportant(scanner) {
-	    scanner.eat(EXCLAMATIONMARK$2);
-	    scanner.skipSC();
-
-	    var important = scanner.consume(IDENTIFIER$6);
-
-	    // store original value in case it differ from `important`
-	    // for better original source restoring and hacks like `!ie` support
-	    return important === 'important' ? true : important;
-	}
-
-	var TYPE$e = tokenizer.TYPE;
-
-	var WHITESPACE$4 = TYPE$e.WhiteSpace;
-	var COMMENT$4 = TYPE$e.Comment;
-	var SEMICOLON$4 = TYPE$e.Semicolon;
-
-	function consumeRaw$2(startToken) {
-	    return this.Raw(startToken, 0, SEMICOLON$4, true, true);
-	}
-
-	var DeclarationList = {
-	    name: 'DeclarationList',
-	    structure: {
-	        children: [[
-	            'Declaration'
-	        ]]
-	    },
-	    parse: function() {
-	        var children = this.createList();
-
-	        scan:
-	        while (!this.scanner.eof) {
-	            switch (this.scanner.tokenType) {
-	                case WHITESPACE$4:
-	                case COMMENT$4:
-	                case SEMICOLON$4:
-	                    this.scanner.next();
-	                    break;
-
-	                default:
-	                    children.push(this.parseWithFallback(this.Declaration, consumeRaw$2));
-	            }
-	        }
-
-	        return {
-	            type: 'DeclarationList',
-	            loc: this.getLocationFromList(children),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node, function(prev) {
-	            if (prev.type === 'Declaration') {
-	                this.chunk(';');
-	            }
-	        });
-	    }
-	};
-
-	var NUMBER$3 = tokenizer.TYPE.Number;
-
-	// special reader for units to avoid adjoined IE hacks (i.e. '1px\9')
-	function readUnit(scanner) {
-	    var unit = scanner.getTokenValue();
-	    var backSlashPos = unit.indexOf('\\');
-
-	    if (backSlashPos > 0) {
-	        // patch token offset
-	        scanner.tokenStart += backSlashPos;
-
-	        // return part before backslash
-	        return unit.substring(0, backSlashPos);
-	    }
-
-	    // no backslash in unit name
-	    scanner.next();
-
-	    return unit;
-	}
-
-	// number ident
-	var Dimension = {
-	    name: 'Dimension',
-	    structure: {
-	        value: String,
-	        unit: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var value = this.scanner.consume(NUMBER$3);
-	        var unit = readUnit(this.scanner);
-
-	        return {
-	            type: 'Dimension',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            value: value,
-	            unit: unit
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	        this.chunk(node.unit);
-	    }
-	};
-
-	var TYPE$f = tokenizer.TYPE;
-	var RIGHTPARENTHESIS$3 = TYPE$f.RightParenthesis;
-
-	// <function-token> <sequence> ')'
-	var _Function = {
-	    name: 'Function',
-	    structure: {
-	        name: String,
-	        children: [[]]
-	    },
-	    parse: function(readSequence, recognizer) {
-	        var start = this.scanner.tokenStart;
-	        var name = this.scanner.consumeFunctionName();
-	        var nameLowerCase = name.toLowerCase();
-	        var children;
-
-	        children = recognizer.hasOwnProperty(nameLowerCase)
-	            ? recognizer[nameLowerCase].call(this, recognizer)
-	            : readSequence.call(this, recognizer);
-
-	        if (!this.scanner.eof) {
-	            this.scanner.eat(RIGHTPARENTHESIS$3);
-	        }
-
-	        return {
-	            type: 'Function',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: name,
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.name);
-	        this.chunk('(');
-	        this.children(node);
-	        this.chunk(')');
-	    },
-	    walkContext: 'function'
-	};
-
-	var isHex$2 = tokenizer.isHex;
-	var TYPE$g = tokenizer.TYPE;
-
-	var IDENTIFIER$7 = TYPE$g.Identifier;
-	var NUMBER$4 = TYPE$g.Number;
-	var NUMBERSIGN$3 = TYPE$g.NumberSign;
-
-	function consumeHexSequence(scanner, required) {
-	    if (!isHex$2(scanner.source.charCodeAt(scanner.tokenStart))) {
-	        if (required) {
-	            scanner.error('Unexpected input', scanner.tokenStart);
-	        } else {
-	            return;
-	        }
-	    }
-
-	    for (var pos = scanner.tokenStart + 1; pos < scanner.tokenEnd; pos++) {
-	        var code = scanner.source.charCodeAt(pos);
-
-	        // break on non-hex char
-	        if (!isHex$2(code)) {
-	            // break token, exclude symbol
-	            scanner.tokenStart = pos;
-	            return;
-	        }
-	    }
-
-	    // token is full hex sequence, go to next token
-	    scanner.next();
-	}
-
-	// # ident
-	var HexColor = {
-	    name: 'HexColor',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-
-	        this.scanner.eat(NUMBERSIGN$3);
-
-	        scan:
-	        switch (this.scanner.tokenType) {
-	            case NUMBER$4:
-	                consumeHexSequence(this.scanner, true);
-
-	                // if token is identifier then number consists of hex only,
-	                // try to add identifier to result
-	                if (this.scanner.tokenType === IDENTIFIER$7) {
-	                    consumeHexSequence(this.scanner, false);
-	                }
-
-	                break;
-
-	            case IDENTIFIER$7:
-	                consumeHexSequence(this.scanner, true);
-	                break;
-
-	            default:
-	                this.scanner.error('Number or identifier is expected');
-	        }
-
-	        return {
-	            type: 'HexColor',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            value: this.scanner.substrToCursor(start + 1) // skip #
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('#');
-	        this.chunk(node.value);
-	    }
-	};
-
-	var TYPE$h = tokenizer.TYPE;
-	var IDENTIFIER$8 = TYPE$h.Identifier;
-
-	var Identifier = {
-	    name: 'Identifier',
-	    structure: {
-	        name: String
-	    },
-	    parse: function() {
-	        return {
-	            type: 'Identifier',
-	            loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
-	            name: this.scanner.consume(IDENTIFIER$8)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.name);
-	    }
-	};
-
-	var TYPE$i = tokenizer.TYPE;
-	var IDENTIFIER$9 = TYPE$i.Identifier;
-	var NUMBERSIGN$4 = TYPE$i.NumberSign;
-
-	// '#' ident
-	var IdSelector = {
-	    name: 'IdSelector',
-	    structure: {
-	        name: String
-	    },
-	    parse: function() {
-	        this.scanner.eat(NUMBERSIGN$4);
-
-	        return {
-	            type: 'IdSelector',
-	            loc: this.getLocation(this.scanner.tokenStart - 1, this.scanner.tokenEnd),
-	            name: this.scanner.consume(IDENTIFIER$9)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('#');
-	        this.chunk(node.name);
-	    }
-	};
-
-	var TYPE$j = tokenizer.TYPE;
-
-	var IDENTIFIER$a = TYPE$j.Identifier;
-	var NUMBER$5 = TYPE$j.Number;
-	var LEFTPARENTHESIS$3 = TYPE$j.LeftParenthesis;
-	var RIGHTPARENTHESIS$4 = TYPE$j.RightParenthesis;
-	var COLON$2 = TYPE$j.Colon;
-	var SOLIDUS$3 = TYPE$j.Solidus;
-
-	var MediaFeature = {
-	    name: 'MediaFeature',
-	    structure: {
-	        name: String,
-	        value: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var name;
-	        var value = null;
-
-	        this.scanner.eat(LEFTPARENTHESIS$3);
-	        this.scanner.skipSC();
-
-	        name = this.scanner.consume(IDENTIFIER$a);
-	        this.scanner.skipSC();
-
-	        if (this.scanner.tokenType !== RIGHTPARENTHESIS$4) {
-	            this.scanner.eat(COLON$2);
-	            this.scanner.skipSC();
-
-	            switch (this.scanner.tokenType) {
-	                case NUMBER$5:
-	                    if (this.scanner.lookupType(1) === IDENTIFIER$a) {
-	                        value = this.Dimension();
-	                    } else if (this.scanner.lookupNonWSType(1) === SOLIDUS$3) {
-	                        value = this.Ratio();
-	                    } else {
-	                        value = this.Number();
-	                    }
-
-	                    break;
-
-	                case IDENTIFIER$a:
-	                    value = this.Identifier();
-
-	                    break;
-
-	                default:
-	                    this.scanner.error('Number, dimension, ratio or identifier is expected');
-	            }
-
-	            this.scanner.skipSC();
-	        }
-
-	        this.scanner.eat(RIGHTPARENTHESIS$4);
-
-	        return {
-	            type: 'MediaFeature',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: name,
-	            value: value
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('(');
-	        this.chunk(node.name);
-	        if (node.value !== null) {
-	            this.chunk(':');
-	            this.node(node.value);
-	        }
-	        this.chunk(')');
-	    }
-	};
-
-	var TYPE$k = tokenizer.TYPE;
-
-	var WHITESPACE$5 = TYPE$k.WhiteSpace;
-	var COMMENT$5 = TYPE$k.Comment;
-	var IDENTIFIER$b = TYPE$k.Identifier;
-	var LEFTPARENTHESIS$4 = TYPE$k.LeftParenthesis;
-
-	var MediaQuery = {
-	    name: 'MediaQuery',
-	    structure: {
-	        children: [[
-	            'Identifier',
-	            'MediaFeature',
-	            'WhiteSpace'
-	        ]]
-	    },
-	    parse: function() {
-	        this.scanner.skipSC();
-
-	        var children = this.createList();
-	        var child = null;
-	        var space = null;
-
-	        scan:
-	        while (!this.scanner.eof) {
-	            switch (this.scanner.tokenType) {
-	                case COMMENT$5:
-	                    this.scanner.next();
-	                    continue;
-
-	                case WHITESPACE$5:
-	                    space = this.WhiteSpace();
-	                    continue;
-
-	                case IDENTIFIER$b:
-	                    child = this.Identifier();
-	                    break;
-
-	                case LEFTPARENTHESIS$4:
-	                    child = this.MediaFeature();
-	                    break;
-
-	                default:
-	                    break scan;
-	            }
-
-	            if (space !== null) {
-	                children.push(space);
-	                space = null;
-	            }
-
-	            children.push(child);
-	        }
-
-	        if (child === null) {
-	            this.scanner.error('Identifier or parenthesis is expected');
-	        }
-
-	        return {
-	            type: 'MediaQuery',
-	            loc: this.getLocationFromList(children),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node);
-	    }
-	};
-
-	var COMMA$1 = tokenizer.TYPE.Comma;
-
-	var MediaQueryList = {
-	    name: 'MediaQueryList',
-	    structure: {
-	        children: [[
-	            'MediaQuery'
-	        ]]
-	    },
-	    parse: function(relative) {
-	        var children = this.createList();
-
-	        this.scanner.skipSC();
-
-	        while (!this.scanner.eof) {
-	            children.push(this.MediaQuery(relative));
-
-	            if (this.scanner.tokenType !== COMMA$1) {
-	                break;
-	            }
-
-	            this.scanner.next();
-	        }
-
-	        return {
-	            type: 'MediaQueryList',
-	            loc: this.getLocationFromList(children),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node, function() {
-	            this.chunk(',');
-	        });
-	    }
-	};
-
-	// https://drafts.csswg.org/css-syntax-3/#the-anb-type
-	var Nth = {
-	    name: 'Nth',
-	    structure: {
-	        nth: ['AnPlusB', 'Identifier'],
-	        selector: ['SelectorList', null]
-	    },
-	    parse: function(allowOfClause) {
-	        this.scanner.skipSC();
-
-	        var start = this.scanner.tokenStart;
-	        var end = start;
-	        var selector = null;
-	        var query;
-
-	        if (this.scanner.lookupValue(0, 'odd') || this.scanner.lookupValue(0, 'even')) {
-	            query = this.Identifier();
-	        } else {
-	            query = this.AnPlusB();
-	        }
-
-	        this.scanner.skipSC();
-
-	        if (allowOfClause && this.scanner.lookupValue(0, 'of')) {
-	            this.scanner.next();
-
-	            selector = this.SelectorList();
-
-	            if (this.needPositions) {
-	                end = this.getLastListNode(selector.children).loc.end.offset;
-	            }
-	        } else {
-	            if (this.needPositions) {
-	                end = query.loc.end.offset;
-	            }
-	        }
-
-	        return {
-	            type: 'Nth',
-	            loc: this.getLocation(start, end),
-	            nth: query,
-	            selector: selector
-	        };
-	    },
-	    generate: function(node) {
-	        this.node(node.nth);
-	        if (node.selector !== null) {
-	            this.chunk(' of ');
-	            this.node(node.selector);
-	        }
-	    }
-	};
-
-	var NUMBER$6 = tokenizer.TYPE.Number;
-
-	var _Number = {
-	    name: 'Number',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        return {
-	            type: 'Number',
-	            loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
-	            value: this.scanner.consume(NUMBER$6)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	    }
-	};
-
-	// '/' | '*' | ',' | ':' | '+' | '-'
-	var Operator = {
-	    name: 'Operator',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-
-	        this.scanner.next();
-
-	        return {
-	            type: 'Operator',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            value: this.scanner.substrToCursor(start)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	    }
-	};
-
-	var TYPE$l = tokenizer.TYPE;
-	var LEFTPARENTHESIS$5 = TYPE$l.LeftParenthesis;
-	var RIGHTPARENTHESIS$5 = TYPE$l.RightParenthesis;
-
-	var Parentheses = {
-	    name: 'Parentheses',
-	    structure: {
-	        children: [[]]
-	    },
-	    parse: function(readSequence, recognizer) {
-	        var start = this.scanner.tokenStart;
-	        var children = null;
-
-	        this.scanner.eat(LEFTPARENTHESIS$5);
-
-	        children = readSequence.call(this, recognizer);
-
-	        if (!this.scanner.eof) {
-	            this.scanner.eat(RIGHTPARENTHESIS$5);
-	        }
-
-	        return {
-	            type: 'Parentheses',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('(');
-	        this.children(node);
-	        this.chunk(')');
-	    }
-	};
-
-	var TYPE$m = tokenizer.TYPE;
-
-	var NUMBER$7 = TYPE$m.Number;
-	var PERCENTSIGN = TYPE$m.PercentSign;
-
-	var Percentage = {
-	    name: 'Percentage',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var number = this.scanner.consume(NUMBER$7);
-
-	        this.scanner.eat(PERCENTSIGN);
-
-	        return {
-	            type: 'Percentage',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            value: number
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	        this.chunk('%');
-	    }
-	};
-
-	var TYPE$n = tokenizer.TYPE;
-
-	var IDENTIFIER$c = TYPE$n.Identifier;
-	var FUNCTION$2 = TYPE$n.Function;
-	var COLON$3 = TYPE$n.Colon;
-	var RIGHTPARENTHESIS$6 = TYPE$n.RightParenthesis;
-
-	// : ident [ '(' .. ')' ]?
-	var PseudoClassSelector = {
-	    name: 'PseudoClassSelector',
-	    structure: {
-	        name: String,
-	        children: [['Raw'], null]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var children = null;
-	        var name;
-	        var nameLowerCase;
-
-	        this.scanner.eat(COLON$3);
-
-	        if (this.scanner.tokenType === FUNCTION$2) {
-	            name = this.scanner.consumeFunctionName();
-	            nameLowerCase = name.toLowerCase();
-
-	            if (this.pseudo.hasOwnProperty(nameLowerCase)) {
-	                this.scanner.skipSC();
-	                children = this.pseudo[nameLowerCase].call(this);
-	                this.scanner.skipSC();
-	            } else {
-	                children = this.createList();
-	                children.push(
-	                    this.Raw(this.scanner.currentToken, 0, 0, false, false)
-	                );
-	            }
-
-	            this.scanner.eat(RIGHTPARENTHESIS$6);
-	        } else {
-	            name = this.scanner.consume(IDENTIFIER$c);
-	        }
-
-	        return {
-	            type: 'PseudoClassSelector',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: name,
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(':');
-	        this.chunk(node.name);
-
-	        if (node.children !== null) {
-	            this.chunk('(');
-	            this.children(node);
-	            this.chunk(')');
-	        }
-	    },
-	    walkContext: 'function'
-	};
-
-	var TYPE$o = tokenizer.TYPE;
-
-	var IDENTIFIER$d = TYPE$o.Identifier;
-	var FUNCTION$3 = TYPE$o.Function;
-	var COLON$4 = TYPE$o.Colon;
-	var RIGHTPARENTHESIS$7 = TYPE$o.RightParenthesis;
-
-	// :: ident [ '(' .. ')' ]?
-	var PseudoElementSelector = {
-	    name: 'PseudoElementSelector',
-	    structure: {
-	        name: String,
-	        children: [['Raw'], null]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var children = null;
-	        var name;
-	        var nameLowerCase;
-
-	        this.scanner.eat(COLON$4);
-	        this.scanner.eat(COLON$4);
-
-	        if (this.scanner.tokenType === FUNCTION$3) {
-	            name = this.scanner.consumeFunctionName();
-	            nameLowerCase = name.toLowerCase();
-
-	            if (this.pseudo.hasOwnProperty(nameLowerCase)) {
-	                this.scanner.skipSC();
-	                children = this.pseudo[nameLowerCase].call(this);
-	                this.scanner.skipSC();
-	            } else {
-	                children = this.createList();
-	                children.push(
-	                    this.Raw(this.scanner.currentToken, 0, 0, false, false)
-	                );
-	            }
-
-	            this.scanner.eat(RIGHTPARENTHESIS$7);
-	        } else {
-	            name = this.scanner.consume(IDENTIFIER$d);
-	        }
-
-	        return {
-	            type: 'PseudoElementSelector',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: name,
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('::');
-	        this.chunk(node.name);
-
-	        if (node.children !== null) {
-	            this.chunk('(');
-	            this.children(node);
-	            this.chunk(')');
-	        }
-	    },
-	    walkContext: 'function'
-	};
-
-	var isNumber$4 = tokenizer.isNumber;
-	var TYPE$p = tokenizer.TYPE;
-	var NUMBER$8 = TYPE$p.Number;
-	var SOLIDUS$4 = TYPE$p.Solidus;
-	var FULLSTOP$3 = TYPE$p.FullStop;
-
-	// Terms of <ratio> should to be a positive number (not zero or negative)
-	// (see https://drafts.csswg.org/mediaqueries-3/#values)
-	// However, -o-min-device-pixel-ratio takes fractional values as a ratio's term
-	// and this is using by various sites. Therefore we relax checking on parse
-	// to test a term is unsigned number without exponent part.
-	// Additional checks may to be applied on lexer validation.
-	function consumeNumber$1(scanner) {
-	    var value = scanner.consumeNonWS(NUMBER$8);
-
-	    for (var i = 0; i < value.length; i++) {
-	        var code = value.charCodeAt(i);
-	        if (!isNumber$4(code) && code !== FULLSTOP$3) {
-	            scanner.error('Unsigned number is expected', scanner.tokenStart - value.length + i);
-	        }
-	    }
-
-	    if (Number(value) === 0) {
-	        scanner.error('Zero number is not allowed', scanner.tokenStart - value.length);
-	    }
-
-	    return value;
-	}
-
-	// <positive-integer> S* '/' S* <positive-integer>
-	var Ratio = {
-	    name: 'Ratio',
-	    structure: {
-	        left: String,
-	        right: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var left = consumeNumber$1(this.scanner);
-	        var right;
-
-	        this.scanner.eatNonWS(SOLIDUS$4);
-	        right = consumeNumber$1(this.scanner);
-
-	        return {
-	            type: 'Ratio',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            left: left,
-	            right: right
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.left);
-	        this.chunk('/');
-	        this.chunk(node.right);
-	    }
-	};
-
-	var Raw = {
-	    name: 'Raw',
-	    structure: {
-	        value: String
-	    },
-	    parse: function(startToken, endTokenType1, endTokenType2, includeTokenType2, excludeWhiteSpace) {
-	        var startOffset = this.scanner.getTokenStart(startToken);
-	        var endOffset;
-
-	        this.scanner.skip(
-	            this.scanner.getRawLength(
-	                startToken,
-	                endTokenType1,
-	                endTokenType2,
-	                includeTokenType2
-	            )
-	        );
-
-	        if (excludeWhiteSpace && this.scanner.tokenStart > startOffset) {
-	            endOffset = this.scanner.getOffsetExcludeWS();
-	        } else {
-	            endOffset = this.scanner.tokenStart;
-	        }
-
-	        return {
-	            type: 'Raw',
-	            loc: this.getLocation(startOffset, endOffset),
-	            value: this.scanner.source.substring(startOffset, endOffset)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	    }
-	};
-
-	var TYPE$q = tokenizer.TYPE;
-
-	var LEFTCURLYBRACKET$5 = TYPE$q.LeftCurlyBracket;
-
-	function consumeRaw$3(startToken) {
-	    return this.Raw(startToken, LEFTCURLYBRACKET$5, 0, false, true);
-	}
-
-	function consumePrelude() {
-	    var prelude = this.SelectorList();
-
-	    if (prelude.type !== 'Raw' &&
-	        this.scanner.eof === false &&
-	        this.scanner.tokenType !== LEFTCURLYBRACKET$5) {
-	        this.scanner.error();
-	    }
-
-	    return prelude;
-	}
-
-	var Rule = {
-	    name: 'Rule',
-	    structure: {
-	        prelude: ['SelectorList', 'Raw'],
-	        block: ['Block']
-	    },
-	    parse: function() {
-	        var startToken = this.scanner.currentToken;
-	        var startOffset = this.scanner.tokenStart;
-	        var prelude;
-	        var block;
-
-	        if (this.parseRulePrelude) {
-	            prelude = this.parseWithFallback(consumePrelude, consumeRaw$3);
-	        } else {
-	            prelude = consumeRaw$3.call(this, startToken);
-	        }
-
-	        block = this.Block(true);
-
-	        return {
-	            type: 'Rule',
-	            loc: this.getLocation(startOffset, this.scanner.tokenStart),
-	            prelude: prelude,
-	            block: block
-	        };
-	    },
-	    generate: function(node) {
-	        this.node(node.prelude);
-	        this.node(node.block);
-	    },
-	    walkContext: 'rule'
-	};
-
-	var Selector = {
-	    name: 'Selector',
-	    structure: {
-	        children: [[
-	            'TypeSelector',
-	            'IdSelector',
-	            'ClassSelector',
-	            'AttributeSelector',
-	            'PseudoClassSelector',
-	            'PseudoElementSelector',
-	            'Combinator',
-	            'WhiteSpace'
-	        ]]
-	    },
-	    parse: function() {
-	        var children = this.readSequence(this.scope.Selector);
-
-	        // nothing were consumed
-	        if (this.getFirstListNode(children) === null) {
-	            this.scanner.error('Selector is expected');
-	        }
-
-	        return {
-	            type: 'Selector',
-	            loc: this.getLocationFromList(children),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node);
-	    }
-	};
-
-	var TYPE$r = tokenizer.TYPE;
-
-	var COMMA$2 = TYPE$r.Comma;
-
-	var SelectorList = {
-	    name: 'SelectorList',
-	    structure: {
-	        children: [[
-	            'Selector',
-	            'Raw'
-	        ]]
-	    },
-	    parse: function() {
-	        var children = this.createList();
-
-	        while (!this.scanner.eof) {
-	            children.push(this.Selector());
-
-	            if (this.scanner.tokenType === COMMA$2) {
-	                this.scanner.next();
-	                continue;
-	            }
-
-	            break;
-	        }
-
-	        return {
-	            type: 'SelectorList',
-	            loc: this.getLocationFromList(children),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node, function() {
-	            this.chunk(',');
-	        });
-	    },
-	    walkContext: 'selector'
-	};
-
-	var STRING$3 = tokenizer.TYPE.String;
-
-	var _String = {
-	    name: 'String',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        return {
-	            type: 'String',
-	            loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
-	            value: this.scanner.consume(STRING$3)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	    }
-	};
-
-	var TYPE$s = tokenizer.TYPE;
-
-	var WHITESPACE$6 = TYPE$s.WhiteSpace;
-	var COMMENT$6 = TYPE$s.Comment;
-	var EXCLAMATIONMARK$3 = TYPE$s.ExclamationMark;
-	var ATKEYWORD$4 = TYPE$s.AtKeyword;
-	var CDO$3 = TYPE$s.CDO;
-	var CDC$3 = TYPE$s.CDC;
-
-	function consumeRaw$4(startToken) {
-	    return this.Raw(startToken, 0, 0, false, false);
-	}
-
-	var StyleSheet = {
-	    name: 'StyleSheet',
-	    structure: {
-	        children: [[
-	            'Comment',
-	            'CDO',
-	            'CDC',
-	            'Atrule',
-	            'Rule',
-	            'Raw'
-	        ]]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var children = this.createList();
-	        var child;
-
-	        scan:
-	        while (!this.scanner.eof) {
-	            switch (this.scanner.tokenType) {
-	                case WHITESPACE$6:
-	                    this.scanner.next();
-	                    continue;
-
-	                case COMMENT$6:
-	                    // ignore comments except exclamation comments (i.e. /*! .. */) on top level
-	                    if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 2) !== EXCLAMATIONMARK$3) {
-	                        this.scanner.next();
-	                        continue;
-	                    }
-
-	                    child = this.Comment();
-	                    break;
-
-	                case CDO$3: // <!--
-	                    child = this.CDO();
-	                    break;
-
-	                case CDC$3: // -->
-	                    child = this.CDC();
-	                    break;
-
-	                // CSS Syntax Module Level 3
-	                // §2.2 Error handling
-	                // At the "top level" of a stylesheet, an <at-keyword-token> starts an at-rule.
-	                case ATKEYWORD$4:
-	                    child = this.parseWithFallback(this.Atrule, consumeRaw$4);
-	                    break;
-
-	                // Anything else starts a qualified rule ...
-	                default:
-	                    child = this.parseWithFallback(this.Rule, consumeRaw$4);
-	            }
-
-	            children.push(child);
-	        }
-
-	        return {
-	            type: 'StyleSheet',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node);
-	    },
-	    walkContext: 'stylesheet'
-	};
-
-	var TYPE$t = tokenizer.TYPE;
-
-	var IDENTIFIER$e = TYPE$t.Identifier;
-	var ASTERISK$4 = TYPE$t.Asterisk;
-	var VERTICALLINE$2 = TYPE$t.VerticalLine;
-
-	function eatIdentifierOrAsterisk() {
-	    if (this.scanner.tokenType !== IDENTIFIER$e &&
-	        this.scanner.tokenType !== ASTERISK$4) {
-	        this.scanner.error('Identifier or asterisk is expected');
-	    }
-
-	    this.scanner.next();
-	}
-
-	// ident
-	// ident|ident
-	// ident|*
-	// *
-	// *|ident
-	// *|*
-	// |ident
-	// |*
-	var TypeSelector = {
-	    name: 'TypeSelector',
-	    structure: {
-	        name: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-
-	        if (this.scanner.tokenType === VERTICALLINE$2) {
-	            this.scanner.next();
-	            eatIdentifierOrAsterisk.call(this);
-	        } else {
-	            eatIdentifierOrAsterisk.call(this);
-
-	            if (this.scanner.tokenType === VERTICALLINE$2) {
-	                this.scanner.next();
-	                eatIdentifierOrAsterisk.call(this);
-	            }
-	        }
-
-	        return {
-	            type: 'TypeSelector',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            name: this.scanner.substrToCursor(start)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.name);
-	    }
-	};
-
-	var isHex$3 = tokenizer.isHex;
-	var TYPE$u = tokenizer.TYPE;
-
-	var IDENTIFIER$f = TYPE$u.Identifier;
-	var NUMBER$9 = TYPE$u.Number;
-	var PLUSSIGN$7 = TYPE$u.PlusSign;
-	var HYPHENMINUS$6 = TYPE$u.HyphenMinus;
-	var FULLSTOP$4 = TYPE$u.FullStop;
-	var QUESTIONMARK$1 = TYPE$u.QuestionMark;
-
-	function scanUnicodeNumber(scanner) {
-	    for (var pos = scanner.tokenStart + 1; pos < scanner.tokenEnd; pos++) {
-	        var code = scanner.source.charCodeAt(pos);
-
-	        // break on fullstop or hyperminus/plussign after exponent
-	        if (code === FULLSTOP$4 || code === PLUSSIGN$7) {
-	            // break token, exclude symbol
-	            scanner.tokenStart = pos;
-	            return false;
-	        }
-	    }
-
-	    return true;
-	}
-
-	// https://drafts.csswg.org/css-syntax-3/#urange
-	function scanUnicodeRange(scanner) {
-	    var hexStart = scanner.tokenStart + 1; // skip +
-	    var hexLength = 0;
-
-	    scan: {
-	        if (scanner.tokenType === NUMBER$9) {
-	            if (scanner.source.charCodeAt(scanner.tokenStart) !== FULLSTOP$4 && scanUnicodeNumber(scanner)) {
-	                scanner.next();
-	            } else if (scanner.source.charCodeAt(scanner.tokenStart) !== HYPHENMINUS$6) {
-	                break scan;
-	            }
-	        } else {
-	            scanner.next(); // PLUSSIGN
-	        }
-
-	        if (scanner.tokenType === HYPHENMINUS$6) {
-	            scanner.next();
-	        }
-
-	        if (scanner.tokenType === NUMBER$9) {
-	            scanner.next();
-	        }
-
-	        if (scanner.tokenType === IDENTIFIER$f) {
-	            scanner.next();
-	        }
-
-	        if (scanner.tokenStart === hexStart) {
-	            scanner.error('Unexpected input', hexStart);
-	        }
-	    }
-
-	    // validate for U+x{1,6} or U+x{1,6}-x{1,6}
-	    // where x is [0-9a-fA-F]
-	    for (var i = hexStart, wasHyphenMinus = false; i < scanner.tokenStart; i++) {
-	        var code = scanner.source.charCodeAt(i);
-
-	        if (isHex$3(code) === false && (code !== HYPHENMINUS$6 || wasHyphenMinus)) {
-	            scanner.error('Unexpected input', i);
-	        }
-
-	        if (code === HYPHENMINUS$6) {
-	            // hex sequence shouldn't be an empty
-	            if (hexLength === 0) {
-	                scanner.error('Unexpected input', i);
-	            }
-
-	            wasHyphenMinus = true;
-	            hexLength = 0;
-	        } else {
-	            hexLength++;
-
-	            // too long hex sequence
-	            if (hexLength > 6) {
-	                scanner.error('Too long hex sequence', i);
-	            }
-	        }
-
-	    }
-
-	    // check we have a non-zero sequence
-	    if (hexLength === 0) {
-	        scanner.error('Unexpected input', i - 1);
-	    }
-
-	    // U+abc???
-	    if (!wasHyphenMinus) {
-	        // consume as many U+003F QUESTION MARK (?) code points as possible
-	        for (; hexLength < 6 && !scanner.eof; scanner.next()) {
-	            if (scanner.tokenType !== QUESTIONMARK$1) {
-	                break;
-	            }
-
-	            hexLength++;
-	        }
-	    }
-	}
-
-	var UnicodeRange = {
-	    name: 'UnicodeRange',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-
-	        this.scanner.next(); // U or u
-	        scanUnicodeRange(this.scanner);
-
-	        return {
-	            type: 'UnicodeRange',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            value: this.scanner.substrToCursor(start)
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	    }
-	};
-
-	var TYPE$v = tokenizer.TYPE;
-
-	var STRING$4 = TYPE$v.String;
-	var URL$3 = TYPE$v.Url;
-	var RAW$2 = TYPE$v.Raw;
-	var RIGHTPARENTHESIS$8 = TYPE$v.RightParenthesis;
-
-	// url '(' S* (string | raw) S* ')'
-	var Url = {
-	    name: 'Url',
-	    structure: {
-	        value: ['String', 'Raw']
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var value;
-
-	        this.scanner.eat(URL$3);
-	        this.scanner.skipSC();
-
-	        switch (this.scanner.tokenType) {
-	            case STRING$4:
-	                value = this.String();
-	                break;
-
-	            case RAW$2:
-	                value = this.Raw(this.scanner.currentToken, 0, RAW$2, true, false);
-	                break;
-
-	            default:
-	                this.scanner.error('String or Raw is expected');
-	        }
-
-	        this.scanner.skipSC();
-	        this.scanner.eat(RIGHTPARENTHESIS$8);
-
-	        return {
-	            type: 'Url',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            value: value
-	        };
-	    },
-	    generate: function(node) {
-	        this.chunk('url');
-	        this.chunk('(');
-	        this.node(node.value);
-	        this.chunk(')');
-	    }
-	};
-
-	var Value = {
-	    name: 'Value',
-	    structure: {
-	        children: [[]]
-	    },
-	    parse: function() {
-	        var start = this.scanner.tokenStart;
-	        var children = this.readSequence(this.scope.Value);
-
-	        return {
-	            type: 'Value',
-	            loc: this.getLocation(start, this.scanner.tokenStart),
-	            children: children
-	        };
-	    },
-	    generate: function(node) {
-	        this.children(node);
-	    }
-	};
-
-	var WHITESPACE$7 = tokenizer.TYPE.WhiteSpace;
-	var SPACE$4 = Object.freeze({
-	    type: 'WhiteSpace',
-	    loc: null,
-	    value: ' '
-	});
-
-	var WhiteSpace = {
-	    name: 'WhiteSpace',
-	    structure: {
-	        value: String
-	    },
-	    parse: function() {
-	        this.scanner.eat(WHITESPACE$7);
-	        return SPACE$4;
-
-	        // return {
-	        //     type: 'WhiteSpace',
-	        //     loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
-	        //     value: this.scanner.consume(WHITESPACE)
-	        // };
-	    },
-	    generate: function(node) {
-	        this.chunk(node.value);
-	    }
-	};
-
-	var node = {
-	    AnPlusB: AnPlusB,
-	    Atrule: Atrule,
-	    AtrulePrelude: AtrulePrelude,
-	    AttributeSelector: AttributeSelector,
-	    Block: Block,
-	    Brackets: Brackets,
-	    CDC: CDC_1,
-	    CDO: CDO_1,
-	    ClassSelector: ClassSelector,
-	    Combinator: Combinator,
-	    Comment: Comment,
-	    Declaration: Declaration,
-	    DeclarationList: DeclarationList,
-	    Dimension: Dimension,
-	    Function: _Function,
-	    HexColor: HexColor,
-	    Identifier: Identifier,
-	    IdSelector: IdSelector,
-	    MediaFeature: MediaFeature,
-	    MediaQuery: MediaQuery,
-	    MediaQueryList: MediaQueryList,
-	    Nth: Nth,
-	    Number: _Number,
-	    Operator: Operator,
-	    Parentheses: Parentheses,
-	    Percentage: Percentage,
-	    PseudoClassSelector: PseudoClassSelector,
-	    PseudoElementSelector: PseudoElementSelector,
-	    Ratio: Ratio,
-	    Raw: Raw,
-	    Rule: Rule,
-	    Selector: Selector,
-	    SelectorList: SelectorList,
-	    String: _String,
-	    StyleSheet: StyleSheet,
-	    TypeSelector: TypeSelector,
-	    UnicodeRange: UnicodeRange,
-	    Url: Url,
-	    Value: Value,
-	    WhiteSpace: WhiteSpace
-	};
-
-	var lexer = {
-	    generic: true,
-	    types: data.types,
-	    properties: data.properties,
-	    node: node
-	};
-
-	var cmpChar$2 = tokenizer.cmpChar;
-	var TYPE$w = tokenizer.TYPE;
-
-	var IDENTIFIER$g = TYPE$w.Identifier;
-	var STRING$5 = TYPE$w.String;
-	var NUMBER$a = TYPE$w.Number;
-	var FUNCTION$4 = TYPE$w.Function;
-	var URL$4 = TYPE$w.Url;
-	var NUMBERSIGN$5 = TYPE$w.NumberSign;
-	var LEFTPARENTHESIS$6 = TYPE$w.LeftParenthesis;
-	var LEFTSQUAREBRACKET$4 = TYPE$w.LeftSquareBracket;
-	var PLUSSIGN$8 = TYPE$w.PlusSign;
-	var HYPHENMINUS$7 = TYPE$w.HyphenMinus;
-	var COMMA$3 = TYPE$w.Comma;
-	var SOLIDUS$5 = TYPE$w.Solidus;
-	var ASTERISK$5 = TYPE$w.Asterisk;
-	var PERCENTSIGN$1 = TYPE$w.PercentSign;
-	var BACKSLASH = TYPE$w.Backslash;
-	var U = 117; // 'u'.charCodeAt(0)
-
-	var _default = function defaultRecognizer(context) {
-	    switch (this.scanner.tokenType) {
-	        case NUMBERSIGN$5:
-	            return this.HexColor();
-
-	        case COMMA$3:
-	            context.space = null;
-	            context.ignoreWSAfter = true;
-	            return this.Operator();
-
-	        case SOLIDUS$5:
-	        case ASTERISK$5:
-	        case PLUSSIGN$8:
-	        case HYPHENMINUS$7:
-	            return this.Operator();
-
-	        case LEFTPARENTHESIS$6:
-	            return this.Parentheses(this.readSequence, context.recognizer);
-
-	        case LEFTSQUAREBRACKET$4:
-	            return this.Brackets(this.readSequence, context.recognizer);
-
-	        case STRING$5:
-	            return this.String();
-
-	        case NUMBER$a:
-	            switch (this.scanner.lookupType(1)) {
-	                case PERCENTSIGN$1:
-	                    return this.Percentage();
-
-	                case IDENTIFIER$g:
-	                    // edge case: number with folowing \0 and \9 hack shouldn't to be a Dimension
-	                    if (cmpChar$2(this.scanner.source, this.scanner.tokenEnd, BACKSLASH)) {
-	                        return this.Number();
-	                    } else {
-	                        return this.Dimension();
-	                    }
-
-	                default:
-	                    return this.Number();
-	            }
-
-	        case FUNCTION$4:
-	            return this.Function(this.readSequence, context.recognizer);
-
-	        case URL$4:
-	            return this.Url();
-
-	        case IDENTIFIER$g:
-	            // check for unicode range, it should start with u+ or U+
-	            if (cmpChar$2(this.scanner.source, this.scanner.tokenStart, U) &&
-	                cmpChar$2(this.scanner.source, this.scanner.tokenStart + 1, PLUSSIGN$8)) {
-	                return this.UnicodeRange();
-	            } else {
-	                return this.Identifier();
-	            }
-	    }
-	};
-
-	var atrulePrelude = {
-	    getNode: _default
-	};
-
-	var TYPE$x = tokenizer.TYPE;
-
-	var IDENTIFIER$h = TYPE$x.Identifier;
-	var NUMBER$b = TYPE$x.Number;
-	var NUMBERSIGN$6 = TYPE$x.NumberSign;
-	var LEFTSQUAREBRACKET$5 = TYPE$x.LeftSquareBracket;
-	var PLUSSIGN$9 = TYPE$x.PlusSign;
-	var SOLIDUS$6 = TYPE$x.Solidus;
-	var ASTERISK$6 = TYPE$x.Asterisk;
-	var FULLSTOP$5 = TYPE$x.FullStop;
-	var COLON$5 = TYPE$x.Colon;
-	var GREATERTHANSIGN$3 = TYPE$x.GreaterThanSign;
-	var VERTICALLINE$3 = TYPE$x.VerticalLine;
-	var TILDE$2 = TYPE$x.Tilde;
-
-	function getNode(context) {
-	    switch (this.scanner.tokenType) {
-	        case PLUSSIGN$9:
-	        case GREATERTHANSIGN$3:
-	        case TILDE$2:
-	            context.space = null;
-	            context.ignoreWSAfter = true;
-	            return this.Combinator();
-
-	        case SOLIDUS$6:  // /deep/
-	            return this.Combinator();
-
-	        case FULLSTOP$5:
-	            return this.ClassSelector();
-
-	        case LEFTSQUAREBRACKET$5:
-	            return this.AttributeSelector();
-
-	        case NUMBERSIGN$6:
-	            return this.IdSelector();
-
-	        case COLON$5:
-	            if (this.scanner.lookupType(1) === COLON$5) {
-	                return this.PseudoElementSelector();
-	            } else {
-	                return this.PseudoClassSelector();
-	            }
-
-	        case IDENTIFIER$h:
-	        case ASTERISK$6:
-	        case VERTICALLINE$3:
-	            return this.TypeSelector();
-
-	        case NUMBER$b:
-	            return this.Percentage();
-	    }
-	}
-	var selector = {
-	    getNode: getNode
-	};
-
-	// https://drafts.csswg.org/css-images-4/#element-notation
-	// https://developer.mozilla.org/en-US/docs/Web/CSS/element
-	var element = function() {
-	    this.scanner.skipSC();
-
-	    var children = this.createSingleNodeList(
-	        this.IdSelector()
-	    );
-
-	    this.scanner.skipSC();
-
-	    return children;
-	};
-
-	// legacy IE function
-	// expression '(' raw ')'
-	var expression$1 = function() {
-	    return this.createSingleNodeList(
-	        this.Raw(this.scanner.currentToken, 0, 0, false, false)
-	    );
-	};
-
-	var TYPE$y = tokenizer.TYPE;
-
-	var IDENTIFIER$i = TYPE$y.Identifier;
-	var COMMA$4 = TYPE$y.Comma;
-	var SEMICOLON$5 = TYPE$y.Semicolon;
-	var HYPHENMINUS$8 = TYPE$y.HyphenMinus;
-	var EXCLAMATIONMARK$4 = TYPE$y.ExclamationMark;
-
-	// var '(' ident (',' <value>? )? ')'
-	var _var = function() {
-	    var children = this.createList();
-
-	    this.scanner.skipSC();
-
-	    var identStart = this.scanner.tokenStart;
-
-	    this.scanner.eat(HYPHENMINUS$8);
-	    if (this.scanner.source.charCodeAt(this.scanner.tokenStart) !== HYPHENMINUS$8) {
-	        this.scanner.error('HyphenMinus is expected');
-	    }
-	    this.scanner.eat(IDENTIFIER$i);
-
-	    children.push({
-	        type: 'Identifier',
-	        loc: this.getLocation(identStart, this.scanner.tokenStart),
-	        name: this.scanner.substrToCursor(identStart)
-	    });
-
-	    this.scanner.skipSC();
-
-	    if (this.scanner.tokenType === COMMA$4) {
-	        children.push(this.Operator());
-	        children.push(this.parseCustomProperty
-	            ? this.Value(null)
-	            : this.Raw(this.scanner.currentToken, EXCLAMATIONMARK$4, SEMICOLON$5, false, false)
-	        );
-	    }
-
-	    return children;
-	};
-
-	var value = {
-	    getNode: _default,
-	    '-moz-element': element,
-	    'element': element,
-	    'expression': expression$1,
-	    'var': _var
-	};
-
-	var scope = {
-	    AtrulePrelude: atrulePrelude,
-	    Selector: selector,
-	    Value: value
-	};
-
-	var fontFace = {
-	    parse: {
-	        prelude: null,
-	        block: function() {
-	            return this.Block(true);
-	        }
-	    }
-	};
-
-	var TYPE$z = tokenizer.TYPE;
-
-	var STRING$6 = TYPE$z.String;
-	var IDENTIFIER$j = TYPE$z.Identifier;
-	var URL$5 = TYPE$z.Url;
-	var LEFTPARENTHESIS$7 = TYPE$z.LeftParenthesis;
-
-	var _import = {
-	    parse: {
-	        prelude: function() {
-	            var children = this.createList();
-
-	            this.scanner.skipSC();
-
-	            switch (this.scanner.tokenType) {
-	                case STRING$6:
-	                    children.push(this.String());
-	                    break;
-
-	                case URL$5:
-	                    children.push(this.Url());
-	                    break;
-
-	                default:
-	                    this.scanner.error('String or url() is expected');
-	            }
-
-	            if (this.scanner.lookupNonWSType(0) === IDENTIFIER$j ||
-	                this.scanner.lookupNonWSType(0) === LEFTPARENTHESIS$7) {
-	                children.push(this.WhiteSpace());
-	                children.push(this.MediaQueryList());
-	            }
-
-	            return children;
-	        },
-	        block: null
-	    }
-	};
-
-	var media = {
-	    parse: {
-	        prelude: function() {
-	            return this.createSingleNodeList(
-	                this.MediaQueryList()
-	            );
-	        },
-	        block: function() {
-	            return this.Block(false);
-	        }
-	    }
-	};
-
-	var page = {
-	    parse: {
-	        prelude: function() {
-	            return this.createSingleNodeList(
-	                this.SelectorList()
-	            );
-	        },
-	        block: function() {
-	            return this.Block(true);
-	        }
-	    }
-	};
-
-	var TYPE$A = tokenizer.TYPE;
-
-	var WHITESPACE$8 = TYPE$A.WhiteSpace;
-	var COMMENT$7 = TYPE$A.Comment;
-	var IDENTIFIER$k = TYPE$A.Identifier;
-	var FUNCTION$5 = TYPE$A.Function;
-	var LEFTPARENTHESIS$8 = TYPE$A.LeftParenthesis;
-	var HYPHENMINUS$9 = TYPE$A.HyphenMinus;
-	var COLON$6 = TYPE$A.Colon;
-
-	function consumeRaw$5() {
-	    return this.createSingleNodeList(
-	        this.Raw(this.scanner.currentToken, 0, 0, false, false)
-	    );
-	}
-
-	function parentheses() {
-	    var index = 0;
-
-	    this.scanner.skipSC();
-
-	    // TODO: make it simplier
-	    if (this.scanner.tokenType === IDENTIFIER$k) {
-	        index = 1;
-	    } else if (this.scanner.tokenType === HYPHENMINUS$9 &&
-	               this.scanner.lookupType(1) === IDENTIFIER$k) {
-	        index = 2;
-	    }
-
-	    if (index !== 0 && this.scanner.lookupNonWSType(index) === COLON$6) {
-	        return this.createSingleNodeList(
-	            this.Declaration()
-	        );
-	    }
-
-	    return readSequence.call(this);
-	}
-
-	function readSequence() {
-	    var children = this.createList();
-	    var space = null;
-	    var child;
-
-	    this.scanner.skipSC();
-
-	    scan:
-	    while (!this.scanner.eof) {
-	        switch (this.scanner.tokenType) {
-	            case WHITESPACE$8:
-	                space = this.WhiteSpace();
-	                continue;
-
-	            case COMMENT$7:
-	                this.scanner.next();
-	                continue;
-
-	            case FUNCTION$5:
-	                child = this.Function(consumeRaw$5, this.scope.AtrulePrelude);
-	                break;
-
-	            case IDENTIFIER$k:
-	                child = this.Identifier();
-	                break;
-
-	            case LEFTPARENTHESIS$8:
-	                child = this.Parentheses(parentheses, this.scope.AtrulePrelude);
-	                break;
-
-	            default:
-	                break scan;
-	        }
-
-	        if (space !== null) {
-	            children.push(space);
-	            space = null;
-	        }
-
-	        children.push(child);
-	    }
-
-	    return children;
-	}
-
-	var supports = {
-	    parse: {
-	        prelude: function() {
-	            var children = readSequence.call(this);
-
-	            if (this.getFirstListNode(children) === null) {
-	                this.scanner.error('Condition is expected');
-	            }
-
-	            return children;
-	        },
-	        block: function() {
-	            return this.Block(false);
-	        }
-	    }
-	};
-
-	var atrule = {
-	    'font-face': fontFace,
-	    'import': _import,
-	    'media': media,
-	    'page': page,
-	    'supports': supports
-	};
-
-	var dir = {
-	    parse: function() {
-	        return this.createSingleNodeList(
-	            this.Identifier()
-	        );
-	    }
-	};
-
-	var has$1 = {
-	    parse: function() {
-	        return this.createSingleNodeList(
-	            this.SelectorList()
-	        );
-	    }
-	};
-
-	var lang = {
-	    parse: function() {
-	        return this.createSingleNodeList(
-	            this.Identifier()
-	        );
-	    }
-	};
-
-	var selectorList = {
-	    parse: function selectorList() {
-	        return this.createSingleNodeList(
-	            this.SelectorList()
-	        );
-	    }
-	};
-
-	var matches = selectorList;
-
-	var not = selectorList;
-
-	var ALLOW_OF_CLAUSE = true;
-
-	var nthWithOfClause = {
-	    parse: function nthWithOfClause() {
-	        return this.createSingleNodeList(
-	            this.Nth(ALLOW_OF_CLAUSE)
-	        );
-	    }
-	};
-
-	var nthChild = nthWithOfClause;
-
-	var nthLastChild = nthWithOfClause;
-
-	var DISALLOW_OF_CLAUSE = false;
-
-	var nth$1 = {
-	    parse: function nth() {
-	        return this.createSingleNodeList(
-	            this.Nth(DISALLOW_OF_CLAUSE)
-	        );
-	    }
-	};
-
-	var nthLastOfType = nth$1;
-
-	var nthOfType = nth$1;
-
-	var slotted = {
-	    parse: function compoundSelector() {
-	        return this.createSingleNodeList(
-	            this.Selector()
-	        );
-	    }
-	};
-
-	var pseudo = {
-	    'dir': dir,
-	    'has': has$1,
-	    'lang': lang,
-	    'matches': matches,
-	    'not': not,
-	    'nth-child': nthChild,
-	    'nth-last-child': nthLastChild,
-	    'nth-last-of-type': nthLastOfType,
-	    'nth-of-type': nthOfType,
-	    'slotted': slotted
-	};
-
-	var parser = {
-	    parseContext: {
-	        default: 'StyleSheet',
-	        stylesheet: 'StyleSheet',
-	        atrule: 'Atrule',
-	        atrulePrelude: function(options) {
-	            return this.AtrulePrelude(options.atrule ? String(options.atrule) : null);
-	        },
-	        mediaQueryList: 'MediaQueryList',
-	        mediaQuery: 'MediaQuery',
-	        rule: 'Rule',
-	        selectorList: 'SelectorList',
-	        selector: 'Selector',
-	        block: function() {
-	            return this.Block(true);
-	        },
-	        declarationList: 'DeclarationList',
-	        declaration: 'Declaration',
-	        value: 'Value'
-	    },
-	    scope: scope,
-	    atrule: atrule,
-	    pseudo: pseudo,
-	    node: node
-	};
-
-	var walker = {
-	    node: node
-	};
-
-	function merge() {
-	    var dest = {};
-
-	    for (var i = 0; i < arguments.length; i++) {
-	        var src = arguments[i];
-	        for (var key in src) {
-	            dest[key] = src[key];
-	        }
-	    }
-
-	    return dest;
-	}
-
-	var syntax = create$5.create(
-	    merge(
-	        lexer,
-	        parser,
-	        walker
-	    )
-	);
-
-	var lib = syntax;
-
-	class Sheet {
-		constructor(url, hooks) {
-
-			if (hooks) {
-				this.hooks = hooks;
-			} else {
-				this.hooks = {};
-				this.hooks.onUrl = new Hook(this);
-				this.hooks.onAtPage = new Hook(this);
-				this.hooks.onAtMedia = new Hook(this);
-				this.hooks.onRule = new Hook(this);
-				this.hooks.onDeclaration = new Hook(this);
-				this.hooks.onContent = new Hook(this);
-				this.hooks.onImport = new Hook(this);
-
-				this.hooks.beforeTreeParse = new Hook(this);
-				this.hooks.beforeTreeWalk = new Hook(this);
-				this.hooks.afterTreeWalk = new Hook(this);
-			}
-
-			try {
-				this.url = new URL(url, window.location.href);
-			} catch (e) {
-				this.url = new URL(window.location.href);
-			}
-		}
-
-
-
-		// parse
-		async parse(text) {
-			this.text = text;
-
-			await this.hooks.beforeTreeParse.trigger(this.text, this);
-
-			// send to csstree
-			this.ast = lib.parse(this._text);
-
-			await this.hooks.beforeTreeWalk.trigger(this.ast);
-
-			// Replace urls
-			this.replaceUrls(this.ast);
-
-			// Scope
-			this.id = UUID();
-			// this.addScope(this.ast, this.uuid);
-
-			// Replace IDs with data-id
-			this.replaceIds(this.ast);
-
-			this.imported = [];
-
-			// Trigger Hooks
-			this.urls(this.ast);
-			this.rules(this.ast);
-			this.atrules(this.ast);
-
-			await this.hooks.afterTreeWalk.trigger(this.ast, this);
-
-			// return ast
-			return this.ast;
-		}
-
-		insertRule(rule) {
-			let inserted = this.ast.children.appendData(rule);
-			inserted.forEach((item) => {
-				this.declarations(item);
-			});
-		}
-
-		urls(ast) {
-			lib.walk(ast, {
-				visit: "Url",
-				enter: (node, item, list) => {
-					this.hooks.onUrl.trigger(node, item, list);
-				}
-			});
-		}
-
-		atrules(ast) {
-			lib.walk(ast, {
-				visit: "Atrule",
-				enter: (node, item, list) => {
-					const basename = lib.keyword(node.name).basename;
-
-					if (basename === "page") {
-						this.hooks.onAtPage.trigger(node, item, list);
-						this.declarations(node, item, list);
-					}
-
-					if (basename === "media") {
-						this.hooks.onAtMedia.trigger(node, item, list);
-						this.declarations(node, item, list);
-					}
-
-					if (basename === "import") {
-						this.hooks.onImport.trigger(node, item, list);
-						this.imports(node, item, list);
-					}
-				}
-			});
-		}
-
-
-		rules(ast) {
-			lib.walk(ast, {
-				visit: "Rule",
-				enter: (ruleNode, ruleItem, rulelist) => {
-					// console.log("rule", ruleNode);
-
-					this.hooks.onRule.trigger(ruleNode, ruleItem, rulelist);
-					this.declarations(ruleNode, ruleItem, rulelist);
-				}
-			});
-		}
-
-		declarations(ruleNode, ruleItem, rulelist) {
-			lib.walk(ruleNode, {
-				visit: "Declaration",
-				enter: (declarationNode, dItem, dList) => {
-					// console.log(declarationNode);
-
-					this.hooks.onDeclaration.trigger(declarationNode, dItem, dList, {ruleNode, ruleItem, rulelist});
-
-					if (declarationNode.property === "content") {
-						lib.walk(declarationNode, {
-							visit: "Function",
-							enter: (funcNode, fItem, fList) => {
-								this.hooks.onContent.trigger(funcNode, fItem, fList, {declarationNode, dItem, dList}, {ruleNode, ruleItem, rulelist});
-							}
-						});
-					}
-
-				}
-			});
-		}
-
-		replaceUrls(ast) {
-			lib.walk(ast, {
-				visit: "Url",
-				enter: (node, item, list) => {
-					let href = node.value.value.replace(/["']/g, "");
-					let url = new URL(href, this.url);
-					node.value.value = url.toString();
-				}
-			});
-		}
-
-		addScope(ast, id) {
-			// Get all selector lists
-			// add an id
-			lib.walk(ast, {
-				visit: "Selector",
-				enter: (node, item, list) => {
-					let children = node.children;
-					children.prepend(children.createItem({
-						type: "WhiteSpace",
-						value: " "
-					}));
-					children.prepend(children.createItem({
-						type: "IdSelector",
-						name: id,
-						loc: null,
-						children: null
-					}));
-				}
-			});
-		}
-
-		getNamedPageSelectors(ast) {
-			let namedPageSelectors = {};
-			lib.walk(ast, {
-				visit: "Rule",
-				enter: (node, item, list) => {
-					lib.walk(node, {
-						visit: "Declaration",
-						enter: (declaration, dItem, dList) => {
-							if (declaration.property === "page") {
-								let value = declaration.value.children.first();
-								let name = value.name;
-								let selector = lib.generate(node.prelude);
-								namedPageSelectors[name] = {
-									name: name,
-									selector: selector
-								};
-
-								// dList.remove(dItem);
-
-								// Add in page break
-								declaration.property = "break-before";
-								value.type = "Identifier";
-								value.name = "always";
-
-							}
-						}
-					});
-				}
-			});
-			return namedPageSelectors;
-		}
-
-		replaceIds(ast) {
-			lib.walk(ast, {
-				visit: "Rule",
-				enter: (node, item, list) => {
-
-					lib.walk(node, {
-						visit: "IdSelector",
-						enter: (idNode, idItem, idList) => {
-							let name = idNode.name;
-							idNode.flags = null;
-							idNode.matcher = "=";
-							idNode.name = {type: "Identifier", loc: null, name: "data-id"};
-							idNode.type = "AttributeSelector";
-							idNode.value = {type: "String", loc: null, value: `"${name}"`};
-						}
-					});
-				}
-			});
-		}
-
-		imports(node, item, list) {
-			// console.log("import", node, item, list);
-			let queries = [];
-			lib.walk(node, {
-				visit: "MediaQuery",
-				enter: (mqNode, mqItem, mqList) => {
-					lib.walk(mqNode, {
-						visit: "Identifier",
-						enter: (identNode, identItem, identList) => {
-							queries.push(identNode.name);
-						}
-					});
-				}
-			});
-
-			// Just basic media query support for now
-			let shouldNotApply = queries.some((query, index) => {
-				let q = query;
-				if (q === "not") {
-					q = queries[index + 1];
-					return !(q === "screen" || q === "speech");
-				} else {
-					return (q === "screen" || q === "speech");
-				}
-			});
-
-			if (shouldNotApply) {
-				return;
-			}
-
-			lib.walk(node, {
-				visit: "String",
-				enter: (urlNode, urlItem, urlList) => {
-					let href = urlNode.value.replace(/["']/g, "");
-					let url = new URL(href, this.url);
-					let value = url.toString();
-
-					this.imported.push(value);
-
-					// Remove the original
-					list.remove(item);
-				}
-			});
-		}
-
-		set text(t) {
-			this._text = t;
-		}
-
-		get text() {
-			return this._text;
-		}
-
-		// generate string
-		toString(ast) {
-			return lib.generate(ast || this.ast);
-		}
-	}
-
-	var baseStyles = `
-:root {
-	--pagedjs-width: 8.5in;
-	--pagedjs-height: 11in;
-	--pagedjs-pagebox-width: 8.5in;
-	--pagedjs-pagebox-height: 11in;
-	--pagedjs-margin-top: 1in;
-	--pagedjs-margin-right: 1in;
-	--pagedjs-margin-bottom: 1in;
-	--pagedjs-margin-left: 1in;
-	--pagedjs-bleed-top: 0;
-	--pagedjs-bleed-right: 0;
-	--pagedjs-bleed-bottom: 0;
-	--pagedjs-bleed-left: 0;
-	--pagedjs-crop-color: black;
-	--pagedjs-crop-offset: 2mm;
-	--pagedjs-crop-stroke: 1px;
-	--pagedjs-cross-size: 5mm;
-	--pagedjs-mark-cross-display: none;
-	--pagedjs-mark-crop-display: none;
-	--pagedjs-page-count: 0;
-}
-
-@page {
-	size: letter;
-	margin: 0;
-}
-
-.pagedjs_sheet {
-	box-sizing: border-box;
-	width: var(--pagedjs-width);
-	height: var(--pagedjs-height);
-	overflow: hidden;
-	position: relative;
-	display: grid;
-	grid-template-columns: [bleed-left] var(--pagedjs-bleed-left) [sheet-center] calc(var(--pagedjs-width) - var(--pagedjs-bleed-left) - var(--pagedjs-bleed-right)) [bleed-right] var(--pagedjs-bleed-right);
-	grid-template-rows: [bleed-top] var(--pagedjs-bleed-top) [sheet-middle] calc(var(--pagedjs-height) - var(--pagedjs-bleed-top) - var(--pagedjs-bleed-bottom)) [bleed-bottom] var(--pagedjs-bleed-bottom);
-}
-
-.pagedjs_bleed {
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	flex-wrap: nowrap;
-	overflow: hidden;
-}
-
-.pagedjs_bleed-top {
-	grid-column: bleed-left / -1;
-	grid-row: bleed-top;
-	flex-direction: row;
-}
-
-.pagedjs_bleed-bottom {
-	grid-column: bleed-left / -1;
-	grid-row: bleed-bottom;
-	flex-direction: row;
-}
-
-.pagedjs_bleed-left {
-	grid-column: bleed-left;
-	grid-row: bleed-top / -1;
-	flex-direction: column;
-}
-
-.pagedjs_bleed-right {
-	grid-column: bleed-right;
-	grid-row: bleed-top / -1;
-	flex-direction: column;
-}
-
-.pagedjs_marks-crop {
-	display: var(--pagedjs-mark-crop-display);
-	flex-grow: 0;
-	flex-shrink: 0;
-}
-
-.pagedjs_bleed-top .pagedjs_marks-crop:nth-child(1),
-.pagedjs_bleed-bottom .pagedjs_marks-crop:nth-child(1) {
-	width: calc(var(--pagedjs-bleed-left) - var(--pagedjs-crop-stroke));
-	border-right: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
-}
-
-.pagedjs_bleed-top .pagedjs_marks-crop:nth-child(3),
-.pagedjs_bleed-bottom .pagedjs_marks-crop:nth-child(3) {
-	width: calc(var(--pagedjs-bleed-right) - var(--pagedjs-crop-stroke));
-	border-left: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
-}
-
-.pagedjs_bleed-top .pagedjs_marks-crop {
-	align-self: flex-start;
-	height: calc(var(--pagedjs-bleed-top) - var(--pagedjs-crop-offset));
-}
-
-.pagedjs_bleed-bottom .pagedjs_marks-crop {
-	align-self: flex-end;
-	height: calc(var(--pagedjs-bleed-bottom) - var(--pagedjs-crop-offset));
-}
-
-.pagedjs_bleed-left .pagedjs_marks-crop:nth-child(1),
-.pagedjs_bleed-right .pagedjs_marks-crop:nth-child(1) {
-	height: calc(var(--pagedjs-bleed-top) - var(--pagedjs-crop-stroke));
-	border-bottom: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
-}
-
-.pagedjs_bleed-left .pagedjs_marks-crop:nth-child(3),
-.pagedjs_bleed-right .pagedjs_marks-crop:nth-child(3) {
-	height: calc(var(--pagedjs-bleed-bottom) - var(--pagedjs-crop-stroke));
-	border-top: var(--pagedjs-crop-stroke) solid var(--pagedjs-crop-color);
-}
-
-.pagedjs_bleed-left .pagedjs_marks-crop {
-	width: calc(var(--pagedjs-bleed-left) - var(--pagedjs-crop-offset));
-	align-self: flex-start;
-}
-
-.pagedjs_bleed-right .pagedjs_marks-crop {
-	width: calc(var(--pagedjs-bleed-right) - var(--pagedjs-crop-offset));
-	align-self: flex-end;
-}
-
-.pagedjs_marks-middle {
-	display: flex;
-	flex-grow: 1;
-	flex-shrink: 0;
-	align-items: center;
-	justify-content: center;
-}
-
-.pagedjs_marks-cross {
-	display: var(--pagedjs-mark-cross-display);
-	background-image: url(data:image/svg+xml;base64,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);
-  background-repeat: no-repeat;
-  background-position: 50% 50%;
-  background-size: var(--pagedjs-cross-size);
-
-  z-index: 2147483647;
-	width: var(--pagedjs-cross-size);
-	height: var(--pagedjs-cross-size);
-}
-
-.pagedjs_pagebox {
-	box-sizing: border-box;
-	width: var(--pagedjs-pagebox-width);
-	height: var(--pagedjs-pagebox-height);
-	position: relative;
-	display: grid;
-	grid-template-columns: [left] var(--pagedjs-margin-left) [center] calc(var(--pagedjs-pagebox-width) - var(--pagedjs-margin-left) - var(--pagedjs-margin-right)) [right] var(--pagedjs-margin-right);
-	grid-template-rows: [header] var(--pagedjs-margin-top) [page] calc(var(--pagedjs-pagebox-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom)) [footer] var(--pagedjs-margin-bottom);
-	grid-column: sheet-center;
-	grid-row: sheet-middle;
-}
-
-.pagedjs_pagebox * {
-	box-sizing: border-box;
-}
-
-.pagedjs_margin-top {
-	width: calc(var(--pagedjs-pagebox-width) - var(--pagedjs-margin-left) - var(--pagedjs-margin-right));
-	height: var(--pagedjs-margin-top);
-	grid-column: center;
-	grid-row: header;
-	flex-wrap: nowrap;
-	display: grid;
-	grid-template-columns: repeat(3, 1fr);
-	grid-template-rows: 100%;
-}
-
-.pagedjs_margin-top-left-corner-holder {
-	width: var(--pagedjs-margin-left);
-	height: var(--pagedjs-margin-top);
-	display: flex;
-	grid-column: left;
-	grid-row: header;
-}
-
-.pagedjs_margin-top-right-corner-holder {
-	width: var(--pagedjs-margin-right);
-	height: var(--pagedjs-margin-top);
-	display: flex;
-	grid-column: right;
-	grid-row: header;
-}
-
-.pagedjs_margin-top-left-corner {
-	width: var(--pagedjs-margin-left);
-}
-
-.pagedjs_margin-top-right-corner {
-	width: var(--pagedjs-margin-right);
-}
-
-.pagedjs_margin-right {
-	height: calc(var(--pagedjs-pagebox-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
-	width: var(--pagedjs-margin-right);
-	right: 0;
-	grid-column: right;
-	grid-row: page;
-	display: grid;
-	grid-template-rows: repeat(3, 33.3333%);
-	grid-template-columns: 100%;
-}
-
-.pagedjs_margin-bottom {
-	width: calc(var(--pagedjs-pagebox-width) - var(--pagedjs-margin-left) - var(--pagedjs-margin-right));
-	height: var(--pagedjs-margin-bottom);
-	grid-column: center;
-	grid-row: footer;
-	display: grid;
-	grid-template-columns: repeat(3, 1fr);
-	grid-template-rows: 100%;
-}
-
-.pagedjs_margin-bottom-left-corner-holder {
-	width: var(--pagedjs-margin-left);
-	height: var(--pagedjs-margin-bottom);
-	display: flex;
-	grid-column: left;
-	grid-row: footer;
-}
-
-.pagedjs_margin-bottom-right-corner-holder {
-	width: var(--pagedjs-margin-right);
-	height: var(--pagedjs-margin-bottom);
-	display: flex;
-	grid-column: right;
-	grid-row: footer;
-}
-
-.pagedjs_margin-bottom-left-corner {
-	width: var(--pagedjs-margin-left);
-}
-
-.pagedjs_margin-bottom-right-corner {
-	width: var(--pagedjs-margin-right);
-}
-
-
-
-.pagedjs_margin-left {
-	height: calc(var(--pagedjs-pagebox-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
-	width: var(--pagedjs-margin-left);
-	grid-column: left;
-	grid-row: page;
-	display: grid;
-	grid-template-rows: repeat(3, 33.33333%);
-	grid-template-columns: 100%;
-}
-
-.pagedjs_pages .pagedjs_pagebox .pagedjs_margin:not(.hasContent) {
-	visibility: hidden;
-}
-
-.pagedjs_pagebox > .pagedjs_area {
-	grid-column: center;
-	grid-row: page;
-	width: 100%;
-	height: 100%;
-}
-
-.pagedjs_pagebox > .pagedjs_area > .pagedjs_page_content {
-	width: 100%;
-	height: 100%;
-	position: relative;
-	column-fill: auto;
-}
-
-.pagedjs_page {
-	counter-increment: page;
-	width: var(--pagedjs-width);
-	height: var(--pagedjs-height);
-}
-
-.pagedjs_pages {
-	counter-reset: pages var(--pagedjs-page-count);
-}
-
-
-.pagedjs_pagebox .pagedjs_margin-top-left-corner,
-.pagedjs_pagebox .pagedjs_margin-top-right-corner,
-.pagedjs_pagebox .pagedjs_margin-bottom-left-corner,
-.pagedjs_pagebox .pagedjs_margin-bottom-right-corner,
-.pagedjs_pagebox .pagedjs_margin-top-left,
-.pagedjs_pagebox .pagedjs_margin-top-right,
-.pagedjs_pagebox .pagedjs_margin-bottom-left,
-.pagedjs_pagebox .pagedjs_margin-bottom-right,
-.pagedjs_pagebox .pagedjs_margin-top-center,
-.pagedjs_pagebox .pagedjs_margin-bottom-center,
-.pagedjs_pagebox .pagedjs_margin-top-center,
-.pagedjs_pagebox .pagedjs_margin-bottom-center,
-.pagedjs_margin-right-middle,
-.pagedjs_margin-left-middle  {
-	display: flex;
-	align-items: center;
-}
-
-.pagedjs_margin-right-top,
-.pagedjs_margin-left-top  {
-	display: flex;
-	align-items: flex-top;
-}
-
-
-.pagedjs_margin-right-bottom,
-.pagedjs_margin-left-bottom  {
-	display: flex;
-	align-items: flex-end;
-}
-
-
-
-/*
-.pagedjs_pagebox .pagedjs_margin-top-center,
-.pagedjs_pagebox .pagedjs_margin-bottom-center {
-	height: 100%;
-	display: none;
-	align-items: center;
-	flex: 1 0 33%;
-	margin: 0 auto;
-}
-
-.pagedjs_pagebox .pagedjs_margin-top-left-corner,
-.pagedjs_pagebox .pagedjs_margin-top-right-corner,
-.pagedjs_pagebox .pagedjs_margin-bottom-right-corner,
-.pagedjs_pagebox .pagedjs_margin-bottom-left-corner {
-	display: none;
-	align-items: center;
-}
-
-.pagedjs_pagebox .pagedjs_margin-left-top,
-.pagedjs_pagebox .pagedjs_margin-right-top {
-	display: none;
-	align-items: flex-start;
-}
-
-.pagedjs_pagebox .pagedjs_margin-right-middle,
-.pagedjs_pagebox .pagedjs_margin-left-middle {
-	display: none;
-	align-items: center;
-}
-
-.pagedjs_pagebox .pagedjs_margin-left-bottom,
-.pagedjs_pagebox .pagedjs_margin-right-bottom {
-	display: none;
-	align-items: flex-end;
-}
-*/
-
-.pagedjs_pagebox .pagedjs_margin-top-left,
-.pagedjs_pagebox .pagedjs_margin-top-right-corner,
-.pagedjs_pagebox .pagedjs_margin-bottom-left,
-.pagedjs_pagebox .pagedjs_margin-bottom-right-corner { text-align: left; }
-
-.pagedjs_pagebox .pagedjs_margin-top-left-corner,
-.pagedjs_pagebox .pagedjs_margin-top-right,
-.pagedjs_pagebox .pagedjs_margin-bottom-left-corner,
-.pagedjs_pagebox .pagedjs_margin-bottom-right { text-align: right; }
-
-.pagedjs_pagebox .pagedjs_margin-top-center,
-.pagedjs_pagebox .pagedjs_margin-bottom-center,
-.pagedjs_pagebox .pagedjs_margin-left-top,
-.pagedjs_pagebox .pagedjs_margin-left-middle,
-.pagedjs_pagebox .pagedjs_margin-left-bottom,
-.pagedjs_pagebox .pagedjs_margin-right-top,
-.pagedjs_pagebox .pagedjs_margin-right-middle,
-.pagedjs_pagebox .pagedjs_margin-right-bottom { text-align: center; }
-
-.pagedjs_pages .pagedjs_margin .pagedjs_margin-content {
-	width: 100%;
-}
-
-.pagedjs_pages .pagedjs_margin-left .pagedjs_margin-content::after,
-.pagedjs_pages .pagedjs_margin-top .pagedjs_margin-content::after,
-.pagedjs_pages .pagedjs_margin-right .pagedjs_margin-content::after,
-.pagedjs_pages .pagedjs_margin-bottom .pagedjs_margin-content::after {
-	display: block;
-}
-
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-to] {
-	margin-bottom: unset;
-	padding-bottom: unset;
-}
-
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from] {
-	text-indent: unset;
-	margin-top: unset;
-	padding-top: unset;
-	initial-letter: unset;
-}
-
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from] > *::first-letter,
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from]::first-letter {
-	color: unset;
-	font-size: unset;
-	font-weight: unset;
-	font-family: unset;
-	color: unset;
-	line-height: unset;
-	float: unset;
-	padding: unset;
-	margin: unset;
-}
-
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-to]:after,
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-to]::after {
-	content: unset;
-}
-
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from]:before,
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div [data-split-from]::before {
-	content: unset;
-}
-
-.pagedjs_pages > .pagedjs_page > .pagedjs_sheet > .pagedjs_pagebox > .pagedjs_area > div li[data-split-from]:first-of-type {
-	list-style: none;
-}
-
-/*
-[data-page]:not([data-split-from]),
-[data-break-before="page"]:not([data-split-from]),
-[data-break-before="always"]:not([data-split-from]),
-[data-break-before="left"]:not([data-split-from]),
-[data-break-before="right"]:not([data-split-from]),
-[data-break-before="recto"]:not([data-split-from]),
-[data-break-before="verso"]:not([data-split-from])
-{
-	break-before: column;
-}
-
-[data-page]:not([data-split-to]),
-[data-break-after="page"]:not([data-split-to]),
-[data-break-after="always"]:not([data-split-to]),
-[data-break-after="left"]:not([data-split-to]),
-[data-break-after="right"]:not([data-split-to]),
-[data-break-after="recto"]:not([data-split-to]),
-[data-break-after="verso"]:not([data-split-to])
-{
-	break-after: column;
-}
-*/
-
-.pagedjs_clear-after::after {
-	content: none !important;
-}
-
-img {
-	height: auto;
-}
-
-@media print {
-	html {
-		width: 100%;
-		height: 100%;
-	}
-	body {
-		margin: 0;
-		padding: 0;
-		width: 100% !important;
-		height: 100% !important;
-		min-width: 100%;
-		max-width: 100%;
-		min-height: 100%;
-		max-height: 100%;
-	}
-	.pagedjs_pages {
-		width: var(--pagedjs-width);
-		display: block !important;
-		transform: none !important;
-		height: 100% !important;
-		min-height: 100%;
-		max-height: 100%;
-		overflow: visible;
-	}
-	.pagedjs_page {
-		margin: 0;
-		padding: 0;
-		max-height: 100%;
-		min-height: 100%;
-		height: 100% !important;
-		page-break-after: always;
-		break-after: page;
-	}
-}
-`;
-
-	async function request(url, options={}) {
-		return new Promise(function(resolve, reject) {
-			let request = new XMLHttpRequest();
-
-			request.open(options.method || 'get', url, true);
-
-			for (let i in options.headers) {
-				request.setRequestHeader(i, options.headers[i]);
-			}
-
-			request.withCredentials = options.credentials=='include';
-
-			request.onload = () => {
-	 			// Chrome returns a status code of 0 for local files
-	 			const status = request.status === 0 && url.startsWith('file://') ? 200 : request.status;
-				resolve(new Response(request.responseText, {status}));
-			};
-
-			request.onerror = reject;
-
-			request.send(options.body || null);
-		});
-	}
-
-	class Polisher {
-		constructor(setup) {
-			this.sheets = [];
-			this.inserted = [];
-
-			this.hooks = {};
-			this.hooks.onUrl = new Hook(this);
-			this.hooks.onAtPage = new Hook(this);
-			this.hooks.onAtMedia = new Hook(this);
-			this.hooks.onRule = new Hook(this);
-			this.hooks.onDeclaration = new Hook(this);
-			this.hooks.onContent = new Hook(this);
-			this.hooks.onImport = new Hook(this);
-
-			this.hooks.beforeTreeParse = new Hook(this);
-			this.hooks.beforeTreeWalk = new Hook(this);
-			this.hooks.afterTreeWalk = new Hook(this);
-
-			if (setup !== false) {
-				this.setup();
-			}
-		}
-
-		setup() {
-			this.base = this.insert(baseStyles);
-			this.styleEl = document.createElement("style");
-			document.head.appendChild(this.styleEl);
-			this.styleSheet = this.styleEl.sheet;
-			return this.styleSheet;
-		}
-
-		async add() {
-			let fetched = [];
-			let urls = [];
-
-			for (var i = 0; i < arguments.length; i++) {
-				let f;
-
-				if (typeof arguments[i] === "object") {
-					for (let url in arguments[i]) {
-						let obj = arguments[i];
-						f = new Promise(function(resolve, reject) {
-							urls.push(url);
-							resolve(obj[url]);
-						});
-					}
-				} else {
-					urls.push(arguments[i]);
-					f = request(arguments[i]).then((response) => {
-						return response.text();
-					});
-				}
-
-
-				fetched.push(f);
-			}
-
-			return await Promise.all(fetched)
-				.then(async (originals) => {
-					let text = "";
-					for (let index = 0; index < originals.length; index++) {
-						text = await this.convertViaSheet(originals[index], urls[index]);
-						this.insert(text);
-					}
-					return text;
-				});
-		}
-
-		async convertViaSheet(cssStr, href) {
-			let sheet = new Sheet(href, this.hooks);
-			await sheet.parse(cssStr);
-
-			// Insert the imported sheets first
-			for (let url of sheet.imported) {
-				let str = await request(url).then((response) => {
-					return response.text();
-				});
-				let text = await this.convertViaSheet(str, url);
-				this.insert(text);
-			}
-
-			this.sheets.push(sheet);
-
-			if (typeof sheet.width !== "undefined") {
-				this.width = sheet.width;
-			}
-			if (typeof sheet.height !== "undefined") {
-				this.height = sheet.height;
-			}
-			if (typeof sheet.orientation !== "undefined") {
-				this.orientation = sheet.orientation;
-			}
-			return sheet.toString();
-		}
-
-		insert(text){
-			let head = document.querySelector("head");
-			let style = document.createElement("style");
-			style.type = "text/css";
-			style.setAttribute("data-pagedjs-inserted-styles", "true");
-
-			style.appendChild(document.createTextNode(text));
-
-			head.appendChild(style);
-
-			this.inserted.push(style);
-			return style;
-		}
-
-		destroy() {
-			this.styleEl.remove();
-			this.inserted.forEach((s) => {
-				s.remove();
-			});
-			this.sheets = [];
-		}
-	}
-
-	class Handler {
-		constructor(chunker, polisher, caller) {
-			let hooks = Object.assign({}, chunker && chunker.hooks, polisher && polisher.hooks, caller && caller.hooks);
-			this.chunker = chunker;
-			this.polisher = polisher;
-			this.caller = caller;
-
-			for (let name in hooks) {
-				if (name in this) {
-					let hook = hooks[name];
-					hook.register(this[name].bind(this));
-				}
-			}
-		}
-	}
-
-	eventEmitter(Handler.prototype);
-
-	// https://www.w3.org/TR/css3-page/#page-size-prop
-
-	var pageSizes = {
-		"A0": {
-			width: {
-				value: 841,
-				unit: "mm"
-			},
-			height: {
-				value: 1189,
-				unit: "mm"
-			}
-		},
-		"A1": {
-			width: {
-				value: 594,
-				unit: "mm"
-			},
-			height: {
-				value: 841,
-				unit: "mm"
-			}
-		},
-		"A2": {
-			width: {
-				value: 420,
-				unit: "mm"
-			},
-			height: {
-				value: 594,
-				unit: "mm"
-			}
-		},
-		"A3": {
-			width: {
-				value: 297,
-				unit: "mm"
-			},
-			height: {
-				value: 420,
-				unit: "mm"
-			}
-		},
-		"A4": {
-			width: {
-				value: 210,
-				unit: "mm"
-			},
-			height: {
-				value: 297,
-				unit: "mm"
-			}
-		},
-		"A5": {
-			width: {
-				value: 148,
-				unit: "mm"
-			},
-			height: {
-				value: 210,
-				unit: "mm"
-			}
-		},
-		"A6": {
-			width: {
-				value: 105,
-				unit: "mm"
-			},
-			height: {
-				value: 148,
-				unit: "mm"
-			}
-		},
-		"A7": {
-			width: {
-				value: 74,
-				unit: "mm"
-			},
-			height: {
-				value: 105,
-				unit: "mm"
-			}
-		},
-		"A8": {
-			width: {
-				value: 52,
-				unit: "mm"
-			},
-			height: {
-				value: 74,
-				unit: "mm"
-			}
-		},
-		"A9": {
-			width: {
-				value: 37,
-				unit: "mm"
-			},
-			height: {
-				value: 52,
-				unit: "mm"
-			}
-		},
-		"A10": {
-			width: {
-				value: 26,
-				unit: "mm"
-			},
-			height: {
-				value: 37,
-				unit: "mm"
-			}
-		},
-		"B4": {
-			width: {
-				value: 250,
-				unit: "mm"
-			},
-			height: {
-				value: 353,
-				unit: "mm"
-			}
-		},
-		"B5": {
-			width: {
-				value: 250,
-				unit: "mm"
-			},
-			height: {
-				value: 250,
-				unit: "mm"
-			}
-		},
-		"letter": {
-			width: {
-				value: 8.5,
-				unit: "in"
-			},
-			height: {
-				value: 11,
-				unit: "in"
-			}
-		},
-		"legal": {
-			width: {
-				value: 8.5,
-				unit: "mm"
-			},
-			height: {
-				value: 14,
-				unit: "mm"
-			}
-		},
-		"ledger": {
-			width: {
-				value: 11,
-				unit: "mm"
-			},
-			height: {
-				value: 17,
-				unit: "mm"
-			}
-		}
-	};
-
-	class AtPage extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-
-			this.pages = {};
-
-			this.width = undefined;
-			this.height = undefined;
-			this.orientation = undefined;
-
-			this.marginalia = {};
-		}
-
-		pageModel(selector) {
-			return {
-				selector: selector,
-				name: undefined,
-				psuedo: undefined,
-				nth: undefined,
-				marginalia: {},
-				width: undefined,
-				height: undefined,
-				orientation: undefined,
-				margin : {
-					top: {},
-					right: {},
-					left: {},
-					bottom: {}
-				},
-				block: {},
-				marks: undefined
-			};
-		}
-
-		// Find and Remove @page rules
-		onAtPage(node, item, list) {
-			let page, marginalia;
-			let selector = "";
-			let named, psuedo, nth;
-			let needsMerge = false;
-
-			if (node.prelude) {
-				named = this.getTypeSelector(node);
-				psuedo = this.getPsuedoSelector(node);
-				nth = this.getNthSelector(node);
-				selector = lib.generate(node.prelude);
-			} else {
-				selector = "*";
-			}
-
-			if (selector in this.pages) {
-				// this.pages[selector] = Object.assign(this.pages[selector], page);
-				// console.log("after", selector, this.pages[selector]);
-
-				// this.pages[selector].added = false;
-				page = this.pages[selector];
-				marginalia = this.replaceMarginalia(node);
-				needsMerge = true;
-			} else {
-				page = this.pageModel(selector);
-				marginalia = this.replaceMarginalia(node);
-				this.pages[selector] = page;
-			}
-
-			page.name = named;
-			page.psuedo = psuedo;
-			page.nth = nth;
-
-			if (needsMerge) {
-				page.marginalia = Object.assign(page.marginalia, marginalia);
-			} else {
-				page.marginalia = marginalia;
-			}
-
-			let declarations = this.replaceDeclartations(node);
-
-			if (declarations.size) {
-				page.size = declarations.size;
-				page.width = declarations.size.width;
-				page.height = declarations.size.height;
-				page.orientation = declarations.size.orientation;
-				page.format = declarations.size.format;
-			}
-
-			if (declarations.bleed && declarations.bleed[0] != "auto") {
-				switch (declarations.bleed.length) {
-					case 4: // top right bottom left
-						page.bleed = {
-							top: declarations.bleed[0],
-							right: declarations.bleed[1],
-							bottom: declarations.bleed[2],
-							left: declarations.bleed[3]
-						};
-						break;
-					case 3: // top right bottom right
-						page.bleed = {
-							top: declarations.bleed[0],
-							right: declarations.bleed[1],
-							bottom: declarations.bleed[2],
-							left: declarations.bleed[1]
-						};
-						break;
-					case 2: // top right top right
-						page.bleed = {
-							top: declarations.bleed[0],
-							right: declarations.bleed[1],
-							bottom: declarations.bleed[0],
-							left: declarations.bleed[1]
-						};
-						break;
-					default:
-						page.bleed = {
-							top: declarations.bleed[0],
-							right: declarations.bleed[0],
-							bottom: declarations.bleed[0],
-							left: declarations.bleed[0]
-						};
-				}
-			}
-
-			if (declarations.marks) {
-				if (!declarations.bleed || declarations.bleed && declarations.bleed[0] === "auto") {
-					// Spec say 6pt, but needs more space for marks
-					page.bleed = {
-						top: { value: 6, unit: "mm" },
-						right: { value: 6, unit: "mm" },
-						bottom: { value: 6, unit: "mm" },
-						left: { value: 6, unit: "mm" }
-					};
-				}
-
-				page.marks = declarations.marks;
-			}
-
-			if (declarations.margin) {
-				page.margin = declarations.margin;
-			}
-
-			if (declarations.marks) {
-				page.marks = declarations.marks;
-			}
-
-			if (needsMerge) {
-				page.block.children.appendList(node.block.children);
-			} else {
-				page.block = node.block;
-			}
-
-			// Remove the rule
-			list.remove(item);
-		}
-
-		/* Handled in breaks */
-		/*
-		afterParsed(parsed) {
-			for (let b in this.named) {
-				// Find elements
-				let elements = parsed.querySelectorAll(b);
-				// Add break data
-				for (var i = 0; i < elements.length; i++) {
-					elements[i].setAttribute("data-page", this.named[b]);
-				}
-			}
-		}
-		*/
-
-		afterTreeWalk(ast, sheet) {
-			this.addPageClasses(this.pages, ast, sheet);
-
-			if ("*" in this.pages) {
-				let width = this.pages["*"].width;
-				let height = this.pages["*"].height;
-				let format = this.pages["*"].format;
-				let orientation = this.pages["*"].orientation;
-				let bleed = this.pages["*"].bleed;
-				let marks = this.pages["*"].marks;
-
-
-				if ((width && height) &&
-						(this.width !== width || this.height !== height)) {
-					this.width = width;
-					this.height = height;
-					this.format = format;
-					this.orientation = orientation;
-
-					this.addRootVars(ast, width, height, orientation, bleed, marks);
-					this.addRootPage(ast, this.pages["*"].size, bleed);
-
-					this.emit("size", { width, height, orientation, format, bleed });
-				}
-
-			}
-		}
-
-		getTypeSelector(ast) {
-			// Find page name
-			let name;
-
-			lib.walk(ast, {
-				visit: "TypeSelector",
-				enter: (node, item, list) => {
-					name = node.name;
-				}
-			});
-
-			return name;
-		}
-
-		getPsuedoSelector(ast) {
-			// Find if it has :left & :right & :black & :first
-			let name;
-			lib.walk(ast, {
-				visit: "PseudoClassSelector",
-				enter: (node, item, list) => {
-					if (node.name !== "nth") {
-						name = node.name;
-					}
-				}
-			});
-
-			return name;
-		}
-
-		getNthSelector(ast) {
-			// Find if it has :nth
-			let nth;
-			lib.walk(ast, {
-				visit: "PseudoClassSelector",
-				enter: (node, item, list) => {
-					if (node.name === "nth" && node.children) {
-						let raw = node.children.first();
-						nth = raw.value;
-					}
-				}
-			});
-
-			return nth;
-		}
-
-		replaceMarginalia(ast) {
-			let parsed = {};
-
-			lib.walk(ast.block, {
-				visit: "Atrule",
-				enter: (node, item, list) => {
-					let name = node.name;
-					if (name === "top") {
-						name = "top-center";
-					}
-					if (name === "right") {
-						name = "right-middle";
-					}
-					if (name === "left") {
-						name = "left-middle";
-					}
-					if (name === "bottom") {
-						name = "bottom-center";
-					}
-					parsed[name] = node.block;
-					list.remove(item);
-				}
-			});
-
-			return parsed;
-		}
-
-		replaceDeclartations(ast) {
-			let parsed = {};
-
-			lib.walk(ast.block, {
-				visit: "Declaration",
-				enter: (declaration, dItem, dList) => {
-					let prop = lib.property(declaration.property).name;
-					let value = declaration.value;
-
-					if (prop === "marks") {
-						parsed.marks = [];
-						lib.walk(declaration, {
-							visit: "Identifier",
-							enter: (ident) => {
-								parsed.marks.push(ident.name);
-							}
-						});
-						dList.remove(dItem);
-					} else if (prop === "margin") {
-						parsed.margin = this.getMargins(declaration);
-						dList.remove(dItem);
-					} else if (prop.indexOf("margin-") === 0) {
-						let m = prop.substring("margin-".length);
-						if (!parsed.margin) {
-							parsed.margin = {
-								top: {},
-								right: {},
-								left: {},
-								bottom: {}
-							};
-						}
-						parsed.margin[m] = declaration.value.children.first();
-						dList.remove(dItem);
-					} else if (prop === "size") {
-						parsed.size = this.getSize(declaration);
-						dList.remove(dItem);
-					} else if (prop === "bleed") {
-						parsed.bleed = [];
-
-						lib.walk(declaration, {
-							enter: (subNode) => {
-								switch (subNode.type) {
-									case "String": // bleed: "auto"
-										if (subNode.value.indexOf("auto") > -1) {
-											parsed.bleed.push("auto");
-										}
-										break;
-									case "Dimension": // bleed: 1in 2in, bleed: 20px ect.
-										parsed.bleed.push({
-											value: subNode.value,
-											unit: subNode.unit
-										});
-										break;
-									case "Number":
-										parsed.bleed.push({
-											value: subNode.value,
-											unit: "px"
-										});
-										break;
-									default:
-										// ignore
-								}
-
-							}
-						});
-
-						dList.remove(dItem);
-					}
-
-				}
-			});
-
-			return parsed;
-		}
-
-		getSize(declaration) {
-			let width, height, orientation, format;
-
-			// Get size: Xmm Ymm
-			lib.walk(declaration, {
-				visit: "Dimension",
-				enter: (node, item, list) => {
-					let {value, unit} = node;
-					if (typeof width === "undefined") {
-						width = { value, unit };
-					} else if (typeof height === "undefined") {
-						height = { value, unit };
-					}
-				}
-			});
-
-			// Get size: "A4"
-			lib.walk(declaration, {
-				visit: "String",
-				enter: (node, item, list) => {
-					let name = node.value.replace(/["|']/g, "");
-					let s = pageSizes[name];
-					if (s) {
-						width = s.width;
-						height = s.height;
-					}
-				}
-			});
-
-			// Get Format or Landscape or Portrait
-			lib.walk(declaration, {
-				visit: "Identifier",
-				enter: (node, item, list) => {
-					let name = node.name;
-					if (name === "landscape" || name === "portrait") {
-						orientation = node.name;
-					} else if (name !== "auto") {
-						let s = pageSizes[name];
-						if (s) {
-							width = s.width;
-							height = s.height;
-						}
-						format = name;
-					}
-				}
-			});
-
-			return {
-				width,
-				height,
-				orientation,
-				format
-			};
-		}
-
-		getMargins(declaration) {
-			let margins = [];
-			let margin = {
-				top: {},
-				right: {},
-				left: {},
-				bottom: {}
-			};
-
-			lib.walk(declaration, {
-				visit: "Dimension",
-				enter: (node, item, list) => {
-					margins.push(node);
-				}
-			});
-
-			if (margins.length === 1) {
-				for (let m in margin) {
-					margin[m] = margins[0];
-				}
-			} else if (margins.length === 2) {
-				margin.top = margins[0];
-				margin.right = margins[1];
-				margin.bottom = margins[0];
-				margin.left = margins[1];
-			} else if (margins.length === 3) {
-				margin.top = margins[0];
-				margin.right = margins[1];
-				margin.bottom = margins[2];
-				margin.left = margins[1];
-			} else if (margins.length === 4) {
-				margin.top = margins[0];
-				margin.right = margins[1];
-				margin.bottom = margins[2];
-				margin.left = margins[3];
-			}
-
-			return margin;
-		}
-
-		addPageClasses(pages, ast, sheet) {
-			// First add * page
-			if ("*" in pages && !pages["*"].added) {
-				let p = this.createPage(pages["*"], ast.children, sheet);
-				sheet.insertRule(p);
-				pages["*"].added = true;
-			}
-			// Add :left & :right
-			if (":left" in pages && !pages[":left"].added) {
-				let left = this.createPage(pages[":left"], ast.children, sheet);
-				sheet.insertRule(left);
-				pages[":left"].added = true;
-			}
-			if (":right" in pages && !pages[":right"].added) {
-				let right = this.createPage(pages[":right"], ast.children, sheet);
-				sheet.insertRule(right);
-				pages[":right"].added = true;
-			}
-			// Add :first & :blank
-			if (":first" in pages && !pages[":first"].first) {
-				let first = this.createPage(pages[":first"], ast.children, sheet);
-				sheet.insertRule(first);
-				pages[":first"].added = true;
-			}
-			if (":blank" in pages && !pages[":blank"].added) {
-				let blank = this.createPage(pages[":blank"], ast.children, sheet);
-				sheet.insertRule(blank);
-				pages[":blank"].added = true;
-			}
-			// Add nth pages
-			for (let pg in pages) {
-				if (pages[pg].nth && !pages[pg].added) {
-					let nth = this.createPage(pages[pg], ast.children, sheet);
-					sheet.insertRule(nth);
-					pages[pg].added = true;
-				}
-			}
-
-			// Add named pages
-			for (let pg in pages) {
-				if (pages[pg].name && !pages[pg].added) {
-					let named = this.createPage(pages[pg], ast.children, sheet);
-					sheet.insertRule(named);
-					pages[pg].added = true;
-				}
-			}
-
-		}
-
-		createPage(page, ruleList, sheet) {
-
-			let selectors = this.selectorsForPage(page);
-			let children = page.block.children.copy();
-			let block = {
-				type: "Block",
-				loc: 0,
-				children: children
-			};
-			let rule = this.createRule(selectors, block);
-
-			this.addMarginVars(page.margin, children, children.first());
-
-			if (page.width) {
-				this.addDimensions(page.width, page.height, page.orientation, children, children.first());
-			}
-
-			if (page.marginalia) {
-				this.addMarginaliaStyles(page, ruleList, rule, sheet);
-				this.addMarginaliaContent(page, ruleList, rule, sheet);
-			}
-
-			return rule;
-		}
-
-		addMarginVars(margin, list, item) {
-			// variables for margins
-			for (let m in margin) {
-				if (typeof margin[m].value !== "undefined") {
-					let value = margin[m].value + (margin[m].unit || "");
-					let mVar = list.createItem({
-						type: "Declaration",
-						property: "--pagedjs-margin-" + m,
-						value: {
-							type: "Raw",
-							value: value
-						}
-					});
-					list.append(mVar, item);
-				}
-			}
-		}
-
-		addDimensions(width, height, orientation, list, item) {
-			let widthString, heightString;
-
-			widthString = CSSValueToString(width);
-			heightString = CSSValueToString(height);
-
-			if (orientation && orientation !== "portrait") {
-				// reverse for orientation
-				[widthString, heightString] = [heightString, widthString];
-			}
-
-			// width variable
-			let wVar = this.createVariable("--pagedjs-pagebox-width", widthString);
-			list.appendData(wVar);
-
-			// height variable
-			let hVar = this.createVariable("--pagedjs-pagebox-height", heightString);
-			list.appendData(hVar);
-
-			// let w = this.createDimension("width", width);
-			// let h = this.createDimension("height", height);
-			// list.appendData(w);
-			// list.appendData(h);
-		}
-
-		addMarginaliaStyles(page, list, item, sheet) {
-			for (let loc in page.marginalia) {
-				let block = lib.clone(page.marginalia[loc]);
-				let hasContent$$1 = false;
-
-				if(block.children.isEmpty()) {
-					continue;
-				}
-
-				lib.walk(block, {
-					visit: "Declaration",
-					enter: (node, item, list) => {
-						if (node.property === "content") {
-							if (node.value.children && node.value.children.first().name === "none") {
-								hasContent$$1 = false;
-							} else {
-								hasContent$$1 = true;
-							}
-							list.remove(item);
-						}
-						if (node.property === "vertical-align") {
-							lib.walk(node, {
-								visit: "Identifier",
-								enter: (identNode, identItem, identlist) => {
-									let name = identNode.name;
-									if (name === "top") {
-										identNode.name = "flex-start";
-									} else if (name === "middle") {
-										identNode.name = "center";
-									} else if (name === "bottom") {
-										identNode.name = "flex-end";
-									}
-								}
-							});
-							node.property = "align-items";
-						}
-
-						if (node.property === "width" &&
-							(loc === "top-left" ||
-							 loc === "top-center" ||
-							 loc === "top-right" ||
-							 loc === "bottom-left" ||
-							 loc === "bottom-center" ||
-							 loc === "bottom-right")) {
-							let c = lib.clone(node);
-							c.property = "max-width";
-							list.appendData(c);
-						}
-
-						if (node.property === "height" &&
-							(loc === "left-top" ||
-							 loc === "left-middle" ||
-							 loc === "left-bottom" ||
-							 loc === "right-top" ||
-							 loc === "right-middle" ||
-							 loc === "right-bottom")) {
-							let c = lib.clone(node);
-							c.property = "max-height";
-							list.appendData(c);
-						}
-					}
-				});
-
-				let marginSelectors = this.selectorsForPageMargin(page, loc);
-				let marginRule = this.createRule(marginSelectors, block);
-
-				list.appendData(marginRule);
-
-				let sel = lib.generate({
-					type: "Selector",
-					children: marginSelectors
-				});
-
-				this.marginalia[sel] = {
-					page: page,
-					selector: sel,
-					block: page.marginalia[loc],
-					hasContent: hasContent$$1
-				};
-
-			}
-		}
-
-		addMarginaliaContent(page, list, item, sheet) {
-			let displayNone;
-			// Just content
-			for (let loc in page.marginalia) {
-				let content = lib.clone(page.marginalia[loc]);
-				lib.walk(content, {
-					visit: "Declaration",
-					enter: (node, item, list) => {
-						if (node.property !== "content") {
-							list.remove(item);
-						}
-
-						if (node.value.children && node.value.children.first().name === "none") {
-							displayNone = true;
-						}
-					}
-				});
-
-				if(content.children.isEmpty()) {
-					continue;
-				}
-
-				let displaySelectors = this.selectorsForPageMargin(page, loc);
-				let displayDeclaration;
-
-				displaySelectors.insertData({
-					type: "Combinator",
-					name: ">"
-				});
-
-				displaySelectors.insertData({
-					type: "ClassSelector",
-					name: "pagedjs_margin-content"
-				});
-
-				displaySelectors.insertData({
-					type: "Combinator",
-					name: ">"
-				});
-
-				displaySelectors.insertData({
-					type: "TypeSelector",
-					name: "*"
-				});
-
-				if (displayNone) {
-					displayDeclaration = this.createDeclaration("display", "none");
-				} else {
-					displayDeclaration = this.createDeclaration("display", "block");
-				}
-
-				let displayRule = this.createRule(displaySelectors, [displayDeclaration]);
-				sheet.insertRule(displayRule);
-
-				// insert content rule
-				let contentSelectors = this.selectorsForPageMargin(page, loc);
-
-				contentSelectors.insertData({
-					type: "Combinator",
-					name: ">"
-				});
-
-				contentSelectors.insertData({
-					type: "ClassSelector",
-					name: "pagedjs_margin-content"
-				});
-
-				contentSelectors.insertData({
-					type: "PseudoElementSelector",
-					name: "after",
-					children: null
-				});
-
-				let contentRule = this.createRule(contentSelectors, content);
-				sheet.insertRule(contentRule);
-			}
-		}
-
-		addRootVars(ast, width, height, orientation, bleed, marks) {
-			let rules = [];
-			let selectors = new lib.List();
-			selectors.insertData({
-				type: "PseudoClassSelector",
-				name: "root",
-				children: null
-			});
-
-			let widthString, heightString;
-
-			if (!bleed) {
-				widthString = CSSValueToString(width);
-				heightString = CSSValueToString(height);
-			} else {
-				widthString = `calc( ${CSSValueToString(width)} + ${CSSValueToString(bleed.left)} + ${CSSValueToString(bleed.right)} )`;
-				heightString = `calc( ${CSSValueToString(height)} + ${CSSValueToString(bleed.top)} + ${CSSValueToString(bleed.bottom)} )`;
-
-				let bleedTop = this.createVariable("--pagedjs-bleed-top", CSSValueToString(bleed.top));
-				let bleedRight = this.createVariable("--pagedjs-bleed-right", CSSValueToString(bleed.right));
-				let bleedBottom = this.createVariable("--pagedjs-bleed-bottom", CSSValueToString(bleed.bottom));
-				let bleedLeft = this.createVariable("--pagedjs-bleed-left", CSSValueToString(bleed.left));
-
-				let pageWidthVar = this.createVariable("--pagedjs-width", CSSValueToString(width));
-				let pageHeightVar = this.createVariable("--pagedjs-height", CSSValueToString(height));
-
-				rules.push(bleedTop, bleedRight, bleedBottom, bleedLeft, pageWidthVar, pageHeightVar);
-			}
-
-			if (marks) {
-				marks.forEach((mark) => {
-					let markDisplay = this.createVariable("--pagedjs-mark-" + mark + "-display", "block");
-					rules.push(markDisplay);
-				});
-			}
-
-			// orientation variable
-			if (orientation) {
-				let oVar = this.createVariable("--pagedjs-orientation", orientation);
-				rules.push(oVar);
-
-				if (orientation !== "portrait") {
-					// reverse for orientation
-					[widthString, heightString] = [heightString, widthString];
-				}
-			}
-
-			let wVar = this.createVariable("--pagedjs-width", widthString);
-			let hVar = this.createVariable("--pagedjs-height", heightString);
-
-			rules.push(wVar, hVar);
-
-			let rule = this.createRule(selectors, rules);
-
-			ast.children.appendData(rule);
-		}
-
-		/*
-		@page {
-			size: var(--pagedjs-width) var(--pagedjs-height);
-			margin: 0;
-			padding: 0;
-		}
-		*/
-		addRootPage(ast, size, bleed) {
-			let { width, height, orientation, format } = size;
-			let children = new lib.List();
-			let dimensions = new lib.List();
-
-			if (bleed) {
-				let widthCalculations = new lib.List();
-				let heightCalculations = new lib.List();
-
-				// width
-				widthCalculations.appendData({
-					type: "Dimension",
-					unit: width.unit,
-					value: width.value
-				});
-
-				widthCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				widthCalculations.appendData({
-					type: "Operator",
-					value: "+"
-				});
-
-				widthCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				widthCalculations.appendData({
-					type: "Dimension",
-					unit: bleed.left.unit,
-					value: bleed.left.value
-				});
-
-				widthCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				widthCalculations.appendData({
-					type: "Operator",
-					value: "+"
-				});
-
-				widthCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				widthCalculations.appendData({
-					type: "Dimension",
-					unit: bleed.right.unit,
-					value: bleed.right.value
-				});
-
-				// height
-				heightCalculations.appendData({
-					type: "Dimension",
-					unit: height.unit,
-					value: height.value
-				});
-
-				heightCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				heightCalculations.appendData({
-					type: "Operator",
-					value: "+"
-				});
-
-				heightCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				heightCalculations.appendData({
-					type: "Dimension",
-					unit: bleed.top.unit,
-					value: bleed.top.value
-				});
-
-				heightCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				heightCalculations.appendData({
-					type: "Operator",
-					value: "+"
-				});
-
-				heightCalculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				heightCalculations.appendData({
-					type: "Dimension",
-					unit: bleed.bottom.unit,
-					value: bleed.bottom.value
-				});
-
-				dimensions.appendData({
-					type: "Function",
-					name: "calc",
-					children: widthCalculations
-				});
-
-				dimensions.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				dimensions.appendData({
-					type: "Function",
-					name: "calc",
-					children: heightCalculations
-				});
-
-			} else if (format) {
-				dimensions.appendData({
-					type: "Identifier",
-					name: format
-				});
-
-				if (orientation) {
-					dimensions.appendData({
-						type: "WhiteSpace",
-						value: " "
-					});
-
-					dimensions.appendData({
-						type: "Identifier",
-						name: orientation
-					});
-				}
-			} else {
-				dimensions.appendData({
-					type: "Dimension",
-					unit: width.unit,
-					value: width.value
-				});
-
-				dimensions.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				dimensions.appendData({
-					type: "Dimension",
-					unit: height.unit,
-					value: height.value
-				});
-			}
-
-			children.appendData({
-				type: "Declaration",
-				property: "size",
-				loc: null,
-				value: {
-					type: "Value",
-					children: dimensions
-				}
-			});
-
-			children.appendData({
-				type: "Declaration",
-				property: "margin",
-				loc: null,
-				value: {
-					type: "Value",
-					children: [{
-						type: "Dimension",
-						unit: "px",
-						value: 0
-					}]
-				}
-			});
-
-			children.appendData({
-				type: "Declaration",
-				property: "padding",
-				loc: null,
-				value: {
-					type: "Value",
-					children: [{
-						type: "Dimension",
-						unit: "px",
-						value: 0
-					}]
-				}
-			});
-
-
-			let rule = ast.children.createItem({
-				type: "Atrule",
-				prelude: null,
-				name: "page",
-				block: {
-					type: "Block",
-					loc: null,
-					children: children
-				}
-			});
-
-			ast.children.append(rule);
-		}
-
-		getNth(nth) {
-			let n = nth.indexOf("n");
-			let plus = nth.indexOf("+");
-			let splitN = nth.split("n");
-			let splitP = nth.split("+");
-			let a = null;
-			let b = null;
-			if (n > -1) {
-				a = splitN[0];
-				if (plus > -1) {
-					b = splitP[1];
-				}
-			} else {
-				b = nth;
-			}
-
-			return {
-				type: "Nth",
-				loc: null,
-				selector: null,
-				nth: {
-					type: "AnPlusB",
-					loc: null,
-					a: a,
-					b: b
-				}
-			};
-		}
-
-		addPageAttributes(page, start, pages) {
-			let named = start.dataset.page;
-
-			if (named) {
-				page.name = named;
-				page.element.classList.add("pagedjs_named_page");
-				page.element.classList.add("pagedjs_" + named + "_page");
-
-				if (!start.dataset.splitFrom) {
-					page.element.classList.add("pagedjs_" + named + "_first_page");
-				}
-			}
-		}
-
-		getStartElement(content, breakToken) {
-			let node = breakToken && breakToken.node;
-
-			if (!content && !breakToken) {
-				return;
-			}
-
-			// No break
-			if (!node) {
-				return content.children[0];
-			}
-
-			// Top level element
-			if (node.nodeType === 1 && node.parentNode.nodeType === 11) {
-				return node;
-			}
-
-			// Named page
-			if (node.nodeType === 1 && node.dataset.page) {
-				return node;
-			}
-
-			// Get top level Named parent
-			let fragment = rebuildAncestors(node);
-			let pages = fragment.querySelectorAll("[data-page]");
-
-			if (pages.length) {
-				return pages[pages.length - 1];
-			} else {
-				return fragment.children[0];
-			}
-		}
-
-		beforePageLayout(page, contents, breakToken, chunker) {
-			let start = this.getStartElement(contents, breakToken);
-			if (start) {
-				this.addPageAttributes(page, start, chunker.pages);
-			}
-		}
-
-		afterPageLayout(fragment, page, breakToken, chunker) {
-			for (let m in this.marginalia) {
-				let margin = this.marginalia[m];
-				let sels = m.split(" ");
-
-				let content;
-				if (page.element.matches(sels[0]) && margin.hasContent) {
-					content = page.element.querySelector(sels[1]);
-					content.classList.add("hasContent");
-				}
-			}
-
-			// check center
-			["top", "bottom"].forEach((loc) => {
-				let marginGroup = page.element.querySelector(".pagedjs_margin-" + loc);
-				let center = page.element.querySelector(".pagedjs_margin-" + loc + "-center");
-				let left = page.element.querySelector(".pagedjs_margin-" + loc + "-left");
-				let right = page.element.querySelector(".pagedjs_margin-" + loc + "-right");
-
-				let centerContent = center.classList.contains("hasContent");
-				let leftContent = left.classList.contains("hasContent");
-				let rightContent = right.classList.contains("hasContent");
-				let centerWidth, leftWidth, rightWidth;
-
-				if (leftContent) {
-					leftWidth = window.getComputedStyle(left)["max-width"];
-				}
-
-				if (rightContent) {
-					rightWidth = window.getComputedStyle(right)["max-width"];
-				}
-
-
-				if (centerContent) {
-					centerWidth = window.getComputedStyle(center)["max-width"];
-
-					if(centerWidth === "none" || centerWidth === "auto") {
-						if(!leftContent && !rightContent){
-							marginGroup.style["grid-template-columns"] = "0 1fr 0";
-						}else if(leftContent){
-							if(!rightContent){
-								if(leftWidth !== "none" && leftWidth !== "auto"){
-									marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + leftWidth;
-								}else{
-									marginGroup.style["grid-template-columns"] = "auto auto 1fr";
-									left.style["white-space"] = "nowrap";
-									center.style["white-space"] = "nowrap";
-									let leftOuterWidth = left.offsetWidth;
-									let centerOuterWidth = center.offsetWidth;
-									let outerwidths = leftOuterWidth + centerOuterWidth;
-									let newcenterWidth = centerOuterWidth * 100 / outerwidths;
-									marginGroup.style["grid-template-columns"] = "minmax(16.66%, 1fr) minmax(33%, " + newcenterWidth + "%) minmax(16.66%, 1fr)";
-									left.style["white-space"] = "normal";
-									center.style["white-space"] = "normal";
-								}
-							}else{
-								if(leftWidth !== "none" && leftWidth !== "auto"){
-									if(rightWidth !== "none" && rightWidth !== "auto"){
-										marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + rightWidth;
-									}else{
-										marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + leftWidth;
-									}
-								}else{
-									if(rightWidth !== "none" && rightWidth !== "auto"){
-										marginGroup.style["grid-template-columns"] = rightWidth + " 1fr " + rightWidth;
-									}else{
-										marginGroup.style["grid-template-columns"] = "auto auto 1fr";
-										left.style["white-space"] = "nowrap";
-										center.style["white-space"] = "nowrap";
-										right.style["white-space"] = "nowrap";
-										let leftOuterWidth = left.offsetWidth;
-										let centerOuterWidth = center.offsetWidth;
-										let rightOuterWidth = right.offsetWidth;
-										let outerwidths = leftOuterWidth + centerOuterWidth + rightOuterWidth;
-										let newcenterWidth = centerOuterWidth * 100 / outerwidths;
-										if(newcenterWidth > 40){
-											marginGroup.style["grid-template-columns"] = "minmax(16.66%, 1fr) minmax(33%, " + newcenterWidth + "%) minmax(16.66%, 1fr)";
-										}else{
-											marginGroup.style["grid-template-columns"] = "repeat(3, 1fr)";
-										}
-										left.style["white-space"] = "normal";
-										center.style["white-space"] = "normal";
-										right.style["white-space"] = "normal";
-									}
-								}
-							}
-						}else{
-							if(rightWidth !== "none" && rightWidth !== "auto"){
-								marginGroup.style["grid-template-columns"] = rightWidth + " 1fr " + rightWidth;
-							}else{
-								marginGroup.style["grid-template-columns"] = "auto auto 1fr";
-								right.style["white-space"] = "nowrap";
-								center.style["white-space"] = "nowrap";
-								let rightOuterWidth = right.offsetWidth;
-								let centerOuterWidth = center.offsetWidth;
-								let outerwidths = rightOuterWidth + centerOuterWidth;
-								let newcenterWidth = centerOuterWidth * 100 / outerwidths;
-								marginGroup.style["grid-template-columns"] = "minmax(16.66%, 1fr) minmax(33%, " + newcenterWidth + "%) minmax(16.66%, 1fr)";
-								right.style["white-space"] = "normal";
-								center.style["white-space"] = "normal";
-							}
-						}
-					}else if(centerWidth !== "none" && centerWidth !== "auto"){
-						if(leftContent && leftWidth !== "none" && leftWidth !== "auto"){
-							marginGroup.style["grid-template-columns"] = leftWidth + " " + centerWidth + " 1fr";
-						}else if(rightContent && rightWidth !== "none" && rightWidth !== "auto"){
-							marginGroup.style["grid-template-columns"] = "1fr " + centerWidth + " " + rightWidth;
-						}else{
-							marginGroup.style["grid-template-columns"] = "1fr " + centerWidth + " 1fr";
-						}
-
-					}
-
-				}else{
-					if(leftContent){
-						if(!rightContent){
-							marginGroup.style["grid-template-columns"] = "1fr 0 0";
-						}else{
-							if(leftWidth !== "none" && leftWidth !== "auto"){
-								if(rightWidth !== "none" && rightWidth !== "auto"){
-									marginGroup.style["grid-template-columns"] = leftWidth + " 1fr " + rightWidth;
-								}else{
-									marginGroup.style["grid-template-columns"] = leftWidth + " 0 1fr";
-								}
-							}else{
-								if(rightWidth !== "none" && rightWidth !== "auto"){
-									marginGroup.style["grid-template-columns"] = "1fr 0 " + rightWidth;
-								}else{
-									marginGroup.style["grid-template-columns"] = "auto 1fr auto";
-									left.style["white-space"] = "nowrap";
-									right.style["white-space"] = "nowrap";
-									let leftOuterWidth = left.offsetWidth;
-									let rightOuterWidth = right.offsetWidth;
-									let outerwidths = leftOuterWidth + rightOuterWidth;
-									let newLeftWidth = leftOuterWidth * 100 / outerwidths;
-									marginGroup.style["grid-template-columns"] = "minmax(16.66%, " + newLeftWidth  + "%) 0 1fr";
-									left.style["white-space"] = "normal";
-									right.style["white-space"] = "normal";
-								}
-							}
-						}
-					}else{
-						if(rightWidth !== "none" && rightWidth !== "auto"){
-							marginGroup.style["grid-template-columns"] = "1fr 0 " + rightWidth;
-						}else{
-							marginGroup.style["grid-template-columns"] = "0 0 1fr";
-						}
-					}
-				}
-			});
-
-			// check middle
-			["left", "right"].forEach((loc) => {
-				let middle = page.element.querySelector(".pagedjs_margin-" + loc + "-middle.hasContent");
-				let marginGroup = page.element.querySelector(".pagedjs_margin-" + loc);
-				let top = page.element.querySelector(".pagedjs_margin-" + loc + "-top");
-				let bottom = page.element.querySelector(".pagedjs_margin-" + loc + "-bottom");
-				let topContent = top.classList.contains("hasContent");
-				let bottomContent = bottom.classList.contains("hasContent");
-				let middleHeight, topHeight, bottomHeight;
-
-				if (topContent) {
-					topHeight = window.getComputedStyle(top)["max-height"];
-				}
-
-				if (bottomContent) {
-					bottomHeight = window.getComputedStyle(bottom)["max-height"];
-				}
-
-				if (middle) {
-					middleHeight = window.getComputedStyle(middle)["max-height"];
-
-					if(middleHeight === "none" || middleHeight === "auto") {
-						if(!topContent && !bottomContent){
-							marginGroup.style["grid-template-rows"] = "0 1fr 0";
-						}else if(topContent){
-							if(!bottomContent){
-								if(topHeight !== "none" && topHeight !== "auto"){
-									marginGroup.style["grid-template-rows"] = topHeight + " calc(100% - " + topHeight + "*2) " + topHeight;
-								}
-							}else{
-								if(topHeight !== "none" && topHeight !== "auto"){
-									if(bottomHeight !== "none" && bottomHeight !== "auto"){
-										marginGroup.style["grid-template-rows"] = topHeight + " calc(100% - " + topHeight + " - " + bottomHeight + ") " + bottomHeight;
-									}else{
-										marginGroup.style["grid-template-rows"] = topHeight + " calc(100% - " + topHeight + "*2) " + topHeight;
-									}
-								}else{
-									if(bottomHeight !== "none" && bottomHeight !== "auto"){
-										marginGroup.style["grid-template-rows"] = bottomHeight + " calc(100% - " + bottomHeight + "*2) " + bottomHeight;
-									}
-								}
-							}
-						}else{
-							if(bottomHeight !== "none" && bottomHeight !== "auto"){
-								marginGroup.style["grid-template-rows"] = bottomHeight + " calc(100% - " + bottomHeight + "*2) " + bottomHeight;
-							}
-						}
-					}else{
-						if(topContent && topHeight !== "none" && topHeight !== "auto"){
-							marginGroup.style["grid-template-rows"] = topHeight +" " + middleHeight + " calc(100% - (" + topHeight + " + " + middleHeight + "))";
-						}else if(bottomContent && bottomHeight !== "none" && bottomHeight !== "auto"){
-							marginGroup.style["grid-template-rows"] = "1fr " + middleHeight + " " + bottomHeight;
-						}else{
-							marginGroup.style["grid-template-rows"] = "calc((100% - " + middleHeight + ")/2) " + middleHeight + " calc((100% - " + middleHeight + ")/2)";
-						}
-
-					}
-
-				}else{
-					if(topContent){
-						if(!bottomContent){
-							marginGroup.style["grid-template-rows"] = "1fr 0 0";
-						}else{
-							if(topHeight !== "none" && topHeight !== "auto"){
-								if(bottomHeight !== "none" && bottomHeight !== "auto"){
-									marginGroup.style["grid-template-rows"] = topHeight + " 1fr " + bottomHeight;
-								}else{
-									marginGroup.style["grid-template-rows"] = topHeight + " 0 1fr";
-								}
-							}else{
-								if(bottomHeight !== "none" && bottomHeight !== "auto"){
-									marginGroup.style["grid-template-rows"] = "1fr 0 " + bottomHeight;
-								}else{
-									marginGroup.style["grid-template-rows"] = "1fr 0 1fr";
-								}
-							}
-						}
-					}else{
-						if(bottomHeight !== "none" && bottomHeight !== "auto"){
-							marginGroup.style["grid-template-rows"] = "1fr 0 " + bottomHeight;
-						}else{
-							marginGroup.style["grid-template-rows"] = "0 0 1fr";
-						}
-					}
-				}
-
-
-
-			});
-
-		}
-
-		// CSS Tree Helpers
-
-		selectorsForPage(page) {
-			let nthlist;
-			let nth;
-
-			let selectors = new lib.List();
-
-			selectors.insertData({
-				type: "ClassSelector",
-				name: "pagedjs_page"
-			});
-
-			// Named page
-			if (page.name) {
-				selectors.insertData({
-					type: "ClassSelector",
-					name: "pagedjs_named_page"
-				});
-
-				selectors.insertData({
-					type: "ClassSelector",
-					name: "pagedjs_" + page.name + "_page"
-				});
-			}
-
-			// PsuedoSelector
-			if (page.psuedo && !(page.name && page.psuedo === "first")) {
-				selectors.insertData({
-					type: "ClassSelector",
-					name: "pagedjs_" + page.psuedo + "_page"
-				});
-			}
-
-			if (page.name && page.psuedo === "first") {
-				selectors.insertData({
-					type: "ClassSelector",
-					name: "pagedjs_" + page.name + "_" + page.psuedo + "_page"
-				});
-			}
-
-			// Nth
-			if (page.nth) {
-				nthlist = new lib.List();
-				nth = this.getNth(page.nth);
-
-				nthlist.insertData(nth);
-
-				selectors.insertData({
-					type: "PseudoClassSelector",
-					name: "nth-of-type",
-					children: nthlist
-				});
-			}
-
-			return selectors;
-		}
-
-		selectorsForPageMargin(page, margin) {
-			let selectors = this.selectorsForPage(page);
-
-			selectors.insertData({
-				type: "Combinator",
-				name: " "
-			});
-
-			selectors.insertData({
-				type: "ClassSelector",
-				name: "pagedjs_margin-" + margin
-			});
-
-			return selectors;
-		}
-
-		createDeclaration(property, value, important) {
-			let children = new lib.List();
-
-			children.insertData({
-				type: "Identifier",
-				loc: null,
-				name: value
-			});
-
-			return {
-				type: "Declaration",
-				loc: null,
-				important: important,
-				property: property,
-				value: {
-					type: "Value",
-					loc: null,
-					children: children
-				}
-			};
-		}
-
-		createVariable(property, value) {
-			return {
-				type: "Declaration",
-				loc: null,
-				property: property,
-				value: {
-					type: "Raw",
-					value: value
-				}
-			};
-		}
-
-		createCalculatedDimension(property, items, important, operator="+") {
-			let children = new lib.List();
-			let calculations = new lib.List();
-
-			items.forEach((item, index) => {
-				calculations.appendData({
-					type: "Dimension",
-					unit: item.unit,
-					value: item.value
-				});
-
-				calculations.appendData({
-					type: "WhiteSpace",
-					value: " "
-				});
-
-				if (index + 1 < items.length) {
-					calculations.appendData({
-						type: "Operator",
-						value: operator
-					});
-
-					calculations.appendData({
-						type: "WhiteSpace",
-						value: " "
-					});
-				}
-			});
-
-			children.insertData({
-				type: "Function",
-				loc: null,
-				name: "calc",
-				children: calculations
-			});
-
-			return {
-				type: "Declaration",
-				loc: null,
-				important: important,
-				property: property,
-				value: {
-					type: "Value",
-					loc: null,
-					children: children
-				}
-			};
-		}
-
-		createDimension(property, cssValue, important) {
-			let children = new lib.List();
-
-			children.insertData({
-				type: "Dimension",
-				loc: null,
-				value: cssValue.value,
-				unit: cssValue.unit
-			});
-
-			return {
-				type: "Declaration",
-				loc: null,
-				important: important,
-				property: property,
-				value: {
-					type: "Value",
-					loc: null,
-					children: children
-				}
-			};
-		}
-
-		createBlock(declarations) {
-			let block = new lib.List();
-
-			declarations.forEach((declaration) => {
-				block.insertData(declaration);
-			});
-
-			return {
-				type: "Block",
-				loc: null,
-				children: block
-			};
-		}
-
-		createRule(selectors, block) {
-			let selectorList = new lib.List();
-			selectorList.insertData({
-				type: "Selector",
-				children: selectors
-			});
-
-			if (Array.isArray(block)) {
-				block = this.createBlock(block);
-			}
-
-			return {
-				type: "Rule",
-				prelude: {
-					type: "SelectorList",
-					children: selectorList
-				},
-				block: block
-			};
-		}
-
-	}
-
-	class Breaks extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-
-			this.breaks = {};
-		}
-
-		onDeclaration(declaration, dItem, dList, rule) {
-			let property = declaration.property;
-
-			if (property === "page") {
-				let children = declaration.value.children.first();
-				let value = children.name;
-				let selector = lib.generate(rule.ruleNode.prelude);
-				let name = value;
-
-				let breaker = {
-					property: property,
-					value: value,
-					selector: selector,
-					name: name
-				};
-
-				selector.split(",").forEach((s) => {
-					if (!this.breaks[s]) {
-						this.breaks[s] = [breaker];
-					} else {
-						this.breaks[s].push(breaker);
-					}
-				});
-
-				dList.remove(dItem);
-			}
-
-			if (property === "break-before" ||
-					property === "break-after" ||
-					property === "page-break-before" ||
-					property === "page-break-after"
-			) {
-				let child$$1 = declaration.value.children.first();
-				let value = child$$1.name;
-				let selector = lib.generate(rule.ruleNode.prelude);
-
-				if (property === "page-break-before") {
-					property = "break-before";
-				} else if (property === "page-break-after") {
-					property = "break-after";
-				}
-
-				let breaker = {
-					property: property,
-					value: value,
-					selector: selector
-				};
-
-				selector.split(",").forEach((s) => {
-					if (!this.breaks[s]) {
-						this.breaks[s] = [breaker];
-					} else {
-						this.breaks[s].push(breaker);
-					}
-				});
-
-				// Remove from CSS -- handle right / left in module
-				dList.remove(dItem);
-			}
-		}
-
-		afterParsed(parsed) {
-			this.processBreaks(parsed, this.breaks);
-		}
-
-		processBreaks(parsed, breaks) {
-			for (let b in breaks) {
-				// Find elements
-				let elements = parsed.querySelectorAll(b);
-				// Add break data
-				for (var i = 0; i < elements.length; i++) {
-					for (let prop of breaks[b]) {
-
-						if (prop.property === "break-after") {
-							let nodeAfter$$1 = elementAfter(elements[i], parsed);
-
-							elements[i].setAttribute("data-break-after", prop.value);
-
-							if (nodeAfter$$1) {
-								nodeAfter$$1.setAttribute("data-previous-break-after", prop.value);
-							}
-						} else if (prop.property === "page") {
-							elements[i].setAttribute("data-page", prop.value);
-
-							let nodeAfter$$1 = elementAfter(elements[i], parsed);
-
-							if (nodeAfter$$1) {
-								nodeAfter$$1.setAttribute("data-after-page", prop.value);
-							}
-						} else {
-							elements[i].setAttribute("data-" + prop.property, prop.value);
-						}
-					}
-				}
-			}
-		}
-
-		mergeBreaks(pageBreaks, newBreaks) {
-			for (let b in newBreaks) {
-				if (b in pageBreaks) {
-					pageBreaks[b] = pageBreaks[b].concat(newBreaks[b]);
-				} else {
-					pageBreaks[b] = newBreaks[b];
-				}
-			}
-			return pageBreaks;
-		}
-
-		addBreakAttributes(pageElement, page) {
-			let before = pageElement.querySelector("[data-break-before]");
-			let after = pageElement.querySelector("[data-break-after]");
-			let previousBreakAfter = pageElement.querySelector("[data-previous-break-after]");
-
-			if (before) {
-				if (before.dataset.splitFrom) {
-					page.splitFrom = before.dataset.splitFrom;
-					pageElement.setAttribute("data-split-from", before.dataset.splitFrom);
-				} else if (before.dataset.breakBefore && before.dataset.breakBefore !== "avoid") {
-					page.breakBefore = before.dataset.breakBefore;
-					pageElement.setAttribute("data-break-before", before.dataset.breakBefore);
-				}
-			}
-
-			if (after && after.dataset) {
-				if (after.dataset.splitTo) {
-					page.splitTo = after.dataset.splitTo;
-					pageElement.setAttribute("data-split-to", after.dataset.splitTo);
-				} else if (after.dataset.breakAfter && after.dataset.breakAfter !== "avoid") {
-					page.breakAfter = after.dataset.breakAfter;
-					pageElement.setAttribute("data-break-after", after.dataset.breakAfter);
-				}
-			}
-
-			if (previousBreakAfter && previousBreakAfter.dataset) {
-				if (previousBreakAfter.dataset.previousBreakAfter && previousBreakAfter.dataset.previousBreakAfter !== "avoid") {
-					page.previousBreakAfter = previousBreakAfter.dataset.previousBreakAfter;
-				}
-			}
-		}
-
-		afterPageLayout(pageElement, page) {
-			this.addBreakAttributes(pageElement, page);
-		}
-	}
-
-	class PrintMedia extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-		}
-
-		onAtMedia(node, item, list) {
-			let media = this.getMediaName(node);
-			let rules;
-
-			if (media === "print") {
-				rules = node.block.children;
-
-				// Remove rules from the @media block
-				node.block.children = new lib.List();
-
-				// Append rules to the end of main rules list
-				list.appendList(rules);
-			}
-
-		}
-
-		getMediaName(node) {
-			let media = "";
-
-			if (typeof node.prelude === "undefined" ||
-					node.prelude.type !== "AtrulePrelude" ) {
-				return;
-			}
-
-			lib.walk(node.prelude, {
-				visit: "Identifier",
-				enter: (identNode, iItem, iList) => {
-					media = identNode.name;
-				}
-			});
-			return media;
-		}
-
-
-	}
-
-	class Splits extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-		}
-
-		afterPageLayout(pageElement, page, breakToken, chunker) {
-			let splits = Array.from(pageElement.querySelectorAll("[data-split-from]"));
-			let pages = pageElement.parentNode;
-			let index = Array.prototype.indexOf.call(pages.children, pageElement);
-			let prevPage;
-
-			if (index === 0) {
-				return;
-			}
-
-			prevPage = pages.children[index - 1];
-
-			splits.forEach((split) => {
-				let ref = split.dataset.ref;
-				let from = prevPage.querySelector("[data-ref='"+ ref +"']:not([data-split-to])");
-
-				if (from) {
-					from.dataset.splitTo = ref;
-
-					if (!from.dataset.splitFrom) {
-						from.dataset.splitOriginal = true;
-					}
-
-					this.handleAlignment(from);
-				}
-			});
-		}
-
-		handleAlignment(node) {
-			let styles = window.getComputedStyle(node);
-			let align = styles["text-align"];
-			let alignLast = styles["text-align-last"];
-			if (align === "justify" && alignLast === "auto") {
-				node.style["text-align-last"] = "justify";
-			}
-		}
-
-	}
-
-	class Counters extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-
-			this.styleSheet = polisher.styleSheet;
-			this.counters = {};
-		}
-
-		onDeclaration(declaration, dItem, dList, rule) {
-			let property = declaration.property;
-
-			if (property === "counter-increment") {
-				let inc = this.handleIncrement(declaration, rule);
-				if (inc) {
-					dList.remove(dItem);
-				}
-			} else if (property === "counter-reset") {
-				let reset = this.handleReset(declaration, rule);
-				if (reset) {
-					dList.remove(dItem);
-				}
-			}
-		}
-
-		onContent(funcNode, fItem, fList, declaration, rule) {
-			if (funcNode.name === "counter") ;
-		}
-
-		afterParsed(parsed) {
-			this.processCounters(parsed, this.counters);
-		}
-
-		addCounter(name) {
-			if (name in this.counters) {
-				return this.counters[name];
-			}
-
-			this.counters[name] = {
-				name: name,
-				increments: {},
-				resets: {}
-			};
-
-			return this.counters[name];
-		}
-
-		handleIncrement(declaration, rule) {
-			let identifier = declaration.value.children.first();
-			let number = declaration.value.children.getSize() > 1
-								&& declaration.value.children.last().value;
-			let name = identifier && identifier.name;
-
-			if (name === "page" || name.indexOf("target-counter-") === 0) {
-				return;
-			}
-
-			let selector = lib.generate(rule.ruleNode.prelude);
-
-			let counter;
-			if (!(name in this.counters)) {
-				counter = this.addCounter(name);
-			} else {
-				counter = this.counters[name];
-			}
-
-			return counter.increments[selector] = {
-				selector: selector,
-				number: number || 1
-			};
-		}
-
-		handleReset(declaration, rule) {
-			let identifier = declaration.value.children.first();
-			let number = declaration.value.children.getSize() > 1
-								&& declaration.value.children.last().value;
-			let name = identifier && identifier.name;
-			let selector = lib.generate(rule.ruleNode.prelude);
-			let counter;
-
-			if (!(name in this.counters)) {
-				counter = this.addCounter(name);
-			} else {
-				counter = this.counters[name];
-			}
-
-			return counter.resets[selector] = {
-				selector: selector,
-				number: number || 0
-			};
-		}
-
-		processCounters(parsed, counters) {
-			let counter;
-			for (let c in counters) {
-				counter = this.counters[c];
-				this.processCounterIncrements(parsed, counter);
-				this.processCounterResets(parsed, counter);
-				this.addCounterValues(parsed, counter);
-			}
-		}
-
-		processCounterIncrements(parsed, counter) {
-			let increment;
-			for (let inc in counter.increments) {
-				increment = counter.increments[inc];
-				// Find elements for increments
-				let incrementElements = parsed.querySelectorAll(increment.selector);
-				// Add counter data
-				for (var i = 0; i < incrementElements.length; i++) {
-					incrementElements[i].setAttribute("data-counter-"+ counter.name +"-increment", increment.number);
-				}
-			}
-		}
-
-		processCounterResets(parsed, counter) {
-			let reset;
-			for (let r in counter.resets) {
-				reset = counter.resets[r];
-				// Find elements for resets
-				let resetElements = parsed.querySelectorAll(reset.selector);
-				// Add counter data
-				for (var i = 0; i < resetElements.length; i++) {
-					resetElements[i].setAttribute("data-counter-"+ counter.name +"-reset", reset.number);
-				}
-			}
-		}
-
-		addCounterValues(parsed, counter) {
-			let counterName = counter.name;
-			let elements = parsed.querySelectorAll("[data-counter-"+ counterName +"-reset], [data-counter-"+ counterName +"-increment]");
-
-			let count = 0;
-			let element;
-			let increment, reset;
-
-			for (var i = 0; i < elements.length; i++) {
-				element = elements[i];
-
-				if (element.hasAttribute("data-counter-"+ counterName +"-reset")) {
-					reset = element.getAttribute("data-counter-"+ counterName +"-reset");
-					count = parseInt(reset);
-				}
-
-				if (element.hasAttribute("data-counter-"+ counterName +"-increment")) {
-
-					increment = element.getAttribute("data-counter-"+ counterName +"-increment");
-
-					this.styleSheet.insertRule(`[data-ref="${element.dataset.ref}"] { counter-reset: ${counterName} ${count} }`, this.styleSheet.cssRules.length);
-					this.styleSheet.insertRule(`[data-ref="${element.dataset.ref}"] { counter-increment: ${counterName} ${increment}}`, this.styleSheet.cssRules.length);
-
-					count += parseInt(increment);
-
-					element.setAttribute("data-counter-"+counterName+"-value", count);
-				}
-
-			}
-		}
-
-		afterPageLayout(pageElement, page) {
-			let pgreset = pageElement.querySelectorAll("[data-counter-page-reset]");
-			pgreset.forEach((reset) => {
-				let value = reset.datasetCounterPageReset;
-				this.styleSheet.insertRule(`[data-page-number="${pageElement.dataset.pageNumber}"] { counter-reset: page ${value} }`, this.styleSheet.cssRules.length);
-			});
-		}
-
-	}
-
-	class Lists extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-		}
-		afterParsed(content) {
-			const orderedLists = content.querySelectorAll("ol");
-
-			for (var list of orderedLists) {
-				this.addDataNumbers(list);
-			}
-		}
-
-		afterPageLayout(pageElement, page, breakToken, chunker) {
-			var orderedLists = pageElement.getElementsByTagName("ol");
-			for (var list of orderedLists) {
-				if (list.hasChildNodes()) {
-				list.start = list.firstElementChild.dataset.itemNum;
-				}
-				else {
-					list.parentNode.removeChild(list);
-				}
-			}
-		}
-
-		addDataNumbers(list) {
-			let items = list.children;
-			for (var i = 0; i < items.length; i++) {
-				items[i].setAttribute("data-item-num", i + 1);
-			}
-		}
-
-	}
-
-	var pagedMediaHandlers = [
-		AtPage,
-		Breaks,
-		PrintMedia,
-		Splits,
-		Counters,
-		Lists
-	];
-
-	class RunningHeaders extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-
-			this.runningSelectors = {};
-			this.elements = {};
-		}
-
-		onDeclaration(declaration, dItem, dList, rule) {
-			if (declaration.property === "position") {
-				let selector = lib.generate(rule.ruleNode.prelude);
-				let identifier = declaration.value.children.first().name;
-
-				if (identifier === "running") {
-					let value;
-					lib.walk(declaration, {
-						visit: "Function",
-						enter: (node, item, list) => {
-							value = node.children.first().name;
-						}
-					});
-
-					this.runningSelectors[value] = {
-						identifier: identifier,
-						value: value,
-						selector: selector
-					};
-				}
-			}
-
-			if (declaration.property === "content") {
-
-				lib.walk(declaration, {
-					visit: "Function",
-					enter: (funcNode, fItem, fList) => {
-
-						if (funcNode.name.indexOf("element") > -1) {
-
-							let selector = lib.generate(rule.ruleNode.prelude);
-
-							let func = funcNode.name;
-
-							let value = funcNode.children.first().name;
-
-							let args = [value];
-
-							// we only handle first for now
-							let style = "first";
-
-							selector.split(",").forEach((s) => {
-								// remove before / after
-								s = s.replace(/::after|::before/, "");
-
-								this.elements[s] = {
-									func: func,
-									args: args,
-									value: value,
-									style: style,
-									selector: s,
-									fullSelector: selector
-								};
-							});
-						}
-
-					}
-				});
-			}
-		}
-
-		afterParsed(fragment) {
-			for (let name of Object.keys(this.runningSelectors)) {
-				let set = this.runningSelectors[name];
-				let selected = Array.from(fragment.querySelectorAll(set.selector));
-
-				if (set.identifier === "running") {
-					for (let header of selected) {
-						header.style.display = "none";
-					}
-				}
-
-			}
-		}
-
-		afterPageLayout(fragment) {
-			for (let name of Object.keys(this.runningSelectors)) {
-				let set = this.runningSelectors[name];
-				let selected = fragment.querySelector(set.selector);
-				if (selected) {
-					// let cssVar;
-					if (set.identifier === "running") {
-						// cssVar = selected.textContent.replace(/\\([\s\S])|(["|'])/g,"\\$1$2");
-						// this.styleSheet.insertRule(`:root { --string-${name}: "${cssVar}"; }`, this.styleSheet.cssRules.length);
-						// fragment.style.setProperty(`--string-${name}`, `"${cssVar}"`);
-						set.first = selected;
-					} else {
-						console.warn(set.value + "needs css replacement");
-					}
-				}
-			}
-
-			// move elements
-			if (!this.orderedSelectors) {
-				this.orderedSelectors = this.orderSelectors(this.elements);
-			}
-
-			for (let selector of this.orderedSelectors) {
-				if (selector) {
-
-					let el = this.elements[selector];
-					let selected = fragment.querySelector(selector);
-					if (selected) {
-						let running = this.runningSelectors[el.args[0]];
-						if (running && running.first) {
-							selected.innerHTML = ""; // Clear node
-							// selected.classList.add("pagedjs_clear-after"); // Clear ::after
-							let clone = running.first.cloneNode(true);
-							clone.style.display = null;
-							selected.appendChild(clone);
-						}
-					}
-				}
-			}
-		}
-
-		/**
-		* Assign a weight to @page selector classes
-		* 1) page
-		* 2) left & right
-		* 3) blank
-		* 4) first & nth
-		* 5) named page
-		* 6) named left & right
-		* 7) named first & nth
-		* @param {string} [s] selector string
-		* @return {int} weight
-		*/
-		pageWeight(s) {
-			let weight = 1;
-			let selector = s.split(" ");
-			let parts = selector.length && selector[0].split(".");
-
-			parts.shift(); // remove empty first part
-
-			switch (parts.length) {
-				case 4:
-					if (parts[3] === "pagedjs_first_page") {
-						weight = 7;
-					} else if (parts[3] === "pagedjs_left_page" || parts[3] === "pagedjs_right_page") {
-						weight = 6;
-					}
-					break;
-				case 3:
-					if (parts[1] === "pagedjs_named_page") {
-						if (parts[2].indexOf(":nth-of-type") > -1) {
-							weight = 7;
-						} else {
-							weight = 5;
-						}
-					}
-					break;
-				case 2:
-					if (parts[1] === "pagedjs_first_page") {
-						weight = 4;
-					} else if (parts[1] === "pagedjs_blank_page") {
-						weight = 3;
-					} else if (parts[1] === "pagedjs_left_page" || parts[1] === "pagedjs_right_page") {
-						weight = 2;
-					}
-					break;
-				default:
-					if (parts[0].indexOf(":nth-of-type") > -1) {
-						weight = 4;
-					} else {
-						weight = 1;
-					}
-			}
-
-			return weight;
-		}
-
-		/**
-		* Orders the selectors based on weight
-		*
-		* Does not try to deduplicate base on specifity of the selector
-		* Previous matched selector will just be overwritten
-		* @param {obj} [obj] selectors object
-		* @return {Array} orderedSelectors
-		*/
-		orderSelectors(obj) {
-			let selectors = Object.keys(obj);
-			let weighted = {
-				1: [],
-				2: [],
-				3: [],
-				4: [],
-				5: [],
-				6: [],
-				7: []
-			};
-
-			let orderedSelectors = [];
-
-			for (let s of selectors) {
-				let w = this.pageWeight(s);
-				weighted[w].unshift(s);
-			}
-
-			for (var i = 1; i <= 7; i++) {
-				orderedSelectors = orderedSelectors.concat(weighted[i]);
-			}
-
-			return orderedSelectors;
-		}
-
-		beforeTreeParse(text, sheet) {
-			// element(x) is parsed as image element selector, so update element to element-ident
-			sheet.text = text.replace(/element[\s]*\(([^|^#)]*)\)/g, "element-ident($1)");
-		}
-	}
-
-	class StringSets extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-
-			this.stringSetSelectors = {};
-		}
-
-		onDeclaration(declaration, dItem, dList, rule) {
-			if (declaration.property === "string-set") {
-				let selector = lib.generate(rule.ruleNode.prelude);
-
-				let identifier = declaration.value.children.first().name;
-
-				let value;
-				lib.walk(declaration, {
-					visit: "Function",
-					enter: (node, item, list) => {
-						value = lib.generate(node);
-					}
-				});
-
-				this.stringSetSelectors[identifier] = {
-					identifier: identifier,
-					value: value,
-					selector: selector
-				};
-			}
-		}
-
-		onContent(funcNode, fItem, fList, declaration, rule) {
-			if (funcNode.name === "string") {
-				let identifier = funcNode.children && funcNode.children.first().name;
-				funcNode.name = "var";
-				funcNode.children = new lib.List();
-
-				funcNode.children.append(funcNode.children.createItem({
-					type: "Identifier",
-					loc: null,
-					name: "--pagedjs-string-" + identifier
-				}));
-			}
-		}
-
-		afterPageLayout(fragment) {
-			for (let name of Object.keys(this.stringSetSelectors)) {
-				let set = this.stringSetSelectors[name];
-				let selected = fragment.querySelector(set.selector);
-				if (selected) {
-					let cssVar;
-					if (set.value === "content" || set.value === "content()" || set.value === "content(text)") {
-						cssVar = selected.textContent.replace(/\\([\s\S])|(["|'])/g,"\\$1$2");
-						// this.styleSheet.insertRule(`:root { --pagedjs-string-${name}: "${cssVar}"; }`, this.styleSheet.cssRules.length);
-						// fragment.style.setProperty(`--pagedjs-string-${name}`, `"${cssVar}"`);
-						set.first = cssVar;
-						fragment.style.setProperty(`--pagedjs-string-${name}`, `"${set.first}"`);
-					} else {
-						console.warn(set.value + "needs css replacement");
-					}
-				} else {
-					// Use the previous values
-					if (set.first) {
-						fragment.style.setProperty(`--pagedjs-string-${name}`, `"${set.first}"`);
-					}
-				}
-			}
-		}
-	}
-
-	class TargetCounters extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-
-			this.styleSheet = polisher.styleSheet;
-
-			this.counterTargets = {};
-		}
-
-		onContent(funcNode, fItem, fList, declaration, rule) {
-			if (funcNode.name === "target-counter") {
-				let selector = lib.generate(rule.ruleNode.prelude);
-				let first = funcNode.children.first();
-				let func = first.name;
-
-				let value = lib.generate(funcNode);
-
-				let args = [];
-
-				first.children.forEach((child) => {
-					if (child.type === "Identifier") {
-						args.push(child.name);
-					}
-				});
-
-				let counter;
-				let style;
-				let styleIdentifier;
-
-				funcNode.children.forEach((child) => {
-					if (child.type === "Identifier") {
-						if (!counter) {
-							counter = child.name;
-						} else if (!style) {
-							styleIdentifier = lib.clone(child);
-							style = child.name;
-						}
-					}
-				});
-
-				let variable = "target-counter-" + UUID();
-
-				selector.split(",").forEach((s) => {
-					this.counterTargets[s] = {
-						func: func,
-						args: args,
-						value: value,
-						counter: counter,
-						style: style,
-						selector: s,
-						fullSelector: selector,
-						variable: variable
-					};
-				});
-
-				// Replace with counter
-				funcNode.name = "counter";
-				funcNode.children = new lib.List();
-				funcNode.children.appendData({
-					type: "Identifier",
-					loc: 0,
-					name: variable
-				});
-				if (styleIdentifier) {
-					funcNode.children.appendData({type: "Operator", loc: null, value: ","});
-					funcNode.children.appendData(styleIdentifier);
-				}
-			}
-		}
-
-		afterPageLayout(fragment, page, breakToken, chunker) {
-			Object.keys(this.counterTargets).forEach((name) => {
-				let target = this.counterTargets[name];
-				let split = target.selector.split("::");
-				let query = split[0];
-
-				let queried = chunker.pagesArea.querySelectorAll(query + ":not([data-" + target.variable + "])");
-
-				queried.forEach((selected, index) => {
-					// TODO: handle func other than attr
-					if (target.func !== "attr") {
-						return;
-					}
-					let val = attr(selected, target.args);
-					let element = chunker.pagesArea.querySelector(querySelectorEscape(val));
-
-					if (element) {
-						let selector = UUID();
-						selected.setAttribute("data-" + target.variable, selector);
-						// TODO: handle other counter types (by query)
-						if (target.counter === "page") {
-							let pages = chunker.pagesArea.querySelectorAll(".pagedjs_page");
-							let pg = 0;
-							for (var i = 0; i < pages.length; i++) {
-								let styles = window.getComputedStyle(pages[i]);
-								let reset = styles["counter-reset"].replace("page", "").trim();
-
-								if (reset !== "none") {
-									pg = parseInt(reset);
-								}
-								pg += 1;
-
-								if (pages[i].contains( element )){
-									break;
-								}
-							}
-
-							let psuedo = "";
-							if (split.length > 1) {
-								psuedo += "::" + split[1];
-							}
-							this.styleSheet.insertRule(`[data-${target.variable}="${selector}"]${psuedo} { counter-reset: ${target.variable} ${pg}; }`, this.styleSheet.cssRules.length);
-						} else {
-							let value = element.getAttribute(`data-counter-${target.counter}-value`);
-							if (value) {
-								this.styleSheet.insertRule(`[data-${target.variable}="${selector}"]${psuedo} { counter-reset: ${target.variable} ${target.variable} ${parseInt(value)}; }`, this.styleSheet.cssRules.length);
-							}
-						}
-					}
-				});
-			});
-		}
-	}
-
-	class TargetText extends Handler {
-		constructor(chunker, polisher, caller) {
-			super(chunker, polisher, caller);
-
-			this.styleSheet = polisher.styleSheet;
-			this.textTargets = {};
-		}
-
-		onContent(funcNode, fItem, fList, declaration, rule) {
-			if (funcNode.name === "target-text") {
-				let selector = lib.generate(rule.ruleNode.prelude);
-				let first = funcNode.children.first();
-				let last = funcNode.children.last();
-				let func = first.name;
-
-				let value = lib.generate(funcNode);
-
-				let args = [];
-
-				first.children.forEach((child) => {
-					if (child.type === "Identifier") {
-						args.push(child.name);
-					}
-				});
-
-				let style;
-				if (last !== first) {
-					style = last.name;
-				}
-
-				let variable = "--pagedjs-" + UUID();
-
-				selector.split(",").forEach((s) => {
-					this.textTargets[s] = {
-						func: func,
-						args: args,
-						value: value,
-						style: style || "content",
-						selector: s,
-						fullSelector: selector,
-						variable: variable
-					};
-				});
-
-				// Replace with variable
-				funcNode.name = "var";
-				funcNode.children = new lib.List();
-				funcNode.children.appendData({
-					type: "Identifier",
-					loc: 0,
-					name: variable
-				});
-			}
-		}
-
-		afterParsed(fragment) {
-			Object.keys(this.textTargets).forEach((name) => {
-				let target = this.textTargets[name];
-				let split = target.selector.split("::");
-				let query = split[0];
-				let queried = fragment.querySelectorAll(query);
-				queried.forEach((selected, index) => {
-					let val = attr(selected, target.args);
-					let element = fragment.querySelector(querySelectorEscape(val));
-					if (element) {
-						if (target.style === "content") {
-							let selector = UUID();
-							selected.setAttribute("data-target-text", selector);
-
-							let psuedo = "";
-							if (split.length > 1) {
-								psuedo += "::" + split[1];
-							}
-
-							let textContent = element.textContent.trim().replace(/["']/g, (match) => {
-								return "\\" + match;
-							}).replace(/[\n]/g, (match) => {
-								return "\\00000A";
-							});
-
-							// this.styleSheet.insertRule(`[data-target-text="${selector}"]${psuedo} { content: "${element.textContent}" }`, this.styleSheet.cssRules.length);
-							this.styleSheet.insertRule(`[data-target-text="${selector}"]${psuedo} { ${target.variable}: "${textContent}" }`, this.styleSheet.cssRules.length);
-
-						}
-					} else {
-						console.warn("missed target", val);
-					}
-				});
-
-			});
-		}
-	}
-
-	var generatedContentHandlers = [
-		RunningHeaders,
-		StringSets,
-		TargetCounters,
-		TargetText
-	];
-
-	var isImplemented$3 = function () {
-		var from = Array.from, arr, result;
-		if (typeof from !== "function") return false;
-		arr = ["raz", "dwa"];
-		result = from(arr);
-		return Boolean(result && (result !== arr) && (result[1] === "dwa"));
-	};
-
-	var validTypes = { object: true, symbol: true };
-
-	var isImplemented$4 = function () {
-		if (typeof Symbol !== 'function') return false;
-		try { } catch (e) { return false; }
-
-		// Return 'true' also for polyfills
-		if (!validTypes[typeof Symbol.iterator]) return false;
-		if (!validTypes[typeof Symbol.toPrimitive]) return false;
-		if (!validTypes[typeof Symbol.toStringTag]) return false;
-
-		return true;
-	};
-
-	var isSymbol = function (x) {
-		if (!x) return false;
-		if (typeof x === 'symbol') return true;
-		if (!x.constructor) return false;
-		if (x.constructor.name !== 'Symbol') return false;
-		return (x[x.constructor.toStringTag] === 'Symbol');
-	};
-
-	var validateSymbol = function (value) {
-		if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
-		return value;
-	};
-
-	var create$6 = Object.create, defineProperties = Object.defineProperties
-	  , defineProperty = Object.defineProperty, objPrototype = Object.prototype
-	  , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create$6(null)
-	  , isNativeSafe;
-
-	if (typeof Symbol === 'function') {
-		NativeSymbol = Symbol;
-		try {
-			String(NativeSymbol());
-			isNativeSafe = true;
-		} catch (ignore) {}
-	}
-
-	var generateName = (function () {
-		var created = create$6(null);
-		return function (desc) {
-			var postfix = 0, name, ie11BugWorkaround;
-			while (created[desc + (postfix || '')]) ++postfix;
-			desc += (postfix || '');
-			created[desc] = true;
-			name = '@@' + desc;
-			defineProperty(objPrototype, name, d_1.gs(null, function (value) {
-				// For IE11 issue see:
-				// https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
-				//    ie11-broken-getters-on-dom-objects
-				// https://github.com/medikoo/es6-symbol/issues/12
-				if (ie11BugWorkaround) return;
-				ie11BugWorkaround = true;
-				defineProperty(this, name, d_1(value));
-				ie11BugWorkaround = false;
-			}));
-			return name;
-		};
-	}());
-
-	// Internal constructor (not one exposed) for creating Symbol instances.
-	// This one is used to ensure that `someSymbol instanceof Symbol` always return false
-	HiddenSymbol = function Symbol(description) {
-		if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
-		return SymbolPolyfill(description);
-	};
-
-	// Exposed `Symbol` constructor
-	// (returns instances of HiddenSymbol)
-	var polyfill = SymbolPolyfill = function Symbol(description) {
-		var symbol;
-		if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
-		if (isNativeSafe) return NativeSymbol(description);
-		symbol = create$6(HiddenSymbol.prototype);
-		description = (description === undefined ? '' : String(description));
-		return defineProperties(symbol, {
-			__description__: d_1('', description),
-			__name__: d_1('', generateName(description))
-		});
-	};
-	defineProperties(SymbolPolyfill, {
-		for: d_1(function (key) {
-			if (globalSymbols[key]) return globalSymbols[key];
-			return (globalSymbols[key] = SymbolPolyfill(String(key)));
-		}),
-		keyFor: d_1(function (s) {
-			var key;
-			validateSymbol(s);
-			for (key in globalSymbols) if (globalSymbols[key] === s) return key;
-		}),
-
-		// To ensure proper interoperability with other native functions (e.g. Array.from)
-		// fallback to eventual native implementation of given symbol
-		hasInstance: d_1('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
-		isConcatSpreadable: d_1('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
-			SymbolPolyfill('isConcatSpreadable')),
-		iterator: d_1('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
-		match: d_1('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
-		replace: d_1('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
-		search: d_1('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
-		species: d_1('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
-		split: d_1('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
-		toPrimitive: d_1('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
-		toStringTag: d_1('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
-		unscopables: d_1('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
-	});
-
-	// Internal tweaks for real symbol producer
-	defineProperties(HiddenSymbol.prototype, {
-		constructor: d_1(SymbolPolyfill),
-		toString: d_1('', function () { return this.__name__; })
-	});
-
-	// Proper implementation of methods exposed on Symbol.prototype
-	// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
-	defineProperties(SymbolPolyfill.prototype, {
-		toString: d_1(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
-		valueOf: d_1(function () { return validateSymbol(this); })
-	});
-	defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d_1('', function () {
-		var symbol = validateSymbol(this);
-		if (typeof symbol === 'symbol') return symbol;
-		return symbol.toString();
-	}));
-	defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d_1('c', 'Symbol'));
-
-	// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
-	defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
-		d_1('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
-
-	// Note: It's important to define `toPrimitive` as last one, as some implementations
-	// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
-	// And that may invoke error in definition flow:
-	// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
-	defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
-		d_1('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
-
-	var es6Symbol = isImplemented$4() ? Symbol : polyfill;
-
-	var objToString = Object.prototype.toString
-	  , id = objToString.call(
-		(function () {
-			return arguments;
-		})()
-	);
-
-	var isArguments = function (value) {
-		return objToString.call(value) === id;
-	};
-
-	var objToString$1 = Object.prototype.toString, id$1 = objToString$1.call(noop);
-
-	var isFunction = function (value) {
-		return typeof value === "function" && objToString$1.call(value) === id$1;
-	};
-
-	var isImplemented$5 = function () {
-		var sign = Math.sign;
-		if (typeof sign !== "function") return false;
-		return (sign(10) === 1) && (sign(-20) === -1);
-	};
-
-	var shim$3 = function (value) {
-		value = Number(value);
-		if (isNaN(value) || (value === 0)) return value;
-		return value > 0 ? 1 : -1;
-	};
-
-	var sign = isImplemented$5()
-		? Math.sign
-		: shim$3;
-
-	var abs = Math.abs, floor = Math.floor;
-
-	var toInteger = function (value) {
-		if (isNaN(value)) return 0;
-		value = Number(value);
-		if ((value === 0) || !isFinite(value)) return value;
-		return sign(value) * floor(abs(value));
-	};
-
-	var max$1 = Math.max;
-
-	var toPosInteger = function (value) {
-	 return max$1(0, toInteger(value));
-	};
-
-	var objToString$2 = Object.prototype.toString, id$2 = objToString$2.call("");
-
-	var isString = function (value) {
-		return (
-			typeof value === "string" ||
-			(value &&
-				typeof value === "object" &&
-				(value instanceof String || objToString$2.call(value) === id$2)) ||
-			false
-		);
-	};
-
-	var iteratorSymbol = es6Symbol.iterator
-	  , isArray        = Array.isArray
-	  , call           = Function.prototype.call
-	  , desc           = { configurable: true, enumerable: true, writable: true, value: null }
-	  , defineProperty$1 = Object.defineProperty;
-
-	// eslint-disable-next-line complexity
-	var shim$4 = function (arrayLike /*, mapFn, thisArg*/) {
-		var mapFn = arguments[1]
-		  , thisArg = arguments[2]
-		  , Context
-		  , i
-		  , j
-		  , arr
-		  , length
-		  , code
-		  , iterator
-		  , result
-		  , getIterator
-		  , value;
-
-		arrayLike = Object(validValue(arrayLike));
-
-		if (isValue(mapFn)) validCallable(mapFn);
-		if (!this || this === Array || !isFunction(this)) {
-			// Result: Plain array
-			if (!mapFn) {
-				if (isArguments(arrayLike)) {
-					// Source: Arguments
-					length = arrayLike.length;
-					if (length !== 1) return Array.apply(null, arrayLike);
-					arr = new Array(1);
-					arr[0] = arrayLike[0];
-					return arr;
-				}
-				if (isArray(arrayLike)) {
-					// Source: Array
-					arr = new Array(length = arrayLike.length);
-					for (i = 0; i < length; ++i) arr[i] = arrayLike[i];
-					return arr;
-				}
-			}
-			arr = [];
-		} else {
-			// Result: Non plain array
-			Context = this;
-		}
-
-		if (!isArray(arrayLike)) {
-			if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
-				// Source: Iterator
-				iterator = validCallable(getIterator).call(arrayLike);
-				if (Context) arr = new Context();
-				result = iterator.next();
-				i = 0;
-				while (!result.done) {
-					value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
-					if (Context) {
-						desc.value = value;
-						defineProperty$1(arr, i, desc);
-					} else {
-						arr[i] = value;
-					}
-					result = iterator.next();
-					++i;
-				}
-				length = i;
-			} else if (isString(arrayLike)) {
-				// Source: String
-				length = arrayLike.length;
-				if (Context) arr = new Context();
-				for (i = 0, j = 0; i < length; ++i) {
-					value = arrayLike[i];
-					if (i + 1 < length) {
-						code = value.charCodeAt(0);
-						// eslint-disable-next-line max-depth
-						if (code >= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
-					}
-					value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
-					if (Context) {
-						desc.value = value;
-						defineProperty$1(arr, j, desc);
-					} else {
-						arr[j] = value;
-					}
-					++j;
-				}
-				length = j;
-			}
-		}
-		if (length === undefined) {
-			// Source: array or array-like
-			length = toPosInteger(arrayLike.length);
-			if (Context) arr = new Context(length);
-			for (i = 0; i < length; ++i) {
-				value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
-				if (Context) {
-					desc.value = value;
-					defineProperty$1(arr, i, desc);
-				} else {
-					arr[i] = value;
-				}
-			}
-		}
-		if (Context) {
-			desc.value = null;
-			arr.length = length;
-		}
-		return arr;
-	};
-
-	var from_1 = isImplemented$3()
-		? Array.from
-		: shim$4;
-
-	var isImplemented$6 = function () {
-		var numberIsNaN = Number.isNaN;
-		if (typeof numberIsNaN !== "function") return false;
-		return !numberIsNaN({}) && numberIsNaN(NaN) && !numberIsNaN(34);
-	};
-
-	var shim$5 = function (value) {
-		// eslint-disable-next-line no-self-compare
-		return value !== value;
-	};
-
-	var isNan = isImplemented$6()
-		? Number.isNaN
-		: shim$5;
-
-	var indexOf$2           = Array.prototype.indexOf
-	  , objHasOwnProperty = Object.prototype.hasOwnProperty
-	  , abs$1               = Math.abs
-	  , floor$1             = Math.floor;
-
-	var eIndexOf = function (searchElement /*, fromIndex*/) {
-		var i, length, fromIndex, val;
-		if (!isNan(searchElement)) return indexOf$2.apply(this, arguments);
-
-		length = toPosInteger(validValue(this).length);
-		fromIndex = arguments[1];
-		if (isNaN(fromIndex)) fromIndex = 0;
-		else if (fromIndex >= 0) fromIndex = floor$1(fromIndex);
-		else fromIndex = toPosInteger(this.length) - floor$1(abs$1(fromIndex));
-
-		for (i = fromIndex; i < length; ++i) {
-			if (objHasOwnProperty.call(this, i)) {
-				val = this[i];
-				if (isNan(val)) return i; // Jslint: ignore
-			}
-		}
-		return -1;
-	};
-
-	var forEach$1 = Array.prototype.forEach
-	  , splice  = Array.prototype.splice;
-
-	// eslint-disable-next-line no-unused-vars
-	var remove = function (itemToRemove /*, …item*/) {
-		forEach$1.call(
-			arguments,
-			function (item) {
-				var index = eIndexOf.call(this, item);
-				if (index !== -1) splice.call(this, index, 1);
-			},
-			this
-		);
-	};
-
-	var map = { function: true, object: true };
-
-	var isObject$1 = function (value) {
-		return (isValue(value) && map[typeof value]) || false;
-	};
-
-	var validObject = function (value) {
-		if (!isObject$1(value)) throw new TypeError(value + " is not an Object");
-		return value;
-	};
-
-	var emit           = eventEmitter.methods.emit
-
-	  , defineProperty$2 = Object.defineProperty
-	  , hasOwnProperty$6 = Object.prototype.hasOwnProperty
-	  , getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-
-	var pipe = function (e1, e2/*, name*/) {
-		var pipes, pipe, desc, name;
-
-		(validObject(e1) && validObject(e2));
-		name = arguments[2];
-		if (name === undefined) name = 'emit';
-
-		pipe = {
-			close: function () { remove.call(pipes, e2); }
-		};
-		if (hasOwnProperty$6.call(e1, '__eePipes__')) {
-			(pipes = e1.__eePipes__).push(e2);
-			return pipe;
-		}
-		defineProperty$2(e1, '__eePipes__', d_1('c', pipes = [e2]));
-		desc = getOwnPropertyDescriptor(e1, name);
-		if (!desc) {
-			desc = d_1('c', undefined);
-		} else {
-			delete desc.get;
-			delete desc.set;
-		}
-		desc.value = function () {
-			var i, emitter, data = from_1(pipes);
-			emit.apply(this, arguments);
-			for (i = 0; (emitter = data[i]); ++i) emit.apply(emitter, arguments);
-		};
-		defineProperty$2(e1, name, desc);
-		return pipe;
-	};
-
-	let registeredHandlers = [...pagedMediaHandlers, ...generatedContentHandlers];
-
-	class Handlers {
-		constructor(chunker, polisher, caller) {
-
-			registeredHandlers.forEach((Handler) => {
-				let handler = new Handler(chunker, polisher, caller);
-				pipe(handler, this);
-			});
-		}
-	}
-
-	eventEmitter(Handlers.prototype);
-
-	function registerHandlers() {
-		for (var i = 0; i < arguments.length; i++) {
-			registeredHandlers.push(arguments[i]);
-		}
-	}
-
-	function initializeHandlers(chunker, polisher, caller) {
-		let handlers = new Handlers(chunker, polisher, caller);
-		return handlers;
-	}
-
-	class Previewer {
-		constructor() {
-			// this.preview = this.getParams("preview") !== "false";
-
-			// Process styles
-			this.polisher = new Polisher(false);
-
-			// Chunk contents
-			this.chunker = new Chunker();
-
-			// Hooks
-			this.hooks = {};
-
-			// default size
-			this.size = {
-				width: {
-					value: 8.5,
-					unit: "in"
-				},
-				height: {
-					value: 11,
-					unit: "in"
-				},
-				format: undefined,
-				orientation: undefined
-			};
-
-			let counter = 0;
-			this.chunker.on("page", (page) => {
-				counter += 1;
-				this.emit("page", page);
-				if (typeof window.PuppeteerLogger !== "undefined") {
-					window.PuppeteerLogger("page", counter);
-				}
-			});
-
-			this.chunker.on("rendering", () => {
-				this.emit("rendering", this.chunker);
-			});
-		}
-
-		initializeHandlers() {
-			let handlers = initializeHandlers(this.chunker, this.polisher, this);
-
-			handlers.on("size", (size) => {
-				this.size = size;
-				this.emit("size", size);
-			});
-
-			return handlers;
-		}
-
-		registerHandlers() {
-			return registerHandlers.apply(registerHandlers, arguments);
-		}
-
-		getParams(name) {
-			let param;
-			let url = new URL(window.location);
-			let params = new URLSearchParams(url.search);
-			for(var pair of params.entries()) {
-				if(pair[0] === name) {
-					param = pair[1];
-				}
-			}
-
-			return param;
-		}
-
-		wrapContent() {
-			// Wrap body in template tag
-			let body = document.querySelector("body");
-
-			// Check if a template exists
-			let template;
-			template = body.querySelector(":scope > template[data-ref='pagedjs-content']");
-
-			if (!template) {
-				// Otherwise create one
-				template = document.createElement("template");
-				template.dataset.ref = "pagedjs-content";
-				template.innerHTML = body.innerHTML;
-				body.innerHTML = "";
-				body.appendChild(template);
-			}
-
-			return template.content;
-		}
-
-		removeStyles(doc=document) {
-			// Get all stylesheets
-			let stylesheets = Array.from(doc.querySelectorAll("link[rel='stylesheet']"));
-			let hrefs = stylesheets.map((sheet) => {
-				sheet.remove();
-				return sheet.href;
-			});
-
-			// Get inline styles
-			let inlineStyles = Array.from(doc.querySelectorAll("style:not([data-pagedjs-inserted-styles])"));
-			inlineStyles.forEach((inlineStyle) => {
-				let obj = {};
-				obj[window.location.href] = inlineStyle.textContent;
-				hrefs.push(obj);
-				inlineStyle.remove();
-			});
-
-			return hrefs;
-		}
-
-		async preview(content, stylesheets, renderTo) {
-
-			if (!content) {
-				content = this.wrapContent();
-			}
-
-			if (!stylesheets) {
-				stylesheets = this.removeStyles();
-			}
-
-			this.polisher.setup();
-
-			this.handlers = this.initializeHandlers();
-
-			await this.polisher.add(...stylesheets);
-
-			let startTime = performance.now();
-
-			// Render flow
-			let flow = await this.chunker.flow(content, renderTo);
-
-			let endTime = performance.now();
-			let msg = "Rendering " + flow.total + " pages took " + (endTime - startTime) + " milliseconds.";
-
-			flow.performance = (endTime - startTime);
-			flow.size = this.size;
-
-			this.emit("rendered", msg, this.size.width && this.size.width.value + this.size.width.unit, this.size.height && this.size.height.value + this.size.height.unit, this.size.orientation, this.size.format);
-			if (typeof window.onPagesRendered !== "undefined") {
-				window.onPagesRendered(msg, this.size.width && this.size.width.value + this.size.width.unit, this.size.height && this.size.height.value + this.size.height.unit, this.size.orientation, this.size.format);
-			}
-
-			return flow;
-		}
-	}
-
-	eventEmitter(Previewer.prototype);
-
-
-
-	var Paged = /*#__PURE__*/Object.freeze({
-		Chunker: Chunker,
-		Polisher: Polisher,
-		Previewer: Previewer,
-		Handler: Handler,
-		registerHandlers: registerHandlers,
-		initializeHandlers: initializeHandlers
-	});
-
-	window.Paged = Paged;
-
-	let ready = new Promise(function(resolve, reject){
-		if (document.readyState === "interactive" || document.readyState === "complete") {
-			resolve(document.readyState);
-			return;
-		}
-
-		document.onreadystatechange = function ($) {
-			if (document.readyState === "interactive") {
-				resolve(document.readyState);
-			}
-		};
-	});
-
-	let config = window.PagedConfig || {
-		auto: true,
-		before: undefined,
-		after: undefined,
-		content: undefined,
-		stylesheets: undefined,
-		renderTo: undefined
-	};
-
-	let previewer = new Previewer(config.content, config.stylesheets, config.renderTo);
-
-
-	ready.then(async function () {
-		let done;
-		if (config.before) {
-			await config.before();
-		}
-
-		if(config.auto !== false) {
-			done = await previewer.preview();
-		}
-
-
-		if (config.after) {
-			await config.after(done);
-		}
-	});
-
-	return previewer;
-
-}));
diff --git a/docs/lua/footnotes.lua b/docs/lua/footnotes.lua
deleted file mode 100644
index 35c75159f8..0000000000
--- a/docs/lua/footnotes.lua
+++ /dev/null
@@ -1,27 +0,0 @@
---[[
-    This filter transforms Pandoc's notes in spans.
-    See https://stackoverflow.com/questions/51548827/pandoc-lua-filter-how-to-preserve-footnotes-formatting
-    and https://github.com/jgm/pandoc/pull/4799
-
-    Requires Pandoc >= 2.2.3
---]]
-
-local options = {} -- where we store pandoc Meta
-local noteId = 0 -- ids for notes
-
-local function getMeta(meta)
-  options = meta
-  return nil -- Do not modify Meta
-end
-
-local function noteToSpan(note)
-  if not options["paged-footnotes"] then return nil end
-  noteId = noteId + 1
-  local inlines = pandoc.utils.blocks_to_inlines(note.content, {pandoc.Str'\010'}) -- insert \n between Pandoc's blocks
-  local attr = {}
-  attr["data-pagedown-footnote-number"] = noteId
-  attr["style"] = "white-space: pre-line;" -- use pre-line to render \n
-  return pandoc.Span(inlines, pandoc.Attr("fn" .. noteId, {"footnote"}, attr))
-end
-
-return {{Meta = getMeta}, {Note = noteToSpan}}
diff --git a/docs/lua/jss.lua b/docs/lua/jss.lua
deleted file mode 100644
index ee8f841362..0000000000
--- a/docs/lua/jss.lua
+++ /dev/null
@@ -1,99 +0,0 @@
---[[
-    A Pandoc filter for the Journal of Statistical Software template
-    This filter performs the following actions:
-    - store plain keywords in a pandoc variable named keywords-plain
-    - calculate the rank for each author
-    - build the DOI from the volume and issue parameters and store it in a variable named doi
-    - use fallback values for missing month, year, volume or issue
---]]
-local isInteger = function(number)
-  return math.floor(number) == number
-end
-
-local padVolume = function(volume)
-  local volumeString = tostring(volume)
-  if volume < 10 then return "00" .. volumeString end
-  if volume < 100 then return "0" .. volumeString end
-  return volumeString
-end
-
-local padIssue = function(issue)
-  local issueString = tostring(issue)
-  if issue < 10 then return "0" .. issueString end
-  return issueString
-end
-
-local getDOI = function(volume, issue)
-  -- store a fallback DOI
-  local fallback = "10.18637/jss.v000.i00"
-
-  -- if volume or issue is missing, return the fallback DOI
-  if not volume or not issue then return fallback end
-
-  local volumeNumber = tonumber(pandoc.utils.stringify(volume))
-  local issueNumber = tonumber(pandoc.utils.stringify(issue))
-
-  -- if volume or issue cannot be coerced to a number, return the fallback DOI
-  if not volumeNumber or not issueNumber then return fallback end
-
-  -- if volume or issue is a number lesser than 1, return the fallback DOI
-  if volumeNumber < 1 or issueNumber < 1 then return fallback end
-
-  -- if volume or issue is not an integer, return the fallback DOI
-  if not isInteger(volumeNumber) or not isInteger(issueNumber) then return fallback end
-
-  -- build the DOI
-  return "10.18637/jss.v" .. padVolume(volumeNumber) .. ".i" .. padIssue(issueNumber)
-end
-
-
-Meta = function(meta)
-  ---------------------------------------
-  --           Keywords                --
-  ---------------------------------------
-  -- Test if there is one keyword:
-  if not meta.keywords then error("At least one keyword must be supplied.") end
-  -- Store plain keywords:
-  local plainKeywords = {}
-
-  if meta.keywords.t == "MetaList" then
-    for i, v in ipairs(meta.keywords) do
-      plainKeywords[i] = pandoc.utils.stringify(v)
-    end
-  else
-    -- we have only one keyword
-    plainKeywords = {pandoc.utils.stringify(meta.keywords)}
-  end
-
-  meta["keywords-plain"] = plainKeywords
-
-  ---------------------------------------
-  --              Author               --
-  ---------------------------------------
-  local author = meta.author
-
-  if author.t == "MetaInlines" then
-    meta.author = {data = author, rank = "1"}
-  else
-    for i, v in ipairs(author) do
-      meta.author[i] = {data = v, rank = tostring(i)}
-    end
-  end
-
-  ----------------------------------------
-  --  Build DOI from volume and issue   --
-  ----------------------------------------
-  meta.doi = getDOI(meta.volume, meta.issue)
-
-  ----------------------------------------
-  -- Fallback values for missing params --
-  ----------------------------------------
-  if not meta.month then meta.month = "MMMMMM" end
-  if not meta.year then meta.year = "YYYY" end
-  if not meta.volume then meta.volume = "VV" end
-  if not meta.issue then meta.issue = "II" end
-  if not meta.submitdate then meta.submitdate = "yyyy-mm-dd" end
-  if not meta.acceptdate then meta.acceptdate = "yyyy-mm-dd" end
-
-  return meta
-end
diff --git a/docs/lua/loft.lua b/docs/lua/loft.lua
deleted file mode 100644
index 52a3bc0422..0000000000
--- a/docs/lua/loft.lua
+++ /dev/null
@@ -1,121 +0,0 @@
---[[
-    A pandoc filter that generates Lists Of Figures and Tables (loft).
-    This filter enables the lot and lof options as in LaTeX output formats.
-
-    The user can also customise the titles with lot-title and lof-title:
-    ---
-    lof:
-    lof-title: "Illustrations" # markdown styling is supported
-    ---
---]]
-
-local options = {}     -- where we store pandoc Meta
-local tablesList = {}  -- where we store the list of tables
-local figuresList = {} -- where we store the list of figures
-
--- The following function stores pandoc Meta in the options local variable
-local function getMeta(meta)
-  options = meta
-  -- If there is no given titles, use default titles
-  if not options["lot-title"] then
-    options["lot-title"] = pandoc.MetaInlines("List of Tables")
-  end
-  if not options["lof-title"] then
-    options["lof-title"] = pandoc.MetaInlines("List of Figures")
-  end
-  return nil -- Do not modify Meta
-end
-
--- This function is called only for Div of class figure inserted by bookdown
-local function getFigCaption(div)
-  local listOfBlocks = div.content
-  local found
-  for i, block in ipairs(listOfBlocks) do
-    if block.t == "RawBlock" then
-      if block.c[2] == '<p class="caption">' then
-        found = i + 1
-        break
-      end
-    end
-  end
-  if found then
-    return pandoc.utils.stringify(div.content[found])
-  else
-    return nil
-  end
-end
-
--- This function looks for div of class figure.
--- It builds and saves the items used by the list of figures.
-local function addFigRef(div)
-  local captionText
-  local figref
-
-  -- do not build the lof if not required
-  if not options.lof then return nil end
-
-  if div.classes:includes("figure") then
-    captionText = getFigCaption(div)
-    if not captionText then return nil end
-
-    -- build figure reference from figure caption
-    figref = "@ref" .. string.gsub(captionText, "#", "")
-    figref = string.gsub(figref, "%)", ") ") -- add a space
-    -- insert figure reference in figuresList
-    table.insert(figuresList, {pandoc.Plain(pandoc.Str(figref))})
-  end
-  return nil -- Do not modify Div
-end
-
--- This function inspects the tables captions.
--- When a bookdown id is found, it builds and saves the items used by
---  the list of tables.
-local function addTabRef(tab)
-  local caption
-  local found
-  local tabref
-
-  -- do not build the lot if not required
-  if not options.lot then return nil end
-
-  caption = pandoc.utils.stringify(tab.caption)
-  -- test the presence of a bookdown table id
-  found = string.find(caption, "%(#tab:.*%)")
-  if found then
-    -- build table reference from table caption
-    tabref = "@ref" .. string.gsub(caption, "#", "")
-    tabref = string.gsub(tabref, "%)", ") ") -- add a space
-    -- insert table reference in tablesList
-    table.insert(tablesList, {pandoc.Plain(pandoc.Str(tabref))})
-  end
-  return nil -- Do not modify Table
-end
-
-local function appendLoft(doc)
-  local lotHeader
-  local lofHeader
-  local idprefix = options.idprefix or ""
-
-  if options.lof then
-    table.insert(doc.blocks, 1, pandoc.BulletList(figuresList))
-    lofHeader =
-      pandoc.Header(1,
-                    {table.unpack(options["lof-title"])},
-                    pandoc.Attr(idprefix .. "LOF", {"lof", "unnumbered", "front-matter"}, {})
-      )
-    table.insert(doc.blocks, 1, lofHeader)
-  end
-
-  if options.lot then
-    table.insert(doc.blocks, 1, pandoc.BulletList(tablesList))
-    lotHeader =
-      pandoc.Header(1,
-                    {table.unpack(options["lot-title"])},
-                    pandoc.Attr(idprefix .. "LOT", {"lot", "unnumbered", "front-matter"}, {})
-      )
-    table.insert(doc.blocks, 1, lotHeader)
-  end
-  return pandoc.Pandoc(doc.blocks, doc.meta)
-end
-
-return {{Meta = getMeta}, {Div = addFigRef, Table = addTabRef, Doc = appendLoft}}
diff --git a/docs/lua/uri-to-fn.lua b/docs/lua/uri-to-fn.lua
deleted file mode 100644
index 346213a5cd..0000000000
--- a/docs/lua/uri-to-fn.lua
+++ /dev/null
@@ -1,59 +0,0 @@
-local options = {} -- where we store pandoc Meta
-
--- This function tests the pandoc version againt a target version
--- The target version has to be of the form {2, 3} or {2, 3, 1}
-local function pandocAvailable(target)
- -- use a shallow copy of PANDOC_VERSION
- -- this is required since pandoc 2.7.3, see https://github.com/rstudio/pagedown/issues/111
-  local pandocVersion = {}
-  for i = 1,3 do
-    table.insert(pandocVersion, PANDOC_VERSION[i])
-  end
-  pandocVersion[3] = pandocVersion[3] or 0 -- because there is not always a patch number
-  target[3] = target[3] or 0
-
-  for i = 1,3 do
-    if pandocVersion[i] > target[i] then return true end
-    if pandocVersion[i] < target[i] then return false end
-  end
-  return true
-end
-
-local function getMeta(meta)
-  options = meta
-  return nil -- Do not modify Meta
-end
-
-local function uriToFootnote(link)
-  local target = link.target
-  local content = link.content
-  local contentString = pandoc.utils.stringify(content)
-  local footnoteContent
-  local classes = {}
-  local attr
-
-  if not options["links-to-footnotes"] then return nil end
-  if target == contentString then return nil end
-  if target == "mailto:" .. contentString then return nil end
-
-  if string.find(target, "://") then
-    if pandocAvailable({2, 3, 1}) then classes = {"uri"} end
-    attr = pandoc.Attr("", classes, {})
-    footnoteContent = {pandoc.Para({pandoc.Link(target, target, "", attr)})}
-    table.insert(content, pandoc.Note(footnoteContent))
-    return content
-  end
-
-  if string.find(target, "^mailto:") then
-    if pandocAvailable({2, 3, 1}) then classes = {"email"} end
-    attr = pandoc.Attr("", classes, {})
-    footnoteContent = {pandoc.Para({
-      pandoc.Link(string.gsub(target, "^mailto:", ""), target, "", attr)
-    })}
-    table.insert(content, pandoc.Note(footnoteContent))
-    return content
-  end
-
-end
-
-return {{Meta = getMeta}, {Link = uriToFootnote}}
diff --git a/docs/media/pagedownresume-print.css b/docs/media/pagedownresume-print.css
deleted file mode 100644
index 659f959ad4..0000000000
--- a/docs/media/pagedownresume-print.css
+++ /dev/null
@@ -1,434 +0,0 @@
-@page{
-  size: letter portrait;
-  margin: 1in 0.5in 1in 0.25in;
-}
-
-*{
-  box-sizing: border-box;
-}
-
-:root{
-  --page-width: 8.5in;
-  --margin-right: 0.5in;
-  --margin-left: 0.25in;
-  --content-width: calc(var(--page-width) - var(--margin-right) - var(--margin-left));
-  --root-font-size: 12pt;
-  --sidebar-width: 15rem;
-  --sidebar-background-color: #f2f2f2;
-  --main-width: calc(var(--content-width) - var(--sidebar-width));
-  --decorator-horizontal-margin: 0.2in;
-
-  --sidebar-horizontal-padding: 0.2in;
-
-  /* XXX: using px for very good precision control */
-  --decorator-outer-offset-top: 10px;
-  --decorator-outer-offset-left: -5.5px;
-  --decorator-border-width: 1px;
-  --decorator-outer-dim: 9px;
-  --decorator-border: 1px solid #ccc;
-
-  --row-blocks-padding-top: 0.5rem;
-  --date-block-width: 0.7in;
-
-  --main-blocks-title-icon-offset-left: calc(-17pt - 0.25 * var(--root-font-size));
-
-  --viewer-background-color: #dcdcdc;
-  --viewer-pages-spacing: 12px;
-  --viewer-shadow-color: #313131;
-}
-
-.pagedjs_page {
-  --content-area-height: calc(var(--pagedjs-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
-  --sidebar-background-width: calc(var(--pagedjs-margin-right) + var(--sidebar-width));
-}
-
-@page{
-  background: linear-gradient(to left, var(--sidebar-background-color), var(--sidebar-background-color) var(--sidebar-background-width), white var(--sidebar-background-width));
-}
-
-html {
-  font-size: var(--root-font-size);
-}
-
-body{
-  width: var(--content-width);
-  font-family: "Open Sans", sans-serif;
-  font-weight: 300;
-  line-height: 1.3;
-  color: #444;
-  hyphens: auto;
-}
-
-h1, h2, h3{
-  margin: 0;
-  color: #000;
-}
-
-#main > h1, #aside > h1, #disclaimer > h2 {
-  display: none;
-}
-
-li{
-  list-style-type: none;
-}
-
-a{
-  text-decoration: none;
-}
-
-img{
-  max-width: 100%;
-}
-
-#main{
-  width: var(--main-width);
-  padding: 0 0.25in 0 0.25in;
-  font-size: 0.7rem;
-  float: left;
-}
-
-#aside{
-  position: relative; /* for disclaimer */
-  height: var(--content-area-height);
-}
-
-.aside{
-  width: var(--sidebar-width);
-  padding: 0.6in var(--sidebar-horizontal-padding);
-  font-size: 0.8rem;
-  float: right;
-  position: absolute;
-  right: 0;
-}
-
-/* main */
-
-/** big title **/
-h1, h2{
-  text-transform: uppercase;
-}
-
-#title{
-  position: relative;
-  left: 0.55in;
-  margin: auto 0.55in 0.3in auto;
-  line-height: 1.2;
-}
-
-#title h1{
-  font-weight: 300;
-  font-size: 1.8rem;
-  line-height: 1.5;
-}
-
-#title h3{
-  font-size: 0.8rem;
-}
-
-
-/*** categorial blocks ***/
-
-.main-block{
-  margin-top: 0.1in;
-}
-
-#main h2{
-  position: relative;
-  top: var(--row-blocks-padding-top);
-  /* XXX: 0.5px for aligning fx printing */
-  left: calc((var(--date-block-width) + var(--decorator-horizontal-margin)));
-  font-weight: 400;
-  font-size: 1.1rem;
-  color: #555;
-}
-
-#main h2 > i{
-  /* use absolute position to prevent icon's width from misaligning title */
-  /* assigning a fixed width here is no better due to needing to align decorator
-     line too */
-  position: absolute;
-  left: var(--main-blocks-title-icon-offset-left);
-  z-index: 1; /* over decorator line */
-  color: #444;
-}
-
-#main h2::after{ /* extends the decorator line */
-  height: calc(var(--row-blocks-padding-top) * 2);
-  position: relative;
-  top: calc(-1 * var(--row-blocks-padding-top));
-  /* XXX: 0.5px for aligning fx printing */
-  left: calc(-1 * var(--decorator-horizontal-margin));
-  display: block;
-  border-left: var(--decorator-border);
-  z-index: 0;
-  line-height: 0;
-  font-size: 0;
-  content: ' ';
-}
-
-/**** minor tweaks on the icon fonts ****/
-#main h2 > .fa-graduation-cap{
-  left: calc(var(--main-blocks-title-icon-offset-left) - 2pt);
-  top: 2pt;
-}
-
-#main h2 > .fa-suitcase{
-  top: 1pt;
-}
-
-#main h2 > .fa-folder-open{
-  top: 1.5pt;
-}
-
-/**** individual row blocks (date - decorator - details) ****/
-
-.blocks{
-  display: flex;
-  flex-flow: row nowrap;
-}
-
-.blocks > div{
-  padding-top: var(--row-blocks-padding-top);
-}
-
-.date{
-  flex: 0 0 var(--date-block-width);
-  padding-top: calc(var(--row-blocks-padding-top) + 0.25rem) !important;
-  padding-right: var(--decorator-horizontal-margin);
-  font-size: 0.7rem;
-  text-align: right;
-  line-height: 1;
-  max-width: var(--date-block-width);
-}
-
-.date span{
-  display: block;
-  text-align: center;
-}
-
-.date span:nth-child(2)::before{
-  position: relative;
-  top: 0.1rem;
-  right: 0;
-  display: block;
-  height: 1rem;
-  content: '|';
-}
-
-.decorator{
-  flex: 0 0 0;
-  position: relative;
-  width: 2pt;
-  min-height: 100%;
-  border-left: var(--decorator-border);
-}
-
-/*
- * XXX: Use two filled circles to achieve the circle-with-white-border effect.
- * The normal technique of only using one pseudo element and
- * border: 1px solid white; style makes firefox erroneously either:
- * 1) overflows the grayshade background (if no background-clip is set), or
- * 2) shows decorator line which should've been masked by the white border
- *
- */
-
-.decorator::before{
-  position: absolute;
-  top: var(--decorator-outer-offset-top);
-  left: var(--decorator-outer-offset-left);
-  content: ' ';
-  display: block;
-  width: var(--decorator-outer-dim);
-  height: var(--decorator-outer-dim);
-  border-radius: calc(var(--decorator-outer-dim) / 2);
-  background-color: #fff;
-}
-
-.decorator::after{
-  position: absolute;
-  top: calc(var(--decorator-outer-offset-top) + var(--decorator-border-width));
-  left: calc(var(--decorator-outer-offset-left) + var(--decorator-border-width));
-  content: ' ';
-  display: block;
-  width: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
-  height: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
-  border-radius: calc((var(--decorator-outer-dim) - (var(--decorator-border-width) * 2)) / 2);
-  background-color: #555;
-}
-
-.blocks:last-child .decorator{ /* slightly shortens it */
-  margin-bottom: 0.25in;
-}
-
-/***** fine-tunes on the details block where the real juice is *****/
-
-.details{
-  flex: 1 0 0;
-  padding-left: var(--decorator-horizontal-margin);
-  padding-top: calc(var(--row-blocks-padding-top) - 0.05rem) !important; /* not sure why but this is needed for better alignment */
-}
-
-.details header{
-  color: #000;
-}
-
-.details h3{
-  font-size: 0.8rem;
-}
-
-.main-block:not(.concise) .details div{
-  margin: 0.18in 0 0.1in 0;
-}
-
-.main-block:not(.concise) .details div:empty {
-  margin: 0;
-}
-
-.main-block:not(.concise) .blocks:last-child .details div{
-  margin-bottom: 0;
-}
-
-.main-block.concise .details div:not(.concise){
-  /* use padding to work around the fact that margin doesn't affect floated
-     neighboring elements */
-  padding: 0.05in 0 0.07in 0;
-}
-
-.details .place{
-  float: left;
-  font-size: 0.75rem;
-}
-
-.details .location{
-  float: right;
-}
-
-.details div{
-  clear: both;
-}
-
-/***** fine-tunes on the lists... *****/
-
-#main ul{
-  padding-left: 0.07in;
-  margin: 0.08in 0;
-}
-
-#main li{
-  margin: 0 0 0.025in 0;
-}
-
-/****** customize list symbol style ******/
-#main li::before{
-  position: relative;
-  margin-left: -4.25pt;
-  content: '• ';
-}
-
-.aside li::before {
-  content: none;
-}
-
-.details .concise ul{
-  margin: 0 !important;
-  -webkit-columns: 2;
-  -moz-columns: 2;
-  columns: 2;
-}
-
-.details .concise li{
-  margin: 0 !important;
-}
-
-.details .concise li{
-  margin-left: 0 !important;
-}
-
-
-
-/* sidebar */
-
-.aside h2{
-  font-weight: 400;
-  font-size: 1.1rem;
-}
-
-.aside .level2{
-  margin-top: 0.5in;
-}
-
-#contact ul{
-  margin-top: 0.05in;
-  padding-left: 0;
-  font-weight: 400;
-  line-height: 1.75;
-}
-
-#contact li > i{
-  width: 0.9rem; /* for text alignment */
-  text-align: right;
-}
-
-#skills{
-  line-height: 1.5;
-}
-
-#skills ul{
-  margin: 0.05in 0 0.15in;
-  padding: 0;
-}
-
-#disclaimer{
-  position: absolute;
-  bottom: 0;
-  right: var(--sidebar-horizontal-padding);
-  font-size: 0.75rem;
-  font-style: italic;
-  line-height: 1.1;
-  text-align: right;
-  color: #777;
-}
-
-#disclaimer code{
-  color: #666;
-  font-family: "Source Code Pro";
-  font-weight: 400;
-  font-style: normal;
-}
-
-/* Page breaks */
-
-h2 {
-  break-after: avoid;
-}
-
-.blocks {
-  break-inside: avoid;
-}
-
-/* Paged.js viewer */
-
-@media screen {
-  body {
-    background-color: var(--viewer-background-color);
-    margin: 0; /* for mobile */
-    width: calc(var(--pagedjs-width) + 2 * var(--viewer-pages-spacing)); /* for mobile */
-  }
-   .pagedjs_pages {
-    max-width: var(--pagedjs-width);
-    margin: 0 auto;
-    display: flex;
-    flex-direction: column;
-  }
-   .pagedjs_page {
-    box-shadow: 0 0 calc(0.66667 * var(--viewer-pages-spacing)) var(--viewer-shadow-color);
-    margin: var(--viewer-pages-spacing) 0;
-  }
-}
- @media screen and (min-width: 8.5in) {
-  /* not a mobile */
-  body {
-    margin: auto;
-    width: unset;
-  }
-}
diff --git a/docs/media/pagedownresume-screen.css b/docs/media/pagedownresume-screen.css
deleted file mode 100644
index 659f959ad4..0000000000
--- a/docs/media/pagedownresume-screen.css
+++ /dev/null
@@ -1,434 +0,0 @@
-@page{
-  size: letter portrait;
-  margin: 1in 0.5in 1in 0.25in;
-}
-
-*{
-  box-sizing: border-box;
-}
-
-:root{
-  --page-width: 8.5in;
-  --margin-right: 0.5in;
-  --margin-left: 0.25in;
-  --content-width: calc(var(--page-width) - var(--margin-right) - var(--margin-left));
-  --root-font-size: 12pt;
-  --sidebar-width: 15rem;
-  --sidebar-background-color: #f2f2f2;
-  --main-width: calc(var(--content-width) - var(--sidebar-width));
-  --decorator-horizontal-margin: 0.2in;
-
-  --sidebar-horizontal-padding: 0.2in;
-
-  /* XXX: using px for very good precision control */
-  --decorator-outer-offset-top: 10px;
-  --decorator-outer-offset-left: -5.5px;
-  --decorator-border-width: 1px;
-  --decorator-outer-dim: 9px;
-  --decorator-border: 1px solid #ccc;
-
-  --row-blocks-padding-top: 0.5rem;
-  --date-block-width: 0.7in;
-
-  --main-blocks-title-icon-offset-left: calc(-17pt - 0.25 * var(--root-font-size));
-
-  --viewer-background-color: #dcdcdc;
-  --viewer-pages-spacing: 12px;
-  --viewer-shadow-color: #313131;
-}
-
-.pagedjs_page {
-  --content-area-height: calc(var(--pagedjs-height) - var(--pagedjs-margin-top) - var(--pagedjs-margin-bottom));
-  --sidebar-background-width: calc(var(--pagedjs-margin-right) + var(--sidebar-width));
-}
-
-@page{
-  background: linear-gradient(to left, var(--sidebar-background-color), var(--sidebar-background-color) var(--sidebar-background-width), white var(--sidebar-background-width));
-}
-
-html {
-  font-size: var(--root-font-size);
-}
-
-body{
-  width: var(--content-width);
-  font-family: "Open Sans", sans-serif;
-  font-weight: 300;
-  line-height: 1.3;
-  color: #444;
-  hyphens: auto;
-}
-
-h1, h2, h3{
-  margin: 0;
-  color: #000;
-}
-
-#main > h1, #aside > h1, #disclaimer > h2 {
-  display: none;
-}
-
-li{
-  list-style-type: none;
-}
-
-a{
-  text-decoration: none;
-}
-
-img{
-  max-width: 100%;
-}
-
-#main{
-  width: var(--main-width);
-  padding: 0 0.25in 0 0.25in;
-  font-size: 0.7rem;
-  float: left;
-}
-
-#aside{
-  position: relative; /* for disclaimer */
-  height: var(--content-area-height);
-}
-
-.aside{
-  width: var(--sidebar-width);
-  padding: 0.6in var(--sidebar-horizontal-padding);
-  font-size: 0.8rem;
-  float: right;
-  position: absolute;
-  right: 0;
-}
-
-/* main */
-
-/** big title **/
-h1, h2{
-  text-transform: uppercase;
-}
-
-#title{
-  position: relative;
-  left: 0.55in;
-  margin: auto 0.55in 0.3in auto;
-  line-height: 1.2;
-}
-
-#title h1{
-  font-weight: 300;
-  font-size: 1.8rem;
-  line-height: 1.5;
-}
-
-#title h3{
-  font-size: 0.8rem;
-}
-
-
-/*** categorial blocks ***/
-
-.main-block{
-  margin-top: 0.1in;
-}
-
-#main h2{
-  position: relative;
-  top: var(--row-blocks-padding-top);
-  /* XXX: 0.5px for aligning fx printing */
-  left: calc((var(--date-block-width) + var(--decorator-horizontal-margin)));
-  font-weight: 400;
-  font-size: 1.1rem;
-  color: #555;
-}
-
-#main h2 > i{
-  /* use absolute position to prevent icon's width from misaligning title */
-  /* assigning a fixed width here is no better due to needing to align decorator
-     line too */
-  position: absolute;
-  left: var(--main-blocks-title-icon-offset-left);
-  z-index: 1; /* over decorator line */
-  color: #444;
-}
-
-#main h2::after{ /* extends the decorator line */
-  height: calc(var(--row-blocks-padding-top) * 2);
-  position: relative;
-  top: calc(-1 * var(--row-blocks-padding-top));
-  /* XXX: 0.5px for aligning fx printing */
-  left: calc(-1 * var(--decorator-horizontal-margin));
-  display: block;
-  border-left: var(--decorator-border);
-  z-index: 0;
-  line-height: 0;
-  font-size: 0;
-  content: ' ';
-}
-
-/**** minor tweaks on the icon fonts ****/
-#main h2 > .fa-graduation-cap{
-  left: calc(var(--main-blocks-title-icon-offset-left) - 2pt);
-  top: 2pt;
-}
-
-#main h2 > .fa-suitcase{
-  top: 1pt;
-}
-
-#main h2 > .fa-folder-open{
-  top: 1.5pt;
-}
-
-/**** individual row blocks (date - decorator - details) ****/
-
-.blocks{
-  display: flex;
-  flex-flow: row nowrap;
-}
-
-.blocks > div{
-  padding-top: var(--row-blocks-padding-top);
-}
-
-.date{
-  flex: 0 0 var(--date-block-width);
-  padding-top: calc(var(--row-blocks-padding-top) + 0.25rem) !important;
-  padding-right: var(--decorator-horizontal-margin);
-  font-size: 0.7rem;
-  text-align: right;
-  line-height: 1;
-  max-width: var(--date-block-width);
-}
-
-.date span{
-  display: block;
-  text-align: center;
-}
-
-.date span:nth-child(2)::before{
-  position: relative;
-  top: 0.1rem;
-  right: 0;
-  display: block;
-  height: 1rem;
-  content: '|';
-}
-
-.decorator{
-  flex: 0 0 0;
-  position: relative;
-  width: 2pt;
-  min-height: 100%;
-  border-left: var(--decorator-border);
-}
-
-/*
- * XXX: Use two filled circles to achieve the circle-with-white-border effect.
- * The normal technique of only using one pseudo element and
- * border: 1px solid white; style makes firefox erroneously either:
- * 1) overflows the grayshade background (if no background-clip is set), or
- * 2) shows decorator line which should've been masked by the white border
- *
- */
-
-.decorator::before{
-  position: absolute;
-  top: var(--decorator-outer-offset-top);
-  left: var(--decorator-outer-offset-left);
-  content: ' ';
-  display: block;
-  width: var(--decorator-outer-dim);
-  height: var(--decorator-outer-dim);
-  border-radius: calc(var(--decorator-outer-dim) / 2);
-  background-color: #fff;
-}
-
-.decorator::after{
-  position: absolute;
-  top: calc(var(--decorator-outer-offset-top) + var(--decorator-border-width));
-  left: calc(var(--decorator-outer-offset-left) + var(--decorator-border-width));
-  content: ' ';
-  display: block;
-  width: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
-  height: calc(var(--decorator-outer-dim) - (var(--decorator-border-width) * 2));
-  border-radius: calc((var(--decorator-outer-dim) - (var(--decorator-border-width) * 2)) / 2);
-  background-color: #555;
-}
-
-.blocks:last-child .decorator{ /* slightly shortens it */
-  margin-bottom: 0.25in;
-}
-
-/***** fine-tunes on the details block where the real juice is *****/
-
-.details{
-  flex: 1 0 0;
-  padding-left: var(--decorator-horizontal-margin);
-  padding-top: calc(var(--row-blocks-padding-top) - 0.05rem) !important; /* not sure why but this is needed for better alignment */
-}
-
-.details header{
-  color: #000;
-}
-
-.details h3{
-  font-size: 0.8rem;
-}
-
-.main-block:not(.concise) .details div{
-  margin: 0.18in 0 0.1in 0;
-}
-
-.main-block:not(.concise) .details div:empty {
-  margin: 0;
-}
-
-.main-block:not(.concise) .blocks:last-child .details div{
-  margin-bottom: 0;
-}
-
-.main-block.concise .details div:not(.concise){
-  /* use padding to work around the fact that margin doesn't affect floated
-     neighboring elements */
-  padding: 0.05in 0 0.07in 0;
-}
-
-.details .place{
-  float: left;
-  font-size: 0.75rem;
-}
-
-.details .location{
-  float: right;
-}
-
-.details div{
-  clear: both;
-}
-
-/***** fine-tunes on the lists... *****/
-
-#main ul{
-  padding-left: 0.07in;
-  margin: 0.08in 0;
-}
-
-#main li{
-  margin: 0 0 0.025in 0;
-}
-
-/****** customize list symbol style ******/
-#main li::before{
-  position: relative;
-  margin-left: -4.25pt;
-  content: '• ';
-}
-
-.aside li::before {
-  content: none;
-}
-
-.details .concise ul{
-  margin: 0 !important;
-  -webkit-columns: 2;
-  -moz-columns: 2;
-  columns: 2;
-}
-
-.details .concise li{
-  margin: 0 !important;
-}
-
-.details .concise li{
-  margin-left: 0 !important;
-}
-
-
-
-/* sidebar */
-
-.aside h2{
-  font-weight: 400;
-  font-size: 1.1rem;
-}
-
-.aside .level2{
-  margin-top: 0.5in;
-}
-
-#contact ul{
-  margin-top: 0.05in;
-  padding-left: 0;
-  font-weight: 400;
-  line-height: 1.75;
-}
-
-#contact li > i{
-  width: 0.9rem; /* for text alignment */
-  text-align: right;
-}
-
-#skills{
-  line-height: 1.5;
-}
-
-#skills ul{
-  margin: 0.05in 0 0.15in;
-  padding: 0;
-}
-
-#disclaimer{
-  position: absolute;
-  bottom: 0;
-  right: var(--sidebar-horizontal-padding);
-  font-size: 0.75rem;
-  font-style: italic;
-  line-height: 1.1;
-  text-align: right;
-  color: #777;
-}
-
-#disclaimer code{
-  color: #666;
-  font-family: "Source Code Pro";
-  font-weight: 400;
-  font-style: normal;
-}
-
-/* Page breaks */
-
-h2 {
-  break-after: avoid;
-}
-
-.blocks {
-  break-inside: avoid;
-}
-
-/* Paged.js viewer */
-
-@media screen {
-  body {
-    background-color: var(--viewer-background-color);
-    margin: 0; /* for mobile */
-    width: calc(var(--pagedjs-width) + 2 * var(--viewer-pages-spacing)); /* for mobile */
-  }
-   .pagedjs_pages {
-    max-width: var(--pagedjs-width);
-    margin: 0 auto;
-    display: flex;
-    flex-direction: column;
-  }
-   .pagedjs_page {
-    box-shadow: 0 0 calc(0.66667 * var(--viewer-pages-spacing)) var(--viewer-shadow-color);
-    margin: var(--viewer-pages-spacing) 0;
-  }
-}
- @media screen and (min-width: 8.5in) {
-  /* not a mobile */
-  body {
-    margin: auto;
-    width: unset;
-  }
-}

From 7676b301df9404b9eb7016865bab32829845a087 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Mon, 10 Aug 2020 16:44:09 -0600
Subject: [PATCH 15/20] updated to be a ds resume

---
 docs/.DS_Store                 | Bin 8196 -> 8196 bytes
 docs/index.md                  |  97 ++++++++++++++++-----------------
 index_2027.md                  |  88 ++++++++++++++++++++++++++++++
 index.md => index_example_1.md |  10 ++--
 4 files changed, 140 insertions(+), 55 deletions(-)
 create mode 100644 index_2027.md
 rename index.md => index_example_1.md (86%)

diff --git a/docs/.DS_Store b/docs/.DS_Store
index 5d00259ba084c8c9251ab46407959bbb97812882..3184b6e9c21ad4006d0d0bed9f35685b6d6ef39d 100644
GIT binary patch
delta 41
xcmZp1XmOa}&nUJrU^hRb*kngRk<AJM6Bsuu2tQ}p*igW@nO)*L%f?DJW&jtF4M6|^

delta 187
zcmZp1XmOa}&nUAoU^hRb%w$JFk<AJM6Bs#J7%~`27;+hMCT|tIUJvKxq#Fh&=jRqM
zfWed#KngCGoA2V1l#`zX6ysoEXqfym{g5N7d<tIqf(&G{FMw=-n$5(Jvw5N5H<r!p
R65m-S9}qmVIZDKe2>{tFFya6J

diff --git a/docs/index.md b/docs/index.md
index aa6c0cb838..5a1228df71 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,86 +1,83 @@
 ---
-layout: cv
-title: Isaac Newtons's CV
+layout: resume
+title: Brigham Young's Resume
 ---
-# Isaac Newton
-Physicist, Mathematician, Cambridge professor.
+# Brigham Young
+The second prophet of The Church of Jesus Christ of Latter-day Saints.
 
 <div id="webaddress">
-<a href="isaac@applesdofall.org">isaac@applesdofall.org</a>
-| <a href="http://en.wikipedia.org/wiki/Isaac_Newton">My wikipedia page</a>
+<a href="datascience@byui.edu">datascience@byui.edu</a>
+| <a href="https://byuidatascience.github.io/development.html">Data Science Program</a>
 </div>
 
-
-## Currently
-
-Standing on the shoulders of giants
-
-### Specialized in
-
-Laws of motion, gravitation, minting coins, disliking [Robert Hooke](http://en.wikipedia.org/wiki/Robert_Hooke)
-
-
-### Research interests
-
-Cooling, power series, optics, alchemy, planetary motions, apples.
+<!-- https://www.monique.tech/the-art-of-markdown -->
 
 
 ## Education
 
-`1654-1660`
-__The King's School, Grantham.__
-
-`June 1661 - now`
-__Trinity College, Cambridge__
+`2025-2027`
+__LDS Business College__, Salt Lake City, UT
 
-- Sizar
+- Full academic scholarship with 4.0 GPA
 
-`1667 - death`
-__Trinity College, Cambridge__
+`Expected 2029`
+__Brigham Young University - Idaho__, Rexburg, ID
 
-- Fellow
+- 4.0 Major GPA
 
 
+## Related Experience
 
-## Awards
+### Internships
 
-`2012`
-President, *Royal Society*, London, UK
+`January 2028 - June 2028`
+__Pacific Northwest National Lab__, Richland, WA
 
-Associate, *French Academy of Science*, Paris, France
+- Worked on novel methods for soil sampling to reduce laboratory measurements
+- Used R and Visual Sample Plan to establish new sampling algorithms
+- Published a journal article in Environmental Quality.
 
+### Data Science Lead
 
+`April 2027 - June 2027`
+__Westmark Credit Union__, Consultant
 
-## Publications
+- Developed a predicted model to support Westmark in custumer conversion from dealer loans.
+- Used R and Python to build a machine learning model using CatBoost in Python and the Tidyverse for data visualization and munging. 
+- Improved previous model development to over 85% balanced accuracy. Expect model to be implemented in Westmark business practices.
 
-<!-- A list is also available [online](http://scholar.google.co.uk/citations?user=LTOTl0YAAAAJ) -->
+`September 2027 - April 2028`
+__Good2Go__, Consultant
 
-### Journals
+- Built product ordering and supply predictive algorithms for chips and beverages categories
+- Established standardized SQL calls and connections for PowerBI dashboards
+- Found over $35k in waste and saved over 200 annual hours of store quality control work 
 
-`1669`
-Newton Sir I, De analysi per æquationes numero terminorum infinitas. 
+### Data Science Consulting Team
 
-`1669`
-Lectiones opticæ.
+`January 2027 - April 2027`
+__Imagine Learning__
 
-etc. etc. etc.
+- Build web scraping tool to find and format school district technology data.
+- Used R and the Rvest package to parse and format web data.
+- Saved 30 hours a month with the automated scripts.
 
-### Patents
+`April 2027 - July 2027`
+__Pinnacle Management Group__, 
 
-`2012`
-Infinitesimal calculus for solutions to physics problems, [SMBC](http://www.techdirt.com/articles/20121011/09312820678/if-patents-had-been-around-time-newton.shtml) patent 001
+- Proof of concept development of dashboards using client's corporate data.
+- Built and documented differences of PowerBI, Google Dashoards, and Tableau.
+- Saved client $10k in database and dashboard server fees and validated future dashboard processes.
 
 
-## Occupation
+## Service and Work History
 
-`1600`
-__Royal Mint__, London
+`2025-2027`
+__Math Tutor__, LDSBC
 
-- Warden
-- Minted coins
 
-`1600`
-__Lucasian professor of Mathematics__, Cambridge University
+`2023-2025`
+__Service Missionary__, South Africa
 
 
 
diff --git a/index_2027.md b/index_2027.md
new file mode 100644
index 0000000000..5a1228df71
--- /dev/null
+++ b/index_2027.md
@@ -0,0 +1,88 @@
+---
+layout: resume
+title: Brigham Young's Resume
+---
+# Brigham Young
+The second prophet of The Church of Jesus Christ of Latter-day Saints.
+
+<div id="webaddress">
+<a href="datascience@byui.edu">datascience@byui.edu</a>
+| <a href="https://byuidatascience.github.io/development.html">Data Science Program</a>
+</div>
+
+<!-- https://www.monique.tech/the-art-of-markdown -->
+
+
+## Education
+
+`2025-2027`
+__LDS Business College__, Salt Lake City, UT
+
+- Full academic scholarship with 4.0 GPA
+
+`Expected 2029`
+__Brigham Young University - Idaho__, Rexburg, ID
+
+- 4.0 Major GPA
+
+
+## Related Experience
+
+### Internships
+
+`January 2028 - June 2028`
+__Pacific Northwest National Lab__, Richland, WA
+
+- Worked on novel methods for soil sampling to reduce laboratory measurements
+- Used R and Visual Sample Plan to establish new sampling algorithms
+- Published a journal article in Environmental Quality.
+
+### Data Science Lead
+
+`April 2027 - June 2027`
+__Westmark Credit Union__, Consultant
+
+- Developed a predicted model to support Westmark in custumer conversion from dealer loans.
+- Used R and Python to build a machine learning model using CatBoost in Python and the Tidyverse for data visualization and munging. 
+- Improved previous model development to over 85% balanced accuracy. Expect model to be implemented in Westmark business practices.
+
+`September 2027 - April 2028`
+__Good2Go__, Consultant
+
+- Built product ordering and supply predictive algorithms for chips and beverages categories
+- Established standardized SQL calls and connections for PowerBI dashboards
+- Found over $35k in waste and saved over 200 annual hours of store quality control work 
+
+### Data Science Consulting Team
+
+`January 2027 - April 2027`
+__Imagine Learning__
+
+- Build web scraping tool to find and format school district technology data.
+- Used R and the Rvest package to parse and format web data.
+- Saved 30 hours a month with the automated scripts.
+
+`April 2027 - July 2027`
+__Pinnacle Management Group__, 
+
+- Proof of concept development of dashboards using client's corporate data.
+- Built and documented differences of PowerBI, Google Dashoards, and Tableau.
+- Saved client $10k in database and dashboard server fees and validated future dashboard processes.
+
+
+## Service and Work History
+
+`2025-2027`
+__Math Tutor__, LDSBC
+
+
+`2023-2025`
+__Service Missionary__, South Africa
+
+
+
+<!-- ### Footer
+
+Last updated: May 2013 -->
+
+
diff --git a/index.md b/index_example_1.md
similarity index 86%
rename from index.md
rename to index_example_1.md
index cf5ad7991b..aa6c0cb838 100644
--- a/index.md
+++ b/index_example_1.md
@@ -1,13 +1,13 @@
 ---
-layout: resume
-title: Brigham Young's Resume
+layout: cv
+title: Isaac Newtons's CV
 ---
-# Brigham Young
+# Isaac Newton
 Physicist, Mathematician, Cambridge professor.
 
 <div id="webaddress">
-<a href="datascience@byui.edu">datascience@byui.edu</a>
-| <a href="https://byuidatascience.github.io/development.html">Data Science Program</a>
+<a href="isaac@applesdofall.org">isaac@applesdofall.org</a>
+| <a href="http://en.wikipedia.org/wiki/Isaac_Newton">My wikipedia page</a>
 </div>
 
 

From 266464b80dc4a597f1246f5b8f2ad0a9ec1b8cd6 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Mon, 10 Aug 2020 16:47:57 -0600
Subject: [PATCH 16/20] changed to cv layout

---
 docs/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/index.md b/docs/index.md
index 5a1228df71..52380e933c 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,5 +1,5 @@
 ---
-layout: resume
+layout: cv
 title: Brigham Young's Resume
 ---
 # Brigham Young

From d71b7bee444713817ec54dc046c36b0e1cfdf2b6 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Mon, 10 Aug 2020 16:52:32 -0600
Subject: [PATCH 17/20] updated links at the top

---
 docs/index.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/index.md b/docs/index.md
index 52380e933c..e1d9104f6e 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -8,11 +8,12 @@ The second prophet of The Church of Jesus Christ of Latter-day Saints.
 <div id="webaddress">
 <a href="datascience@byui.edu">datascience@byui.edu</a>
 | <a href="https://byuidatascience.github.io/development.html">Data Science Program</a>
+| <a href="https://www.linkedin.com/groups/13537407/">LinkedIn</a>
+| <a href="https://github.com/byuids-resumes">GitHub</a>
 </div>
 
 <!-- https://www.monique.tech/the-art-of-markdown -->
 
-
 ## Education
 
 `2025-2027`

From 2f28e9bd83f7e7265b3358e653d8ebfacbaf8f11 Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@byui.edu>
Date: Mon, 30 Nov 2020 13:54:54 -0700
Subject: [PATCH 18/20] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7841129115..236232368e 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ For more details, see the [markdown-csv project page](http://elipapa.github.io/m
 
 ## Customization
 
-Simply [fork the markdown-cv repo](https://github.com/elipapa/markdown-cv)
+Simply [fork the mdresume repo](https://github.com/byuids-resumes/mdresume)
 
 ![](https://help.github.com/assets/images/help/repository/fork_button.jpg)
 

From c36d279de7037b95bb5b2607f6822e7987444b1d Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@gmail.com>
Date: Wed, 2 Dec 2020 14:25:49 -0700
Subject: [PATCH 19/20] picture

---
 docs_setup.png | Bin 0 -> 150717 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 docs_setup.png

diff --git a/docs_setup.png b/docs_setup.png
new file mode 100644
index 0000000000000000000000000000000000000000..0573f7209633b741e12a09e1a815c4037abff5ef
GIT binary patch
literal 150717
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

literal 0
HcmV?d00001


From 1c80945b0e2092830f9c42878dc970115799735e Mon Sep 17 00:00:00 2001
From: "J. Hathaway" <hathawayj@byui.edu>
Date: Wed, 2 Dec 2020 14:28:21 -0700
Subject: [PATCH 20/20] Update README.md

---
 README.md | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 236232368e..e5c19b9b46 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Simply [fork the mdresume repo](https://github.com/byuids-resumes/mdresume)
 
 ![](https://help.github.com/assets/images/help/repository/fork_button.jpg)
 
-and edit the `index.md` file [directly in Github](https://help.github.com/articles/editing-files-in-your-repository/)
+and edit the `index.md` file in the `docs` folder [directly in Github](https://help.github.com/articles/editing-files-in-your-repository/)
 
 ![](https://help.github.com/assets/images/help/repository/edit-file-edit-button.png)
 
@@ -26,10 +26,14 @@ To transform your plain text resume into a beautiful and shareable HTML page, yo
 
 ### I. Use Github Pages to publish it online
 
-1. Create a new branch called `gh-pages`.
-2. Head to *yourusername*.github.io/mdresume to see your resume live.
+1. Edit or move your resume to the `index.md` file in the `docs` folder.
+2. Go to settings > GitHub pages to make the changes shown.
 
-Any change you want to make to your CV from then on would have to be done on the `gh-pages` branch and will be immediately rendered by Github Pages.
+![](docs_setup.png)
+
+3. Head to *yourusername*.github.io/mdresume to see your resume live.
+
+Any change you want to make to your CV from then on would have to be done in the `docs` folder and will be immediately rendered by Github Pages.
 
 ## Styling