update/upgrade

85 files changed, 16041 insertions, 0 deletions

diff --git a/node_modules/postcss-fixes/node_modules/picocolors/LICENSE b/node_modules/postcss-fixes/node_modules/picocolors/LICENSE
new file mode 100644
index 00000000..496098c6
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/picocolors/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/postcss-fixes/node_modules/picocolors/README.md b/node_modules/postcss-fixes/node_modules/picocolors/README.md
new file mode 100644
index 00000000..a57b56db
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/picocolors/README.md
@@ -0,0 +1,23 @@
+# picocolors
+
+    npm install picocolors
+
+A tinier and faster alternative to [nanocolors](https://github.com/ai/nanocolors). Andrey, are you even trying?
+
+```javascript
+import pc from "picocolors";
+
+console.log(pc.green(`How are ${pc.italic(`you`)} doing?`));
+```
+
+- Up to [2x faster and 2x smaller](#benchmarks) than alternatives
+- 3x faster and 10x smaller than `chalk`
+- [TypeScript](https://www.typescriptlang.org/) support
+- [`NO_COLOR`](https://no-color.org/) friendly
+- Node.js v6+ & browsers support
+- The same API, but faster, much faster
+- No `String.prototype` modifications (anyone still doing it?)
+- No dependencies and the smallest `node_modules` footprint
+
+## Docs
+Read **[full docs](https://github.com/alexeyraspopov/picocolors#readme)** on GitHub.
diff --git a/node_modules/postcss-fixes/node_modules/picocolors/package.json b/node_modules/postcss-fixes/node_modules/picocolors/package.json
new file mode 100644
index 00000000..5da3b4d0
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/picocolors/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "picocolors",
+  "version": "0.2.1",
+  "main": "./picocolors.js",
+  "types": "./picocolors.d.ts",
+  "browser": {
+    "./picocolors.js": "./picocolors.browser.js"
+  },
+  "sideEffects": false,
+  "description": "The tiniest and the fastest coloring library ever",
+  "files": [
+    "picocolors.*",
+    "types.ts"
+  ],
+  "keywords": [
+    "terminal",
+    "colors",
+    "formatting",
+    "cli",
+    "console"
+  ],
+  "author": "Alexey Raspopov",
+  "repository": "alexeyraspopov/picocolors",
+  "license": "ISC"
+}
diff --git a/node_modules/postcss-fixes/node_modules/picocolors/picocolors.browser.js b/node_modules/postcss-fixes/node_modules/picocolors/picocolors.browser.js
new file mode 100644
index 00000000..5eb9fbe8
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/picocolors/picocolors.browser.js
@@ -0,0 +1,4 @@
+var x=String;
+var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x}};
+module.exports=create();
+module.exports.createColors = create;
diff --git a/node_modules/postcss-fixes/node_modules/picocolors/picocolors.d.ts b/node_modules/postcss-fixes/node_modules/picocolors/picocolors.d.ts
new file mode 100644
index 00000000..0ae2855b
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/picocolors/picocolors.d.ts
@@ -0,0 +1,5 @@
+import { Colors } from "./types"
+
+declare const picocolors: Colors & { createColors: (enabled: boolean) => Colors }
+
+export = picocolors
diff --git a/node_modules/postcss-fixes/node_modules/picocolors/picocolors.js b/node_modules/postcss-fixes/node_modules/picocolors/picocolors.js
new file mode 100644
index 00000000..5cebd7ca
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/picocolors/picocolors.js
@@ -0,0 +1,60 @@
+let tty = require("tty")
+
+let isColorSupported =
+	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
+	("FORCE_COLOR" in process.env ||
+		process.argv.includes("--color") ||
+		process.platform === "win32" ||
+		(tty.isatty(1) && process.env.TERM !== "dumb") ||
+		"CI" in process.env)
+
+function formatter(open, close, replace = open) {
+	return (input) => {
+		let string = "" + input
+		let index = string.indexOf(close, open.length)
+		return !~index
+			? open + string + close
+			: open + replaceClose(string, close, replace, index) + close
+	}
+}
+
+function replaceClose(string, close, replace, index) {
+	let start = string.substring(0, index) + replace
+	let end = string.substring(index + close.length)
+	let nextIndex = end.indexOf(close)
+	return !~nextIndex ? start + end : start + replaceClose(end, close, replace, nextIndex)
+}
+
+function createColors(enabled = isColorSupported) {
+	return {
+		isColorSupported: enabled,
+		reset: enabled ? (s) => `\x1b[0m${s}\x1b[0m` : String,
+		bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
+		dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
+		italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
+		underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
+		inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
+		hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
+		strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
+		black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
+		red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
+		green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
+		yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
+		blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
+		magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
+		cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
+		white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
+		gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
+		bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
+		bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
+		bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
+		bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
+		bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
+		bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
+		bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
+		bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
+	}
+}
+
+module.exports = createColors()
+module.exports.createColors = createColors
diff --git a/node_modules/postcss-fixes/node_modules/picocolors/types.ts b/node_modules/postcss-fixes/node_modules/picocolors/types.ts
new file mode 100644
index 00000000..b4bacee4
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/picocolors/types.ts
@@ -0,0 +1,30 @@
+export type Formatter = (input: string | number | null | undefined) => string
+
+export interface Colors {
+	isColorSupported: boolean
+	reset: Formatter
+	bold: Formatter
+	dim: Formatter
+	italic: Formatter
+	underline: Formatter
+	inverse: Formatter
+	hidden: Formatter
+	strikethrough: Formatter
+	black: Formatter
+	red: Formatter
+	green: Formatter
+	yellow: Formatter
+	blue: Formatter
+	magenta: Formatter
+	cyan: Formatter
+	white: Formatter
+	gray: Formatter
+	bgBlack: Formatter
+	bgRed: Formatter
+	bgGreen: Formatter
+	bgYellow: Formatter
+	bgBlue: Formatter
+	bgMagenta: Formatter
+	bgCyan: Formatter
+	bgWhite: Formatter
+}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/CHANGELOG.md b/node_modules/postcss-fixes/node_modules/postcss-calc/CHANGELOG.md
new file mode 100755
index 00000000..ccc723bd
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/CHANGELOG.md
@@ -0,0 +1,76 @@
+# 6.0.2 - 2018-09-25
+
+- Fixed: use PostCSS 7 (thanks to @douglasduteil)
+
+# 6.0.1 - 2017-10-10
+
+- Fixed: throwing error for attribute selectors without a value
+
+# 6.0.0 - 2017-05-08
+
+- Breaking: Updated PostCSS from v5.x to v6.x, and reduce-css-calc from v1.x
+  to v2.x (thanks to @andyjansson).
+
+# 5.3.1 - 2016-08-22
+
+- Fixed: avoid security issue related to ``reduce-css-calc@< 1.2.4``.
+
+# 5.3.0 - 2016-07-11
+
+- Added: support for selector transformation via `selectors` option.
+  ([#29](https://github.com/postcss/postcss-calc/pull/29) - @uniquegestaltung)
+
+# 5.2.1 - 2016-04-10
+
+- Fixed: support for multiline value
+  ([#27](https://github.com/postcss/postcss-calc/pull/27))

+
+# 5.2.0 - 2016-01-08
+
+- Added: "mediaQueries" option for `@media` support
+([#22](https://github.com/postcss/postcss-calc/pull/22))
+
+# 5.1.0 - 2016-01-07
+
+- Added: "warnWhenCannotResolve" option to warn when calc() are not reduced to a single value
+([#20](https://github.com/postcss/postcss-calc/pull/20))
+
+# 5.0.0 - 2015-08-25
+
+- Removed: compatibility with postcss v4.x
+- Added: compatibility with postcss v5.x
+
+# 4.1.0 - 2015-04-09
+
+- Added: compatibility with postcss v4.1.x ([#12](https://github.com/postcss/postcss-calc/pull/12))
+
+# 4.0.1 - 2015-04-09
+
+- Fixed: `preserve` option does not create duplicated values ([#7](https://github.com/postcss/postcss-calc/issues/7))
+
+# 4.0.0 - 2015-01-26
+
+- Added: compatibility with postcss v4.x
+- Changed: partial compatiblity with postcss v3.x (stack traces have lost filename)
+
+# 3.0.0 - 2014-11-24
+
+- Added: GNU like exceptions ([#4](https://github.com/postcss/postcss-calc/issues/4))
+- Added: `precision` option ([#5](https://github.com/postcss/postcss-calc/issues/5))
+- Added: `preserve` option ([#6](https://github.com/postcss/postcss-calc/issues/6))
+
+# 2.1.0 - 2014-10-15
+
+- Added: source of the error (gnu like message) (fix [#3](https://github.com/postcss/postcss-calc/issues/3))
+
+# 2.0.1 - 2014-08-10
+
+- Fixed: correctly ignore unrecognized values (fix [#2](https://github.com/postcss/postcss-calc/issues/2))
+
+# 2.0.0 - 2014-08-06
+
+- Changed: Plugin now return a function to have a consistent api. ([ref 1](https://github.com/ianstormtaylor/rework-color-function/issues/6), [ref 2](https://twitter.com/jongleberry/status/496552790416576513))
+
+# 1.0.0 - 2014-08-04
+
+✨ First release based on [rework-calc](https://github.com/reworkcss/rework-calc) v1.1.0 (code mainly exported to [`reduce-css-calc`](https://github.com/MoOx/reduce-css-calc))
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/LICENSE b/node_modules/postcss-fixes/node_modules/postcss-calc/LICENSE
new file mode 100755
index 00000000..8b39b8f1
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Maxime Thirouin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/README.md b/node_modules/postcss-fixes/node_modules/postcss-calc/README.md
new file mode 100755
index 00000000..4cabf731
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/README.md
@@ -0,0 +1,171 @@
+# postcss-calc [![Build Status](https://travis-ci.org/postcss/postcss-calc.png)](https://travis-ci.org/postcss/postcss-calc)
+
+> [PostCSS](https://github.com/postcss/postcss) plugin to reduce `calc()`.
+
+This plugin reduce `calc()` references whenever it's possible.
+This can be particularly useful with the [postcss-custom-properties](https://github.com/postcss/postcss-custom-properties) plugin.
+
+**Note:** When multiple units are mixed together in the same expression, the `calc()` statement is left as is, to fallback to the [w3c calc() feature](http://www.w3.org/TR/css3-values/#calc).
+
+## Installation
+
+```console
+$ npm install postcss-calc
+```
+
+## Usage
+
+```js
+// dependencies
+var fs = require("fs")
+var postcss = require("postcss")
+var calc = require("postcss-calc")
+
+// css to be processed
+var css = fs.readFileSync("input.css", "utf8")
+
+// process css
+var output = postcss()
+  .use(calc())
+  .process(css)
+  .css
+```
+
+**Example** (with [postcss-custom-properties](https://github.com/postcss/postcss-custom-properties) enabled as well):
+
+```js
+// dependencies
+var fs = require("fs")
+var postcss = require("postcss")
+var customProperties = require("postcss-custom-properties")
+var calc = require("postcss-calc")
+
+// css to be processed
+var css = fs.readFileSync("input.css", "utf8")
+
+// process css
+var output = postcss()
+  .use(customProperties())
+  .use(calc())
+  .process(css)
+  .css
+```
+
+Using this `input.css`:
+
+```css
+:root {
+  --main-font-size: 16px;
+}
+
+body {
+  font-size: var(--main-font-size);
+}
+
+h1 {
+  font-size: calc(var(--main-font-size) * 2);
+  height: calc(100px - 2em);
+  margin-bottom: calc(
+      var(--main-font-size)
+      * 1.5
+    )
+}
+```
+
+you will get:
+
+```css
+body {
+  font-size: 16px
+}
+
+h1 {
+  font-size: 32px;
+  height: calc(100px - 2em);
+  margin-bottom: 24px
+}
+```
+
+Checkout [tests](src/__tests__/index.js) for more examples.
+
+### Options
+
+#### `precision` (default: `5`)
+
+Allow you to define the precision for decimal numbers.
+
+```js
+var out = postcss()
+  .use(calc({precision: 10}))
+  .process(css)
+  .css
+```
+
+#### `preserve` (default: `false`)
+
+Allow you to preserve calc() usage in output so browsers will handle decimal precision themselves.
+
+```js
+var out = postcss()
+  .use(calc({preserve: true}))
+  .process(css)
+  .css
+```
+
+#### `warnWhenCannotResolve` (default: `false`)
+
+Adds warnings when calc() are not reduced to a single value.
+
+```js
+var out = postcss()
+  .use(calc({warnWhenCannotResolve: true}))
+  .process(css)
+  .css
+```
+
+#### `mediaQueries` (default: `false`)
+
+Allows calc() usage as part of media query declarations.
+
+```js
+var out = postcss()
+  .use(calc({mediaQueries: true}))
+  .process(css)
+  .css
+```
+
+#### `selectors` (default: `false`)
+
+Allows calc() usage as part of selectors.
+
+```js
+var out = postcss()
+  .use(calc({selectors: true}))
+  .process(css)
+  .css
+```
+
+Example:
+
+```css
+div[data-size="calc(3*3)"] {
+  width: 100px;
+}
+```
+
+---
+
+## Contributing
+
+Work on a branch, install dev-dependencies, respect coding style & run tests before submitting a bug fix or a feature.
+
+```console
+$ git clone https://github.com/postcss/postcss-calc.git
+$ git checkout -b patch-1
+$ npm install
+$ npm test
+```
+
+## [Changelog](CHANGELOG.md)
+
+## [License](LICENSE)
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/dist/index.js b/node_modules/postcss-fixes/node_modules/postcss-calc/dist/index.js
new file mode 100644
index 00000000..eb366d7b
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/dist/index.js
@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _postcss = require('postcss');
+
+var _transform = require('./lib/transform');
+
+var _transform2 = _interopRequireDefault(_transform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = (0, _postcss.plugin)('postcss-calc', function (opts) {
+  var options = Object.assign({
+    precision: 5,
+    preserve: false,
+    warnWhenCannotResolve: false,
+    mediaQueries: false,
+    selectors: false
+  }, opts);
+
+  return function (css, result) {
+    css.walk(function (node) {
+      var type = node.type;
+
+      if (type === 'decl') (0, _transform2.default)(node, "value", options, result);
+      if (type === 'atrule' && options.mediaQueries) (0, _transform2.default)(node, "params", options, result);
+      if (type === 'rule' && options.selectors) (0, _transform2.default)(node, "selector", options, result);
+    });
+  };
+});
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/dist/lib/transform.js b/node_modules/postcss-fixes/node_modules/postcss-calc/dist/lib/transform.js
new file mode 100644
index 00000000..1a4505f9
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/dist/lib/transform.js
@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _postcssSelectorParser = require('postcss-selector-parser');
+
+var _postcssSelectorParser2 = _interopRequireDefault(_postcssSelectorParser);
+
+var _reduceCssCalc = require('reduce-css-calc');
+
+var _reduceCssCalc2 = _interopRequireDefault(_reduceCssCalc);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var MATCH_CALC = /((?:\-[a-z]+\-)?calc)/;
+
+function transformValue(value, options, result, item) {
+  if (!value) {
+    return value;
+  }
+
+  var reduced = (0, _reduceCssCalc2.default)(value, options.precision);
+  // if the warnWhenCannotResolve option is on, inform the user that the calc
+  // expression could not be resolved to a single value
+  if (options.warnWhenCannotResolve && MATCH_CALC.test(reduced)) {
+    result.warn("Could not reduce expression: " + value, { plugin: 'postcss-calc', node: item });
+  }
+
+  return reduced;
+}
+
+function transformSelector(value, options, result, item) {
+  return (0, _postcssSelectorParser2.default)(function (selectors) {
+    selectors.walk(function (node) {
+      // attribute value
+      // e.g. the "calc(3*3)" part of "div[data-size="calc(3*3)"]"
+      if (node.type === 'attribute') {
+        var val = transformValue(node.raws.unquoted, options, result, item);
+        node.value = node.quoted ? '"' + val + '"' : val;
+      }
+
+      // tag value
+      // e.g. the "calc(3*3)" part of "div:nth-child(2n + calc(3*3))"
+      if (node.type === 'tag') node.value = transformValue(node.value, options, result, item);
+
+      return;
+    });
+  }).process(value).result.toString();
+}
+
+exports.default = function (node, property, options, result) {
+  var value = property === "selector" ? transformSelector(node[property], options, result, node) : transformValue(node[property], options, result, node);
+
+  // if the preserve option is enabled and the value has changed, write the
+  // transformed value into a cloned node which is inserted before the current
+  // node, preserving the original value. Otherwise, overwrite the original
+  // value.
+  if (options.preserve && node[property] !== value) {
+    var clone = node.clone();
+    clone[property] = value;
+    node.parent.insertBefore(node, clone);
+  } else node[property] = value;
+};
+
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/LICENSE b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/LICENSE
new file mode 100644
index 00000000..da057b45
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/README.md b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/README.md
new file mode 100644
index 00000000..af736927
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/README.md
@@ -0,0 +1,43 @@
+# PostCSS [![Gitter][chat-img]][chat]
+
+<img align="right" width="95" height="95"
+     alt="Philosopher’s stone, logo of PostCSS"
+     src="http://postcss.github.io/postcss/logo.svg">
+
+[chat-img]: https://img.shields.io/badge/Gitter-Join_the_PostCSS_chat-brightgreen.svg
+[chat]:     https://gitter.im/postcss/postcss
+
+PostCSS is a tool for transforming styles with JS plugins.
+These plugins can lint your CSS, support variables and mixins,
+transpile future CSS syntax, inline images, and more.
+
+PostCSS is used by industry leaders including Wikipedia, Twitter, Alibaba,
+and JetBrains. The [Autoprefixer] PostCSS plugin is one of the most popular
+CSS processors.
+
+PostCSS takes a CSS file and provides an API to analyze and modify its rules
+(by transforming them into an [Abstract Syntax Tree]).
+This API can then be used by [plugins] to do a lot of useful things,
+e.g. to find errors automatically insert vendor prefixes.
+
+**Support / Discussion:** [Gitter](https://gitter.im/postcss/postcss)<br>
+**Twitter account:**      [@postcss](https://twitter.com/postcss)<br>
+**VK.com page:**          [postcss](https://vk.com/postcss)<br>
+**中文翻译**:              [`README-cn.md`](./README-cn.md)
+
+For PostCSS commercial support (consulting, improving the front-end culture
+of your company, PostCSS plugins), contact [Evil Martians]
+at <surrender@evilmartians.com>.
+
+[Abstract Syntax Tree]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
+[Evil Martians]:        https://evilmartians.com/?utm_source=postcss
+[Autoprefixer]:         https://github.com/postcss/autoprefixer
+[plugins]:              https://github.com/postcss/postcss#plugins
+
+<a href="https://evilmartians.com/?utm_source=postcss">
+  <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+       alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+## Docs
+Read **[full docs](https://github.com/postcss/postcss#readme)** on GitHub.
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/at-rule.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/at-rule.js
new file mode 100644
index 00000000..ab053a7d
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/at-rule.js
@@ -0,0 +1,127 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _container = _interopRequireDefault(require("./container"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+/**
+ * Represents an at-rule.
+ *
+ * If it’s followed in the CSS by a {} block, this node will have
+ * a nodes property representing its children.
+ *
+ * @extends Container
+ *
+ * @example
+ * const root = postcss.parse('@charset "UTF-8"; @media print {}')
+ *
+ * const charset = root.first
+ * charset.type  //=> 'atrule'
+ * charset.nodes //=> undefined
+ *
+ * const media = root.last
+ * media.nodes   //=> []
+ */
+var AtRule = /*#__PURE__*/function (_Container) {
+  _inheritsLoose(AtRule, _Container);
+
+  function AtRule(defaults) {
+    var _this;
+
+    _this = _Container.call(this, defaults) || this;
+    _this.type = 'atrule';
+    return _this;
+  }
+
+  var _proto = AtRule.prototype;
+
+  _proto.append = function append() {
+    var _Container$prototype$;
+
+    if (!this.nodes) this.nodes = [];
+
+    for (var _len = arguments.length, children = new Array(_len), _key = 0; _key < _len; _key++) {
+      children[_key] = arguments[_key];
+    }
+
+    return (_Container$prototype$ = _Container.prototype.append).call.apply(_Container$prototype$, [this].concat(children));
+  };
+
+  _proto.prepend = function prepend() {
+    var _Container$prototype$2;
+
+    if (!this.nodes) this.nodes = [];
+
+    for (var _len2 = arguments.length, children = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      children[_key2] = arguments[_key2];
+    }
+
+    return (_Container$prototype$2 = _Container.prototype.prepend).call.apply(_Container$prototype$2, [this].concat(children));
+  }
+  /**
+   * @memberof AtRule#
+   * @member {string} name The at-rule’s name immediately follows the `@`.
+   *
+   * @example
+   * const root  = postcss.parse('@media print {}')
+   * media.name //=> 'media'
+   * const media = root.first
+   */
+
+  /**
+   * @memberof AtRule#
+   * @member {string} params The at-rule’s parameters, the values
+   *                         that follow the at-rule’s name but precede
+   *                         any {} block.
+   *
+   * @example
+   * const root  = postcss.parse('@media print, screen {}')
+   * const media = root.first
+   * media.params //=> 'print, screen'
+   */
+
+  /**
+   * @memberof AtRule#
+   * @member {object} raws Information to generate byte-to-byte equal
+   *                        node string as it was in the origin input.
+   *
+   * Every parser saves its own properties,
+   * but the default CSS parser uses:
+   *
+   * * `before`: the space symbols before the node. It also stores `*`
+   *   and `_` symbols before the declaration (IE hack).
+   * * `after`: the space symbols after the last child of the node
+   *   to the end of the node.
+   * * `between`: the symbols between the property and value
+   *   for declarations, selector and `{` for rules, or last parameter
+   *   and `{` for at-rules.
+   * * `semicolon`: contains true if the last child has
+   *   an (optional) semicolon.
+   * * `afterName`: the space between the at-rule name and its parameters.
+   *
+   * PostCSS cleans at-rule parameters from comments and extra spaces,
+   * but it stores origin content in raws properties.
+   * As such, if you don’t change a declaration’s value,
+   * PostCSS will use the raw value with comments.
+   *
+   * @example
+   * const root = postcss.parse('  @media\nprint {\n}')
+   * root.first.first.raws //=> { before: '  ',
+   *                       //     between: ' ',
+   *                       //     afterName: '\n',
+   *                       //     after: '\n' }
+   */
+  ;
+
+  return AtRule;
+}(_container.default);
+
+var _default = AtRule;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/comment.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/comment.js
new file mode 100644
index 00000000..345b5636
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/comment.js
@@ -0,0 +1,55 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+/**
+ * Represents a comment between declarations or statements (rule and at-rules).
+ *
+ * Comments inside selectors, at-rule parameters, or declaration values
+ * will be stored in the `raws` properties explained above.
+ *
+ * @extends Node
+ */
+var Comment = /*#__PURE__*/function (_Node) {
+  _inheritsLoose(Comment, _Node);
+
+  function Comment(defaults) {
+    var _this;
+
+    _this = _Node.call(this, defaults) || this;
+    _this.type = 'comment';
+    return _this;
+  }
+  /**
+   * @memberof Comment#
+   * @member {string} text The comment’s text.
+   */
+
+  /**
+   * @memberof Comment#
+   * @member {object} raws Information to generate byte-to-byte equal
+   *                       node string as it was in the origin input.
+   *
+   * Every parser saves its own properties,
+   * but the default CSS parser uses:
+   *
+   * * `before`: the space symbols before the node.
+   * * `left`: the space symbols between `/*` and the comment’s text.
+   * * `right`: the space symbols between the comment’s text.
+   */
+
+
+  return Comment;
+}(_node.default);
+
+var _default = Comment;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1lbnQuZXM2Il0sIm5hbWVzIjpbIkNvbW1lbnQiLCJkZWZhdWx0cyIsInR5cGUiLCJOb2RlIl0sIm1hcHBpbmdzIjoiOzs7OztBQUFBOzs7Ozs7QUFFQTs7Ozs7Ozs7SUFRTUEsTzs7O0FBQ0osbUJBQWFDLFFBQWIsRUFBdUI7QUFBQTs7QUFDckIsNkJBQU1BLFFBQU47QUFDQSxVQUFLQyxJQUFMLEdBQVksU0FBWjtBQUZxQjtBQUd0QjtBQUVEOzs7OztBQUtBOzs7Ozs7Ozs7Ozs7Ozs7RUFYb0JDLGE7O2VBeUJQSCxPIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IE5vZGUgZnJvbSAnLi9ub2RlJ1xuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBjb21tZW50IGJldHdlZW4gZGVjbGFyYXRpb25zIG9yIHN0YXRlbWVudHMgKHJ1bGUgYW5kIGF0LXJ1bGVzKS5cbiAqXG4gKiBDb21tZW50cyBpbnNpZGUgc2VsZWN0b3JzLCBhdC1ydWxlIHBhcmFtZXRlcnMsIG9yIGRlY2xhcmF0aW9uIHZhbHVlc1xuICogd2lsbCBiZSBzdG9yZWQgaW4gdGhlIGByYXdzYCBwcm9wZXJ0aWVzIGV4cGxhaW5lZCBhYm92ZS5cbiAqXG4gKiBAZXh0ZW5kcyBOb2RlXG4gKi9cbmNsYXNzIENvbW1lbnQgZXh0ZW5kcyBOb2RlIHtcbiAgY29uc3RydWN0b3IgKGRlZmF1bHRzKSB7XG4gICAgc3VwZXIoZGVmYXVsdHMpXG4gICAgdGhpcy50eXBlID0gJ2NvbW1lbnQnXG4gIH1cblxuICAvKipcbiAgICogQG1lbWJlcm9mIENvbW1lbnQjXG4gICAqIEBtZW1iZXIge3N0cmluZ30gdGV4dCBUaGUgY29tbWVudOKAmXMgdGV4dC5cbiAgICovXG5cbiAgLyoqXG4gICAqIEBtZW1iZXJvZiBDb21tZW50I1xuICAgKiBAbWVtYmVyIHtvYmplY3R9IHJhd3MgSW5mb3JtYXRpb24gdG8gZ2VuZXJhdGUgYnl0ZS10by1ieXRlIGVxdWFsXG4gICAqICAgICAgICAgICAgICAgICAgICAgICBub2RlIHN0cmluZyBhcyBpdCB3YXMgaW4gdGhlIG9yaWdpbiBpbnB1dC5cbiAgICpcbiAgICogRXZlcnkgcGFyc2VyIHNhdmVzIGl0cyBvd24gcHJvcGVydGllcyxcbiAgICogYnV0IHRoZSBkZWZhdWx0IENTUyBwYXJzZXIgdXNlczpcbiAgICpcbiAgICogKiBgYmVmb3JlYDogdGhlIHNwYWNlIHN5bWJvbHMgYmVmb3JlIHRoZSBub2RlLlxuICAgKiAqIGBsZWZ0YDogdGhlIHNwYWNlIHN5bWJvbHMgYmV0d2VlbiBgLypgIGFuZCB0aGUgY29tbWVudOKAmXMgdGV4dC5cbiAgICogKiBgcmlnaHRgOiB0aGUgc3BhY2Ugc3ltYm9scyBiZXR3ZWVuIHRoZSBjb21tZW504oCZcyB0ZXh0LlxuICAgKi9cbn1cblxuZXhwb3J0IGRlZmF1bHQgQ29tbWVudFxuIl0sImZpbGUiOiJjb21tZW50LmpzIn0=
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/container.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/container.js
new file mode 100644
index 00000000..ef97d56d
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/container.js
@@ -0,0 +1,774 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _declaration = _interopRequireDefault(require("./declaration"));
+
+var _comment = _interopRequireDefault(require("./comment"));
+
+var _node = _interopRequireDefault(require("./node"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+function cleanSource(nodes) {
+  return nodes.map(function (i) {
+    if (i.nodes) i.nodes = cleanSource(i.nodes);
+    delete i.source;
+    return i;
+  });
+}
+/**
+ * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes
+ * inherit some common methods to help work with their children.
+ *
+ * Note that all containers can store any content. If you write a rule inside
+ * a rule, PostCSS will parse it.
+ *
+ * @extends Node
+ * @abstract
+ */
+
+
+var Container = /*#__PURE__*/function (_Node) {
+  _inheritsLoose(Container, _Node);
+
+  function Container() {
+    return _Node.apply(this, arguments) || this;
+  }
+
+  var _proto = Container.prototype;
+
+  _proto.push = function push(child) {
+    child.parent = this;
+    this.nodes.push(child);
+    return this;
+  }
+  /**
+   * Iterates through the container’s immediate children,
+   * calling `callback` for each child.
+   *
+   * Returning `false` in the callback will break iteration.
+   *
+   * This method only iterates through the container’s immediate children.
+   * If you need to recursively iterate through all the container’s descendant
+   * nodes, use {@link Container#walk}.
+   *
+   * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
+   * if you are mutating the array of child nodes during iteration.
+   * PostCSS will adjust the current index to match the mutations.
+   *
+   * @param {childIterator} callback Iterator receives each node and index.
+   *
+   * @return {false|undefined} Returns `false` if iteration was broke.
+   *
+   * @example
+   * const root = postcss.parse('a { color: black; z-index: 1 }')
+   * const rule = root.first
+   *
+   * for (const decl of rule.nodes) {
+   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
+   *   // Cycle will be infinite, because cloneBefore moves the current node
+   *   // to the next index
+   * }
+   *
+   * rule.each(decl => {
+   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
+   *   // Will be executed only for color and z-index
+   * })
+   */
+  ;
+
+  _proto.each = function each(callback) {
+    if (!this.lastEach) this.lastEach = 0;
+    if (!this.indexes) this.indexes = {};
+    this.lastEach += 1;
+    var id = this.lastEach;
+    this.indexes[id] = 0;
+    if (!this.nodes) return undefined;
+    var index, result;
+
+    while (this.indexes[id] < this.nodes.length) {
+      index = this.indexes[id];
+      result = callback(this.nodes[index], index);
+      if (result === false) break;
+      this.indexes[id] += 1;
+    }
+
+    delete this.indexes[id];
+    return result;
+  }
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each node.
+   *
+   * Like container.each(), this method is safe to use
+   * if you are mutating arrays during iteration.
+   *
+   * If you only need to iterate through the container’s immediate children,
+   * use {@link Container#each}.
+   *
+   * @param {childIterator} callback Iterator receives each node and index.
+   *
+   * @return {false|undefined} Returns `false` if iteration was broke.
+   *
+   * @example
+   * root.walk(node => {
+   *   // Traverses all descendant nodes.
+   * })
+   */
+  ;
+
+  _proto.walk = function walk(callback) {
+    return this.each(function (child, i) {
+      var result;
+
+      try {
+        result = callback(child, i);
+      } catch (e) {
+        e.postcssNode = child;
+
+        if (e.stack && child.source && /\n\s{4}at /.test(e.stack)) {
+          var s = child.source;
+          e.stack = e.stack.replace(/\n\s{4}at /, "$&" + s.input.from + ":" + s.start.line + ":" + s.start.column + "$&");
+        }
+
+        throw e;
+      }
+
+      if (result !== false && child.walk) {
+        result = child.walk(callback);
+      }
+
+      return result;
+    });
+  }
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each declaration node.
+   *
+   * If you pass a filter, iteration will only happen over declarations
+   * with matching properties.
+   *
+   * Like {@link Container#each}, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * @param {string|RegExp} [prop]   String or regular expression
+   *                                 to filter declarations by property name.
+   * @param {childIterator} callback Iterator receives each node and index.
+   *
+   * @return {false|undefined} Returns `false` if iteration was broke.
+   *
+   * @example
+   * root.walkDecls(decl => {
+   *   checkPropertySupport(decl.prop)
+   * })
+   *
+   * root.walkDecls('border-radius', decl => {
+   *   decl.remove()
+   * })
+   *
+   * root.walkDecls(/^background/, decl => {
+   *   decl.value = takeFirstColorFromGradient(decl.value)
+   * })
+   */
+  ;
+
+  _proto.walkDecls = function walkDecls(prop, callback) {
+    if (!callback) {
+      callback = prop;
+      return this.walk(function (child, i) {
+        if (child.type === 'decl') {
+          return callback(child, i);
+        }
+      });
+    }
+
+    if (prop instanceof RegExp) {
+      return this.walk(function (child, i) {
+        if (child.type === 'decl' && prop.test(child.prop)) {
+          return callback(child, i);
+        }
+      });
+    }
+
+    return this.walk(function (child, i) {
+      if (child.type === 'decl' && child.prop === prop) {
+        return callback(child, i);
+      }
+    });
+  }
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each rule node.
+   *
+   * If you pass a filter, iteration will only happen over rules
+   * with matching selectors.
+   *
+   * Like {@link Container#each}, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * @param {string|RegExp} [selector] String or regular expression
+   *                                   to filter rules by selector.
+   * @param {childIterator} callback   Iterator receives each node and index.
+   *
+   * @return {false|undefined} returns `false` if iteration was broke.
+   *
+   * @example
+   * const selectors = []
+   * root.walkRules(rule => {
+   *   selectors.push(rule.selector)
+   * })
+   * console.log(`Your CSS uses ${ selectors.length } selectors`)
+   */
+  ;
+
+  _proto.walkRules = function walkRules(selector, callback) {
+    if (!callback) {
+      callback = selector;
+      return this.walk(function (child, i) {
+        if (child.type === 'rule') {
+          return callback(child, i);
+        }
+      });
+    }
+
+    if (selector instanceof RegExp) {
+      return this.walk(function (child, i) {
+        if (child.type === 'rule' && selector.test(child.selector)) {
+          return callback(child, i);
+        }
+      });
+    }
+
+    return this.walk(function (child, i) {
+      if (child.type === 'rule' && child.selector === selector) {
+        return callback(child, i);
+      }
+    });
+  }
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each at-rule node.
+   *
+   * If you pass a filter, iteration will only happen over at-rules
+   * that have matching names.
+   *
+   * Like {@link Container#each}, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * @param {string|RegExp} [name]   String or regular expression
+   *                                 to filter at-rules by name.
+   * @param {childIterator} callback Iterator receives each node and index.
+   *
+   * @return {false|undefined} Returns `false` if iteration was broke.
+   *
+   * @example
+   * root.walkAtRules(rule => {
+   *   if (isOld(rule.name)) rule.remove()
+   * })
+   *
+   * let first = false
+   * root.walkAtRules('charset', rule => {
+   *   if (!first) {
+   *     first = true
+   *   } else {
+   *     rule.remove()
+   *   }
+   * })
+   */
+  ;
+
+  _proto.walkAtRules = function walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name;
+      return this.walk(function (child, i) {
+        if (child.type === 'atrule') {
+          return callback(child, i);
+        }
+      });
+    }
+
+    if (name instanceof RegExp) {
+      return this.walk(function (child, i) {
+        if (child.type === 'atrule' && name.test(child.name)) {
+          return callback(child, i);
+        }
+      });
+    }
+
+    return this.walk(function (child, i) {
+      if (child.type === 'atrule' && child.name === name) {
+        return callback(child, i);
+      }
+    });
+  }
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each comment node.
+   *
+   * Like {@link Container#each}, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * @param {childIterator} callback Iterator receives each node and index.
+   *
+   * @return {false|undefined} Returns `false` if iteration was broke.
+   *
+   * @example
+   * root.walkComments(comment => {
+   *   comment.remove()
+   * })
+   */
+  ;
+
+  _proto.walkComments = function walkComments(callback) {
+    return this.walk(function (child, i) {
+      if (child.type === 'comment') {
+        return callback(child, i);
+      }
+    });
+  }
+  /**
+   * Inserts new nodes to the end of the container.
+   *
+   * @param {...(Node|object|string|Node[])} children New nodes.
+   *
+   * @return {Node} This node for methods chain.
+   *
+   * @example
+   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })
+   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })
+   * rule.append(decl1, decl2)
+   *
+   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
+   * root.append({ selector: 'a' })                       // rule
+   * rule.append({ prop: 'color', value: 'black' })       // declaration
+   * rule.append({ text: 'Comment' })                     // comment
+   *
+   * root.append('a {}')
+   * root.first.append('color: black; z-index: 1')
+   */
+  ;
+
+  _proto.append = function append() {
+    for (var _len = arguments.length, children = new Array(_len), _key = 0; _key < _len; _key++) {
+      children[_key] = arguments[_key];
+    }
+
+    for (var _i = 0, _children = children; _i < _children.length; _i++) {
+      var child = _children[_i];
+      var nodes = this.normalize(child, this.last);
+
+      for (var _iterator = _createForOfIteratorHelperLoose(nodes), _step; !(_step = _iterator()).done;) {
+        var node = _step.value;
+        this.nodes.push(node);
+      }
+    }
+
+    return this;
+  }
+  /**
+   * Inserts new nodes to the start of the container.
+   *
+   * @param {...(Node|object|string|Node[])} children New nodes.
+   *
+   * @return {Node} This node for methods chain.
+   *
+   * @example
+   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })
+   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })
+   * rule.prepend(decl1, decl2)
+   *
+   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
+   * root.append({ selector: 'a' })                       // rule
+   * rule.append({ prop: 'color', value: 'black' })       // declaration
+   * rule.append({ text: 'Comment' })                     // comment
+   *
+   * root.append('a {}')
+   * root.first.append('color: black; z-index: 1')
+   */
+  ;
+
+  _proto.prepend = function prepend() {
+    for (var _len2 = arguments.length, children = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      children[_key2] = arguments[_key2];
+    }
+
+    children = children.reverse();
+
+    for (var _iterator2 = _createForOfIteratorHelperLoose(children), _step2; !(_step2 = _iterator2()).done;) {
+      var child = _step2.value;
+      var nodes = this.normalize(child, this.first, 'prepend').reverse();
+
+      for (var _iterator3 = _createForOfIteratorHelperLoose(nodes), _step3; !(_step3 = _iterator3()).done;) {
+        var node = _step3.value;
+        this.nodes.unshift(node);
+      }
+
+      for (var id in this.indexes) {
+        this.indexes[id] = this.indexes[id] + nodes.length;
+      }
+    }
+
+    return this;
+  };
+
+  _proto.cleanRaws = function cleanRaws(keepBetween) {
+    _Node.prototype.cleanRaws.call(this, keepBetween);
+
+    if (this.nodes) {
+      for (var _iterator4 = _createForOfIteratorHelperLoose(this.nodes), _step4; !(_step4 = _iterator4()).done;) {
+        var node = _step4.value;
+        node.cleanRaws(keepBetween);
+      }
+    }
+  }
+  /**
+   * Insert new node before old node within the container.
+   *
+   * @param {Node|number} exist             Child or child’s index.
+   * @param {Node|object|string|Node[]} add New node.
+   *
+   * @return {Node} This node for methods chain.
+   *
+   * @example
+   * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }))
+   */
+  ;
+
+  _proto.insertBefore = function insertBefore(exist, add) {
+    exist = this.index(exist);
+    var type = exist === 0 ? 'prepend' : false;
+    var nodes = this.normalize(add, this.nodes[exist], type).reverse();
+
+    for (var _iterator5 = _createForOfIteratorHelperLoose(nodes), _step5; !(_step5 = _iterator5()).done;) {
+      var node = _step5.value;
+      this.nodes.splice(exist, 0, node);
+    }
+
+    var index;
+
+    for (var id in this.indexes) {
+      index = this.indexes[id];
+
+      if (exist <= index) {
+        this.indexes[id] = index + nodes.length;
+      }
+    }
+
+    return this;
+  }
+  /**
+   * Insert new node after old node within the container.
+   *
+   * @param {Node|number} exist             Child or child’s index.
+   * @param {Node|object|string|Node[]} add New node.
+   *
+   * @return {Node} This node for methods chain.
+   */
+  ;
+
+  _proto.insertAfter = function insertAfter(exist, add) {
+    exist = this.index(exist);
+    var nodes = this.normalize(add, this.nodes[exist]).reverse();
+
+    for (var _iterator6 = _createForOfIteratorHelperLoose(nodes), _step6; !(_step6 = _iterator6()).done;) {
+      var node = _step6.value;
+      this.nodes.splice(exist + 1, 0, node);
+    }
+
+    var index;
+
+    for (var id in this.indexes) {
+      index = this.indexes[id];
+
+      if (exist < index) {
+        this.indexes[id] = index + nodes.length;
+      }
+    }
+
+    return this;
+  }
+  /**
+   * Removes node from the container and cleans the parent properties
+   * from the node and its children.
+   *
+   * @param {Node|number} child Child or child’s index.
+   *
+   * @return {Node} This node for methods chain
+   *
+   * @example
+   * rule.nodes.length  //=> 5
+   * rule.removeChild(decl)
+   * rule.nodes.length  //=> 4
+   * decl.parent        //=> undefined
+   */
+  ;
+
+  _proto.removeChild = function removeChild(child) {
+    child = this.index(child);
+    this.nodes[child].parent = undefined;
+    this.nodes.splice(child, 1);
+    var index;
+
+    for (var id in this.indexes) {
+      index = this.indexes[id];
+
+      if (index >= child) {
+        this.indexes[id] = index - 1;
+      }
+    }
+
+    return this;
+  }
+  /**
+   * Removes all children from the container
+   * and cleans their parent properties.
+   *
+   * @return {Node} This node for methods chain.
+   *
+   * @example
+   * rule.removeAll()
+   * rule.nodes.length //=> 0
+   */
+  ;
+
+  _proto.removeAll = function removeAll() {
+    for (var _iterator7 = _createForOfIteratorHelperLoose(this.nodes), _step7; !(_step7 = _iterator7()).done;) {
+      var node = _step7.value;
+      node.parent = undefined;
+    }
+
+    this.nodes = [];
+    return this;
+  }
+  /**
+   * Passes all declaration values within the container that match pattern
+   * through callback, replacing those values with the returned result
+   * of callback.
+   *
+   * This method is useful if you are using a custom unit or function
+   * and need to iterate through all values.
+   *
+   * @param {string|RegExp} pattern      Replace pattern.
+   * @param {object} opts                Options to speed up the search.
+   * @param {string|string[]} opts.props An array of property names.
+   * @param {string} opts.fast           String that’s used to narrow down
+   *                                     values and speed up the regexp search.
+   * @param {function|string} callback   String to replace pattern or callback
+   *                                     that returns a new value. The callback
+   *                                     will receive the same arguments
+   *                                     as those passed to a function parameter
+   *                                     of `String#replace`.
+   *
+   * @return {Node} This node for methods chain.
+   *
+   * @example
+   * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
+   *   return 15 * parseInt(string) + 'px'
+   * })
+   */
+  ;
+
+  _proto.replaceValues = function replaceValues(pattern, opts, callback) {
+    if (!callback) {
+      callback = opts;
+      opts = {};
+    }
+
+    this.walkDecls(function (decl) {
+      if (opts.props && opts.props.indexOf(decl.prop) === -1) return;
+      if (opts.fast && decl.value.indexOf(opts.fast) === -1) return;
+      decl.value = decl.value.replace(pattern, callback);
+    });
+    return this;
+  }
+  /**
+   * Returns `true` if callback returns `true`
+   * for all of the container’s children.
+   *
+   * @param {childCondition} condition Iterator returns true or false.
+   *
+   * @return {boolean} Is every child pass condition.
+   *
+   * @example
+   * const noPrefixes = rule.every(i => i.prop[0] !== '-')
+   */
+  ;
+
+  _proto.every = function every(condition) {
+    return this.nodes.every(condition);
+  }
+  /**
+   * Returns `true` if callback returns `true` for (at least) one
+   * of the container’s children.
+   *
+   * @param {childCondition} condition Iterator returns true or false.
+   *
+   * @return {boolean} Is some child pass condition.
+   *
+   * @example
+   * const hasPrefix = rule.some(i => i.prop[0] === '-')
+   */
+  ;
+
+  _proto.some = function some(condition) {
+    return this.nodes.some(condition);
+  }
+  /**
+   * Returns a `child`’s index within the {@link Container#nodes} array.
+   *
+   * @param {Node} child Child of the current container.
+   *
+   * @return {number} Child index.
+   *
+   * @example
+   * rule.index( rule.nodes[2] ) //=> 2
+   */
+  ;
+
+  _proto.index = function index(child) {
+    if (typeof child === 'number') {
+      return child;
+    }
+
+    return this.nodes.indexOf(child);
+  }
+  /**
+   * The container’s first child.
+   *
+   * @type {Node}
+   *
+   * @example
+   * rule.first === rules.nodes[0]
+   */
+  ;
+
+  _proto.normalize = function normalize(nodes, sample) {
+    var _this = this;
+
+    if (typeof nodes === 'string') {
+      var parse = require('./parse');
+
+      nodes = cleanSource(parse(nodes).nodes);
+    } else if (Array.isArray(nodes)) {
+      nodes = nodes.slice(0);
+
+      for (var _iterator8 = _createForOfIteratorHelperLoose(nodes), _step8; !(_step8 = _iterator8()).done;) {
+        var i = _step8.value;
+        if (i.parent) i.parent.removeChild(i, 'ignore');
+      }
+    } else if (nodes.type === 'root') {
+      nodes = nodes.nodes.slice(0);
+
+      for (var _iterator9 = _createForOfIteratorHelperLoose(nodes), _step9; !(_step9 = _iterator9()).done;) {
+        var _i2 = _step9.value;
+        if (_i2.parent) _i2.parent.removeChild(_i2, 'ignore');
+      }
+    } else if (nodes.type) {
+      nodes = [nodes];
+    } else if (nodes.prop) {
+      if (typeof nodes.value === 'undefined') {
+        throw new Error('Value field is missed in node creation');
+      } else if (typeof nodes.value !== 'string') {
+        nodes.value = String(nodes.value);
+      }
+
+      nodes = [new _declaration.default(nodes)];
+    } else if (nodes.selector) {
+      var Rule = require('./rule');
+
+      nodes = [new Rule(nodes)];
+    } else if (nodes.name) {
+      var AtRule = require('./at-rule');
+
+      nodes = [new AtRule(nodes)];
+    } else if (nodes.text) {
+      nodes = [new _comment.default(nodes)];
+    } else {
+      throw new Error('Unknown node type in node creation');
+    }
+
+    var processed = nodes.map(function (i) {
+      if (i.parent) i.parent.removeChild(i);
+
+      if (typeof i.raws.before === 'undefined') {
+        if (sample && typeof sample.raws.before !== 'undefined') {
+          i.raws.before = sample.raws.before.replace(/[^\s]/g, '');
+        }
+      }
+
+      i.parent = _this;
+      return i;
+    });
+    return processed;
+  }
+  /**
+   * @memberof Container#
+   * @member {Node[]} nodes An array containing the container’s children.
+   *
+   * @example
+   * const root = postcss.parse('a { color: black }')
+   * root.nodes.length           //=> 1
+   * root.nodes[0].selector      //=> 'a'
+   * root.nodes[0].nodes[0].prop //=> 'color'
+   */
+  ;
+
+  _createClass(Container, [{
+    key: "first",
+    get: function get() {
+      if (!this.nodes) return undefined;
+      return this.nodes[0];
+    }
+    /**
+     * The container’s last child.
+     *
+     * @type {Node}
+     *
+     * @example
+     * rule.last === rule.nodes[rule.nodes.length - 1]
+     */
+
+  }, {
+    key: "last",
+    get: function get() {
+      if (!this.nodes) return undefined;
+      return this.nodes[this.nodes.length - 1];
+    }
+  }]);
+
+  return Container;
+}(_node.default);
+
+var _default = Container;
+/**
+ * @callback childCondition
+ * @param {Node} node    Container child.
+ * @param {number} index Child index.
+ * @param {Node[]} nodes All container children.
+ * @return {boolean}
+ */
+
+/**
+ * @callback childIterator
+ * @param {Node} node    Container child.
+ * @param {number} index Child index.
+ * @return {false|undefined} Returning `false` will break iteration.
+ */
+
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["container.es6"],"names":["cleanSource","nodes","map","i","source","Container","push","child","parent","each","callback","lastEach","indexes","id","undefined","index","result","length","walk","e","postcssNode","stack","test","s","replace","input","from","start","line","column","walkDecls","prop","type","RegExp","walkRules","selector","walkAtRules","name","walkComments","append","children","normalize","last","node","prepend","reverse","first","unshift","cleanRaws","keepBetween","insertBefore","exist","add","splice","insertAfter","removeChild","removeAll","replaceValues","pattern","opts","decl","props","indexOf","fast","value","every","condition","some","sample","parse","require","Array","isArray","slice","Error","String","Declaration","Rule","AtRule","text","Comment","processed","raws","before","Node"],"mappings":"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","sourcesContent":["import Declaration from './declaration'\nimport Comment from './comment'\nimport Node from './node'\n\nfunction cleanSource (nodes) {\n  return nodes.map(i => {\n    if (i.nodes) i.nodes = cleanSource(i.nodes)\n    delete i.source\n    return i\n  })\n}\n\n/**\n * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes\n * inherit some common methods to help work with their children.\n *\n * Note that all containers can store any content. If you write a rule inside\n * a rule, PostCSS will parse it.\n *\n * @extends Node\n * @abstract\n */\nclass Container extends Node {\n  push (child) {\n    child.parent = this\n    this.nodes.push(child)\n    return this\n  }\n\n  /**\n   * Iterates through the container’s immediate children,\n   * calling `callback` for each child.\n   *\n   * Returning `false` in the callback will break iteration.\n   *\n   * This method only iterates through the container’s immediate children.\n   * If you need to recursively iterate through all the container’s descendant\n   * nodes, use {@link Container#walk}.\n   *\n   * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe\n   * if you are mutating the array of child nodes during iteration.\n   * PostCSS will adjust the current index to match the mutations.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black; z-index: 1 }')\n   * const rule = root.first\n   *\n   * for (const decl of rule.nodes) {\n   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })\n   *   // Cycle will be infinite, because cloneBefore moves the current node\n   *   // to the next index\n   * }\n   *\n   * rule.each(decl => {\n   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })\n   *   // Will be executed only for color and z-index\n   * })\n   */\n  each (callback) {\n    if (!this.lastEach) this.lastEach = 0\n    if (!this.indexes) this.indexes = { }\n\n    this.lastEach += 1\n    let id = this.lastEach\n    this.indexes[id] = 0\n\n    if (!this.nodes) return undefined\n\n    let index, result\n    while (this.indexes[id] < this.nodes.length) {\n      index = this.indexes[id]\n      result = callback(this.nodes[index], index)\n      if (result === false) break\n\n      this.indexes[id] += 1\n    }\n\n    delete this.indexes[id]\n\n    return result\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each node.\n   *\n   * Like container.each(), this method is safe to use\n   * if you are mutating arrays during iteration.\n   *\n   * If you only need to iterate through the container’s immediate children,\n   * use {@link Container#each}.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walk(node => {\n   *   // Traverses all descendant nodes.\n   * })\n   */\n  walk (callback) {\n    return this.each((child, i) => {\n      let result\n      try {\n        result = callback(child, i)\n      } catch (e) {\n        e.postcssNode = child\n        if (e.stack && child.source && /\\n\\s{4}at /.test(e.stack)) {\n          let s = child.source\n          e.stack = e.stack.replace(/\\n\\s{4}at /,\n            `$&${ s.input.from }:${ s.start.line }:${ s.start.column }$&`)\n        }\n        throw e\n      }\n      if (result !== false && child.walk) {\n        result = child.walk(callback)\n      }\n      return result\n    })\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each declaration node.\n   *\n   * If you pass a filter, iteration will only happen over declarations\n   * with matching properties.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [prop]   String or regular expression\n   *                                 to filter declarations by property name.\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkDecls(decl => {\n   *   checkPropertySupport(decl.prop)\n   * })\n   *\n   * root.walkDecls('border-radius', decl => {\n   *   decl.remove()\n   * })\n   *\n   * root.walkDecls(/^background/, decl => {\n   *   decl.value = takeFirstColorFromGradient(decl.value)\n   * })\n   */\n  walkDecls (prop, callback) {\n    if (!callback) {\n      callback = prop\n      return this.walk((child, i) => {\n        if (child.type === 'decl') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (prop instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'decl' && prop.test(child.prop)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'decl' && child.prop === prop) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each rule node.\n   *\n   * If you pass a filter, iteration will only happen over rules\n   * with matching selectors.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [selector] String or regular expression\n   *                                   to filter rules by selector.\n   * @param {childIterator} callback   Iterator receives each node and index.\n   *\n   * @return {false|undefined} returns `false` if iteration was broke.\n   *\n   * @example\n   * const selectors = []\n   * root.walkRules(rule => {\n   *   selectors.push(rule.selector)\n   * })\n   * console.log(`Your CSS uses ${ selectors.length } selectors`)\n   */\n  walkRules (selector, callback) {\n    if (!callback) {\n      callback = selector\n\n      return this.walk((child, i) => {\n        if (child.type === 'rule') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (selector instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'rule' && selector.test(child.selector)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'rule' && child.selector === selector) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each at-rule node.\n   *\n   * If you pass a filter, iteration will only happen over at-rules\n   * that have matching names.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {string|RegExp} [name]   String or regular expression\n   *                                 to filter at-rules by name.\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkAtRules(rule => {\n   *   if (isOld(rule.name)) rule.remove()\n   * })\n   *\n   * let first = false\n   * root.walkAtRules('charset', rule => {\n   *   if (!first) {\n   *     first = true\n   *   } else {\n   *     rule.remove()\n   *   }\n   * })\n   */\n  walkAtRules (name, callback) {\n    if (!callback) {\n      callback = name\n      return this.walk((child, i) => {\n        if (child.type === 'atrule') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (name instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'atrule' && name.test(child.name)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'atrule' && child.name === name) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  /**\n   * Traverses the container’s descendant nodes, calling callback\n   * for each comment node.\n   *\n   * Like {@link Container#each}, this method is safe\n   * to use if you are mutating arrays during iteration.\n   *\n   * @param {childIterator} callback Iterator receives each node and index.\n   *\n   * @return {false|undefined} Returns `false` if iteration was broke.\n   *\n   * @example\n   * root.walkComments(comment => {\n   *   comment.remove()\n   * })\n   */\n  walkComments (callback) {\n    return this.walk((child, i) => {\n      if (child.type === 'comment') {\n        return callback(child, i)\n      }\n    })\n  }\n\n  /**\n   * Inserts new nodes to the end of the container.\n   *\n   * @param {...(Node|object|string|Node[])} children New nodes.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })\n   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })\n   * rule.append(decl1, decl2)\n   *\n   * root.append({ name: 'charset', params: '\"UTF-8\"' })  // at-rule\n   * root.append({ selector: 'a' })                       // rule\n   * rule.append({ prop: 'color', value: 'black' })       // declaration\n   * rule.append({ text: 'Comment' })                     // comment\n   *\n   * root.append('a {}')\n   * root.first.append('color: black; z-index: 1')\n   */\n  append (...children) {\n    for (let child of children) {\n      let nodes = this.normalize(child, this.last)\n      for (let node of nodes) this.nodes.push(node)\n    }\n    return this\n  }\n\n  /**\n   * Inserts new nodes to the start of the container.\n   *\n   * @param {...(Node|object|string|Node[])} children New nodes.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * const decl1 = postcss.decl({ prop: 'color', value: 'black' })\n   * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' })\n   * rule.prepend(decl1, decl2)\n   *\n   * root.append({ name: 'charset', params: '\"UTF-8\"' })  // at-rule\n   * root.append({ selector: 'a' })                       // rule\n   * rule.append({ prop: 'color', value: 'black' })       // declaration\n   * rule.append({ text: 'Comment' })                     // comment\n   *\n   * root.append('a {}')\n   * root.first.append('color: black; z-index: 1')\n   */\n  prepend (...children) {\n    children = children.reverse()\n    for (let child of children) {\n      let nodes = this.normalize(child, this.first, 'prepend').reverse()\n      for (let node of nodes) this.nodes.unshift(node)\n      for (let id in this.indexes) {\n        this.indexes[id] = this.indexes[id] + nodes.length\n      }\n    }\n    return this\n  }\n\n  cleanRaws (keepBetween) {\n    super.cleanRaws(keepBetween)\n    if (this.nodes) {\n      for (let node of this.nodes) node.cleanRaws(keepBetween)\n    }\n  }\n\n  /**\n   * Insert new node before old node within the container.\n   *\n   * @param {Node|number} exist             Child or child’s index.\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }))\n   */\n  insertBefore (exist, add) {\n    exist = this.index(exist)\n\n    let type = exist === 0 ? 'prepend' : false\n    let nodes = this.normalize(add, this.nodes[exist], type).reverse()\n    for (let node of nodes) this.nodes.splice(exist, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (exist <= index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Insert new node after old node within the container.\n   *\n   * @param {Node|number} exist             Child or child’s index.\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   */\n  insertAfter (exist, add) {\n    exist = this.index(exist)\n\n    let nodes = this.normalize(add, this.nodes[exist]).reverse()\n    for (let node of nodes) this.nodes.splice(exist + 1, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (exist < index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Removes node from the container and cleans the parent properties\n   * from the node and its children.\n   *\n   * @param {Node|number} child Child or child’s index.\n   *\n   * @return {Node} This node for methods chain\n   *\n   * @example\n   * rule.nodes.length  //=> 5\n   * rule.removeChild(decl)\n   * rule.nodes.length  //=> 4\n   * decl.parent        //=> undefined\n   */\n  removeChild (child) {\n    child = this.index(child)\n    this.nodes[child].parent = undefined\n    this.nodes.splice(child, 1)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (index >= child) {\n        this.indexes[id] = index - 1\n      }\n    }\n\n    return this\n  }\n\n  /**\n   * Removes all children from the container\n   * and cleans their parent properties.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * rule.removeAll()\n   * rule.nodes.length //=> 0\n   */\n  removeAll () {\n    for (let node of this.nodes) node.parent = undefined\n    this.nodes = []\n    return this\n  }\n\n  /**\n   * Passes all declaration values within the container that match pattern\n   * through callback, replacing those values with the returned result\n   * of callback.\n   *\n   * This method is useful if you are using a custom unit or function\n   * and need to iterate through all values.\n   *\n   * @param {string|RegExp} pattern      Replace pattern.\n   * @param {object} opts                Options to speed up the search.\n   * @param {string|string[]} opts.props An array of property names.\n   * @param {string} opts.fast           String that’s used to narrow down\n   *                                     values and speed up the regexp search.\n   * @param {function|string} callback   String to replace pattern or callback\n   *                                     that returns a new value. The callback\n   *                                     will receive the same arguments\n   *                                     as those passed to a function parameter\n   *                                     of `String#replace`.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * root.replaceValues(/\\d+rem/, { fast: 'rem' }, string => {\n   *   return 15 * parseInt(string) + 'px'\n   * })\n   */\n  replaceValues (pattern, opts, callback) {\n    if (!callback) {\n      callback = opts\n      opts = { }\n    }\n\n    this.walkDecls(decl => {\n      if (opts.props && opts.props.indexOf(decl.prop) === -1) return\n      if (opts.fast && decl.value.indexOf(opts.fast) === -1) return\n\n      decl.value = decl.value.replace(pattern, callback)\n    })\n\n    return this\n  }\n\n  /**\n   * Returns `true` if callback returns `true`\n   * for all of the container’s children.\n   *\n   * @param {childCondition} condition Iterator returns true or false.\n   *\n   * @return {boolean} Is every child pass condition.\n   *\n   * @example\n   * const noPrefixes = rule.every(i => i.prop[0] !== '-')\n   */\n  every (condition) {\n    return this.nodes.every(condition)\n  }\n\n  /**\n   * Returns `true` if callback returns `true` for (at least) one\n   * of the container’s children.\n   *\n   * @param {childCondition} condition Iterator returns true or false.\n   *\n   * @return {boolean} Is some child pass condition.\n   *\n   * @example\n   * const hasPrefix = rule.some(i => i.prop[0] === '-')\n   */\n  some (condition) {\n    return this.nodes.some(condition)\n  }\n\n  /**\n   * Returns a `child`’s index within the {@link Container#nodes} array.\n   *\n   * @param {Node} child Child of the current container.\n   *\n   * @return {number} Child index.\n   *\n   * @example\n   * rule.index( rule.nodes[2] ) //=> 2\n   */\n  index (child) {\n    if (typeof child === 'number') {\n      return child\n    }\n    return this.nodes.indexOf(child)\n  }\n\n  /**\n   * The container’s first child.\n   *\n   * @type {Node}\n   *\n   * @example\n   * rule.first === rules.nodes[0]\n   */\n  get first () {\n    if (!this.nodes) return undefined\n    return this.nodes[0]\n  }\n\n  /**\n   * The container’s last child.\n   *\n   * @type {Node}\n   *\n   * @example\n   * rule.last === rule.nodes[rule.nodes.length - 1]\n   */\n  get last () {\n    if (!this.nodes) return undefined\n    return this.nodes[this.nodes.length - 1]\n  }\n\n  normalize (nodes, sample) {\n    if (typeof nodes === 'string') {\n      let parse = require('./parse')\n      nodes = cleanSource(parse(nodes).nodes)\n    } else if (Array.isArray(nodes)) {\n      nodes = nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\n    } else if (nodes.type === 'root') {\n      nodes = nodes.nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\n    } else if (nodes.type) {\n      nodes = [nodes]\n    } else if (nodes.prop) {\n      if (typeof nodes.value === 'undefined') {\n        throw new Error('Value field is missed in node creation')\n      } else if (typeof nodes.value !== 'string') {\n        nodes.value = String(nodes.value)\n      }\n      nodes = [new Declaration(nodes)]\n    } else if (nodes.selector) {\n      let Rule = require('./rule')\n      nodes = [new Rule(nodes)]\n    } else if (nodes.name) {\n      let AtRule = require('./at-rule')\n      nodes = [new AtRule(nodes)]\n    } else if (nodes.text) {\n      nodes = [new Comment(nodes)]\n    } else {\n      throw new Error('Unknown node type in node creation')\n    }\n\n    let processed = nodes.map(i => {\n      if (i.parent) i.parent.removeChild(i)\n      if (typeof i.raws.before === 'undefined') {\n        if (sample && typeof sample.raws.before !== 'undefined') {\n          i.raws.before = sample.raws.before.replace(/[^\\s]/g, '')\n        }\n      }\n      i.parent = this\n      return i\n    })\n\n    return processed\n  }\n\n  /**\n   * @memberof Container#\n   * @member {Node[]} nodes An array containing the container’s children.\n   *\n   * @example\n   * const root = postcss.parse('a { color: black }')\n   * root.nodes.length           //=> 1\n   * root.nodes[0].selector      //=> 'a'\n   * root.nodes[0].nodes[0].prop //=> 'color'\n   */\n}\n\nexport default Container\n\n/**\n * @callback childCondition\n * @param {Node} node    Container child.\n * @param {number} index Child index.\n * @param {Node[]} nodes All container children.\n * @return {boolean}\n */\n\n/**\n * @callback childIterator\n * @param {Node} node    Container child.\n * @param {number} index Child index.\n * @return {false|undefined} Returning `false` will break iteration.\n */\n"],"file":"container.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/css-syntax-error.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/css-syntax-error.js
new file mode 100644
index 00000000..de129128
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/css-syntax-error.js
@@ -0,0 +1,296 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _picocolors = _interopRequireDefault(require("picocolors"));
+
+var _terminalHighlight = _interopRequireDefault(require("./terminal-highlight"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+/**
+ * The CSS parser throws this error for broken CSS.
+ *
+ * Custom parsers can throw this error for broken custom syntax using
+ * the {@link Node#error} method.
+ *
+ * PostCSS will use the input source map to detect the original error location.
+ * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,
+ * PostCSS will show the original position in the Sass file.
+ *
+ * If you need the position in the PostCSS input
+ * (e.g., to debug the previous compiler), use `error.input.file`.
+ *
+ * @example
+ * // Catching and checking syntax error
+ * try {
+ *   postcss.parse('a{')
+ * } catch (error) {
+ *   if (error.name === 'CssSyntaxError') {
+ *     error //=> CssSyntaxError
+ *   }
+ * }
+ *
+ * @example
+ * // Raising error from plugin
+ * throw node.error('Unknown variable', { plugin: 'postcss-vars' })
+ */
+var CssSyntaxError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(CssSyntaxError, _Error);
+
+  /**
+   * @param {string} message  Error message.
+   * @param {number} [line]   Source line of the error.
+   * @param {number} [column] Source column of the error.
+   * @param {string} [source] Source code of the broken file.
+   * @param {string} [file]   Absolute path to the broken file.
+   * @param {string} [plugin] PostCSS plugin name, if error came from plugin.
+   */
+  function CssSyntaxError(message, line, column, source, file, plugin) {
+    var _this;
+
+    _this = _Error.call(this, message) || this;
+    /**
+     * Always equal to `'CssSyntaxError'`. You should always check error type
+     * by `error.name === 'CssSyntaxError'`
+     * instead of `error instanceof CssSyntaxError`,
+     * because npm could have several PostCSS versions.
+     *
+     * @type {string}
+     *
+     * @example
+     * if (error.name === 'CssSyntaxError') {
+     *   error //=> CssSyntaxError
+     * }
+     */
+
+    _this.name = 'CssSyntaxError';
+    /**
+     * Error message.
+     *
+     * @type {string}
+     *
+     * @example
+     * error.message //=> 'Unclosed block'
+     */
+
+    _this.reason = message;
+
+    if (file) {
+      /**
+       * Absolute path to the broken file.
+       *
+       * @type {string}
+       *
+       * @example
+       * error.file       //=> 'a.sass'
+       * error.input.file //=> 'a.css'
+       */
+      _this.file = file;
+    }
+
+    if (source) {
+      /**
+       * Source code of the broken file.
+       *
+       * @type {string}
+       *
+       * @example
+       * error.source       //=> 'a { b {} }'
+       * error.input.column //=> 'a b { }'
+       */
+      _this.source = source;
+    }
+
+    if (plugin) {
+      /**
+       * Plugin name, if error came from plugin.
+       *
+       * @type {string}
+       *
+       * @example
+       * error.plugin //=> 'postcss-vars'
+       */
+      _this.plugin = plugin;
+    }
+
+    if (typeof line !== 'undefined' && typeof column !== 'undefined') {
+      /**
+       * Source line of the error.
+       *
+       * @type {number}
+       *
+       * @example
+       * error.line       //=> 2
+       * error.input.line //=> 4
+       */
+      _this.line = line;
+      /**
+       * Source column of the error.
+       *
+       * @type {number}
+       *
+       * @example
+       * error.column       //=> 1
+       * error.input.column //=> 4
+       */
+
+      _this.column = column;
+    }
+
+    _this.setMessage();
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(_assertThisInitialized(_this), CssSyntaxError);
+    }
+
+    return _this;
+  }
+
+  var _proto = CssSyntaxError.prototype;
+
+  _proto.setMessage = function setMessage() {
+    /**
+     * Full error text in the GNU error format
+     * with plugin, file, line and column.
+     *
+     * @type {string}
+     *
+     * @example
+     * error.message //=> 'a.css:1:1: Unclosed block'
+     */
+    this.message = this.plugin ? this.plugin + ': ' : '';
+    this.message += this.file ? this.file : '<css input>';
+
+    if (typeof this.line !== 'undefined') {
+      this.message += ':' + this.line + ':' + this.column;
+    }
+
+    this.message += ': ' + this.reason;
+  }
+  /**
+   * Returns a few lines of CSS source that caused the error.
+   *
+   * If the CSS has an input source map without `sourceContent`,
+   * this method will return an empty string.
+   *
+   * @param {boolean} [color] Whether arrow will be colored red by terminal
+   *                          color codes. By default, PostCSS will detect
+   *                          color support by `process.stdout.isTTY`
+   *                          and `process.env.NODE_DISABLE_COLORS`.
+   *
+   * @example
+   * error.showSourceCode() //=> "  4 | }
+   *                        //      5 | a {
+   *                        //    > 6 |   bad
+   *                        //        |   ^
+   *                        //      7 | }
+   *                        //      8 | b {"
+   *
+   * @return {string} Few lines of CSS source that caused the error.
+   */
+  ;
+
+  _proto.showSourceCode = function showSourceCode(color) {
+    var _this2 = this;
+
+    if (!this.source) return '';
+    var css = this.source;
+
+    if (_terminalHighlight.default) {
+      if (typeof color === 'undefined') color = _picocolors.default.isColorSupported;
+      if (color) css = (0, _terminalHighlight.default)(css);
+    }
+
+    var lines = css.split(/\r?\n/);
+    var start = Math.max(this.line - 3, 0);
+    var end = Math.min(this.line + 2, lines.length);
+    var maxWidth = String(end).length;
+
+    function mark(text) {
+      if (color && _picocolors.default.red) {
+        return _picocolors.default.red(_picocolors.default.bold(text));
+      }
+
+      return text;
+    }
+
+    function aside(text) {
+      if (color && _picocolors.default.gray) {
+        return _picocolors.default.gray(text);
+      }
+
+      return text;
+    }
+
+    return lines.slice(start, end).map(function (line, index) {
+      var number = start + 1 + index;
+      var gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';
+
+      if (number === _this2.line) {
+        var spacing = aside(gutter.replace(/\d/g, ' ')) + line.slice(0, _this2.column - 1).replace(/[^\t]/g, ' ');
+        return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^');
+      }
+
+      return ' ' + aside(gutter) + line;
+    }).join('\n');
+  }
+  /**
+   * Returns error position, message and source code of the broken part.
+   *
+   * @example
+   * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block
+   *                  //    > 1 | a {
+   *                  //        | ^"
+   *
+   * @return {string} Error position, message and source code.
+   */
+  ;
+
+  _proto.toString = function toString() {
+    var code = this.showSourceCode();
+
+    if (code) {
+      code = '\n\n' + code + '\n';
+    }
+
+    return this.name + ': ' + this.message + code;
+  }
+  /**
+   * @memberof CssSyntaxError#
+   * @member {Input} input Input object with PostCSS internal information
+   *                       about input file. If input has source map
+   *                       from previous tool, PostCSS will use origin
+   *                       (for example, Sass) source. You can use this
+   *                       object to get PostCSS input source.
+   *
+   * @example
+   * error.input.file //=> 'a.css'
+   * error.file       //=> 'a.sass'
+   */
+  ;
+
+  return CssSyntaxError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var _default = CssSyntaxError;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["css-syntax-error.es6"],"names":["CssSyntaxError","message","line","column","source","file","plugin","name","reason","setMessage","Error","captureStackTrace","showSourceCode","color","css","terminalHighlight","pico","isColorSupported","lines","split","start","Math","max","end","min","length","maxWidth","String","mark","text","red","bold","aside","gray","slice","map","index","number","gutter","spacing","replace","join","toString","code"],"mappings":"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","sourcesContent":["import pico from 'picocolors'\n\nimport terminalHighlight from './terminal-highlight'\n\n/**\n * The CSS parser throws this error for broken CSS.\n *\n * Custom parsers can throw this error for broken custom syntax using\n * the {@link Node#error} method.\n *\n * PostCSS will use the input source map to detect the original error location.\n * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,\n * PostCSS will show the original position in the Sass file.\n *\n * If you need the position in the PostCSS input\n * (e.g., to debug the previous compiler), use `error.input.file`.\n *\n * @example\n * // Catching and checking syntax error\n * try {\n *   postcss.parse('a{')\n * } catch (error) {\n *   if (error.name === 'CssSyntaxError') {\n *     error //=> CssSyntaxError\n *   }\n * }\n *\n * @example\n * // Raising error from plugin\n * throw node.error('Unknown variable', { plugin: 'postcss-vars' })\n */\nclass CssSyntaxError extends Error {\n  /**\n   * @param {string} message  Error message.\n   * @param {number} [line]   Source line of the error.\n   * @param {number} [column] Source column of the error.\n   * @param {string} [source] Source code of the broken file.\n   * @param {string} [file]   Absolute path to the broken file.\n   * @param {string} [plugin] PostCSS plugin name, if error came from plugin.\n   */\n  constructor (message, line, column, source, file, plugin) {\n    super(message)\n\n    /**\n     * Always equal to `'CssSyntaxError'`. You should always check error type\n     * by `error.name === 'CssSyntaxError'`\n     * instead of `error instanceof CssSyntaxError`,\n     * because npm could have several PostCSS versions.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (error.name === 'CssSyntaxError') {\n     *   error //=> CssSyntaxError\n     * }\n     */\n    this.name = 'CssSyntaxError'\n    /**\n     * Error message.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'Unclosed block'\n     */\n    this.reason = message\n\n    if (file) {\n      /**\n       * Absolute path to the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.file       //=> 'a.sass'\n       * error.input.file //=> 'a.css'\n       */\n      this.file = file\n    }\n    if (source) {\n      /**\n       * Source code of the broken file.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.source       //=> 'a { b {} }'\n       * error.input.column //=> 'a b { }'\n       */\n      this.source = source\n    }\n    if (plugin) {\n      /**\n       * Plugin name, if error came from plugin.\n       *\n       * @type {string}\n       *\n       * @example\n       * error.plugin //=> 'postcss-vars'\n       */\n      this.plugin = plugin\n    }\n    if (typeof line !== 'undefined' && typeof column !== 'undefined') {\n      /**\n       * Source line of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.line       //=> 2\n       * error.input.line //=> 4\n       */\n      this.line = line\n      /**\n       * Source column of the error.\n       *\n       * @type {number}\n       *\n       * @example\n       * error.column       //=> 1\n       * error.input.column //=> 4\n       */\n      this.column = column\n    }\n\n    this.setMessage()\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, CssSyntaxError)\n    }\n  }\n\n  setMessage () {\n    /**\n     * Full error text in the GNU error format\n     * with plugin, file, line and column.\n     *\n     * @type {string}\n     *\n     * @example\n     * error.message //=> 'a.css:1:1: Unclosed block'\n     */\n    this.message = this.plugin ? this.plugin + ': ' : ''\n    this.message += this.file ? this.file : '<css input>'\n    if (typeof this.line !== 'undefined') {\n      this.message += ':' + this.line + ':' + this.column\n    }\n    this.message += ': ' + this.reason\n  }\n\n  /**\n   * Returns a few lines of CSS source that caused the error.\n   *\n   * If the CSS has an input source map without `sourceContent`,\n   * this method will return an empty string.\n   *\n   * @param {boolean} [color] Whether arrow will be colored red by terminal\n   *                          color codes. By default, PostCSS will detect\n   *                          color support by `process.stdout.isTTY`\n   *                          and `process.env.NODE_DISABLE_COLORS`.\n   *\n   * @example\n   * error.showSourceCode() //=> \"  4 | }\n   *                        //      5 | a {\n   *                        //    > 6 |   bad\n   *                        //        |   ^\n   *                        //      7 | }\n   *                        //      8 | b {\"\n   *\n   * @return {string} Few lines of CSS source that caused the error.\n   */\n  showSourceCode (color) {\n    if (!this.source) return ''\n\n    let css = this.source\n    if (terminalHighlight) {\n      if (typeof color === 'undefined') color = pico.isColorSupported\n      if (color) css = terminalHighlight(css)\n    }\n\n    let lines = css.split(/\\r?\\n/)\n    let start = Math.max(this.line - 3, 0)\n    let end = Math.min(this.line + 2, lines.length)\n\n    let maxWidth = String(end).length\n\n    function mark (text) {\n      if (color && pico.red) {\n        return pico.red(pico.bold(text))\n      }\n      return text\n    }\n    function aside (text) {\n      if (color && pico.gray) {\n        return pico.gray(text)\n      }\n      return text\n    }\n\n    return lines\n      .slice(start, end)\n      .map((line, index) => {\n        let number = start + 1 + index\n        let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '\n        if (number === this.line) {\n          let spacing =\n            aside(gutter.replace(/\\d/g, ' ')) +\n            line.slice(0, this.column - 1).replace(/[^\\t]/g, ' ')\n          return mark('>') + aside(gutter) + line + '\\n ' + spacing + mark('^')\n        }\n        return ' ' + aside(gutter) + line\n      })\n      .join('\\n')\n  }\n\n  /**\n   * Returns error position, message and source code of the broken part.\n   *\n   * @example\n   * error.toString() //=> \"CssSyntaxError: app.css:1:1: Unclosed block\n   *                  //    > 1 | a {\n   *                  //        | ^\"\n   *\n   * @return {string} Error position, message and source code.\n   */\n  toString () {\n    let code = this.showSourceCode()\n    if (code) {\n      code = '\\n\\n' + code + '\\n'\n    }\n    return this.name + ': ' + this.message + code\n  }\n\n  /**\n   * @memberof CssSyntaxError#\n   * @member {Input} input Input object with PostCSS internal information\n   *                       about input file. If input has source map\n   *                       from previous tool, PostCSS will use origin\n   *                       (for example, Sass) source. You can use this\n   *                       object to get PostCSS input source.\n   *\n   * @example\n   * error.input.file //=> 'a.css'\n   * error.file       //=> 'a.sass'\n   */\n}\n\nexport default CssSyntaxError\n"],"file":"css-syntax-error.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/declaration.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/declaration.js
new file mode 100644
index 00000000..9381f4ad
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/declaration.js
@@ -0,0 +1,96 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+/**
+ * Represents a CSS declaration.
+ *
+ * @extends Node
+ *
+ * @example
+ * const root = postcss.parse('a { color: black }')
+ * const decl = root.first.first
+ * decl.type       //=> 'decl'
+ * decl.toString() //=> ' color: black'
+ */
+var Declaration = /*#__PURE__*/function (_Node) {
+  _inheritsLoose(Declaration, _Node);
+
+  function Declaration(defaults) {
+    var _this;
+
+    _this = _Node.call(this, defaults) || this;
+    _this.type = 'decl';
+    return _this;
+  }
+  /**
+   * @memberof Declaration#
+   * @member {string} prop The declaration’s property name.
+   *
+   * @example
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   * decl.prop //=> 'color'
+   */
+
+  /**
+   * @memberof Declaration#
+   * @member {string} value The declaration’s value.
+   *
+   * @example
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   * decl.value //=> 'black'
+   */
+
+  /**
+   * @memberof Declaration#
+   * @member {boolean} important `true` if the declaration
+   *                             has an !important annotation.
+   *
+   * @example
+   * const root = postcss.parse('a { color: black !important; color: red }')
+   * root.first.first.important //=> true
+   * root.first.last.important  //=> undefined
+   */
+
+  /**
+   * @memberof Declaration#
+   * @member {object} raws Information to generate byte-to-byte equal
+   *                       node string as it was in the origin input.
+   *
+   * Every parser saves its own properties,
+   * but the default CSS parser uses:
+   *
+   * * `before`: the space symbols before the node. It also stores `*`
+   *   and `_` symbols before the declaration (IE hack).
+   * * `between`: the symbols between the property and value
+   *   for declarations.
+   * * `important`: the content of the important statement,
+   *   if it is not just `!important`.
+   *
+   * PostCSS cleans declaration from comments and extra spaces,
+   * but it stores origin content in raws properties.
+   * As such, if you don’t change a declaration’s value,
+   * PostCSS will use the raw value with comments.
+   *
+   * @example
+   * const root = postcss.parse('a {\n  color:black\n}')
+   * root.first.first.raws //=> { before: '\n  ', between: ':' }
+   */
+
+
+  return Declaration;
+}(_node.default);
+
+var _default = Declaration;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/input.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/input.js
new file mode 100644
index 00000000..42201350
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/input.js
@@ -0,0 +1,214 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _cssSyntaxError = _interopRequireDefault(require("./css-syntax-error"));
+
+var _previousMap = _interopRequireDefault(require("./previous-map"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var sequence = 0;
+/**
+ * Represents the source CSS.
+ *
+ * @example
+ * const root  = postcss.parse(css, { from: file })
+ * const input = root.source.input
+ */
+
+var Input = /*#__PURE__*/function () {
+  /**
+   * @param {string} css    Input CSS source.
+   * @param {object} [opts] {@link Processor#process} options.
+   */
+  function Input(css, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    if (css === null || typeof css === 'undefined' || typeof css === 'object' && !css.toString) {
+      throw new Error("PostCSS received " + css + " instead of CSS string");
+    }
+    /**
+     * Input CSS source
+     *
+     * @type {string}
+     *
+     * @example
+     * const input = postcss.parse('a{}', { from: file }).input
+     * input.css //=> "a{}"
+     */
+
+
+    this.css = css.toString();
+
+    if (this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE") {
+      this.hasBOM = true;
+      this.css = this.css.slice(1);
+    } else {
+      this.hasBOM = false;
+    }
+
+    if (opts.from) {
+      if (/^\w+:\/\//.test(opts.from) || _path.default.isAbsolute(opts.from)) {
+        /**
+         * The absolute path to the CSS source file defined
+         * with the `from` option.
+         *
+         * @type {string}
+         *
+         * @example
+         * const root = postcss.parse(css, { from: 'a.css' })
+         * root.source.input.file //=> '/home/ai/a.css'
+         */
+        this.file = opts.from;
+      } else {
+        this.file = _path.default.resolve(opts.from);
+      }
+    }
+
+    var map = new _previousMap.default(this.css, opts);
+
+    if (map.text) {
+      /**
+       * The input source map passed from a compilation step before PostCSS
+       * (for example, from Sass compiler).
+       *
+       * @type {PreviousMap}
+       *
+       * @example
+       * root.source.input.map.consumer().sources //=> ['a.sass']
+       */
+      this.map = map;
+      var file = map.consumer().file;
+      if (!this.file && file) this.file = this.mapResolve(file);
+    }
+
+    if (!this.file) {
+      sequence += 1;
+      /**
+       * The unique ID of the CSS source. It will be created if `from` option
+       * is not provided (because PostCSS does not know the file path).
+       *
+       * @type {string}
+       *
+       * @example
+       * const root = postcss.parse(css)
+       * root.source.input.file //=> undefined
+       * root.source.input.id   //=> "<input css 1>"
+       */
+
+      this.id = '<input css ' + sequence + '>';
+    }
+
+    if (this.map) this.map.file = this.from;
+  }
+
+  var _proto = Input.prototype;
+
+  _proto.error = function error(message, line, column, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    var result;
+    var origin = this.origin(line, column);
+
+    if (origin) {
+      result = new _cssSyntaxError.default(message, origin.line, origin.column, origin.source, origin.file, opts.plugin);
+    } else {
+      result = new _cssSyntaxError.default(message, line, column, this.css, this.file, opts.plugin);
+    }
+
+    result.input = {
+      line: line,
+      column: column,
+      source: this.css
+    };
+    if (this.file) result.input.file = this.file;
+    return result;
+  }
+  /**
+   * Reads the input source map and returns a symbol position
+   * in the input source (e.g., in a Sass file that was compiled
+   * to CSS before being passed to PostCSS).
+   *
+   * @param {number} line   Line in input CSS.
+   * @param {number} column Column in input CSS.
+   *
+   * @return {filePosition} Position in input source.
+   *
+   * @example
+   * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }
+   */
+  ;
+
+  _proto.origin = function origin(line, column) {
+    if (!this.map) return false;
+    var consumer = this.map.consumer();
+    var from = consumer.originalPositionFor({
+      line: line,
+      column: column
+    });
+    if (!from.source) return false;
+    var result = {
+      file: this.mapResolve(from.source),
+      line: from.line,
+      column: from.column
+    };
+    var source = consumer.sourceContentFor(from.source);
+    if (source) result.source = source;
+    return result;
+  };
+
+  _proto.mapResolve = function mapResolve(file) {
+    if (/^\w+:\/\//.test(file)) {
+      return file;
+    }
+
+    return _path.default.resolve(this.map.consumer().sourceRoot || '.', file);
+  }
+  /**
+   * The CSS source identifier. Contains {@link Input#file} if the user
+   * set the `from` option, or {@link Input#id} if they did not.
+   *
+   * @type {string}
+   *
+   * @example
+   * const root = postcss.parse(css, { from: 'a.css' })
+   * root.source.input.from //=> "/home/ai/a.css"
+   *
+   * const root = postcss.parse(css)
+   * root.source.input.from //=> "<input css 1>"
+   */
+  ;
+
+  _createClass(Input, [{
+    key: "from",
+    get: function get() {
+      return this.file || this.id;
+    }
+  }]);
+
+  return Input;
+}();
+
+var _default = Input;
+/**
+ * @typedef  {object} filePosition
+ * @property {string} file   Path to file.
+ * @property {number} line   Source line in file.
+ * @property {number} column Source column in file.
+ */
+
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["input.es6"],"names":["sequence","Input","css","opts","toString","Error","hasBOM","slice","from","test","path","isAbsolute","file","resolve","map","PreviousMap","text","consumer","mapResolve","id","error","message","line","column","result","origin","CssSyntaxError","source","plugin","input","originalPositionFor","sourceContentFor","sourceRoot"],"mappings":"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","sourcesContent":["import path from 'path'\n\nimport CssSyntaxError from './css-syntax-error'\nimport PreviousMap from './previous-map'\n\nlet sequence = 0\n\n/**\n * Represents the source CSS.\n *\n * @example\n * const root  = postcss.parse(css, { from: file })\n * const input = root.source.input\n */\nclass Input {\n  /**\n   * @param {string} css    Input CSS source.\n   * @param {object} [opts] {@link Processor#process} options.\n   */\n  constructor (css, opts = { }) {\n    if (\n      css === null ||\n      typeof css === 'undefined' ||\n      (typeof css === 'object' && !css.toString)\n    ) {\n      throw new Error(`PostCSS received ${ css } instead of CSS string`)\n    }\n\n    /**\n     * Input CSS source\n     *\n     * @type {string}\n     *\n     * @example\n     * const input = postcss.parse('a{}', { from: file }).input\n     * input.css //=> \"a{}\"\n     */\n    this.css = css.toString()\n\n    if (this.css[0] === '\\uFEFF' || this.css[0] === '\\uFFFE') {\n      this.hasBOM = true\n      this.css = this.css.slice(1)\n    } else {\n      this.hasBOM = false\n    }\n\n    if (opts.from) {\n      if (/^\\w+:\\/\\//.test(opts.from) || path.isAbsolute(opts.from)) {\n        /**\n         * The absolute path to the CSS source file defined\n         * with the `from` option.\n         *\n         * @type {string}\n         *\n         * @example\n         * const root = postcss.parse(css, { from: 'a.css' })\n         * root.source.input.file //=> '/home/ai/a.css'\n         */\n        this.file = opts.from\n      } else {\n        this.file = path.resolve(opts.from)\n      }\n    }\n\n    let map = new PreviousMap(this.css, opts)\n    if (map.text) {\n      /**\n       * The input source map passed from a compilation step before PostCSS\n       * (for example, from Sass compiler).\n       *\n       * @type {PreviousMap}\n       *\n       * @example\n       * root.source.input.map.consumer().sources //=> ['a.sass']\n       */\n      this.map = map\n      let file = map.consumer().file\n      if (!this.file && file) this.file = this.mapResolve(file)\n    }\n\n    if (!this.file) {\n      sequence += 1\n      /**\n       * The unique ID of the CSS source. It will be created if `from` option\n       * is not provided (because PostCSS does not know the file path).\n       *\n       * @type {string}\n       *\n       * @example\n       * const root = postcss.parse(css)\n       * root.source.input.file //=> undefined\n       * root.source.input.id   //=> \"<input css 1>\"\n       */\n      this.id = '<input css ' + sequence + '>'\n    }\n    if (this.map) this.map.file = this.from\n  }\n\n  error (message, line, column, opts = { }) {\n    let result\n    let origin = this.origin(line, column)\n    if (origin) {\n      result = new CssSyntaxError(\n        message, origin.line, origin.column,\n        origin.source, origin.file, opts.plugin\n      )\n    } else {\n      result = new CssSyntaxError(\n        message, line, column, this.css, this.file, opts.plugin)\n    }\n\n    result.input = { line, column, source: this.css }\n    if (this.file) result.input.file = this.file\n\n    return result\n  }\n\n  /**\n   * Reads the input source map and returns a symbol position\n   * in the input source (e.g., in a Sass file that was compiled\n   * to CSS before being passed to PostCSS).\n   *\n   * @param {number} line   Line in input CSS.\n   * @param {number} column Column in input CSS.\n   *\n   * @return {filePosition} Position in input source.\n   *\n   * @example\n   * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }\n   */\n  origin (line, column) {\n    if (!this.map) return false\n    let consumer = this.map.consumer()\n\n    let from = consumer.originalPositionFor({ line, column })\n    if (!from.source) return false\n\n    let result = {\n      file: this.mapResolve(from.source),\n      line: from.line,\n      column: from.column\n    }\n\n    let source = consumer.sourceContentFor(from.source)\n    if (source) result.source = source\n\n    return result\n  }\n\n  mapResolve (file) {\n    if (/^\\w+:\\/\\//.test(file)) {\n      return file\n    }\n    return path.resolve(this.map.consumer().sourceRoot || '.', file)\n  }\n\n  /**\n   * The CSS source identifier. Contains {@link Input#file} if the user\n   * set the `from` option, or {@link Input#id} if they did not.\n   *\n   * @type {string}\n   *\n   * @example\n   * const root = postcss.parse(css, { from: 'a.css' })\n   * root.source.input.from //=> \"/home/ai/a.css\"\n   *\n   * const root = postcss.parse(css)\n   * root.source.input.from //=> \"<input css 1>\"\n   */\n  get from () {\n    return this.file || this.id\n  }\n}\n\nexport default Input\n\n/**\n * @typedef  {object} filePosition\n * @property {string} file   Path to file.\n * @property {number} line   Source line in file.\n * @property {number} column Source column in file.\n */\n"],"file":"input.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/lazy-result.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/lazy-result.js
new file mode 100644
index 00000000..1d00c98b
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/lazy-result.js
@@ -0,0 +1,437 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _mapGenerator = _interopRequireDefault(require("./map-generator"));
+
+var _stringify2 = _interopRequireDefault(require("./stringify"));
+
+var _warnOnce = _interopRequireDefault(require("./warn-once"));
+
+var _result = _interopRequireDefault(require("./result"));
+
+var _parse = _interopRequireDefault(require("./parse"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function isPromise(obj) {
+  return typeof obj === 'object' && typeof obj.then === 'function';
+}
+/**
+ * A Promise proxy for the result of PostCSS transformations.
+ *
+ * A `LazyResult` instance is returned by {@link Processor#process}.
+ *
+ * @example
+ * const lazy = postcss([autoprefixer]).process(css)
+ */
+
+
+var LazyResult = /*#__PURE__*/function () {
+  function LazyResult(processor, css, opts) {
+    this.stringified = false;
+    this.processed = false;
+    var root;
+
+    if (typeof css === 'object' && css !== null && css.type === 'root') {
+      root = css;
+    } else if (css instanceof LazyResult || css instanceof _result.default) {
+      root = css.root;
+
+      if (css.map) {
+        if (typeof opts.map === 'undefined') opts.map = {};
+        if (!opts.map.inline) opts.map.inline = false;
+        opts.map.prev = css.map;
+      }
+    } else {
+      var parser = _parse.default;
+      if (opts.syntax) parser = opts.syntax.parse;
+      if (opts.parser) parser = opts.parser;
+      if (parser.parse) parser = parser.parse;
+
+      try {
+        root = parser(css, opts);
+      } catch (error) {
+        this.error = error;
+      }
+    }
+
+    this.result = new _result.default(processor, root, opts);
+  }
+  /**
+   * Returns a {@link Processor} instance, which will be used
+   * for CSS transformations.
+   *
+   * @type {Processor}
+   */
+
+
+  var _proto = LazyResult.prototype;
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and calls {@link Result#warnings()}.
+   *
+   * @return {Warning[]} Warnings from plugins.
+   */
+  _proto.warnings = function warnings() {
+    return this.sync().warnings();
+  }
+  /**
+   * Alias for the {@link LazyResult#css} property.
+   *
+   * @example
+   * lazy + '' === lazy.css
+   *
+   * @return {string} Output CSS.
+   */
+  ;
+
+  _proto.toString = function toString() {
+    return this.css;
+  }
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls `onFulfilled` with a Result instance. If a plugin throws
+   * an error, the `onRejected` callback will be executed.
+   *
+   * It implements standard Promise API.
+   *
+   * @param {onFulfilled} onFulfilled Callback will be executed
+   *                                  when all plugins will finish work.
+   * @param {onRejected}  onRejected  Callback will be executed on any error.
+   *
+   * @return {Promise} Promise API to make queue.
+   *
+   * @example
+   * postcss([autoprefixer]).process(css, { from: cssPath }).then(result => {
+   *   console.log(result.css)
+   * })
+   */
+  ;
+
+  _proto.then = function then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this.opts)) {
+        (0, _warnOnce.default)('Without `from` option PostCSS could generate wrong source map ' + 'and will not find Browserslist config. Set it to CSS file path ' + 'or to `undefined` to prevent this warning.');
+      }
+    }
+
+    return this.async().then(onFulfilled, onRejected);
+  }
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onRejected for each error thrown in any plugin.
+   *
+   * It implements standard Promise API.
+   *
+   * @param {onRejected} onRejected Callback will be executed on any error.
+   *
+   * @return {Promise} Promise API to make queue.
+   *
+   * @example
+   * postcss([autoprefixer]).process(css).then(result => {
+   *   console.log(result.css)
+   * }).catch(error => {
+   *   console.error(error)
+   * })
+   */
+  ;
+
+  _proto.catch = function _catch(onRejected) {
+    return this.async().catch(onRejected);
+  }
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onFinally on any error or when all plugins will finish work.
+   *
+   * It implements standard Promise API.
+   *
+   * @param {onFinally} onFinally Callback will be executed on any error or
+   *                              when all plugins will finish work.
+   *
+   * @return {Promise} Promise API to make queue.
+   *
+   * @example
+   * postcss([autoprefixer]).process(css).finally(() => {
+   *   console.log('processing ended')
+   * })
+   */
+  ;
+
+  _proto.finally = function _finally(onFinally) {
+    return this.async().then(onFinally, onFinally);
+  };
+
+  _proto.handleError = function handleError(error, plugin) {
+    try {
+      this.error = error;
+
+      if (error.name === 'CssSyntaxError' && !error.plugin) {
+        error.plugin = plugin.postcssPlugin;
+        error.setMessage();
+      } else if (plugin.postcssVersion) {
+        if (process.env.NODE_ENV !== 'production') {
+          var pluginName = plugin.postcssPlugin;
+          var pluginVer = plugin.postcssVersion;
+          var runtimeVer = this.result.processor.version;
+          var a = pluginVer.split('.');
+          var b = runtimeVer.split('.');
+
+          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
+            console.error('Unknown error from PostCSS plugin. Your current PostCSS ' + 'version is ' + runtimeVer + ', but ' + pluginName + ' uses ' + pluginVer + '. Perhaps this is the source of the error below.');
+          }
+        }
+      }
+    } catch (err) {
+      if (console && console.error) console.error(err);
+    }
+  };
+
+  _proto.asyncTick = function asyncTick(resolve, reject) {
+    var _this = this;
+
+    if (this.plugin >= this.processor.plugins.length) {
+      this.processed = true;
+      return resolve();
+    }
+
+    try {
+      var plugin = this.processor.plugins[this.plugin];
+      var promise = this.run(plugin);
+      this.plugin += 1;
+
+      if (isPromise(promise)) {
+        promise.then(function () {
+          _this.asyncTick(resolve, reject);
+        }).catch(function (error) {
+          _this.handleError(error, plugin);
+
+          _this.processed = true;
+          reject(error);
+        });
+      } else {
+        this.asyncTick(resolve, reject);
+      }
+    } catch (error) {
+      this.processed = true;
+      reject(error);
+    }
+  };
+
+  _proto.async = function async() {
+    var _this2 = this;
+
+    if (this.processed) {
+      return new Promise(function (resolve, reject) {
+        if (_this2.error) {
+          reject(_this2.error);
+        } else {
+          resolve(_this2.stringify());
+        }
+      });
+    }
+
+    if (this.processing) {
+      return this.processing;
+    }
+
+    this.processing = new Promise(function (resolve, reject) {
+      if (_this2.error) return reject(_this2.error);
+      _this2.plugin = 0;
+
+      _this2.asyncTick(resolve, reject);
+    }).then(function () {
+      _this2.processed = true;
+      return _this2.stringify();
+    });
+    return this.processing;
+  };
+
+  _proto.sync = function sync() {
+    if (this.processed) return this.result;
+    this.processed = true;
+
+    if (this.processing) {
+      throw new Error('Use process(css).then(cb) to work with async plugins');
+    }
+
+    if (this.error) throw this.error;
+
+    for (var _iterator = _createForOfIteratorHelperLoose(this.result.processor.plugins), _step; !(_step = _iterator()).done;) {
+      var plugin = _step.value;
+      var promise = this.run(plugin);
+
+      if (isPromise(promise)) {
+        throw new Error('Use process(css).then(cb) to work with async plugins');
+      }
+    }
+
+    return this.result;
+  };
+
+  _proto.run = function run(plugin) {
+    this.result.lastPlugin = plugin;
+
+    try {
+      return plugin(this.result.root, this.result);
+    } catch (error) {
+      this.handleError(error, plugin);
+      throw error;
+    }
+  };
+
+  _proto.stringify = function stringify() {
+    if (this.stringified) return this.result;
+    this.stringified = true;
+    this.sync();
+    var opts = this.result.opts;
+    var str = _stringify2.default;
+    if (opts.syntax) str = opts.syntax.stringify;
+    if (opts.stringifier) str = opts.stringifier;
+    if (str.stringify) str = str.stringify;
+    var map = new _mapGenerator.default(str, this.result.root, this.result.opts);
+    var data = map.generate();
+    this.result.css = data[0];
+    this.result.map = data[1];
+    return this.result;
+  };
+
+  _createClass(LazyResult, [{
+    key: "processor",
+    get: function get() {
+      return this.result.processor;
+    }
+    /**
+     * Options from the {@link Processor#process} call.
+     *
+     * @type {processOptions}
+     */
+
+  }, {
+    key: "opts",
+    get: function get() {
+      return this.result.opts;
+    }
+    /**
+     * Processes input CSS through synchronous plugins, converts `Root`
+     * to a CSS string and returns {@link Result#css}.
+     *
+     * This property will only work with synchronous plugins.
+     * If the processor contains any asynchronous plugins
+     * it will throw an error. This is why this method is only
+     * for debug purpose, you should always use {@link LazyResult#then}.
+     *
+     * @type {string}
+     * @see Result#css
+     */
+
+  }, {
+    key: "css",
+    get: function get() {
+      return this.stringify().css;
+    }
+    /**
+     * An alias for the `css` property. Use it with syntaxes
+     * that generate non-CSS output.
+     *
+     * This property will only work with synchronous plugins.
+     * If the processor contains any asynchronous plugins
+     * it will throw an error. This is why this method is only
+     * for debug purpose, you should always use {@link LazyResult#then}.
+     *
+     * @type {string}
+     * @see Result#content
+     */
+
+  }, {
+    key: "content",
+    get: function get() {
+      return this.stringify().content;
+    }
+    /**
+     * Processes input CSS through synchronous plugins
+     * and returns {@link Result#map}.
+     *
+     * This property will only work with synchronous plugins.
+     * If the processor contains any asynchronous plugins
+     * it will throw an error. This is why this method is only
+     * for debug purpose, you should always use {@link LazyResult#then}.
+     *
+     * @type {SourceMapGenerator}
+     * @see Result#map
+     */
+
+  }, {
+    key: "map",
+    get: function get() {
+      return this.stringify().map;
+    }
+    /**
+     * Processes input CSS through synchronous plugins
+     * and returns {@link Result#root}.
+     *
+     * This property will only work with synchronous plugins. If the processor
+     * contains any asynchronous plugins it will throw an error.
+     *
+     * This is why this method is only for debug purpose,
+     * you should always use {@link LazyResult#then}.
+     *
+     * @type {Root}
+     * @see Result#root
+     */
+
+  }, {
+    key: "root",
+    get: function get() {
+      return this.sync().root;
+    }
+    /**
+     * Processes input CSS through synchronous plugins
+     * and returns {@link Result#messages}.
+     *
+     * This property will only work with synchronous plugins. If the processor
+     * contains any asynchronous plugins it will throw an error.
+     *
+     * This is why this method is only for debug purpose,
+     * you should always use {@link LazyResult#then}.
+     *
+     * @type {Message[]}
+     * @see Result#messages
+     */
+
+  }, {
+    key: "messages",
+    get: function get() {
+      return this.sync().messages;
+    }
+  }]);
+
+  return LazyResult;
+}();
+
+var _default = LazyResult;
+/**
+ * @callback onFulfilled
+ * @param {Result} result
+ */
+
+/**
+ * @callback onRejected
+ * @param {Error} error
+ */
+
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lazy-result.es6"],"names":["isPromise","obj","then","LazyResult","processor","css","opts","stringified","processed","root","type","Result","map","inline","prev","parser","parse","syntax","error","result","warnings","sync","toString","onFulfilled","onRejected","process","env","NODE_ENV","async","catch","finally","onFinally","handleError","plugin","name","postcssPlugin","setMessage","postcssVersion","pluginName","pluginVer","runtimeVer","version","a","split","b","parseInt","console","err","asyncTick","resolve","reject","plugins","length","promise","run","Promise","stringify","processing","Error","lastPlugin","str","stringifier","MapGenerator","data","generate","content","messages"],"mappings":"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","sourcesContent":["import MapGenerator from './map-generator'\nimport stringify from './stringify'\nimport warnOnce from './warn-once'\nimport Result from './result'\nimport parse from './parse'\n\nfunction isPromise (obj) {\n  return typeof obj === 'object' && typeof obj.then === 'function'\n}\n\n/**\n * A Promise proxy for the result of PostCSS transformations.\n *\n * A `LazyResult` instance is returned by {@link Processor#process}.\n *\n * @example\n * const lazy = postcss([autoprefixer]).process(css)\n */\nclass LazyResult {\n  constructor (processor, css, opts) {\n    this.stringified = false\n    this.processed = false\n\n    let root\n    if (typeof css === 'object' && css !== null && css.type === 'root') {\n      root = css\n    } else if (css instanceof LazyResult || css instanceof Result) {\n      root = css.root\n      if (css.map) {\n        if (typeof opts.map === 'undefined') opts.map = { }\n        if (!opts.map.inline) opts.map.inline = false\n        opts.map.prev = css.map\n      }\n    } else {\n      let parser = parse\n      if (opts.syntax) parser = opts.syntax.parse\n      if (opts.parser) parser = opts.parser\n      if (parser.parse) parser = parser.parse\n\n      try {\n        root = parser(css, opts)\n      } catch (error) {\n        this.error = error\n      }\n    }\n\n    this.result = new Result(processor, root, opts)\n  }\n\n  /**\n   * Returns a {@link Processor} instance, which will be used\n   * for CSS transformations.\n   *\n   * @type {Processor}\n   */\n  get processor () {\n    return this.result.processor\n  }\n\n  /**\n   * Options from the {@link Processor#process} call.\n   *\n   * @type {processOptions}\n   */\n  get opts () {\n    return this.result.opts\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins, converts `Root`\n   * to a CSS string and returns {@link Result#css}.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {string}\n   * @see Result#css\n   */\n  get css () {\n    return this.stringify().css\n  }\n\n  /**\n   * An alias for the `css` property. Use it with syntaxes\n   * that generate non-CSS output.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {string}\n   * @see Result#content\n   */\n  get content () {\n    return this.stringify().content\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#map}.\n   *\n   * This property will only work with synchronous plugins.\n   * If the processor contains any asynchronous plugins\n   * it will throw an error. This is why this method is only\n   * for debug purpose, you should always use {@link LazyResult#then}.\n   *\n   * @type {SourceMapGenerator}\n   * @see Result#map\n   */\n  get map () {\n    return this.stringify().map\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#root}.\n   *\n   * This property will only work with synchronous plugins. If the processor\n   * contains any asynchronous plugins it will throw an error.\n   *\n   * This is why this method is only for debug purpose,\n   * you should always use {@link LazyResult#then}.\n   *\n   * @type {Root}\n   * @see Result#root\n   */\n  get root () {\n    return this.sync().root\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and returns {@link Result#messages}.\n   *\n   * This property will only work with synchronous plugins. If the processor\n   * contains any asynchronous plugins it will throw an error.\n   *\n   * This is why this method is only for debug purpose,\n   * you should always use {@link LazyResult#then}.\n   *\n   * @type {Message[]}\n   * @see Result#messages\n   */\n  get messages () {\n    return this.sync().messages\n  }\n\n  /**\n   * Processes input CSS through synchronous plugins\n   * and calls {@link Result#warnings()}.\n   *\n   * @return {Warning[]} Warnings from plugins.\n   */\n  warnings () {\n    return this.sync().warnings()\n  }\n\n  /**\n   * Alias for the {@link LazyResult#css} property.\n   *\n   * @example\n   * lazy + '' === lazy.css\n   *\n   * @return {string} Output CSS.\n   */\n  toString () {\n    return this.css\n  }\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls `onFulfilled` with a Result instance. If a plugin throws\n   * an error, the `onRejected` callback will be executed.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFulfilled} onFulfilled Callback will be executed\n   *                                  when all plugins will finish work.\n   * @param {onRejected}  onRejected  Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([autoprefixer]).process(css, { from: cssPath }).then(result => {\n   *   console.log(result.css)\n   * })\n   */\n  then (onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this.opts)) {\n        warnOnce(\n          'Without `from` option PostCSS could generate wrong source map ' +\n          'and will not find Browserslist config. Set it to CSS file path ' +\n          'or to `undefined` to prevent this warning.'\n        )\n      }\n    }\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onRejected for each error thrown in any plugin.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onRejected} onRejected Callback will be executed on any error.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([autoprefixer]).process(css).then(result => {\n   *   console.log(result.css)\n   * }).catch(error => {\n   *   console.error(error)\n   * })\n   */\n  catch (onRejected) {\n    return this.async().catch(onRejected)\n  }\n  /**\n   * Processes input CSS through synchronous and asynchronous plugins\n   * and calls onFinally on any error or when all plugins will finish work.\n   *\n   * It implements standard Promise API.\n   *\n   * @param {onFinally} onFinally Callback will be executed on any error or\n   *                              when all plugins will finish work.\n   *\n   * @return {Promise} Promise API to make queue.\n   *\n   * @example\n   * postcss([autoprefixer]).process(css).finally(() => {\n   *   console.log('processing ended')\n   * })\n   */\n  finally (onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  handleError (error, plugin) {\n    try {\n      this.error = error\n      if (error.name === 'CssSyntaxError' && !error.plugin) {\n        error.plugin = plugin.postcssPlugin\n        error.setMessage()\n      } else if (plugin.postcssVersion) {\n        if (process.env.NODE_ENV !== 'production') {\n          let pluginName = plugin.postcssPlugin\n          let pluginVer = plugin.postcssVersion\n          let runtimeVer = this.result.processor.version\n          let a = pluginVer.split('.')\n          let b = runtimeVer.split('.')\n\n          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {\n            console.error(\n              'Unknown error from PostCSS plugin. Your current PostCSS ' +\n              'version is ' + runtimeVer + ', but ' + pluginName + ' uses ' +\n              pluginVer + '. Perhaps this is the source of the error below.'\n            )\n          }\n        }\n      }\n    } catch (err) {\n      if (console && console.error) console.error(err)\n    }\n  }\n\n  asyncTick (resolve, reject) {\n    if (this.plugin >= this.processor.plugins.length) {\n      this.processed = true\n      return resolve()\n    }\n\n    try {\n      let plugin = this.processor.plugins[this.plugin]\n      let promise = this.run(plugin)\n      this.plugin += 1\n\n      if (isPromise(promise)) {\n        promise.then(() => {\n          this.asyncTick(resolve, reject)\n        }).catch(error => {\n          this.handleError(error, plugin)\n          this.processed = true\n          reject(error)\n        })\n      } else {\n        this.asyncTick(resolve, reject)\n      }\n    } catch (error) {\n      this.processed = true\n      reject(error)\n    }\n  }\n\n  async () {\n    if (this.processed) {\n      return new Promise((resolve, reject) => {\n        if (this.error) {\n          reject(this.error)\n        } else {\n          resolve(this.stringify())\n        }\n      })\n    }\n    if (this.processing) {\n      return this.processing\n    }\n\n    this.processing = new Promise((resolve, reject) => {\n      if (this.error) return reject(this.error)\n      this.plugin = 0\n      this.asyncTick(resolve, reject)\n    }).then(() => {\n      this.processed = true\n      return this.stringify()\n    })\n\n    return this.processing\n  }\n\n  sync () {\n    if (this.processed) return this.result\n    this.processed = true\n\n    if (this.processing) {\n      throw new Error(\n        'Use process(css).then(cb) to work with async plugins')\n    }\n\n    if (this.error) throw this.error\n\n    for (let plugin of this.result.processor.plugins) {\n      let promise = this.run(plugin)\n      if (isPromise(promise)) {\n        throw new Error(\n          'Use process(css).then(cb) to work with async plugins')\n      }\n    }\n\n    return this.result\n  }\n\n  run (plugin) {\n    this.result.lastPlugin = plugin\n\n    try {\n      return plugin(this.result.root, this.result)\n    } catch (error) {\n      this.handleError(error, plugin)\n      throw error\n    }\n  }\n\n  stringify () {\n    if (this.stringified) return this.result\n    this.stringified = true\n\n    this.sync()\n\n    let opts = this.result.opts\n    let str = stringify\n    if (opts.syntax) str = opts.syntax.stringify\n    if (opts.stringifier) str = opts.stringifier\n    if (str.stringify) str = str.stringify\n\n    let map = new MapGenerator(str, this.result.root, this.result.opts)\n    let data = map.generate()\n    this.result.css = data[0]\n    this.result.map = data[1]\n\n    return this.result\n  }\n}\n\nexport default LazyResult\n\n/**\n * @callback onFulfilled\n * @param {Result} result\n */\n\n/**\n * @callback onRejected\n * @param {Error} error\n */\n"],"file":"lazy-result.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/list.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/list.js
new file mode 100644
index 00000000..d2feb760
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/list.js
@@ -0,0 +1,93 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Contains helpers for safely splitting lists of CSS values,
+ * preserving parentheses and quotes.
+ *
+ * @example
+ * const list = postcss.list
+ *
+ * @namespace list
+ */
+var list = {
+  split: function split(string, separators, last) {
+    var array = [];
+    var current = '';
+    var split = false;
+    var func = 0;
+    var quote = false;
+    var escape = false;
+
+    for (var i = 0; i < string.length; i++) {
+      var letter = string[i];
+
+      if (quote) {
+        if (escape) {
+          escape = false;
+        } else if (letter === '\\') {
+          escape = true;
+        } else if (letter === quote) {
+          quote = false;
+        }
+      } else if (letter === '"' || letter === '\'') {
+        quote = letter;
+      } else if (letter === '(') {
+        func += 1;
+      } else if (letter === ')') {
+        if (func > 0) func -= 1;
+      } else if (func === 0) {
+        if (separators.indexOf(letter) !== -1) split = true;
+      }
+
+      if (split) {
+        if (current !== '') array.push(current.trim());
+        current = '';
+        split = false;
+      } else {
+        current += letter;
+      }
+    }
+
+    if (last || current !== '') array.push(current.trim());
+    return array;
+  },
+
+  /**
+   * Safely splits space-separated values (such as those for `background`,
+   * `border-radius`, and other shorthand properties).
+   *
+   * @param {string} string Space-separated values.
+   *
+   * @return {string[]} Split values.
+   *
+   * @example
+   * postcss.list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)']
+   */
+  space: function space(string) {
+    var spaces = [' ', '\n', '\t'];
+    return list.split(string, spaces);
+  },
+
+  /**
+   * Safely splits comma-separated values (such as those for `transition-*`
+   * and `background` properties).
+   *
+   * @param {string} string Comma-separated values.
+   *
+   * @return {string[]} Split values.
+   *
+   * @example
+   * postcss.list.comma('black, linear-gradient(white, black)')
+   * //=> ['black', 'linear-gradient(white, black)']
+   */
+  comma: function comma(string) {
+    return list.split(string, [','], true);
+  }
+};
+var _default = list;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/map-generator.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/map-generator.js
new file mode 100644
index 00000000..a0d4f95c
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/map-generator.js
@@ -0,0 +1,347 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _sourceMap = _interopRequireDefault(require("source-map"));
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var MapGenerator = /*#__PURE__*/function () {
+  function MapGenerator(stringify, root, opts) {
+    this.stringify = stringify;
+    this.mapOpts = opts.map || {};
+    this.root = root;
+    this.opts = opts;
+  }
+
+  var _proto = MapGenerator.prototype;
+
+  _proto.isMap = function isMap() {
+    if (typeof this.opts.map !== 'undefined') {
+      return !!this.opts.map;
+    }
+
+    return this.previous().length > 0;
+  };
+
+  _proto.previous = function previous() {
+    var _this = this;
+
+    if (!this.previousMaps) {
+      this.previousMaps = [];
+      this.root.walk(function (node) {
+        if (node.source && node.source.input.map) {
+          var map = node.source.input.map;
+
+          if (_this.previousMaps.indexOf(map) === -1) {
+            _this.previousMaps.push(map);
+          }
+        }
+      });
+    }
+
+    return this.previousMaps;
+  };
+
+  _proto.isInline = function isInline() {
+    if (typeof this.mapOpts.inline !== 'undefined') {
+      return this.mapOpts.inline;
+    }
+
+    var annotation = this.mapOpts.annotation;
+
+    if (typeof annotation !== 'undefined' && annotation !== true) {
+      return false;
+    }
+
+    if (this.previous().length) {
+      return this.previous().some(function (i) {
+        return i.inline;
+      });
+    }
+
+    return true;
+  };
+
+  _proto.isSourcesContent = function isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
+      return this.mapOpts.sourcesContent;
+    }
+
+    if (this.previous().length) {
+      return this.previous().some(function (i) {
+        return i.withContent();
+      });
+    }
+
+    return true;
+  };
+
+  _proto.clearAnnotation = function clearAnnotation() {
+    if (this.mapOpts.annotation === false) return;
+    var node;
+
+    for (var i = this.root.nodes.length - 1; i >= 0; i--) {
+      node = this.root.nodes[i];
+      if (node.type !== 'comment') continue;
+
+      if (node.text.indexOf('# sourceMappingURL=') === 0) {
+        this.root.removeChild(i);
+      }
+    }
+  };
+
+  _proto.setSourcesContent = function setSourcesContent() {
+    var _this2 = this;
+
+    var already = {};
+    this.root.walk(function (node) {
+      if (node.source) {
+        var from = node.source.input.from;
+
+        if (from && !already[from]) {
+          already[from] = true;
+
+          var relative = _this2.relative(from);
+
+          _this2.map.setSourceContent(relative, node.source.input.css);
+        }
+      }
+    });
+  };
+
+  _proto.applyPrevMaps = function applyPrevMaps() {
+    for (var _iterator = _createForOfIteratorHelperLoose(this.previous()), _step; !(_step = _iterator()).done;) {
+      var prev = _step.value;
+      var from = this.relative(prev.file);
+
+      var root = prev.root || _path.default.dirname(prev.file);
+
+      var map = void 0;
+
+      if (this.mapOpts.sourcesContent === false) {
+        map = new _sourceMap.default.SourceMapConsumer(prev.text);
+
+        if (map.sourcesContent) {
+          map.sourcesContent = map.sourcesContent.map(function () {
+            return null;
+          });
+        }
+      } else {
+        map = prev.consumer();
+      }
+
+      this.map.applySourceMap(map, from, this.relative(root));
+    }
+  };
+
+  _proto.isAnnotation = function isAnnotation() {
+    if (this.isInline()) {
+      return true;
+    }
+
+    if (typeof this.mapOpts.annotation !== 'undefined') {
+      return this.mapOpts.annotation;
+    }
+
+    if (this.previous().length) {
+      return this.previous().some(function (i) {
+        return i.annotation;
+      });
+    }
+
+    return true;
+  };
+
+  _proto.toBase64 = function toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString('base64');
+    }
+
+    return window.btoa(unescape(encodeURIComponent(str)));
+  };
+
+  _proto.addAnnotation = function addAnnotation() {
+    var content;
+
+    if (this.isInline()) {
+      content = 'data:application/json;base64,' + this.toBase64(this.map.toString());
+    } else if (typeof this.mapOpts.annotation === 'string') {
+      content = this.mapOpts.annotation;
+    } else {
+      content = this.outputFile() + '.map';
+    }
+
+    var eol = '\n';
+    if (this.css.indexOf('\r\n') !== -1) eol = '\r\n';
+    this.css += eol + '/*# sourceMappingURL=' + content + ' */';
+  };
+
+  _proto.outputFile = function outputFile() {
+    if (this.opts.to) {
+      return this.relative(this.opts.to);
+    }
+
+    if (this.opts.from) {
+      return this.relative(this.opts.from);
+    }
+
+    return 'to.css';
+  };
+
+  _proto.generateMap = function generateMap() {
+    this.generateString();
+    if (this.isSourcesContent()) this.setSourcesContent();
+    if (this.previous().length > 0) this.applyPrevMaps();
+    if (this.isAnnotation()) this.addAnnotation();
+
+    if (this.isInline()) {
+      return [this.css];
+    }
+
+    return [this.css, this.map];
+  };
+
+  _proto.relative = function relative(file) {
+    if (file.indexOf('<') === 0) return file;
+    if (/^\w+:\/\//.test(file)) return file;
+    var from = this.opts.to ? _path.default.dirname(this.opts.to) : '.';
+
+    if (typeof this.mapOpts.annotation === 'string') {
+      from = _path.default.dirname(_path.default.resolve(from, this.mapOpts.annotation));
+    }
+
+    file = _path.default.relative(from, file);
+
+    if (_path.default.sep === '\\') {
+      return file.replace(/\\/g, '/');
+    }
+
+    return file;
+  };
+
+  _proto.sourcePath = function sourcePath(node) {
+    if (this.mapOpts.from) {
+      return this.mapOpts.from;
+    }
+
+    return this.relative(node.source.input.from);
+  };
+
+  _proto.generateString = function generateString() {
+    var _this3 = this;
+
+    this.css = '';
+    this.map = new _sourceMap.default.SourceMapGenerator({
+      file: this.outputFile()
+    });
+    var line = 1;
+    var column = 1;
+    var lines, last;
+    this.stringify(this.root, function (str, node, type) {
+      _this3.css += str;
+
+      if (node && type !== 'end') {
+        if (node.source && node.source.start) {
+          _this3.map.addMapping({
+            source: _this3.sourcePath(node),
+            generated: {
+              line: line,
+              column: column - 1
+            },
+            original: {
+              line: node.source.start.line,
+              column: node.source.start.column - 1
+            }
+          });
+        } else {
+          _this3.map.addMapping({
+            source: '<no source>',
+            original: {
+              line: 1,
+              column: 0
+            },
+            generated: {
+              line: line,
+              column: column - 1
+            }
+          });
+        }
+      }
+
+      lines = str.match(/\n/g);
+
+      if (lines) {
+        line += lines.length;
+        last = str.lastIndexOf('\n');
+        column = str.length - last;
+      } else {
+        column += str.length;
+      }
+
+      if (node && type !== 'start') {
+        var p = node.parent || {
+          raws: {}
+        };
+
+        if (node.type !== 'decl' || node !== p.last || p.raws.semicolon) {
+          if (node.source && node.source.end) {
+            _this3.map.addMapping({
+              source: _this3.sourcePath(node),
+              generated: {
+                line: line,
+                column: column - 2
+              },
+              original: {
+                line: node.source.end.line,
+                column: node.source.end.column - 1
+              }
+            });
+          } else {
+            _this3.map.addMapping({
+              source: '<no source>',
+              original: {
+                line: 1,
+                column: 0
+              },
+              generated: {
+                line: line,
+                column: column - 1
+              }
+            });
+          }
+        }
+      }
+    });
+  };
+
+  _proto.generate = function generate() {
+    this.clearAnnotation();
+
+    if (this.isMap()) {
+      return this.generateMap();
+    }
+
+    var result = '';
+    this.stringify(this.root, function (i) {
+      result += i;
+    });
+    return [result];
+  };
+
+  return MapGenerator;
+}();
+
+var _default = MapGenerator;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["map-generator.es6"],"names":["MapGenerator","stringify","root","opts","mapOpts","map","isMap","previous","length","previousMaps","walk","node","source","input","indexOf","push","isInline","inline","annotation","some","i","isSourcesContent","sourcesContent","withContent","clearAnnotation","nodes","type","text","removeChild","setSourcesContent","already","from","relative","setSourceContent","css","applyPrevMaps","prev","file","path","dirname","mozilla","SourceMapConsumer","consumer","applySourceMap","isAnnotation","toBase64","str","Buffer","toString","window","btoa","unescape","encodeURIComponent","addAnnotation","content","outputFile","eol","to","generateMap","generateString","test","resolve","sep","replace","sourcePath","SourceMapGenerator","line","column","lines","last","start","addMapping","generated","original","match","lastIndexOf","p","parent","raws","semicolon","end","generate","result"],"mappings":"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","sourcesContent":["import mozilla from 'source-map'\nimport path from 'path'\n\nclass MapGenerator {\n  constructor (stringify, root, opts) {\n    this.stringify = stringify\n    this.mapOpts = opts.map || { }\n    this.root = root\n    this.opts = opts\n  }\n\n  isMap () {\n    if (typeof this.opts.map !== 'undefined') {\n      return !!this.opts.map\n    }\n    return this.previous().length > 0\n  }\n\n  previous () {\n    if (!this.previousMaps) {\n      this.previousMaps = []\n      this.root.walk(node => {\n        if (node.source && node.source.input.map) {\n          let map = node.source.input.map\n          if (this.previousMaps.indexOf(map) === -1) {\n            this.previousMaps.push(map)\n          }\n        }\n      })\n    }\n\n    return this.previousMaps\n  }\n\n  isInline () {\n    if (typeof this.mapOpts.inline !== 'undefined') {\n      return this.mapOpts.inline\n    }\n\n    let annotation = this.mapOpts.annotation\n    if (typeof annotation !== 'undefined' && annotation !== true) {\n      return false\n    }\n\n    if (this.previous().length) {\n      return this.previous().some(i => i.inline)\n    }\n    return true\n  }\n\n  isSourcesContent () {\n    if (typeof this.mapOpts.sourcesContent !== 'undefined') {\n      return this.mapOpts.sourcesContent\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.withContent())\n    }\n    return true\n  }\n\n  clearAnnotation () {\n    if (this.mapOpts.annotation === false) return\n\n    let node\n    for (let i = this.root.nodes.length - 1; i >= 0; i--) {\n      node = this.root.nodes[i]\n      if (node.type !== 'comment') continue\n      if (node.text.indexOf('# sourceMappingURL=') === 0) {\n        this.root.removeChild(i)\n      }\n    }\n  }\n\n  setSourcesContent () {\n    let already = { }\n    this.root.walk(node => {\n      if (node.source) {\n        let from = node.source.input.from\n        if (from && !already[from]) {\n          already[from] = true\n          let relative = this.relative(from)\n          this.map.setSourceContent(relative, node.source.input.css)\n        }\n      }\n    })\n  }\n\n  applyPrevMaps () {\n    for (let prev of this.previous()) {\n      let from = this.relative(prev.file)\n      let root = prev.root || path.dirname(prev.file)\n      let map\n\n      if (this.mapOpts.sourcesContent === false) {\n        map = new mozilla.SourceMapConsumer(prev.text)\n        if (map.sourcesContent) {\n          map.sourcesContent = map.sourcesContent.map(() => null)\n        }\n      } else {\n        map = prev.consumer()\n      }\n\n      this.map.applySourceMap(map, from, this.relative(root))\n    }\n  }\n\n  isAnnotation () {\n    if (this.isInline()) {\n      return true\n    }\n    if (typeof this.mapOpts.annotation !== 'undefined') {\n      return this.mapOpts.annotation\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.annotation)\n    }\n    return true\n  }\n\n  toBase64 (str) {\n    if (Buffer) {\n      return Buffer.from(str).toString('base64')\n    }\n    return window.btoa(unescape(encodeURIComponent(str)))\n  }\n\n  addAnnotation () {\n    let content\n\n    if (this.isInline()) {\n      content = 'data:application/json;base64,' +\n                this.toBase64(this.map.toString())\n    } else if (typeof this.mapOpts.annotation === 'string') {\n      content = this.mapOpts.annotation\n    } else {\n      content = this.outputFile() + '.map'\n    }\n\n    let eol = '\\n'\n    if (this.css.indexOf('\\r\\n') !== -1) eol = '\\r\\n'\n\n    this.css += eol + '/*# sourceMappingURL=' + content + ' */'\n  }\n\n  outputFile () {\n    if (this.opts.to) {\n      return this.relative(this.opts.to)\n    }\n    if (this.opts.from) {\n      return this.relative(this.opts.from)\n    }\n    return 'to.css'\n  }\n\n  generateMap () {\n    this.generateString()\n    if (this.isSourcesContent()) this.setSourcesContent()\n    if (this.previous().length > 0) this.applyPrevMaps()\n    if (this.isAnnotation()) this.addAnnotation()\n\n    if (this.isInline()) {\n      return [this.css]\n    }\n    return [this.css, this.map]\n  }\n\n  relative (file) {\n    if (file.indexOf('<') === 0) return file\n    if (/^\\w+:\\/\\//.test(file)) return file\n\n    let from = this.opts.to ? path.dirname(this.opts.to) : '.'\n\n    if (typeof this.mapOpts.annotation === 'string') {\n      from = path.dirname(path.resolve(from, this.mapOpts.annotation))\n    }\n\n    file = path.relative(from, file)\n    if (path.sep === '\\\\') {\n      return file.replace(/\\\\/g, '/')\n    }\n    return file\n  }\n\n  sourcePath (node) {\n    if (this.mapOpts.from) {\n      return this.mapOpts.from\n    }\n    return this.relative(node.source.input.from)\n  }\n\n  generateString () {\n    this.css = ''\n    this.map = new mozilla.SourceMapGenerator({ file: this.outputFile() })\n\n    let line = 1\n    let column = 1\n\n    let lines, last\n    this.stringify(this.root, (str, node, type) => {\n      this.css += str\n\n      if (node && type !== 'end') {\n        if (node.source && node.source.start) {\n          this.map.addMapping({\n            source: this.sourcePath(node),\n            generated: { line, column: column - 1 },\n            original: {\n              line: node.source.start.line,\n              column: node.source.start.column - 1\n            }\n          })\n        } else {\n          this.map.addMapping({\n            source: '<no source>',\n            original: { line: 1, column: 0 },\n            generated: { line, column: column - 1 }\n          })\n        }\n      }\n\n      lines = str.match(/\\n/g)\n      if (lines) {\n        line += lines.length\n        last = str.lastIndexOf('\\n')\n        column = str.length - last\n      } else {\n        column += str.length\n      }\n\n      if (node && type !== 'start') {\n        let p = node.parent || { raws: { } }\n        if (node.type !== 'decl' || node !== p.last || p.raws.semicolon) {\n          if (node.source && node.source.end) {\n            this.map.addMapping({\n              source: this.sourcePath(node),\n              generated: { line, column: column - 2 },\n              original: {\n                line: node.source.end.line,\n                column: node.source.end.column - 1\n              }\n            })\n          } else {\n            this.map.addMapping({\n              source: '<no source>',\n              original: { line: 1, column: 0 },\n              generated: { line, column: column - 1 }\n            })\n          }\n        }\n      }\n    })\n  }\n\n  generate () {\n    this.clearAnnotation()\n\n    if (this.isMap()) {\n      return this.generateMap()\n    }\n\n    let result = ''\n    this.stringify(this.root, i => {\n      result += i\n    })\n    return [result]\n  }\n}\n\nexport default MapGenerator\n"],"file":"map-generator.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/node.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/node.js
new file mode 100644
index 00000000..840fea5b
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/node.js
@@ -0,0 +1,606 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _cssSyntaxError = _interopRequireDefault(require("./css-syntax-error"));
+
+var _stringifier = _interopRequireDefault(require("./stringifier"));
+
+var _stringify = _interopRequireDefault(require("./stringify"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function cloneNode(obj, parent) {
+  var cloned = new obj.constructor();
+
+  for (var i in obj) {
+    if (!obj.hasOwnProperty(i)) continue;
+    var value = obj[i];
+    var type = typeof value;
+
+    if (i === 'parent' && type === 'object') {
+      if (parent) cloned[i] = parent;
+    } else if (i === 'source') {
+      cloned[i] = value;
+    } else if (value instanceof Array) {
+      cloned[i] = value.map(function (j) {
+        return cloneNode(j, cloned);
+      });
+    } else {
+      if (type === 'object' && value !== null) value = cloneNode(value);
+      cloned[i] = value;
+    }
+  }
+
+  return cloned;
+}
+/**
+ * All node classes inherit the following common methods.
+ *
+ * @abstract
+ */
+
+
+var Node = /*#__PURE__*/function () {
+  /**
+   * @param {object} [defaults] Value for node properties.
+   */
+  function Node(defaults) {
+    if (defaults === void 0) {
+      defaults = {};
+    }
+
+    this.raws = {};
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (typeof defaults !== 'object' && typeof defaults !== 'undefined') {
+        throw new Error('PostCSS nodes constructor accepts object, not ' + JSON.stringify(defaults));
+      }
+    }
+
+    for (var name in defaults) {
+      this[name] = defaults[name];
+    }
+  }
+  /**
+   * Returns a `CssSyntaxError` instance containing the original position
+   * of the node in the source, showing line and column numbers and also
+   * a small excerpt to facilitate debugging.
+   *
+   * If present, an input source map will be used to get the original position
+   * of the source, even from a previous compilation step
+   * (e.g., from Sass compilation).
+   *
+   * This method produces very useful error messages.
+   *
+   * @param {string} message     Error description.
+   * @param {object} [opts]      Options.
+   * @param {string} opts.plugin Plugin name that created this error.
+   *                             PostCSS will set it automatically.
+   * @param {string} opts.word   A word inside a node’s string that should
+   *                             be highlighted as the source of the error.
+   * @param {number} opts.index  An index inside a node’s string that should
+   *                             be highlighted as the source of the error.
+   *
+   * @return {CssSyntaxError} Error object to throw it.
+   *
+   * @example
+   * if (!variables[name]) {
+   *   throw decl.error('Unknown variable ' + name, { word: name })
+   *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black
+   *   //   color: $black
+   *   // a
+   *   //          ^
+   *   //   background: white
+   * }
+   */
+
+
+  var _proto = Node.prototype;
+
+  _proto.error = function error(message, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    if (this.source) {
+      var pos = this.positionBy(opts);
+      return this.source.input.error(message, pos.line, pos.column, opts);
+    }
+
+    return new _cssSyntaxError.default(message);
+  }
+  /**
+   * This method is provided as a convenience wrapper for {@link Result#warn}.
+   *
+   * @param {Result} result      The {@link Result} instance
+   *                             that will receive the warning.
+   * @param {string} text        Warning message.
+   * @param {object} [opts]      Options
+   * @param {string} opts.plugin Plugin name that created this warning.
+   *                             PostCSS will set it automatically.
+   * @param {string} opts.word   A word inside a node’s string that should
+   *                             be highlighted as the source of the warning.
+   * @param {number} opts.index  An index inside a node’s string that should
+   *                             be highlighted as the source of the warning.
+   *
+   * @return {Warning} Created warning object.
+   *
+   * @example
+   * const plugin = postcss.plugin('postcss-deprecated', () => {
+   *   return (root, result) => {
+   *     root.walkDecls('bad', decl => {
+   *       decl.warn(result, 'Deprecated property bad')
+   *     })
+   *   }
+   * })
+   */
+  ;
+
+  _proto.warn = function warn(result, text, opts) {
+    var data = {
+      node: this
+    };
+
+    for (var i in opts) {
+      data[i] = opts[i];
+    }
+
+    return result.warn(text, data);
+  }
+  /**
+   * Removes the node from its parent and cleans the parent properties
+   * from the node and its children.
+   *
+   * @example
+   * if (decl.prop.match(/^-webkit-/)) {
+   *   decl.remove()
+   * }
+   *
+   * @return {Node} Node to make calls chain.
+   */
+  ;
+
+  _proto.remove = function remove() {
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+
+    this.parent = undefined;
+    return this;
+  }
+  /**
+   * Returns a CSS string representing the node.
+   *
+   * @param {stringifier|syntax} [stringifier] A syntax to use
+   *                                           in string generation.
+   *
+   * @return {string} CSS string of this node.
+   *
+   * @example
+   * postcss.rule({ selector: 'a' }).toString() //=> "a {}"
+   */
+  ;
+
+  _proto.toString = function toString(stringifier) {
+    if (stringifier === void 0) {
+      stringifier = _stringify.default;
+    }
+
+    if (stringifier.stringify) stringifier = stringifier.stringify;
+    var result = '';
+    stringifier(this, function (i) {
+      result += i;
+    });
+    return result;
+  }
+  /**
+   * Returns an exact clone of the node.
+   *
+   * The resulting cloned node and its (cloned) children will retain
+   * code style properties.
+   *
+   * @param {object} [overrides] New properties to override in the clone.
+   *
+   * @example
+   * decl.raws.before    //=> "\n  "
+   * const cloned = decl.clone({ prop: '-moz-' + decl.prop })
+   * cloned.raws.before  //=> "\n  "
+   * cloned.toString()   //=> -moz-transform: scale(0)
+   *
+   * @return {Node} Clone of the node.
+   */
+  ;
+
+  _proto.clone = function clone(overrides) {
+    if (overrides === void 0) {
+      overrides = {};
+    }
+
+    var cloned = cloneNode(this);
+
+    for (var name in overrides) {
+      cloned[name] = overrides[name];
+    }
+
+    return cloned;
+  }
+  /**
+   * Shortcut to clone the node and insert the resulting cloned node
+   * before the current node.
+   *
+   * @param {object} [overrides] Mew properties to override in the clone.
+   *
+   * @example
+   * decl.cloneBefore({ prop: '-moz-' + decl.prop })
+   *
+   * @return {Node} New node
+   */
+  ;
+
+  _proto.cloneBefore = function cloneBefore(overrides) {
+    if (overrides === void 0) {
+      overrides = {};
+    }
+
+    var cloned = this.clone(overrides);
+    this.parent.insertBefore(this, cloned);
+    return cloned;
+  }
+  /**
+   * Shortcut to clone the node and insert the resulting cloned node
+   * after the current node.
+   *
+   * @param {object} [overrides] New properties to override in the clone.
+   *
+   * @return {Node} New node.
+   */
+  ;
+
+  _proto.cloneAfter = function cloneAfter(overrides) {
+    if (overrides === void 0) {
+      overrides = {};
+    }
+
+    var cloned = this.clone(overrides);
+    this.parent.insertAfter(this, cloned);
+    return cloned;
+  }
+  /**
+   * Inserts node(s) before the current node and removes the current node.
+   *
+   * @param {...Node} nodes Mode(s) to replace current one.
+   *
+   * @example
+   * if (atrule.name === 'mixin') {
+   *   atrule.replaceWith(mixinRules[atrule.params])
+   * }
+   *
+   * @return {Node} Current node to methods chain.
+   */
+  ;
+
+  _proto.replaceWith = function replaceWith() {
+    if (this.parent) {
+      for (var _len = arguments.length, nodes = new Array(_len), _key = 0; _key < _len; _key++) {
+        nodes[_key] = arguments[_key];
+      }
+
+      for (var _i = 0, _nodes = nodes; _i < _nodes.length; _i++) {
+        var node = _nodes[_i];
+        this.parent.insertBefore(this, node);
+      }
+
+      this.remove();
+    }
+
+    return this;
+  }
+  /**
+   * Returns the next child of the node’s parent.
+   * Returns `undefined` if the current node is the last child.
+   *
+   * @return {Node|undefined} Next node.
+   *
+   * @example
+   * if (comment.text === 'delete next') {
+   *   const next = comment.next()
+   *   if (next) {
+   *     next.remove()
+   *   }
+   * }
+   */
+  ;
+
+  _proto.next = function next() {
+    if (!this.parent) return undefined;
+    var index = this.parent.index(this);
+    return this.parent.nodes[index + 1];
+  }
+  /**
+   * Returns the previous child of the node’s parent.
+   * Returns `undefined` if the current node is the first child.
+   *
+   * @return {Node|undefined} Previous node.
+   *
+   * @example
+   * const annotation = decl.prev()
+   * if (annotation.type === 'comment') {
+   *   readAnnotation(annotation.text)
+   * }
+   */
+  ;
+
+  _proto.prev = function prev() {
+    if (!this.parent) return undefined;
+    var index = this.parent.index(this);
+    return this.parent.nodes[index - 1];
+  }
+  /**
+   * Insert new node before current node to current node’s parent.
+   *
+   * Just alias for `node.parent.insertBefore(node, add)`.
+   *
+   * @param {Node|object|string|Node[]} add New node.
+   *
+   * @return {Node} This node for methods chain.
+   *
+   * @example
+   * decl.before('content: ""')
+   */
+  ;
+
+  _proto.before = function before(add) {
+    this.parent.insertBefore(this, add);
+    return this;
+  }
+  /**
+   * Insert new node after current node to current node’s parent.
+   *
+   * Just alias for `node.parent.insertAfter(node, add)`.
+   *
+   * @param {Node|object|string|Node[]} add New node.
+   *
+   * @return {Node} This node for methods chain.
+   *
+   * @example
+   * decl.after('color: black')
+   */
+  ;
+
+  _proto.after = function after(add) {
+    this.parent.insertAfter(this, add);
+    return this;
+  };
+
+  _proto.toJSON = function toJSON() {
+    var fixed = {};
+
+    for (var name in this) {
+      if (!this.hasOwnProperty(name)) continue;
+      if (name === 'parent') continue;
+      var value = this[name];
+
+      if (value instanceof Array) {
+        fixed[name] = value.map(function (i) {
+          if (typeof i === 'object' && i.toJSON) {
+            return i.toJSON();
+          } else {
+            return i;
+          }
+        });
+      } else if (typeof value === 'object' && value.toJSON) {
+        fixed[name] = value.toJSON();
+      } else {
+        fixed[name] = value;
+      }
+    }
+
+    return fixed;
+  }
+  /**
+   * Returns a {@link Node#raws} value. If the node is missing
+   * the code style property (because the node was manually built or cloned),
+   * PostCSS will try to autodetect the code style property by looking
+   * at other nodes in the tree.
+   *
+   * @param {string} prop          Name of code style property.
+   * @param {string} [defaultType] Name of default value, it can be missed
+   *                               if the value is the same as prop.
+   *
+   * @example
+   * const root = postcss.parse('a { background: white }')
+   * root.nodes[0].append({ prop: 'color', value: 'black' })
+   * root.nodes[0].nodes[1].raws.before   //=> undefined
+   * root.nodes[0].nodes[1].raw('before') //=> ' '
+   *
+   * @return {string} Code style value.
+   */
+  ;
+
+  _proto.raw = function raw(prop, defaultType) {
+    var str = new _stringifier.default();
+    return str.raw(this, prop, defaultType);
+  }
+  /**
+   * Finds the Root instance of the node’s tree.
+   *
+   * @example
+   * root.nodes[0].nodes[0].root() === root
+   *
+   * @return {Root} Root parent.
+   */
+  ;
+
+  _proto.root = function root() {
+    var result = this;
+
+    while (result.parent) {
+      result = result.parent;
+    }
+
+    return result;
+  }
+  /**
+   * Clear the code style properties for the node and its children.
+   *
+   * @param {boolean} [keepBetween] Keep the raws.between symbols.
+   *
+   * @return {undefined}
+   *
+   * @example
+   * node.raws.before  //=> ' '
+   * node.cleanRaws()
+   * node.raws.before  //=> undefined
+   */
+  ;
+
+  _proto.cleanRaws = function cleanRaws(keepBetween) {
+    delete this.raws.before;
+    delete this.raws.after;
+    if (!keepBetween) delete this.raws.between;
+  };
+
+  _proto.positionInside = function positionInside(index) {
+    var string = this.toString();
+    var column = this.source.start.column;
+    var line = this.source.start.line;
+
+    for (var i = 0; i < index; i++) {
+      if (string[i] === '\n') {
+        column = 1;
+        line += 1;
+      } else {
+        column += 1;
+      }
+    }
+
+    return {
+      line: line,
+      column: column
+    };
+  };
+
+  _proto.positionBy = function positionBy(opts) {
+    var pos = this.source.start;
+
+    if (opts.index) {
+      pos = this.positionInside(opts.index);
+    } else if (opts.word) {
+      var index = this.toString().indexOf(opts.word);
+      if (index !== -1) pos = this.positionInside(index);
+    }
+
+    return pos;
+  }
+  /**
+   * @memberof Node#
+   * @member {string} type String representing the node’s type.
+   *                       Possible values are `root`, `atrule`, `rule`,
+   *                       `decl`, or `comment`.
+   *
+   * @example
+   * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'
+   */
+
+  /**
+   * @memberof Node#
+   * @member {Container} parent The node’s parent node.
+   *
+   * @example
+   * root.nodes[0].parent === root
+   */
+
+  /**
+   * @memberof Node#
+   * @member {source} source The input source of the node.
+   *
+   * The property is used in source map generation.
+   *
+   * If you create a node manually (e.g., with `postcss.decl()`),
+   * that node will not have a `source` property and will be absent
+   * from the source map. For this reason, the plugin developer should
+   * consider cloning nodes to create new ones (in which case the new node’s
+   * source will reference the original, cloned node) or setting
+   * the `source` property manually.
+   *
+   * ```js
+   * // Bad
+   * const prefixed = postcss.decl({
+   *   prop: '-moz-' + decl.prop,
+   *   value: decl.value
+   * })
+   *
+   * // Good
+   * const prefixed = decl.clone({ prop: '-moz-' + decl.prop })
+   * ```
+   *
+   * ```js
+   * if (atrule.name === 'add-link') {
+   *   const rule = postcss.rule({ selector: 'a', source: atrule.source })
+   *   atrule.parent.insertBefore(atrule, rule)
+   * }
+   * ```
+   *
+   * @example
+   * decl.source.input.from //=> '/home/ai/a.sass'
+   * decl.source.start      //=> { line: 10, column: 2 }
+   * decl.source.end        //=> { line: 10, column: 12 }
+   */
+
+  /**
+   * @memberof Node#
+   * @member {object} raws Information to generate byte-to-byte equal
+   *                       node string as it was in the origin input.
+   *
+   * Every parser saves its own properties,
+   * but the default CSS parser uses:
+   *
+   * * `before`: the space symbols before the node. It also stores `*`
+   *   and `_` symbols before the declaration (IE hack).
+   * * `after`: the space symbols after the last child of the node
+   *   to the end of the node.
+   * * `between`: the symbols between the property and value
+   *   for declarations, selector and `{` for rules, or last parameter
+   *   and `{` for at-rules.
+   * * `semicolon`: contains true if the last child has
+   *   an (optional) semicolon.
+   * * `afterName`: the space between the at-rule name and its parameters.
+   * * `left`: the space symbols between `/*` and the comment’s text.
+   * * `right`: the space symbols between the comment’s text
+   *   and <code>*&#47;</code>.
+   * * `important`: the content of the important statement,
+   *   if it is not just `!important`.
+   *
+   * PostCSS cleans selectors, declaration values and at-rule parameters
+   * from comments and extra spaces, but it stores origin content in raws
+   * properties. As such, if you don’t change a declaration’s value,
+   * PostCSS will use the raw value with comments.
+   *
+   * @example
+   * const root = postcss.parse('a {\n  color:black\n}')
+   * root.first.first.raws //=> { before: '\n  ', between: ':' }
+   */
+  ;
+
+  return Node;
+}();
+
+var _default = Node;
+/**
+ * @typedef {object} position
+ * @property {number} line   Source line in file.
+ * @property {number} column Source column in file.
+ */
+
+/**
+ * @typedef {object} source
+ * @property {Input} input    {@link Input} with input file
+ * @property {position} start The starting position of the node’s source.
+ * @property {position} end   The ending position of the node’s source.
+ */
+
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["node.es6"],"names":["cloneNode","obj","parent","cloned","constructor","i","hasOwnProperty","value","type","Array","map","j","Node","defaults","raws","process","env","NODE_ENV","Error","JSON","stringify","name","error","message","opts","source","pos","positionBy","input","line","column","CssSyntaxError","warn","result","text","data","node","remove","removeChild","undefined","toString","stringifier","clone","overrides","cloneBefore","insertBefore","cloneAfter","insertAfter","replaceWith","nodes","next","index","prev","before","add","after","toJSON","fixed","raw","prop","defaultType","str","Stringifier","root","cleanRaws","keepBetween","between","positionInside","string","start","word","indexOf"],"mappings":"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","sourcesContent":["import CssSyntaxError from './css-syntax-error'\nimport Stringifier from './stringifier'\nimport stringify from './stringify'\n\nfunction cloneNode (obj, parent) {\n  let cloned = new obj.constructor()\n\n  for (let i in obj) {\n    if (!obj.hasOwnProperty(i)) continue\n    let value = obj[i]\n    let type = typeof value\n\n    if (i === 'parent' && type === 'object') {\n      if (parent) cloned[i] = parent\n    } else if (i === 'source') {\n      cloned[i] = value\n    } else if (value instanceof Array) {\n      cloned[i] = value.map(j => cloneNode(j, cloned))\n    } else {\n      if (type === 'object' && value !== null) value = cloneNode(value)\n      cloned[i] = value\n    }\n  }\n\n  return cloned\n}\n\n/**\n * All node classes inherit the following common methods.\n *\n * @abstract\n */\nclass Node {\n  /**\n   * @param {object} [defaults] Value for node properties.\n   */\n  constructor (defaults = { }) {\n    this.raws = { }\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof defaults !== 'object' && typeof defaults !== 'undefined') {\n        throw new Error(\n          'PostCSS nodes constructor accepts object, not ' +\n          JSON.stringify(defaults)\n        )\n      }\n    }\n    for (let name in defaults) {\n      this[name] = defaults[name]\n    }\n  }\n\n  /**\n   * Returns a `CssSyntaxError` instance containing the original position\n   * of the node in the source, showing line and column numbers and also\n   * a small excerpt to facilitate debugging.\n   *\n   * If present, an input source map will be used to get the original position\n   * of the source, even from a previous compilation step\n   * (e.g., from Sass compilation).\n   *\n   * This method produces very useful error messages.\n   *\n   * @param {string} message     Error description.\n   * @param {object} [opts]      Options.\n   * @param {string} opts.plugin Plugin name that created this error.\n   *                             PostCSS will set it automatically.\n   * @param {string} opts.word   A word inside a node’s string that should\n   *                             be highlighted as the source of the error.\n   * @param {number} opts.index  An index inside a node’s string that should\n   *                             be highlighted as the source of the error.\n   *\n   * @return {CssSyntaxError} Error object to throw it.\n   *\n   * @example\n   * if (!variables[name]) {\n   *   throw decl.error('Unknown variable ' + name, { word: name })\n   *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black\n   *   //   color: $black\n   *   // a\n   *   //          ^\n   *   //   background: white\n   * }\n   */\n  error (message, opts = { }) {\n    if (this.source) {\n      let pos = this.positionBy(opts)\n      return this.source.input.error(message, pos.line, pos.column, opts)\n    }\n    return new CssSyntaxError(message)\n  }\n\n  /**\n   * This method is provided as a convenience wrapper for {@link Result#warn}.\n   *\n   * @param {Result} result      The {@link Result} instance\n   *                             that will receive the warning.\n   * @param {string} text        Warning message.\n   * @param {object} [opts]      Options\n   * @param {string} opts.plugin Plugin name that created this warning.\n   *                             PostCSS will set it automatically.\n   * @param {string} opts.word   A word inside a node’s string that should\n   *                             be highlighted as the source of the warning.\n   * @param {number} opts.index  An index inside a node’s string that should\n   *                             be highlighted as the source of the warning.\n   *\n   * @return {Warning} Created warning object.\n   *\n   * @example\n   * const plugin = postcss.plugin('postcss-deprecated', () => {\n   *   return (root, result) => {\n   *     root.walkDecls('bad', decl => {\n   *       decl.warn(result, 'Deprecated property bad')\n   *     })\n   *   }\n   * })\n   */\n  warn (result, text, opts) {\n    let data = { node: this }\n    for (let i in opts) data[i] = opts[i]\n    return result.warn(text, data)\n  }\n\n  /**\n   * Removes the node from its parent and cleans the parent properties\n   * from the node and its children.\n   *\n   * @example\n   * if (decl.prop.match(/^-webkit-/)) {\n   *   decl.remove()\n   * }\n   *\n   * @return {Node} Node to make calls chain.\n   */\n  remove () {\n    if (this.parent) {\n      this.parent.removeChild(this)\n    }\n    this.parent = undefined\n    return this\n  }\n\n  /**\n   * Returns a CSS string representing the node.\n   *\n   * @param {stringifier|syntax} [stringifier] A syntax to use\n   *                                           in string generation.\n   *\n   * @return {string} CSS string of this node.\n   *\n   * @example\n   * postcss.rule({ selector: 'a' }).toString() //=> \"a {}\"\n   */\n  toString (stringifier = stringify) {\n    if (stringifier.stringify) stringifier = stringifier.stringify\n    let result = ''\n    stringifier(this, i => {\n      result += i\n    })\n    return result\n  }\n\n  /**\n   * Returns an exact clone of the node.\n   *\n   * The resulting cloned node and its (cloned) children will retain\n   * code style properties.\n   *\n   * @param {object} [overrides] New properties to override in the clone.\n   *\n   * @example\n   * decl.raws.before    //=> \"\\n  \"\n   * const cloned = decl.clone({ prop: '-moz-' + decl.prop })\n   * cloned.raws.before  //=> \"\\n  \"\n   * cloned.toString()   //=> -moz-transform: scale(0)\n   *\n   * @return {Node} Clone of the node.\n   */\n  clone (overrides = { }) {\n    let cloned = cloneNode(this)\n    for (let name in overrides) {\n      cloned[name] = overrides[name]\n    }\n    return cloned\n  }\n\n  /**\n   * Shortcut to clone the node and insert the resulting cloned node\n   * before the current node.\n   *\n   * @param {object} [overrides] Mew properties to override in the clone.\n   *\n   * @example\n   * decl.cloneBefore({ prop: '-moz-' + decl.prop })\n   *\n   * @return {Node} New node\n   */\n  cloneBefore (overrides = { }) {\n    let cloned = this.clone(overrides)\n    this.parent.insertBefore(this, cloned)\n    return cloned\n  }\n\n  /**\n   * Shortcut to clone the node and insert the resulting cloned node\n   * after the current node.\n   *\n   * @param {object} [overrides] New properties to override in the clone.\n   *\n   * @return {Node} New node.\n   */\n  cloneAfter (overrides = { }) {\n    let cloned = this.clone(overrides)\n    this.parent.insertAfter(this, cloned)\n    return cloned\n  }\n\n  /**\n   * Inserts node(s) before the current node and removes the current node.\n   *\n   * @param {...Node} nodes Mode(s) to replace current one.\n   *\n   * @example\n   * if (atrule.name === 'mixin') {\n   *   atrule.replaceWith(mixinRules[atrule.params])\n   * }\n   *\n   * @return {Node} Current node to methods chain.\n   */\n  replaceWith (...nodes) {\n    if (this.parent) {\n      for (let node of nodes) {\n        this.parent.insertBefore(this, node)\n      }\n\n      this.remove()\n    }\n\n    return this\n  }\n\n  /**\n   * Returns the next child of the node’s parent.\n   * Returns `undefined` if the current node is the last child.\n   *\n   * @return {Node|undefined} Next node.\n   *\n   * @example\n   * if (comment.text === 'delete next') {\n   *   const next = comment.next()\n   *   if (next) {\n   *     next.remove()\n   *   }\n   * }\n   */\n  next () {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index + 1]\n  }\n\n  /**\n   * Returns the previous child of the node’s parent.\n   * Returns `undefined` if the current node is the first child.\n   *\n   * @return {Node|undefined} Previous node.\n   *\n   * @example\n   * const annotation = decl.prev()\n   * if (annotation.type === 'comment') {\n   *   readAnnotation(annotation.text)\n   * }\n   */\n  prev () {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index - 1]\n  }\n\n  /**\n   * Insert new node before current node to current node’s parent.\n   *\n   * Just alias for `node.parent.insertBefore(node, add)`.\n   *\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * decl.before('content: \"\"')\n   */\n  before (add) {\n    this.parent.insertBefore(this, add)\n    return this\n  }\n\n  /**\n   * Insert new node after current node to current node’s parent.\n   *\n   * Just alias for `node.parent.insertAfter(node, add)`.\n   *\n   * @param {Node|object|string|Node[]} add New node.\n   *\n   * @return {Node} This node for methods chain.\n   *\n   * @example\n   * decl.after('color: black')\n   */\n  after (add) {\n    this.parent.insertAfter(this, add)\n    return this\n  }\n\n  toJSON () {\n    let fixed = { }\n\n    for (let name in this) {\n      if (!this.hasOwnProperty(name)) continue\n      if (name === 'parent') continue\n      let value = this[name]\n\n      if (value instanceof Array) {\n        fixed[name] = value.map(i => {\n          if (typeof i === 'object' && i.toJSON) {\n            return i.toJSON()\n          } else {\n            return i\n          }\n        })\n      } else if (typeof value === 'object' && value.toJSON) {\n        fixed[name] = value.toJSON()\n      } else {\n        fixed[name] = value\n      }\n    }\n\n    return fixed\n  }\n\n  /**\n   * Returns a {@link Node#raws} value. If the node is missing\n   * the code style property (because the node was manually built or cloned),\n   * PostCSS will try to autodetect the code style property by looking\n   * at other nodes in the tree.\n   *\n   * @param {string} prop          Name of code style property.\n   * @param {string} [defaultType] Name of default value, it can be missed\n   *                               if the value is the same as prop.\n   *\n   * @example\n   * const root = postcss.parse('a { background: white }')\n   * root.nodes[0].append({ prop: 'color', value: 'black' })\n   * root.nodes[0].nodes[1].raws.before   //=> undefined\n   * root.nodes[0].nodes[1].raw('before') //=> ' '\n   *\n   * @return {string} Code style value.\n   */\n  raw (prop, defaultType) {\n    let str = new Stringifier()\n    return str.raw(this, prop, defaultType)\n  }\n\n  /**\n   * Finds the Root instance of the node’s tree.\n   *\n   * @example\n   * root.nodes[0].nodes[0].root() === root\n   *\n   * @return {Root} Root parent.\n   */\n  root () {\n    let result = this\n    while (result.parent) result = result.parent\n    return result\n  }\n\n  /**\n   * Clear the code style properties for the node and its children.\n   *\n   * @param {boolean} [keepBetween] Keep the raws.between symbols.\n   *\n   * @return {undefined}\n   *\n   * @example\n   * node.raws.before  //=> ' '\n   * node.cleanRaws()\n   * node.raws.before  //=> undefined\n   */\n  cleanRaws (keepBetween) {\n    delete this.raws.before\n    delete this.raws.after\n    if (!keepBetween) delete this.raws.between\n  }\n\n  positionInside (index) {\n    let string = this.toString()\n    let column = this.source.start.column\n    let line = this.source.start.line\n\n    for (let i = 0; i < index; i++) {\n      if (string[i] === '\\n') {\n        column = 1\n        line += 1\n      } else {\n        column += 1\n      }\n    }\n\n    return { line, column }\n  }\n\n  positionBy (opts) {\n    let pos = this.source.start\n    if (opts.index) {\n      pos = this.positionInside(opts.index)\n    } else if (opts.word) {\n      let index = this.toString().indexOf(opts.word)\n      if (index !== -1) pos = this.positionInside(index)\n    }\n    return pos\n  }\n\n  /**\n   * @memberof Node#\n   * @member {string} type String representing the node’s type.\n   *                       Possible values are `root`, `atrule`, `rule`,\n   *                       `decl`, or `comment`.\n   *\n   * @example\n   * postcss.decl({ prop: 'color', value: 'black' }).type //=> 'decl'\n   */\n\n  /**\n   * @memberof Node#\n   * @member {Container} parent The node’s parent node.\n   *\n   * @example\n   * root.nodes[0].parent === root\n   */\n\n  /**\n   * @memberof Node#\n   * @member {source} source The input source of the node.\n   *\n   * The property is used in source map generation.\n   *\n   * If you create a node manually (e.g., with `postcss.decl()`),\n   * that node will not have a `source` property and will be absent\n   * from the source map. For this reason, the plugin developer should\n   * consider cloning nodes to create new ones (in which case the new node’s\n   * source will reference the original, cloned node) or setting\n   * the `source` property manually.\n   *\n   * ```js\n   * // Bad\n   * const prefixed = postcss.decl({\n   *   prop: '-moz-' + decl.prop,\n   *   value: decl.value\n   * })\n   *\n   * // Good\n   * const prefixed = decl.clone({ prop: '-moz-' + decl.prop })\n   * ```\n   *\n   * ```js\n   * if (atrule.name === 'add-link') {\n   *   const rule = postcss.rule({ selector: 'a', source: atrule.source })\n   *   atrule.parent.insertBefore(atrule, rule)\n   * }\n   * ```\n   *\n   * @example\n   * decl.source.input.from //=> '/home/ai/a.sass'\n   * decl.source.start      //=> { line: 10, column: 2 }\n   * decl.source.end        //=> { line: 10, column: 12 }\n   */\n\n  /**\n   * @memberof Node#\n   * @member {object} raws Information to generate byte-to-byte equal\n   *                       node string as it was in the origin input.\n   *\n   * Every parser saves its own properties,\n   * but the default CSS parser uses:\n   *\n   * * `before`: the space symbols before the node. It also stores `*`\n   *   and `_` symbols before the declaration (IE hack).\n   * * `after`: the space symbols after the last child of the node\n   *   to the end of the node.\n   * * `between`: the symbols between the property and value\n   *   for declarations, selector and `{` for rules, or last parameter\n   *   and `{` for at-rules.\n   * * `semicolon`: contains true if the last child has\n   *   an (optional) semicolon.\n   * * `afterName`: the space between the at-rule name and its parameters.\n   * * `left`: the space symbols between `/*` and the comment’s text.\n   * * `right`: the space symbols between the comment’s text\n   *   and <code>*&#47;</code>.\n   * * `important`: the content of the important statement,\n   *   if it is not just `!important`.\n   *\n   * PostCSS cleans selectors, declaration values and at-rule parameters\n   * from comments and extra spaces, but it stores origin content in raws\n   * properties. As such, if you don’t change a declaration’s value,\n   * PostCSS will use the raw value with comments.\n   *\n   * @example\n   * const root = postcss.parse('a {\\n  color:black\\n}')\n   * root.first.first.raws //=> { before: '\\n  ', between: ':' }\n   */\n}\n\nexport default Node\n\n/**\n * @typedef {object} position\n * @property {number} line   Source line in file.\n * @property {number} column Source column in file.\n */\n\n/**\n * @typedef {object} source\n * @property {Input} input    {@link Input} with input file\n * @property {position} start The starting position of the node’s source.\n * @property {position} end   The ending position of the node’s source.\n */\n"],"file":"node.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/parse.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/parse.js
new file mode 100644
index 00000000..99c417ec
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/parse.js
@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _parser = _interopRequireDefault(require("./parser"));
+
+var _input = _interopRequireDefault(require("./input"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parse(css, opts) {
+  var input = new _input.default(css, opts);
+  var parser = new _parser.default(input);
+
+  try {
+    parser.parse();
+  } catch (e) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (e.name === 'CssSyntaxError' && opts && opts.from) {
+        if (/\.scss$/i.test(opts.from)) {
+          e.message += '\nYou tried to parse SCSS with ' + 'the standard CSS parser; ' + 'try again with the postcss-scss parser';
+        } else if (/\.sass/i.test(opts.from)) {
+          e.message += '\nYou tried to parse Sass with ' + 'the standard CSS parser; ' + 'try again with the postcss-sass parser';
+        } else if (/\.less$/i.test(opts.from)) {
+          e.message += '\nYou tried to parse Less with ' + 'the standard CSS parser; ' + 'try again with the postcss-less parser';
+        }
+      }
+    }
+
+    throw e;
+  }
+
+  return parser.root;
+}
+
+var _default = parse;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlLmVzNiJdLCJuYW1lcyI6WyJwYXJzZSIsImNzcyIsIm9wdHMiLCJpbnB1dCIsIklucHV0IiwicGFyc2VyIiwiUGFyc2VyIiwiZSIsInByb2Nlc3MiLCJlbnYiLCJOT0RFX0VOViIsIm5hbWUiLCJmcm9tIiwidGVzdCIsIm1lc3NhZ2UiLCJyb290Il0sIm1hcHBpbmdzIjoiOzs7OztBQUFBOztBQUNBOzs7O0FBRUEsU0FBU0EsS0FBVCxDQUFnQkMsR0FBaEIsRUFBcUJDLElBQXJCLEVBQTJCO0FBQ3pCLE1BQUlDLEtBQUssR0FBRyxJQUFJQyxjQUFKLENBQVVILEdBQVYsRUFBZUMsSUFBZixDQUFaO0FBQ0EsTUFBSUcsTUFBTSxHQUFHLElBQUlDLGVBQUosQ0FBV0gsS0FBWCxDQUFiOztBQUNBLE1BQUk7QUFDRkUsSUFBQUEsTUFBTSxDQUFDTCxLQUFQO0FBQ0QsR0FGRCxDQUVFLE9BQU9PLENBQVAsRUFBVTtBQUNWLFFBQUlDLE9BQU8sQ0FBQ0MsR0FBUixDQUFZQyxRQUFaLEtBQXlCLFlBQTdCLEVBQTJDO0FBQ3pDLFVBQUlILENBQUMsQ0FBQ0ksSUFBRixLQUFXLGdCQUFYLElBQStCVCxJQUEvQixJQUF1Q0EsSUFBSSxDQUFDVSxJQUFoRCxFQUFzRDtBQUNwRCxZQUFJLFdBQVdDLElBQVgsQ0FBZ0JYLElBQUksQ0FBQ1UsSUFBckIsQ0FBSixFQUFnQztBQUM5QkwsVUFBQUEsQ0FBQyxDQUFDTyxPQUFGLElBQWEsb0NBQ0EsMkJBREEsR0FFQSx3Q0FGYjtBQUdELFNBSkQsTUFJTyxJQUFJLFVBQVVELElBQVYsQ0FBZVgsSUFBSSxDQUFDVSxJQUFwQixDQUFKLEVBQStCO0FBQ3BDTCxVQUFBQSxDQUFDLENBQUNPLE9BQUYsSUFBYSxvQ0FDQSwyQkFEQSxHQUVBLHdDQUZiO0FBR0QsU0FKTSxNQUlBLElBQUksV0FBV0QsSUFBWCxDQUFnQlgsSUFBSSxDQUFDVSxJQUFyQixDQUFKLEVBQWdDO0FBQ3JDTCxVQUFBQSxDQUFDLENBQUNPLE9BQUYsSUFBYSxvQ0FDQSwyQkFEQSxHQUVBLHdDQUZiO0FBR0Q7QUFDRjtBQUNGOztBQUNELFVBQU1QLENBQU47QUFDRDs7QUFFRCxTQUFPRixNQUFNLENBQUNVLElBQWQ7QUFDRDs7ZUFFY2YsSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBQYXJzZXIgZnJvbSAnLi9wYXJzZXInXG5pbXBvcnQgSW5wdXQgZnJvbSAnLi9pbnB1dCdcblxuZnVuY3Rpb24gcGFyc2UgKGNzcywgb3B0cykge1xuICBsZXQgaW5wdXQgPSBuZXcgSW5wdXQoY3NzLCBvcHRzKVxuICBsZXQgcGFyc2VyID0gbmV3IFBhcnNlcihpbnB1dClcbiAgdHJ5IHtcbiAgICBwYXJzZXIucGFyc2UoKVxuICB9IGNhdGNoIChlKSB7XG4gICAgaWYgKHByb2Nlc3MuZW52Lk5PREVfRU5WICE9PSAncHJvZHVjdGlvbicpIHtcbiAgICAgIGlmIChlLm5hbWUgPT09ICdDc3NTeW50YXhFcnJvcicgJiYgb3B0cyAmJiBvcHRzLmZyb20pIHtcbiAgICAgICAgaWYgKC9cXC5zY3NzJC9pLnRlc3Qob3B0cy5mcm9tKSkge1xuICAgICAgICAgIGUubWVzc2FnZSArPSAnXFxuWW91IHRyaWVkIHRvIHBhcnNlIFNDU1Mgd2l0aCAnICtcbiAgICAgICAgICAgICAgICAgICAgICAgJ3RoZSBzdGFuZGFyZCBDU1MgcGFyc2VyOyAnICtcbiAgICAgICAgICAgICAgICAgICAgICAgJ3RyeSBhZ2FpbiB3aXRoIHRoZSBwb3N0Y3NzLXNjc3MgcGFyc2VyJ1xuICAgICAgICB9IGVsc2UgaWYgKC9cXC5zYXNzL2kudGVzdChvcHRzLmZyb20pKSB7XG4gICAgICAgICAgZS5tZXNzYWdlICs9ICdcXG5Zb3UgdHJpZWQgdG8gcGFyc2UgU2FzcyB3aXRoICcgK1xuICAgICAgICAgICAgICAgICAgICAgICAndGhlIHN0YW5kYXJkIENTUyBwYXJzZXI7ICcgK1xuICAgICAgICAgICAgICAgICAgICAgICAndHJ5IGFnYWluIHdpdGggdGhlIHBvc3Rjc3Mtc2FzcyBwYXJzZXInXG4gICAgICAgIH0gZWxzZSBpZiAoL1xcLmxlc3MkL2kudGVzdChvcHRzLmZyb20pKSB7XG4gICAgICAgICAgZS5tZXNzYWdlICs9ICdcXG5Zb3UgdHJpZWQgdG8gcGFyc2UgTGVzcyB3aXRoICcgK1xuICAgICAgICAgICAgICAgICAgICAgICAndGhlIHN0YW5kYXJkIENTUyBwYXJzZXI7ICcgK1xuICAgICAgICAgICAgICAgICAgICAgICAndHJ5IGFnYWluIHdpdGggdGhlIHBvc3Rjc3MtbGVzcyBwYXJzZXInXG4gICAgICAgIH1cbiAgICAgIH1cbiAgICB9XG4gICAgdGhyb3cgZVxuICB9XG5cbiAgcmV0dXJuIHBhcnNlci5yb290XG59XG5cbmV4cG9ydCBkZWZhdWx0IHBhcnNlXG4iXSwiZmlsZSI6InBhcnNlLmpzIn0=
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/parser.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/parser.js
new file mode 100644
index 00000000..a471142d
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/parser.js
@@ -0,0 +1,609 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _declaration = _interopRequireDefault(require("./declaration"));
+
+var _tokenize = _interopRequireDefault(require("./tokenize"));
+
+var _comment = _interopRequireDefault(require("./comment"));
+
+var _atRule = _interopRequireDefault(require("./at-rule"));
+
+var _root = _interopRequireDefault(require("./root"));
+
+var _rule = _interopRequireDefault(require("./rule"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Parser = /*#__PURE__*/function () {
+  function Parser(input) {
+    this.input = input;
+    this.root = new _root.default();
+    this.current = this.root;
+    this.spaces = '';
+    this.semicolon = false;
+    this.createTokenizer();
+    this.root.source = {
+      input: input,
+      start: {
+        line: 1,
+        column: 1
+      }
+    };
+  }
+
+  var _proto = Parser.prototype;
+
+  _proto.createTokenizer = function createTokenizer() {
+    this.tokenizer = (0, _tokenize.default)(this.input);
+  };
+
+  _proto.parse = function parse() {
+    var token;
+
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken();
+
+      switch (token[0]) {
+        case 'space':
+          this.spaces += token[1];
+          break;
+
+        case ';':
+          this.freeSemicolon(token);
+          break;
+
+        case '}':
+          this.end(token);
+          break;
+
+        case 'comment':
+          this.comment(token);
+          break;
+
+        case 'at-word':
+          this.atrule(token);
+          break;
+
+        case '{':
+          this.emptyRule(token);
+          break;
+
+        default:
+          this.other(token);
+          break;
+      }
+    }
+
+    this.endFile();
+  };
+
+  _proto.comment = function comment(token) {
+    var node = new _comment.default();
+    this.init(node, token[2], token[3]);
+    node.source.end = {
+      line: token[4],
+      column: token[5]
+    };
+    var text = token[1].slice(2, -2);
+
+    if (/^\s*$/.test(text)) {
+      node.text = '';
+      node.raws.left = text;
+      node.raws.right = '';
+    } else {
+      var match = text.match(/^(\s*)([^]*[^\s])(\s*)$/);
+      node.text = match[2];
+      node.raws.left = match[1];
+      node.raws.right = match[3];
+    }
+  };
+
+  _proto.emptyRule = function emptyRule(token) {
+    var node = new _rule.default();
+    this.init(node, token[2], token[3]);
+    node.selector = '';
+    node.raws.between = '';
+    this.current = node;
+  };
+
+  _proto.other = function other(start) {
+    var end = false;
+    var type = null;
+    var colon = false;
+    var bracket = null;
+    var brackets = [];
+    var tokens = [];
+    var token = start;
+
+    while (token) {
+      type = token[0];
+      tokens.push(token);
+
+      if (type === '(' || type === '[') {
+        if (!bracket) bracket = token;
+        brackets.push(type === '(' ? ')' : ']');
+      } else if (brackets.length === 0) {
+        if (type === ';') {
+          if (colon) {
+            this.decl(tokens);
+            return;
+          } else {
+            break;
+          }
+        } else if (type === '{') {
+          this.rule(tokens);
+          return;
+        } else if (type === '}') {
+          this.tokenizer.back(tokens.pop());
+          end = true;
+          break;
+        } else if (type === ':') {
+          colon = true;
+        }
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop();
+        if (brackets.length === 0) bracket = null;
+      }
+
+      token = this.tokenizer.nextToken();
+    }
+
+    if (this.tokenizer.endOfFile()) end = true;
+    if (brackets.length > 0) this.unclosedBracket(bracket);
+
+    if (end && colon) {
+      while (tokens.length) {
+        token = tokens[tokens.length - 1][0];
+        if (token !== 'space' && token !== 'comment') break;
+        this.tokenizer.back(tokens.pop());
+      }
+
+      this.decl(tokens);
+    } else {
+      this.unknownWord(tokens);
+    }
+  };
+
+  _proto.rule = function rule(tokens) {
+    tokens.pop();
+    var node = new _rule.default();
+    this.init(node, tokens[0][2], tokens[0][3]);
+    node.raws.between = this.spacesAndCommentsFromEnd(tokens);
+    this.raw(node, 'selector', tokens);
+    this.current = node;
+  };
+
+  _proto.decl = function decl(tokens) {
+    var node = new _declaration.default();
+    this.init(node);
+    var last = tokens[tokens.length - 1];
+
+    if (last[0] === ';') {
+      this.semicolon = true;
+      tokens.pop();
+    }
+
+    if (last[4]) {
+      node.source.end = {
+        line: last[4],
+        column: last[5]
+      };
+    } else {
+      node.source.end = {
+        line: last[2],
+        column: last[3]
+      };
+    }
+
+    while (tokens[0][0] !== 'word') {
+      if (tokens.length === 1) this.unknownWord(tokens);
+      node.raws.before += tokens.shift()[1];
+    }
+
+    node.source.start = {
+      line: tokens[0][2],
+      column: tokens[0][3]
+    };
+    node.prop = '';
+
+    while (tokens.length) {
+      var type = tokens[0][0];
+
+      if (type === ':' || type === 'space' || type === 'comment') {
+        break;
+      }
+
+      node.prop += tokens.shift()[1];
+    }
+
+    node.raws.between = '';
+    var token;
+
+    while (tokens.length) {
+      token = tokens.shift();
+
+      if (token[0] === ':') {
+        node.raws.between += token[1];
+        break;
+      } else {
+        if (token[0] === 'word' && /\w/.test(token[1])) {
+          this.unknownWord([token]);
+        }
+
+        node.raws.between += token[1];
+      }
+    }
+
+    if (node.prop[0] === '_' || node.prop[0] === '*') {
+      node.raws.before += node.prop[0];
+      node.prop = node.prop.slice(1);
+    }
+
+    node.raws.between += this.spacesAndCommentsFromStart(tokens);
+    this.precheckMissedSemicolon(tokens);
+
+    for (var i = tokens.length - 1; i > 0; i--) {
+      token = tokens[i];
+
+      if (token[1].toLowerCase() === '!important') {
+        node.important = true;
+        var string = this.stringFrom(tokens, i);
+        string = this.spacesFromEnd(tokens) + string;
+        if (string !== ' !important') node.raws.important = string;
+        break;
+      } else if (token[1].toLowerCase() === 'important') {
+        var cache = tokens.slice(0);
+        var str = '';
+
+        for (var j = i; j > 0; j--) {
+          var _type = cache[j][0];
+
+          if (str.trim().indexOf('!') === 0 && _type !== 'space') {
+            break;
+          }
+
+          str = cache.pop()[1] + str;
+        }
+
+        if (str.trim().indexOf('!') === 0) {
+          node.important = true;
+          node.raws.important = str;
+          tokens = cache;
+        }
+      }
+
+      if (token[0] !== 'space' && token[0] !== 'comment') {
+        break;
+      }
+    }
+
+    this.raw(node, 'value', tokens);
+    if (node.value.indexOf(':') !== -1) this.checkMissedSemicolon(tokens);
+  };
+
+  _proto.atrule = function atrule(token) {
+    var node = new _atRule.default();
+    node.name = token[1].slice(1);
+
+    if (node.name === '') {
+      this.unnamedAtrule(node, token);
+    }
+
+    this.init(node, token[2], token[3]);
+    var prev;
+    var shift;
+    var last = false;
+    var open = false;
+    var params = [];
+
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken();
+
+      if (token[0] === ';') {
+        node.source.end = {
+          line: token[2],
+          column: token[3]
+        };
+        this.semicolon = true;
+        break;
+      } else if (token[0] === '{') {
+        open = true;
+        break;
+      } else if (token[0] === '}') {
+        if (params.length > 0) {
+          shift = params.length - 1;
+          prev = params[shift];
+
+          while (prev && prev[0] === 'space') {
+            prev = params[--shift];
+          }
+
+          if (prev) {
+            node.source.end = {
+              line: prev[4],
+              column: prev[5]
+            };
+          }
+        }
+
+        this.end(token);
+        break;
+      } else {
+        params.push(token);
+      }
+
+      if (this.tokenizer.endOfFile()) {
+        last = true;
+        break;
+      }
+    }
+
+    node.raws.between = this.spacesAndCommentsFromEnd(params);
+
+    if (params.length) {
+      node.raws.afterName = this.spacesAndCommentsFromStart(params);
+      this.raw(node, 'params', params);
+
+      if (last) {
+        token = params[params.length - 1];
+        node.source.end = {
+          line: token[4],
+          column: token[5]
+        };
+        this.spaces = node.raws.between;
+        node.raws.between = '';
+      }
+    } else {
+      node.raws.afterName = '';
+      node.params = '';
+    }
+
+    if (open) {
+      node.nodes = [];
+      this.current = node;
+    }
+  };
+
+  _proto.end = function end(token) {
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon;
+    }
+
+    this.semicolon = false;
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
+    this.spaces = '';
+
+    if (this.current.parent) {
+      this.current.source.end = {
+        line: token[2],
+        column: token[3]
+      };
+      this.current = this.current.parent;
+    } else {
+      this.unexpectedClose(token);
+    }
+  };
+
+  _proto.endFile = function endFile() {
+    if (this.current.parent) this.unclosedBlock();
+
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon;
+    }
+
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
+  };
+
+  _proto.freeSemicolon = function freeSemicolon(token) {
+    this.spaces += token[1];
+
+    if (this.current.nodes) {
+      var prev = this.current.nodes[this.current.nodes.length - 1];
+
+      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
+        prev.raws.ownSemicolon = this.spaces;
+        this.spaces = '';
+      }
+    }
+  } // Helpers
+  ;
+
+  _proto.init = function init(node, line, column) {
+    this.current.push(node);
+    node.source = {
+      start: {
+        line: line,
+        column: column
+      },
+      input: this.input
+    };
+    node.raws.before = this.spaces;
+    this.spaces = '';
+    if (node.type !== 'comment') this.semicolon = false;
+  };
+
+  _proto.raw = function raw(node, prop, tokens) {
+    var token, type;
+    var length = tokens.length;
+    var value = '';
+    var clean = true;
+    var next, prev;
+    var pattern = /^([.|#])?([\w])+/i;
+
+    for (var i = 0; i < length; i += 1) {
+      token = tokens[i];
+      type = token[0];
+
+      if (type === 'comment' && node.type === 'rule') {
+        prev = tokens[i - 1];
+        next = tokens[i + 1];
+
+        if (prev[0] !== 'space' && next[0] !== 'space' && pattern.test(prev[1]) && pattern.test(next[1])) {
+          value += token[1];
+        } else {
+          clean = false;
+        }
+
+        continue;
+      }
+
+      if (type === 'comment' || type === 'space' && i === length - 1) {
+        clean = false;
+      } else {
+        value += token[1];
+      }
+    }
+
+    if (!clean) {
+      var raw = tokens.reduce(function (all, i) {
+        return all + i[1];
+      }, '');
+      node.raws[prop] = {
+        value: value,
+        raw: raw
+      };
+    }
+
+    node[prop] = value;
+  };
+
+  _proto.spacesAndCommentsFromEnd = function spacesAndCommentsFromEnd(tokens) {
+    var lastTokenType;
+    var spaces = '';
+
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0];
+      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break;
+      spaces = tokens.pop()[1] + spaces;
+    }
+
+    return spaces;
+  };
+
+  _proto.spacesAndCommentsFromStart = function spacesAndCommentsFromStart(tokens) {
+    var next;
+    var spaces = '';
+
+    while (tokens.length) {
+      next = tokens[0][0];
+      if (next !== 'space' && next !== 'comment') break;
+      spaces += tokens.shift()[1];
+    }
+
+    return spaces;
+  };
+
+  _proto.spacesFromEnd = function spacesFromEnd(tokens) {
+    var lastTokenType;
+    var spaces = '';
+
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0];
+      if (lastTokenType !== 'space') break;
+      spaces = tokens.pop()[1] + spaces;
+    }
+
+    return spaces;
+  };
+
+  _proto.stringFrom = function stringFrom(tokens, from) {
+    var result = '';
+
+    for (var i = from; i < tokens.length; i++) {
+      result += tokens[i][1];
+    }
+
+    tokens.splice(from, tokens.length - from);
+    return result;
+  };
+
+  _proto.colon = function colon(tokens) {
+    var brackets = 0;
+    var token, type, prev;
+
+    for (var i = 0; i < tokens.length; i++) {
+      token = tokens[i];
+      type = token[0];
+
+      if (type === '(') {
+        brackets += 1;
+      }
+
+      if (type === ')') {
+        brackets -= 1;
+      }
+
+      if (brackets === 0 && type === ':') {
+        if (!prev) {
+          this.doubleColon(token);
+        } else if (prev[0] === 'word' && prev[1] === 'progid') {
+          continue;
+        } else {
+          return i;
+        }
+      }
+
+      prev = token;
+    }
+
+    return false;
+  } // Errors
+  ;
+
+  _proto.unclosedBracket = function unclosedBracket(bracket) {
+    throw this.input.error('Unclosed bracket', bracket[2], bracket[3]);
+  };
+
+  _proto.unknownWord = function unknownWord(tokens) {
+    throw this.input.error('Unknown word', tokens[0][2], tokens[0][3]);
+  };
+
+  _proto.unexpectedClose = function unexpectedClose(token) {
+    throw this.input.error('Unexpected }', token[2], token[3]);
+  };
+
+  _proto.unclosedBlock = function unclosedBlock() {
+    var pos = this.current.source.start;
+    throw this.input.error('Unclosed block', pos.line, pos.column);
+  };
+
+  _proto.doubleColon = function doubleColon(token) {
+    throw this.input.error('Double colon', token[2], token[3]);
+  };
+
+  _proto.unnamedAtrule = function unnamedAtrule(node, token) {
+    throw this.input.error('At-rule without name', token[2], token[3]);
+  };
+
+  _proto.precheckMissedSemicolon = function precheckMissedSemicolon()
+  /* tokens */
+  {// Hook for Safe Parser
+  };
+
+  _proto.checkMissedSemicolon = function checkMissedSemicolon(tokens) {
+    var colon = this.colon(tokens);
+    if (colon === false) return;
+    var founded = 0;
+    var token;
+
+    for (var j = colon - 1; j >= 0; j--) {
+      token = tokens[j];
+
+      if (token[0] !== 'space') {
+        founded += 1;
+        if (founded === 2) break;
+      }
+    }
+
+    throw this.input.error('Missed semicolon', token[2], token[3]);
+  };
+
+  return Parser;
+}();
+
+exports.default = Parser;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["parser.es6"],"names":["Parser","input","root","Root","current","spaces","semicolon","createTokenizer","source","start","line","column","tokenizer","parse","token","endOfFile","nextToken","freeSemicolon","end","comment","atrule","emptyRule","other","endFile","node","Comment","init","text","slice","test","raws","left","right","match","Rule","selector","between","type","colon","bracket","brackets","tokens","push","length","decl","rule","back","pop","unclosedBracket","unknownWord","spacesAndCommentsFromEnd","raw","Declaration","last","before","shift","prop","spacesAndCommentsFromStart","precheckMissedSemicolon","i","toLowerCase","important","string","stringFrom","spacesFromEnd","cache","str","j","trim","indexOf","value","checkMissedSemicolon","AtRule","name","unnamedAtrule","prev","open","params","afterName","nodes","after","parent","unexpectedClose","unclosedBlock","ownSemicolon","clean","next","pattern","reduce","all","lastTokenType","from","result","splice","doubleColon","error","pos","founded"],"mappings":"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","sourcesContent":["import Declaration from './declaration'\nimport tokenizer from './tokenize'\nimport Comment from './comment'\nimport AtRule from './at-rule'\nimport Root from './root'\nimport Rule from './rule'\n\nexport default class Parser {\n  constructor (input) {\n    this.input = input\n\n    this.root = new Root()\n    this.current = this.root\n    this.spaces = ''\n    this.semicolon = false\n\n    this.createTokenizer()\n    this.root.source = { input, start: { line: 1, column: 1 } }\n  }\n\n  createTokenizer () {\n    this.tokenizer = tokenizer(this.input)\n  }\n\n  parse () {\n    let token\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n\n      switch (token[0]) {\n        case 'space':\n          this.spaces += token[1]\n          break\n\n        case ';':\n          this.freeSemicolon(token)\n          break\n\n        case '}':\n          this.end(token)\n          break\n\n        case 'comment':\n          this.comment(token)\n          break\n\n        case 'at-word':\n          this.atrule(token)\n          break\n\n        case '{':\n          this.emptyRule(token)\n          break\n\n        default:\n          this.other(token)\n          break\n      }\n    }\n    this.endFile()\n  }\n\n  comment (token) {\n    let node = new Comment()\n    this.init(node, token[2], token[3])\n    node.source.end = { line: token[4], column: token[5] }\n\n    let text = token[1].slice(2, -2)\n    if (/^\\s*$/.test(text)) {\n      node.text = ''\n      node.raws.left = text\n      node.raws.right = ''\n    } else {\n      let match = text.match(/^(\\s*)([^]*[^\\s])(\\s*)$/)\n      node.text = match[2]\n      node.raws.left = match[1]\n      node.raws.right = match[3]\n    }\n  }\n\n  emptyRule (token) {\n    let node = new Rule()\n    this.init(node, token[2], token[3])\n    node.selector = ''\n    node.raws.between = ''\n    this.current = node\n  }\n\n  other (start) {\n    let end = false\n    let type = null\n    let colon = false\n    let bracket = null\n    let brackets = []\n\n    let tokens = []\n    let token = start\n    while (token) {\n      type = token[0]\n      tokens.push(token)\n\n      if (type === '(' || type === '[') {\n        if (!bracket) bracket = token\n        brackets.push(type === '(' ? ')' : ']')\n      } else if (brackets.length === 0) {\n        if (type === ';') {\n          if (colon) {\n            this.decl(tokens)\n            return\n          } else {\n            break\n          }\n        } else if (type === '{') {\n          this.rule(tokens)\n          return\n        } else if (type === '}') {\n          this.tokenizer.back(tokens.pop())\n          end = true\n          break\n        } else if (type === ':') {\n          colon = true\n        }\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop()\n        if (brackets.length === 0) bracket = null\n      }\n\n      token = this.tokenizer.nextToken()\n    }\n\n    if (this.tokenizer.endOfFile()) end = true\n    if (brackets.length > 0) this.unclosedBracket(bracket)\n\n    if (end && colon) {\n      while (tokens.length) {\n        token = tokens[tokens.length - 1][0]\n        if (token !== 'space' && token !== 'comment') break\n        this.tokenizer.back(tokens.pop())\n      }\n      this.decl(tokens)\n    } else {\n      this.unknownWord(tokens)\n    }\n  }\n\n  rule (tokens) {\n    tokens.pop()\n\n    let node = new Rule()\n    this.init(node, tokens[0][2], tokens[0][3])\n\n    node.raws.between = this.spacesAndCommentsFromEnd(tokens)\n    this.raw(node, 'selector', tokens)\n    this.current = node\n  }\n\n  decl (tokens) {\n    let node = new Declaration()\n    this.init(node)\n\n    let last = tokens[tokens.length - 1]\n    if (last[0] === ';') {\n      this.semicolon = true\n      tokens.pop()\n    }\n    if (last[4]) {\n      node.source.end = { line: last[4], column: last[5] }\n    } else {\n      node.source.end = { line: last[2], column: last[3] }\n    }\n\n    while (tokens[0][0] !== 'word') {\n      if (tokens.length === 1) this.unknownWord(tokens)\n      node.raws.before += tokens.shift()[1]\n    }\n    node.source.start = { line: tokens[0][2], column: tokens[0][3] }\n\n    node.prop = ''\n    while (tokens.length) {\n      let type = tokens[0][0]\n      if (type === ':' || type === 'space' || type === 'comment') {\n        break\n      }\n      node.prop += tokens.shift()[1]\n    }\n\n    node.raws.between = ''\n\n    let token\n    while (tokens.length) {\n      token = tokens.shift()\n\n      if (token[0] === ':') {\n        node.raws.between += token[1]\n        break\n      } else {\n        if (token[0] === 'word' && /\\w/.test(token[1])) {\n          this.unknownWord([token])\n        }\n        node.raws.between += token[1]\n      }\n    }\n\n    if (node.prop[0] === '_' || node.prop[0] === '*') {\n      node.raws.before += node.prop[0]\n      node.prop = node.prop.slice(1)\n    }\n    node.raws.between += this.spacesAndCommentsFromStart(tokens)\n    this.precheckMissedSemicolon(tokens)\n\n    for (let i = tokens.length - 1; i > 0; i--) {\n      token = tokens[i]\n      if (token[1].toLowerCase() === '!important') {\n        node.important = true\n        let string = this.stringFrom(tokens, i)\n        string = this.spacesFromEnd(tokens) + string\n        if (string !== ' !important') node.raws.important = string\n        break\n      } else if (token[1].toLowerCase() === 'important') {\n        let cache = tokens.slice(0)\n        let str = ''\n        for (let j = i; j > 0; j--) {\n          let type = cache[j][0]\n          if (str.trim().indexOf('!') === 0 && type !== 'space') {\n            break\n          }\n          str = cache.pop()[1] + str\n        }\n        if (str.trim().indexOf('!') === 0) {\n          node.important = true\n          node.raws.important = str\n          tokens = cache\n        }\n      }\n\n      if (token[0] !== 'space' && token[0] !== 'comment') {\n        break\n      }\n    }\n\n    this.raw(node, 'value', tokens)\n\n    if (node.value.indexOf(':') !== -1) this.checkMissedSemicolon(tokens)\n  }\n\n  atrule (token) {\n    let node = new AtRule()\n    node.name = token[1].slice(1)\n    if (node.name === '') {\n      this.unnamedAtrule(node, token)\n    }\n    this.init(node, token[2], token[3])\n\n    let prev\n    let shift\n    let last = false\n    let open = false\n    let params = []\n\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n\n      if (token[0] === ';') {\n        node.source.end = { line: token[2], column: token[3] }\n        this.semicolon = true\n        break\n      } else if (token[0] === '{') {\n        open = true\n        break\n      } else if (token[0] === '}') {\n        if (params.length > 0) {\n          shift = params.length - 1\n          prev = params[shift]\n          while (prev && prev[0] === 'space') {\n            prev = params[--shift]\n          }\n          if (prev) {\n            node.source.end = { line: prev[4], column: prev[5] }\n          }\n        }\n        this.end(token)\n        break\n      } else {\n        params.push(token)\n      }\n\n      if (this.tokenizer.endOfFile()) {\n        last = true\n        break\n      }\n    }\n\n    node.raws.between = this.spacesAndCommentsFromEnd(params)\n    if (params.length) {\n      node.raws.afterName = this.spacesAndCommentsFromStart(params)\n      this.raw(node, 'params', params)\n      if (last) {\n        token = params[params.length - 1]\n        node.source.end = { line: token[4], column: token[5] }\n        this.spaces = node.raws.between\n        node.raws.between = ''\n      }\n    } else {\n      node.raws.afterName = ''\n      node.params = ''\n    }\n\n    if (open) {\n      node.nodes = []\n      this.current = node\n    }\n  }\n\n  end (token) {\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.semicolon = false\n\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n    this.spaces = ''\n\n    if (this.current.parent) {\n      this.current.source.end = { line: token[2], column: token[3] }\n      this.current = this.current.parent\n    } else {\n      this.unexpectedClose(token)\n    }\n  }\n\n  endFile () {\n    if (this.current.parent) this.unclosedBlock()\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n  }\n\n  freeSemicolon (token) {\n    this.spaces += token[1]\n    if (this.current.nodes) {\n      let prev = this.current.nodes[this.current.nodes.length - 1]\n      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {\n        prev.raws.ownSemicolon = this.spaces\n        this.spaces = ''\n      }\n    }\n  }\n\n  // Helpers\n\n  init (node, line, column) {\n    this.current.push(node)\n\n    node.source = { start: { line, column }, input: this.input }\n    node.raws.before = this.spaces\n    this.spaces = ''\n    if (node.type !== 'comment') this.semicolon = false\n  }\n\n  raw (node, prop, tokens) {\n    let token, type\n    let length = tokens.length\n    let value = ''\n    let clean = true\n    let next, prev\n    let pattern = /^([.|#])?([\\w])+/i\n\n    for (let i = 0; i < length; i += 1) {\n      token = tokens[i]\n      type = token[0]\n\n      if (type === 'comment' && node.type === 'rule') {\n        prev = tokens[i - 1]\n        next = tokens[i + 1]\n\n        if (\n          prev[0] !== 'space' &&\n          next[0] !== 'space' &&\n          pattern.test(prev[1]) &&\n          pattern.test(next[1])\n        ) {\n          value += token[1]\n        } else {\n          clean = false\n        }\n\n        continue\n      }\n\n      if (type === 'comment' || (type === 'space' && i === length - 1)) {\n        clean = false\n      } else {\n        value += token[1]\n      }\n    }\n    if (!clean) {\n      let raw = tokens.reduce((all, i) => all + i[1], '')\n      node.raws[prop] = { value, raw }\n    }\n    node[prop] = value\n  }\n\n  spacesAndCommentsFromEnd (tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  spacesAndCommentsFromStart (tokens) {\n    let next\n    let spaces = ''\n    while (tokens.length) {\n      next = tokens[0][0]\n      if (next !== 'space' && next !== 'comment') break\n      spaces += tokens.shift()[1]\n    }\n    return spaces\n  }\n\n  spacesFromEnd (tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  stringFrom (tokens, from) {\n    let result = ''\n    for (let i = from; i < tokens.length; i++) {\n      result += tokens[i][1]\n    }\n    tokens.splice(from, tokens.length - from)\n    return result\n  }\n\n  colon (tokens) {\n    let brackets = 0\n    let token, type, prev\n    for (let i = 0; i < tokens.length; i++) {\n      token = tokens[i]\n      type = token[0]\n\n      if (type === '(') {\n        brackets += 1\n      }\n      if (type === ')') {\n        brackets -= 1\n      }\n      if (brackets === 0 && type === ':') {\n        if (!prev) {\n          this.doubleColon(token)\n        } else if (prev[0] === 'word' && prev[1] === 'progid') {\n          continue\n        } else {\n          return i\n        }\n      }\n\n      prev = token\n    }\n    return false\n  }\n\n  // Errors\n\n  unclosedBracket (bracket) {\n    throw this.input.error('Unclosed bracket', bracket[2], bracket[3])\n  }\n\n  unknownWord (tokens) {\n    throw this.input.error('Unknown word', tokens[0][2], tokens[0][3])\n  }\n\n  unexpectedClose (token) {\n    throw this.input.error('Unexpected }', token[2], token[3])\n  }\n\n  unclosedBlock () {\n    let pos = this.current.source.start\n    throw this.input.error('Unclosed block', pos.line, pos.column)\n  }\n\n  doubleColon (token) {\n    throw this.input.error('Double colon', token[2], token[3])\n  }\n\n  unnamedAtrule (node, token) {\n    throw this.input.error('At-rule without name', token[2], token[3])\n  }\n\n  precheckMissedSemicolon (/* tokens */) {\n    // Hook for Safe Parser\n  }\n\n  checkMissedSemicolon (tokens) {\n    let colon = this.colon(tokens)\n    if (colon === false) return\n\n    let founded = 0\n    let token\n    for (let j = colon - 1; j >= 0; j--) {\n      token = tokens[j]\n      if (token[0] !== 'space') {\n        founded += 1\n        if (founded === 2) break\n      }\n    }\n    throw this.input.error('Missed semicolon', token[2], token[3])\n  }\n}\n"],"file":"parser.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/postcss.d.ts b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/postcss.d.ts
new file mode 100644
index 00000000..7513b4da
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/postcss.d.ts
@@ -0,0 +1,1283 @@
+import * as mozilla from 'source-map';
+
+/**
+ * @param plugins Can also be included with the Processor#use method.
+ * @returns A processor that will apply plugins as CSS processors.
+ */
+declare function postcss(plugins?: postcss.AcceptedPlugin[]): postcss.Processor;
+declare function postcss(...plugins: postcss.AcceptedPlugin[]): postcss.Processor;
+declare namespace postcss {
+  type AcceptedPlugin = Plugin<any> | Transformer | {
+    postcss: TransformCallback | Processor;
+  } | Processor;
+  /**
+   * Creates a PostCSS plugin with a standard API.
+   * @param name Plugin name. Same as in name property in package.json. It will
+   * be saved in plugin.postcssPlugin property.
+   * @param initializer Will receive plugin options and should return functions
+   * to modify nodes in input CSS.
+   */
+  function plugin<T>(name: string, initializer: PluginInitializer<T>): Plugin<T>;
+  interface Plugin<T> extends Transformer {
+    (opts?: T): Transformer;
+    postcss: Transformer;
+    process: (css: string | {
+      toString(): string;
+    } | Result, processOpts?: ProcessOptions, pluginOpts?: T) => LazyResult;
+  }
+  interface Transformer extends TransformCallback {
+    postcssPlugin?: string;
+    postcssVersion?: string;
+  }
+  interface TransformCallback {
+    /**
+     * @returns A Promise that resolves when all work is complete. May return
+     * synchronously, but that style of plugin is only meant for debugging and
+     * development. In either case, the resolved or returned value is not used -
+     * the "result" is the output.
+     */
+    (root: Root, result: Result): Promise<any> | any;
+  }
+  interface PluginInitializer<T> {
+    (pluginOptions?: T): Transformer;
+  }
+  /**
+   * Contains helpers for working with vendor prefixes.
+   */
+  export namespace vendor {
+    /**
+     * @returns The vendor prefix extracted from the input string.
+     */
+    function prefix(prop: string): string;
+    /**
+     * @returns The input string stripped of its vendor prefix.
+     */
+    function unprefixed(prop: string): string;
+  }
+  type ParserInput = string | { toString(): string };
+  interface Parser {
+    (css: ParserInput, opts?: Pick<ProcessOptions, 'map' | 'from'>): Root;
+  }
+  interface Builder {
+    (part: string, node?: Node, type?: 'start' | 'end'): void;
+  }
+  interface Stringifier {
+    (node: Node, builder: Builder): void;
+  }
+  /**
+   * Default function to convert a node tree into a CSS string.
+   */
+  const stringify: Stringifier;
+  /**
+   * Parses source CSS.
+   * @param css The CSS to parse.
+   * @param options
+   * @returns {} A new Root node, which contains the source CSS nodes.
+   */
+  const parse: Parser;
+  /**
+   * Contains helpers for safely splitting lists of CSS values, preserving
+   * parentheses and quotes.
+   */
+  export namespace list {
+    /**
+     * Safely splits space-separated values (such as those for background,
+     * border-radius and other shorthand properties).
+     */
+    function space(str: string): string[];
+    /**
+     * Safely splits comma-separated values (such as those for transition-* and
+     * background  properties).
+     */
+    function comma(str: string): string[];
+  }
+  /**
+   * Creates a new Comment node.
+   * @param defaults Properties for the new Comment node.
+   * @returns The new node.
+   */
+  function comment(defaults?: CommentNewProps): Comment;
+  /**
+   * Creates a new AtRule node.
+   * @param defaults Properties for the new AtRule node.
+   * @returns The new node.
+   */
+  function atRule(defaults?: AtRuleNewProps): AtRule;
+  /**
+   * Creates a new Declaration node.
+   * @param defaults Properties for the new Declaration node.
+   * @returns The new node.
+   */
+  function decl(defaults?: DeclarationNewProps): Declaration;
+  /**
+   * Creates a new Rule node.
+   * @param defaults Properties for the new Rule node.
+   * @returns The new node.
+   */
+  function rule(defaults?: RuleNewProps): Rule;
+  /**
+   * Creates a new Root node.
+   * @param defaults Properties for the new Root node.
+   * @returns The new node.
+   */
+  function root(defaults?: object): Root;
+  interface SourceMapOptions {
+    /**
+     * Indicates that the source map should be embedded in the output CSS as a
+     * Base64-encoded comment. By default, it is true. But if all previous maps
+     * are external, not inline, PostCSS will not embed the map even if you do
+     * not set this option.
+     *
+     * If you have an inline source map, the result.map property will be empty,
+     * as the source map will be contained within the text of result.css.
+     */
+    inline?: boolean;
+    /**
+     * Source map content from a previous processing step (e.g., Sass compilation).
+     * PostCSS will try to read the previous source map automatically (based on comments
+     * within the source CSS), but you can use this option to identify it manually.
+     * If desired, you can omit the previous map with prev: false.
+     */
+    prev?: any;
+    /**
+     * Indicates that PostCSS should set the origin content (e.g., Sass source)
+     * of the source map. By default, it is true. But if all previous maps do not
+     * contain sources content, PostCSS will also leave it out even if you do not set
+     * this option.
+     */
+    sourcesContent?: boolean;
+    /**
+     * Indicates that PostCSS should add annotation comments to the CSS. By default,
+     * PostCSS will always add a comment with a path to the source map. PostCSS will
+     * not add annotations to CSS files that do not contain any comments.
+     *
+     * By default, PostCSS presumes that you want to save the source map as
+     * opts.to + '.map' and will use this path in the annotation comment. A different
+     * path can be set by providing a string value for annotation.
+     *
+     * If you have set inline: true, annotation cannot be disabled.
+     */
+    annotation?: string | boolean;
+    /**
+     * Override "from" in map's sources.
+     */
+    from?: string;
+  }
+  /**
+   * A Processor instance contains plugins to process CSS. Create one
+   * Processor  instance, initialize its plugins, and then use that instance
+   * on numerous CSS files.
+   */
+  interface Processor {
+    /**
+     * Adds a plugin to be used as a CSS processor. Plugins can also be
+     * added by passing them as arguments when creating a postcss instance.
+     */
+    use(plugin: AcceptedPlugin): Processor;
+    /**
+     * Parses source CSS. Because some plugins can be asynchronous it doesn't
+     * make any transformations. Transformations will be applied in LazyResult's
+     * methods.
+     * @param css Input CSS or any object with toString() method, like a file
+     * stream. If a Result instance is passed the processor will take the
+     * existing Root parser from it.
+     */
+    process(css: ParserInput | Result | LazyResult | Root, options?: ProcessOptions): LazyResult;
+    /**
+     * Contains plugins added to this processor.
+     */
+    plugins: Plugin<any>[];
+    /**
+     * Contains the current version of PostCSS (e.g., "4.0.5").
+     */
+    version: string;
+  }
+  interface ProcessOptions {
+    /**
+     * The path of the CSS source file. You should always set "from", because it is
+     * used in source map generation and syntax error messages.
+     */
+    from?: string;
+    /**
+     * The path where you'll put the output CSS file. You should always set "to"
+     * to generate correct source maps.
+     */
+    to?: string;
+    /**
+     * Function to generate AST by string.
+     */
+    parser?: Parser;
+    /**
+     * Class to generate string by AST.
+     */
+    stringifier?: Stringifier;
+    /**
+     * Object with parse and stringify.
+     */
+    syntax?: Syntax;
+    /**
+     * Source map options
+     */
+    map?: SourceMapOptions | boolean;
+  }
+  interface Syntax {
+    /**
+     * Function to generate AST by string.
+     */
+    parse?: Parser;
+    /**
+     * Class to generate string by AST.
+     */
+    stringify?: Stringifier;
+  }
+  /**
+   * A promise proxy for the result of PostCSS transformations.
+   */
+  interface LazyResult {
+    /**
+     * Processes input CSS through synchronous and asynchronous plugins.
+     * @param onRejected Called if any plugin throws an error.
+     */
+    then: Promise<Result>["then"];
+    /**
+     * Processes input CSS through synchronous and asynchronous plugins.
+     * @param onRejected Called if any plugin throws an error.
+     */
+    catch: Promise<Result>["catch"];
+    /**
+     * Alias for css property.
+     */
+    toString(): string;
+    /**
+     * Processes input CSS through synchronous plugins and converts Root to
+     * CSS string. This property will only work with synchronous plugins. If
+     * the processor contains any asynchronous plugins it will throw an error.
+     * In this case, you should use LazyResult#then() instead.
+     * @returns Result#css.
+     */
+    css: string;
+    /**
+     * Alias for css property to use when syntaxes generate non-CSS output.
+     */
+    content: string;
+    /**
+     * Processes input CSS through synchronous plugins. This property will
+     * work only with synchronous plugins. If processor contains any
+     * asynchronous plugins it will throw an error. You should use
+     * LazyResult#then() instead.
+     */
+    map: ResultMap;
+    /**
+     * Processes input CSS through synchronous plugins. This property will work
+     * only with synchronous plugins. If processor contains any asynchronous
+     * plugins it will throw an error. You should use LazyResult#then() instead.
+     */
+    root: Root;
+    /**
+     * Processes input CSS through synchronous plugins and calls Result#warnings().
+     * This property will only work with synchronous plugins. If the processor
+     * contains any asynchronous plugins it will throw an error. In this case,
+     * you should use LazyResult#then() instead.
+     */
+    warnings(): Warning[];
+    /**
+     * Processes input CSS through synchronous plugins. This property will work
+     * only with synchronous plugins. If processor contains any asynchronous
+     * plugins it will throw an error. You should use LazyResult#then() instead.
+     */
+    messages: ResultMessage[];
+    /**
+     * @returns A processor used for CSS transformations.
+     */
+    processor: Processor;
+    /**
+     * @returns Options from the Processor#process(css, opts) call that produced
+     * this Result instance.
+     */
+    opts: ResultOptions;
+  }
+  /**
+   * Provides the result of the PostCSS transformations.
+   */
+  interface Result {
+    /**
+     * Alias for css property.
+     */
+    toString(): string;
+    /**
+     * Creates an instance of Warning and adds it to messages.
+     * @param message Used in the text property of the message object.
+     * @param options Properties for Message object.
+     */
+    warn(message: string, options?: WarningOptions): void;
+    /**
+     * @returns Warnings from plugins, filtered from messages.
+     */
+    warnings(): Warning[];
+    /**
+     * A CSS string representing this Result's Root instance.
+     */
+    css: string;
+    /**
+     * Alias for css property to use with syntaxes that generate non-CSS output.
+     */
+    content: string;
+    /**
+     * An instance of the SourceMapGenerator class from the source-map library,
+     * representing changes to the Result's Root instance.
+     * This property will have a value only if the user does not want an inline
+     * source map. By default, PostCSS generates inline source maps, written
+     * directly into the processed CSS. The map property will be empty by default.
+     * An external source map will be generated — and assigned to map — only if
+     * the user has set the map.inline option to false, or if PostCSS was passed
+     * an external input source map.
+     */
+    map: ResultMap;
+    /**
+     * Contains the Root node after all transformations.
+     */
+    root?: Root;
+    /**
+     * Contains messages from plugins (e.g., warnings or custom messages).
+     * Add a warning using Result#warn() and get all warnings
+     * using the Result#warnings() method.
+     */
+    messages: ResultMessage[];
+    /**
+     * The Processor instance used for this transformation.
+     */
+    processor?: Processor;
+    /**
+     * Options from the Processor#process(css, opts) or Root#toResult(opts) call
+     * that produced this Result instance.
+     */
+    opts?: ResultOptions;
+  }
+  interface ResultOptions extends ProcessOptions {
+    /**
+     * The CSS node that was the source of the warning.
+     */
+    node?: postcss.Node;
+    /**
+     * Name of plugin that created this warning. Result#warn() will fill it
+     * automatically with plugin.postcssPlugin value.
+     */
+    plugin?: string;
+  }
+  interface ResultMap {
+    /**
+     * 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:
+     * @param mapping
+     * @returns {}
+     */
+    addMapping(mapping: mozilla.Mapping): void;
+    /**
+     * Set the source content for an original source file.
+     * @param sourceFile The URL of the original source file.
+     * @param sourceContent The content of the source file.
+     */
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    /**
+     * Applies a SourceMap for a source file to the SourceMap. Each mapping to
+     * the supplied source file is rewritten using the supplied SourceMap.
+     * Note: The resolution for the resulting mappings is the minimum of this
+     * map and the supplied map.
+     * @param sourceMapConsumer The SourceMap to be applied.
+     * @param sourceFile The filename of the source file. If omitted, sourceMapConsumer
+     * file will be used, if it exists. Otherwise an error will be thrown.
+     * @param sourceMapPath The dirname of the path to the SourceMap to be applied.
+     * If relative, it is relative to the SourceMap. This parameter is needed when
+     * the two SourceMaps aren't in the same directory, and the SourceMap to be
+     * applied contains relative source paths. If so, those relative source paths
+     * need to be rewritten relative to the SourceMap.
+     * If omitted, it is assumed that both SourceMaps are in the same directory;
+     * thus, not needing any rewriting (Supplying '.' has the same effect).
+     */
+    applySourceMap(
+        sourceMapConsumer: mozilla.SourceMapConsumer,
+        sourceFile?: string,
+        sourceMapPath?: string
+    ): void;
+    /**
+     * Renders the source map being generated to JSON.
+     */
+    toJSON: () => mozilla.RawSourceMap;
+    /**
+     * Renders the source map being generated to a string.
+     */
+    toString: () => string;
+  }
+  interface ResultMessage {
+    type: string;
+    plugin: string;
+    [others: string]: any;
+  }
+  /**
+   * Represents a plugin warning. It can be created using Result#warn().
+   */
+  interface Warning {
+    /**
+     * @returns Error position, message.
+     */
+    toString(): string;
+    /**
+     * Contains the warning message.
+     */
+    text: string;
+    /**
+     * Contains the name of the plugin that created this warning. When you
+     * call Result#warn(), it will fill this property automatically.
+     */
+    plugin: string;
+    /**
+     * The CSS node that caused the warning.
+     */
+    node: Node;
+    /**
+     * The line in the input file with this warning's source.
+     */
+    line: number;
+    /**
+     * Column in the input file with this warning's source.
+     */
+    column: number;
+  }
+  interface WarningOptions extends ResultOptions {
+    /**
+     * A word inside a node's string that should be highlighted as source
+     * of warning.
+     */
+    word?: string;
+    /**
+     * The index inside a node's string that should be highlighted as
+     * source of warning.
+     */
+    index?: number;
+  }
+  /**
+   * The CSS parser throws this error for broken CSS.
+   */
+  interface CssSyntaxError extends InputOrigin {
+    name: string;
+    /**
+     * @returns Error position, message and source code of broken part.
+     */
+    toString(): string;
+    /**
+     * @param color Whether arrow should be colored red by terminal color codes.
+     * By default, PostCSS will use process.stdout.isTTY and
+     * process.env.NODE_DISABLE_COLORS.
+     * @returns A few lines of CSS source that caused the error. If CSS has
+     * input source map without sourceContent this method will return an empty
+     * string.
+     */
+    showSourceCode(color?: boolean): string;
+    /**
+     * Contains full error text in the GNU error format.
+     */
+    message: string;
+    /**
+     * Contains only the error description.
+     */
+    reason: string;
+    /**
+     * Contains the PostCSS plugin name if the error didn't come from the
+     * CSS parser.
+     */
+    plugin?: string;
+    input?: InputOrigin;
+  }
+  interface InputOrigin {
+    /**
+     * If parser's from option is set, contains the absolute path to the
+     * broken file. PostCSS will use the input source map to detect the
+     * original error location. If you wrote a Sass file, then compiled it
+     * to CSS and parsed it with PostCSS, PostCSS will show the original
+     * position in the Sass file. If you need the position in the PostCSS
+     * input (e.g., to debug the previous compiler), use error.input.file.
+     */
+    file?: string;
+    /**
+     * Contains the source line of the error. PostCSS will use the input
+     * source map to detect the original error location. If you wrote a Sass
+     * file, then compiled it to CSS and parsed it with PostCSS, PostCSS
+     * will show the original position in the Sass file. If you need the
+     * position in the PostCSS input (e.g., to debug the previous
+     * compiler), use error.input.line.
+     */
+    line?: number;
+    /**
+     * Contains the source column of the error. PostCSS will use input
+     * source map to detect the original error location. If you wrote a
+     * Sass file, then compiled it to CSS and parsed it with PostCSS,
+     * PostCSS will show the original position in the Sass file. If you
+     * need the position in the PostCSS input (e.g., to debug the
+     * previous compiler), use error.input.column.
+     */
+    column?: number;
+    /**
+     * Contains the source code of the broken file. PostCSS will use the
+     * input source map to detect the original error location. If you wrote
+     * a Sass file, then compiled it to CSS and parsed it with PostCSS,
+     * PostCSS will show the original position in the Sass file. If you need
+     * the position in the PostCSS input (e.g., to debug the previous
+     * compiler), use error.input.source.
+     */
+    source?: string;
+  }
+  export class PreviousMap {
+    private inline;
+    annotation: string;
+    root: string;
+    private consumerCache;
+    text: string;
+    file: string;
+    constructor(css: any, opts: any);
+    consumer(): mozilla.SourceMapConsumer;
+    withContent(): boolean;
+    startWith(string: string, start: string): boolean;
+    getAnnotationURL(sourceMapString: string): string;
+    loadAnnotation(css: string): void;
+    decodeInline(text: string): string;
+    loadMap(
+      file: any,
+      prev: string | Function | mozilla.SourceMapConsumer | mozilla.SourceMapGenerator | mozilla.RawSourceMap
+    ): string;
+    isMap(map: any): boolean;
+  }
+  /**
+   * Represents the source CSS.
+   */
+  interface Input {
+    /**
+     * The absolute path to the CSS source file defined with the "from" option.
+     * Either this property or the "id" property are always defined.
+     */
+    file?: string;
+    /**
+     * The unique ID of the CSS source. Used if "from" option is not provided
+     * (because PostCSS does not know the file path). Either this property
+     * or the "file" property are always defined.
+     */
+    id?: string;
+    /**
+     * The CSS source identifier. Contains input.file if the user set the
+     * "from" option, or input.id if they did not.
+     */
+    from: string;
+    /**
+     * Represents the input source map passed from a compilation step before
+     * PostCSS (e.g., from the Sass compiler).
+     */
+    map: PreviousMap;
+    /**
+     * The flag to indicate whether or not the source code has Unicode BOM.
+     */
+    hasBOM: boolean;
+    /**
+     * Reads the input source map.
+     * @returns A symbol position in the input source (e.g., in a Sass file
+     * that was compiled to CSS before being passed to PostCSS):
+     */
+    origin(line: number, column: number): InputOrigin | false;
+  }
+  type ChildNode = AtRule | Rule | Declaration | Comment;
+  type Node = Root | ChildNode;
+  interface NodeBase {
+    /**
+     * Returns the input source of the node. The property is used in source
+     * map generation. If you create a node manually
+     * (e.g., with postcss.decl() ), that node will not have a source
+     * property and will be absent from the source map. For this reason, the
+     * plugin developer should consider cloning nodes to create new ones
+     * (in which case the new node's source will reference the original,
+     * cloned node) or setting the source property manually.
+     */
+    source?: NodeSource;
+    /**
+     * Contains information to generate byte-to-byte equal node string as it
+     * was in origin input.
+     */
+    raws: NodeRaws;
+    /**
+     * @returns A CSS string representing the node.
+     */
+    toString(stringifier?: Stringifier | Syntax): string;
+    /**
+     * This method produces very useful error messages. If present, an input
+     * source map will be used to get the original position of the source, even
+     * from a previous compilation step (e.g., from Sass compilation).
+     * @returns The original position of the node in the source, showing line
+     * and column numbers and also a small excerpt to facilitate debugging.
+     */
+    error(
+      /**
+       * Error description.
+       */
+      message: string, options?: NodeErrorOptions): CssSyntaxError;
+    /**
+     * Creates an instance of Warning and adds it to messages. This method is
+     * provided as a convenience wrapper for Result#warn.
+     * Note that `opts.node` is automatically passed to Result#warn for you.
+     * @param result The result that will receive the warning.
+     * @param text Warning message. It will be used in the `text` property of
+     * the message object.
+     * @param opts Properties to assign to the message object.
+     */
+    warn(result: Result, text: string, opts?: WarningOptions): void;
+    /**
+     * @returns The next child of the node's parent; or, returns undefined if
+     * the current node is the last child.
+     */
+    next(): ChildNode | undefined;
+    /**
+     * @returns The previous child of the node's parent; or, returns undefined
+     * if the current node is the first child.
+     */
+    prev(): ChildNode | undefined;
+    /**
+     * Insert new node before current node to current node’s parent.
+     *
+     * Just an alias for `node.parent.insertBefore(node, newNode)`.
+     *
+     * @returns this node for method chaining.
+     *
+     * @example
+     * decl.before('content: ""');
+     */
+    before(newNode: Node | object | string | Node[]): this;
+    /**
+     * Insert new node after current node to current node’s parent.
+     *
+     * Just an alias for `node.parent.insertAfter(node, newNode)`.
+     *
+     * @returns this node for method chaining.
+     *
+     * @example
+     * decl.after('color: black');
+     */
+    after(newNode: Node | object | string | Node[]): this;
+    /**
+     * @returns The Root instance of the node's tree.
+     */
+    root(): Root;
+    /**
+     * Removes the node from its parent and cleans the parent property in the
+     * node and its children.
+     * @returns This node for chaining.
+     */
+    remove(): this;
+    /**
+     * Inserts node(s) before the current node and removes the current node.
+     * @returns This node for chaining.
+     */
+    replaceWith(...nodes: (Node | object)[]): this;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+    /**
+     * Shortcut to clone the node and insert the resulting cloned node before
+     * the current node.
+     * @param overrides New Properties to override in the clone.
+     * @returns The cloned node.
+     */
+    cloneBefore(overrides?: object): this;
+    /**
+     * Shortcut to clone the node and insert the resulting cloned node after
+     * the current node.
+     * @param overrides New Properties to override in the clone.
+     * @returns The cloned node.
+     */
+    cloneAfter(overrides?: object): this;
+    /**
+     * @param prop Name or code style property.
+     * @param defaultType Name of default value. It can be easily missed if the
+     * value is the same as prop.
+     * @returns A code style property value. If the node is missing the code
+     * style property (because the node was manually built or cloned), PostCSS
+     * will try to autodetect the code style property by looking at other nodes
+     * in the tree.
+     */
+    raw(prop: string, defaultType?: string): string;
+  }
+  interface NodeNewProps {
+    source?: NodeSource;
+    raws?: NodeRaws;
+  }
+  interface NodeRaws {
+    /**
+     * The space symbols before the node. It also stores `*` and `_`
+     * symbols before the declaration (IE hack).
+     */
+    before?: string;
+    /**
+     * The space symbols after the last child of the node to the end of
+     * the node.
+     */
+    after?: string;
+    /**
+     * The symbols between the property and value for declarations,
+     * selector and "{" for rules, last parameter and "{" for at-rules.
+     */
+    between?: string;
+    /**
+     * True if last child has (optional) semicolon.
+     */
+    semicolon?: boolean;
+    /**
+     * The space between the at-rule's name and parameters.
+     */
+    afterName?: string;
+    /**
+     * The space symbols between "/*" and comment's text.
+     */
+    left?: string;
+    /**
+     * The space symbols between comment's text and "*\/".
+     */
+    right?: string;
+    /**
+     * The content of important statement, if it is not just "!important".
+     */
+    important?: string;
+  }
+  interface NodeSource {
+    input: Input;
+    /**
+     * The starting position of the node's source.
+     */
+    start?: {
+      column: number;
+      line: number;
+    };
+    /**
+     * The ending position of the node's source.
+     */
+    end?: {
+      column: number;
+      line: number;
+    };
+  }
+  interface NodeErrorOptions {
+    /**
+     * Plugin name that created this error. PostCSS will set it automatically.
+     */
+    plugin?: string;
+    /**
+     * A word inside a node's string, that should be highlighted as source
+     * of error.
+     */
+    word?: string;
+    /**
+     * An index inside a node's string that should be highlighted as source
+     * of error.
+     */
+    index?: number;
+  }
+  interface JsonNode {
+    /**
+     * Returns a string representing the node's type. Possible values are
+     * root, atrule, rule, decl or comment.
+     */
+    type?: string;
+    /**
+     * Returns the node's parent node.
+     */
+    parent?: JsonContainer;
+    /**
+     * Returns the input source of the node. The property is used in source
+     * map generation. If you create a node manually (e.g., with
+     * postcss.decl() ), that node will not have a  source  property and
+     * will be absent from the source map. For this reason, the plugin
+     * developer should consider cloning nodes to create new ones (in which
+     * case the new node's source will reference the original, cloned node)
+     * or setting the source property manually.
+     */
+    source?: NodeSource;
+    /**
+     * Contains information to generate byte-to-byte equal node string as it
+     * was in origin input.
+     */
+    raws?: NodeRaws;
+  }
+  type Container = Root | AtRule | Rule;
+  /**
+   * Containers can store any content. If you write a rule inside a rule,
+   * PostCSS will parse it.
+   */
+  interface ContainerBase extends NodeBase {
+    /**
+     * Contains the container's children.
+     */
+    nodes?: ChildNode[];
+    /**
+     * @returns The container's first child.
+     */
+    first?: ChildNode;
+    /**
+     * @returns The container's last child.
+     */
+    last?: ChildNode;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+    /**
+     * @param child Child of the current container.
+     * @returns The child's index within the container's "nodes" array.
+     */
+    index(child: ChildNode | number): number;
+    /**
+     * Determines whether all child nodes satisfy the specified test.
+     * @param callback A function that accepts up to three arguments. The
+     * every method calls the callback function for each node until the
+     * callback returns false, or until the end of the array.
+     * @returns True if the callback returns true for all of the container's
+     * children.
+     */
+    every(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean;
+    /**
+     * Determines whether the specified callback returns true for any child node.
+     * @param callback A function that accepts up to three arguments. The some
+     * method calls the callback for each node until the callback returns true,
+     * or until the end of the array.
+     * @returns True if callback returns true for (at least) one of the
+     * container's children.
+     */
+    some(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean): boolean;
+    /**
+     * Iterates through the container's immediate children, calling the
+     * callback function for each child. If you need to recursively iterate
+     * through all the container's descendant nodes, use container.walk().
+     * Unlike the for {} -cycle or Array#forEach() this iterator is safe if
+     * you are mutating the array of child nodes during iteration.
+     * @param callback Iterator. Returning false will break iteration. Safe
+     * if you are mutating the array of child nodes during iteration. PostCSS
+     * will adjust the current index to match the mutations.
+     * @returns False if the callback returns false during iteration.
+     */
+    each(callback: (node: ChildNode, index: number) => void): void;
+    each(callback: (node: ChildNode, index: number) => boolean): boolean;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * node. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration. If you only need to iterate through
+     * the container's immediate children, use container.each().
+     * @param callback Iterator.
+     */
+    walk(callback: (node: ChildNode, index: number) => void): void;
+    walk(callback: (node: ChildNode, index: number) => boolean): boolean;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * declaration. Like container.each(), this method is safe to use if you
+     * are mutating arrays during iteration.
+     * @param propFilter Filters declarations by property name. Only those
+     * declarations whose property matches propFilter will be iterated over.
+     * @param callback Called for each declaration node within the container.
+     */
+    walkDecls(propFilter: string | RegExp, callback: (decl: Declaration, index: number) => void): void;
+    walkDecls(callback: (decl: Declaration, index: number) => void): void;
+    walkDecls(propFilter: string | RegExp, callback: (decl: Declaration, index: number) => boolean): boolean;
+    walkDecls(callback: (decl: Declaration, index: number) => boolean): boolean;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * at-rule. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration.
+     * @param nameFilter Filters at-rules by name. If provided, iteration
+     * will only happen over at-rules that have matching names.
+     * @param callback Iterator called for each at-rule node within the
+     * container.
+     */
+    walkAtRules(nameFilter: string | RegExp, callback: (atRule: AtRule, index: number) => void): void;
+    walkAtRules(callback: (atRule: AtRule, index: number) => void): void;
+    walkAtRules(nameFilter: string | RegExp, callback: (atRule: AtRule, index: number) => boolean): boolean;
+    walkAtRules(callback: (atRule: AtRule, index: number) => boolean): boolean;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * rule. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration.
+     * @param selectorFilter Filters rules by selector. If provided,
+     * iteration will only happen over rules that have matching names.
+     * @param callback Iterator called for each rule node within the
+     * container.
+     */
+    walkRules(selectorFilter: string | RegExp, callback: (atRule: Rule, index: number) => void): void;
+    walkRules(callback: (atRule: Rule, index: number) => void): void;
+    walkRules(selectorFilter: string | RegExp, callback: (atRule: Rule, index: number) => boolean): boolean;
+    walkRules(callback: (atRule: Rule, index: number) => boolean): boolean;
+    /**
+     * Traverses the container's descendant nodes, calling `callback` for each
+     * comment. Like container.each(), this method is safe to use if you are
+     * mutating arrays during iteration.
+     * @param callback Iterator called for each comment node within the container.
+     */
+    walkComments(callback: (comment: Comment, indexed: number) => void): void;
+    walkComments(callback: (comment: Comment, indexed: number) => boolean): boolean;
+    /**
+     * Passes all declaration values within the container that match pattern
+     * through the callback, replacing those values with the returned result of
+     * callback. This method is useful if you are using a custom unit or
+     * function and need to iterate through all values.
+     * @param pattern Pattern that we need to replace.
+     * @param options Options to speed up the search.
+     * @param callbackOrReplaceValue String to replace pattern or callback
+     * that will return a new value. The callback will receive the same
+     * arguments as those passed to a function parameter of String#replace.
+     */
+    replaceValues(pattern: string | RegExp, options: {
+        /**
+         * Property names. The method will only search for values that match
+         * regexp  within declarations of listed properties.
+         */
+        props?: string[];
+        /**
+         * Used to narrow down values and speed up the regexp search. Searching
+         * every single value with a regexp can be slow. If you pass a fast
+         * string, PostCSS will first check whether the value contains the fast
+         * string; and only if it does will PostCSS check that value against
+         * regexp. For example, instead of just checking for /\d+rem/ on all
+         * values, set fast: 'rem' to first check whether a value has the rem
+         * unit, and only if it does perform the regexp check.
+         */
+        fast?: string;
+    }, callbackOrReplaceValue: string | {
+      (substring: string, ...args: any[]): string;
+    }): this;
+    replaceValues(pattern: string | RegExp, callbackOrReplaceValue: string | {
+      (substring: string, ...args: any[]): string;
+    }): this;
+    /**
+     * Inserts new nodes to the beginning of the container.
+     * Because each node class is identifiable by unique properties, use the
+     * following shortcuts to create nodes in insert methods:
+     *     root.prepend({ name: '@charset', params: '"UTF-8"' }); // at-rule
+     *     root.prepend({ selector: 'a' });                       // rule
+     *     rule.prepend({ prop: 'color', value: 'black' });       // declaration
+     *     rule.prepend({ text: 'Comment' })                      // comment
+     * A string containing the CSS of the new element can also be used. This
+     * approach is slower than the above shortcuts.
+     *     root.prepend('a {}');
+     *     root.first.prepend('color: black; z-index: 1');
+     * @param nodes New nodes.
+     * @returns This container for chaining.
+     */
+    prepend(...nodes: (Node | object | string)[]): this;
+    /**
+     * Inserts new nodes to the end of the container.
+     * Because each node class is identifiable by unique properties, use the
+     * following shortcuts to create nodes in insert methods:
+     *     root.append({ name: '@charset', params: '"UTF-8"' }); // at-rule
+     *     root.append({ selector: 'a' });                       // rule
+     *     rule.append({ prop: 'color', value: 'black' });       // declaration
+     *     rule.append({ text: 'Comment' })                      // comment
+     * A string containing the CSS of the new element can also be used. This
+     * approach is slower than the above shortcuts.
+     *     root.append('a {}');
+     *     root.first.append('color: black; z-index: 1');
+     * @param nodes New nodes.
+     * @returns This container for chaining.
+     */
+    append(...nodes: (Node | object | string)[]): this;
+    /**
+     * Insert newNode before oldNode within the container.
+     * @param oldNode Child or child's index.
+     * @returns This container for chaining.
+     */
+    insertBefore(oldNode: ChildNode | number, newNode: ChildNode | object | string): this;
+    /**
+     * Insert newNode after oldNode within the container.
+     * @param oldNode Child or child's index.
+     * @returns This container for chaining.
+     */
+    insertAfter(oldNode: ChildNode | number, newNode: ChildNode | object | string): this;
+    /**
+     * Removes the container from its parent and cleans the parent property in the
+     * container and its children.
+     * @returns This container for chaining.
+     */
+    remove(): this;
+    /**
+     * Removes child from the container and cleans the parent properties
+     * from the node and its children.
+     * @param child Child or child's index.
+     * @returns This container for chaining.
+     */
+    removeChild(child: ChildNode | number): this;
+    /**
+     * Removes all children from the container and cleans their parent
+     * properties.
+     * @returns This container for chaining.
+     */
+    removeAll(): this;
+  }
+  interface ContainerNewProps extends NodeNewProps {
+    /**
+     * Contains the container's children.
+     */
+    nodes?: ChildNode[];
+    raws?: ContainerRaws;
+  }
+  interface ContainerRaws extends NodeRaws {
+    indent?: string;
+  }
+  interface JsonContainer extends JsonNode {
+    /**
+     * Contains the container's children.
+     */
+    nodes?: ChildNode[];
+    /**
+     * @returns The container's first child.
+     */
+    first?: ChildNode;
+    /**
+     * @returns The container's last child.
+     */
+    last?: ChildNode;
+  }
+    /**
+     * Represents a CSS file and contains all its parsed nodes.
+     */
+  interface Root extends ContainerBase {
+    type: 'root';
+    /**
+     * Inherited from Container. Should always be undefined for a Root node.
+     */
+    parent: void;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+    /**
+     * @returns A Result instance representing the root's CSS.
+     */
+    toResult(options?: {
+      /**
+       * The path where you'll put the output CSS file. You should always
+       * set "to" to generate correct source maps.
+       */
+      to?: string;
+      map?: SourceMapOptions;
+    }): Result;
+    /**
+     * Removes child from the root node, and the parent properties of node and
+     * its children.
+     * @param child Child or child's index.
+     * @returns This root node for chaining.
+     */
+    removeChild(child: ChildNode | number): this;
+  }
+  interface RootNewProps extends ContainerNewProps {
+  }
+  interface JsonRoot extends JsonContainer {
+  }
+  /**
+   * Represents an at-rule. If it's followed in the CSS by a {} block, this
+   * node will have a nodes property representing its children.
+   */
+  interface AtRule extends ContainerBase {
+    type: 'atrule';
+    /**
+     * Returns the atrule's parent node.
+     */
+    parent: Container;
+    /**
+     * The identifier that immediately follows the @.
+     */
+    name: string;
+    /**
+     * These are the values that follow the at-rule's name, but precede any {}
+     * block. The spec refers to this area as the at-rule's "prelude".
+     */
+    params: string;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface AtRuleNewProps extends ContainerNewProps {
+    /**
+     * The identifier that immediately follows the @.
+     */
+    name?: string;
+    /**
+     * These are the values that follow the at-rule's name, but precede any {}
+     * block. The spec refers to this area as the at-rule's "prelude".
+     */
+    params?: string | number;
+    raws?: AtRuleRaws;
+  }
+  interface AtRuleRaws extends NodeRaws {
+    params?: string;
+  }
+  interface JsonAtRule extends JsonContainer {
+    /**
+     * The identifier that immediately follows the @.
+     */
+    name?: string;
+    /**
+     * These are the values that follow the at-rule's name, but precede any {}
+     * block. The spec refers to this area as the at-rule's "prelude".
+     */
+    params?: string;
+  }
+  /**
+   * Represents a CSS rule: a selector followed by a declaration block.
+   */
+  interface Rule extends ContainerBase {
+    type: 'rule';
+    /**
+     * Returns the rule's parent node.
+     */
+    parent: Container;
+    /**
+     * The rule's full selector. If there are multiple comma-separated selectors,
+     * the entire group will be included.
+     */
+    selector: string;
+    /**
+     * An array containing the rule's individual selectors.
+     * Groups of selectors are split at commas.
+     */
+    selectors: string[];
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface RuleNewProps extends ContainerNewProps {
+    /**
+     * The rule's full selector. If there are multiple comma-separated selectors,
+     * the entire group will be included.
+     */
+    selector?: string;
+    /**
+     * An array containing the rule's individual selectors. Groups of selectors
+     * are split at commas.
+     */
+    selectors?: string[];
+    raws?: RuleRaws;
+  }
+  interface RuleRaws extends ContainerRaws {
+    /**
+    * The rule's full selector. If there are multiple comma-separated selectors,
+    * the entire group will be included.
+    */
+    selector?: string;
+  }
+  interface JsonRule extends JsonContainer {
+    /**
+     * The rule's full selector. If there are multiple comma-separated selectors,
+     * the entire group will be included.
+     */
+    selector?: string;
+    /**
+     * An array containing the rule's individual selectors.
+     * Groups of selectors are split at commas.
+     */
+    selectors?: string[];
+  }
+  /**
+   * Represents a CSS declaration.
+   */
+  interface Declaration extends NodeBase {
+    type: 'decl';
+    /**
+     * Returns the declaration's parent node.
+     */
+    parent: Container;
+    /**
+     * The declaration's property name.
+     */
+    prop: string;
+    /**
+     * The declaration's value. This value will be cleaned of comments. If the
+     * source value contained comments, those comments will be available in the
+     * _value.raws property. If you have not changed the value, the result of
+     * decl.toString() will include the original raws value (comments and all).
+     */
+    value: string;
+    /**
+     * True if the declaration has an !important annotation.
+     */
+    important: boolean;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface DeclarationNewProps {
+    /**
+     * The declaration's property name.
+     */
+    prop?: string;
+    /**
+     * The declaration's value. This value will be cleaned of comments. If the
+     * source value contained comments, those comments will be available in the
+     * _value.raws property. If you have not changed the value, the result of
+     * decl.toString() will include the original raws value (comments and all).
+     */
+    value?: string;
+    raws?: DeclarationRaws;
+  }
+  interface DeclarationRaws extends NodeRaws {
+    /**
+     * The declaration's value. This value will be cleaned of comments.
+     * If the source value contained comments, those comments will be
+     * available in the _value.raws property. If you have not changed the value, the result of
+     * decl.toString() will include the original raws value (comments and all).
+     */
+    value?: string;
+  }
+  interface JsonDeclaration extends JsonNode {
+    /**
+     * True if the declaration has an !important annotation.
+     */
+    important?: boolean;
+  }
+  /**
+   * Represents a comment between declarations or statements (rule and at-rules).
+   * Comments inside selectors, at-rule parameters, or declaration values will
+   * be stored in the Node#raws properties.
+   */
+  interface Comment extends NodeBase {
+    type: 'comment';
+    /**
+     * Returns the comment's parent node.
+     */
+    parent: Container;
+    /**
+     * The comment's text.
+     */
+    text: string;
+    /**
+     * @param overrides New properties to override in the clone.
+     * @returns A clone of this node. The node and its (cloned) children will
+     * have a clean parent and code style properties.
+     */
+    clone(overrides?: object): this;
+  }
+  interface CommentNewProps {
+    /**
+     * The comment's text.
+     */
+    text?: string;
+  }
+  interface JsonComment extends JsonNode {
+  }
+}
+export = postcss;
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/postcss.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/postcss.js
new file mode 100644
index 00000000..2e6c5ce4
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/postcss.js
@@ -0,0 +1,285 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _declaration = _interopRequireDefault(require("./declaration"));
+
+var _processor = _interopRequireDefault(require("./processor"));
+
+var _stringify = _interopRequireDefault(require("./stringify"));
+
+var _comment = _interopRequireDefault(require("./comment"));
+
+var _atRule = _interopRequireDefault(require("./at-rule"));
+
+var _vendor = _interopRequireDefault(require("./vendor"));
+
+var _parse = _interopRequireDefault(require("./parse"));
+
+var _list = _interopRequireDefault(require("./list"));
+
+var _rule = _interopRequireDefault(require("./rule"));
+
+var _root = _interopRequireDefault(require("./root"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Create a new {@link Processor} instance that will apply `plugins`
+ * as CSS processors.
+ *
+ * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.
+ *        See {@link Processor#use} for plugin format.
+ *
+ * @return {Processor} Processor to process multiple CSS.
+ *
+ * @example
+ * import postcss from 'postcss'
+ *
+ * postcss(plugins).process(css, { from, to }).then(result => {
+ *   console.log(result.css)
+ * })
+ *
+ * @namespace postcss
+ */
+function postcss() {
+  for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {
+    plugins[_key] = arguments[_key];
+  }
+
+  if (plugins.length === 1 && Array.isArray(plugins[0])) {
+    plugins = plugins[0];
+  }
+
+  return new _processor.default(plugins);
+}
+/**
+ * Creates a PostCSS plugin with a standard API.
+ *
+ * The newly-wrapped function will provide both the name and PostCSS
+ * version of the plugin.
+ *
+ * ```js
+ * const processor = postcss([replace])
+ * processor.plugins[0].postcssPlugin  //=> 'postcss-replace'
+ * processor.plugins[0].postcssVersion //=> '6.0.0'
+ * ```
+ *
+ * The plugin function receives 2 arguments: {@link Root}
+ * and {@link Result} instance. The function should mutate the provided
+ * `Root` node. Alternatively, you can create a new `Root` node
+ * and override the `result.root` property.
+ *
+ * ```js
+ * const cleaner = postcss.plugin('postcss-cleaner', () => {
+ *   return (root, result) => {
+ *     result.root = postcss.root()
+ *   }
+ * })
+ * ```
+ *
+ * As a convenience, plugins also expose a `process` method so that you can use
+ * them as standalone tools.
+ *
+ * ```js
+ * cleaner.process(css, processOpts, pluginOpts)
+ * // This is equivalent to:
+ * postcss([ cleaner(pluginOpts) ]).process(css, processOpts)
+ * ```
+ *
+ * Asynchronous plugins should return a `Promise` instance.
+ *
+ * ```js
+ * postcss.plugin('postcss-import', () => {
+ *   return (root, result) => {
+ *     return new Promise( (resolve, reject) => {
+ *       fs.readFile('base.css', (base) => {
+ *         root.prepend(base)
+ *         resolve()
+ *       })
+ *     })
+ *   }
+ * })
+ * ```
+ *
+ * Add warnings using the {@link Node#warn} method.
+ * Send data to other plugins using the {@link Result#messages} array.
+ *
+ * ```js
+ * postcss.plugin('postcss-caniuse-test', () => {
+ *   return (root, result) => {
+ *     root.walkDecls(decl => {
+ *       if (!caniuse.support(decl.prop)) {
+ *         decl.warn(result, 'Some browsers do not support ' + decl.prop)
+ *       }
+ *     })
+ *   }
+ * })
+ * ```
+ *
+ * @param {string} name          PostCSS plugin name. Same as in `name`
+ *                               property in `package.json`. It will be saved
+ *                               in `plugin.postcssPlugin` property.
+ * @param {function} initializer Will receive plugin options
+ *                               and should return {@link pluginFunction}
+ *
+ * @return {Plugin} PostCSS plugin.
+ */
+
+
+postcss.plugin = function plugin(name, initializer) {
+  function creator() {
+    var transformer = initializer.apply(void 0, arguments);
+    transformer.postcssPlugin = name;
+    transformer.postcssVersion = new _processor.default().version;
+    return transformer;
+  }
+
+  var cache;
+  Object.defineProperty(creator, 'postcss', {
+    get: function get() {
+      if (!cache) cache = creator();
+      return cache;
+    }
+  });
+
+  creator.process = function (css, processOpts, pluginOpts) {
+    return postcss([creator(pluginOpts)]).process(css, processOpts);
+  };
+
+  return creator;
+};
+/**
+ * Default function to convert a node tree into a CSS string.
+ *
+ * @param {Node} node       Start node for stringifing. Usually {@link Root}.
+ * @param {builder} builder Function to concatenate CSS from node’s parts
+ *                          or generate string and source map.
+ *
+ * @return {void}
+ *
+ * @function
+ */
+
+
+postcss.stringify = _stringify.default;
+/**
+ * Parses source css and returns a new {@link Root} node,
+ * which contains the source CSS nodes.
+ *
+ * @param {string|toString} css   String with input CSS or any object
+ *                                with toString() method, like a Buffer
+ * @param {processOptions} [opts] Options with only `from` and `map` keys.
+ *
+ * @return {Root} PostCSS AST.
+ *
+ * @example
+ * // Simple CSS concatenation with source map support
+ * const root1 = postcss.parse(css1, { from: file1 })
+ * const root2 = postcss.parse(css2, { from: file2 })
+ * root1.append(root2).toResult().css
+ *
+ * @function
+ */
+
+postcss.parse = _parse.default;
+/**
+ * Contains the {@link vendor} module.
+ *
+ * @type {vendor}
+ *
+ * @example
+ * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']
+ */
+
+postcss.vendor = _vendor.default;
+/**
+ * Contains the {@link list} module.
+ *
+ * @member {list}
+ *
+ * @example
+ * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']
+ */
+
+postcss.list = _list.default;
+/**
+ * Creates a new {@link Comment} node.
+ *
+ * @param {object} [defaults] Properties for the new node.
+ *
+ * @return {Comment} New comment node
+ *
+ * @example
+ * postcss.comment({ text: 'test' })
+ */
+
+postcss.comment = function (defaults) {
+  return new _comment.default(defaults);
+};
+/**
+ * Creates a new {@link AtRule} node.
+ *
+ * @param {object} [defaults] Properties for the new node.
+ *
+ * @return {AtRule} new at-rule node
+ *
+ * @example
+ * postcss.atRule({ name: 'charset' }).toString() //=> "@charset"
+ */
+
+
+postcss.atRule = function (defaults) {
+  return new _atRule.default(defaults);
+};
+/**
+ * Creates a new {@link Declaration} node.
+ *
+ * @param {object} [defaults] Properties for the new node.
+ *
+ * @return {Declaration} new declaration node
+ *
+ * @example
+ * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> "color: red"
+ */
+
+
+postcss.decl = function (defaults) {
+  return new _declaration.default(defaults);
+};
+/**
+ * Creates a new {@link Rule} node.
+ *
+ * @param {object} [defaults] Properties for the new node.
+ *
+ * @return {Rule} new rule node
+ *
+ * @example
+ * postcss.rule({ selector: 'a' }).toString() //=> "a {\n}"
+ */
+
+
+postcss.rule = function (defaults) {
+  return new _rule.default(defaults);
+};
+/**
+ * Creates a new {@link Root} node.
+ *
+ * @param {object} [defaults] Properties for the new node.
+ *
+ * @return {Root} new root node.
+ *
+ * @example
+ * postcss.root({ after: '\n' }).toString() //=> "\n"
+ */
+
+
+postcss.root = function (defaults) {
+  return new _root.default(defaults);
+};
+
+var _default = postcss;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["postcss.es6"],"names":["postcss","plugins","length","Array","isArray","Processor","plugin","name","initializer","creator","transformer","postcssPlugin","postcssVersion","version","cache","Object","defineProperty","get","process","css","processOpts","pluginOpts","stringify","parse","vendor","list","comment","defaults","Comment","atRule","AtRule","decl","Declaration","rule","Rule","root","Root"],"mappings":";;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;AAEA;;;;;;;;;;;;;;;;;;AAkBA,SAASA,OAAT,GAA8B;AAAA,oCAATC,OAAS;AAATA,IAAAA,OAAS;AAAA;;AAC5B,MAAIA,OAAO,CAACC,MAAR,KAAmB,CAAnB,IAAwBC,KAAK,CAACC,OAAN,CAAcH,OAAO,CAAC,CAAD,CAArB,CAA5B,EAAuD;AACrDA,IAAAA,OAAO,GAAGA,OAAO,CAAC,CAAD,CAAjB;AACD;;AACD,SAAO,IAAII,kBAAJ,CAAcJ,OAAd,CAAP;AACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEAD,OAAO,CAACM,MAAR,GAAiB,SAASA,MAAT,CAAiBC,IAAjB,EAAuBC,WAAvB,EAAoC;AACnD,WAASC,OAAT,GAA2B;AACzB,QAAIC,WAAW,GAAGF,WAAW,MAAX,mBAAlB;AACAE,IAAAA,WAAW,CAACC,aAAZ,GAA4BJ,IAA5B;AACAG,IAAAA,WAAW,CAACE,cAAZ,GAA8B,IAAIP,kBAAJ,EAAD,CAAkBQ,OAA/C;AACA,WAAOH,WAAP;AACD;;AAED,MAAII,KAAJ;AACAC,EAAAA,MAAM,CAACC,cAAP,CAAsBP,OAAtB,EAA+B,SAA/B,EAA0C;AACxCQ,IAAAA,GADwC,iBACjC;AACL,UAAI,CAACH,KAAL,EAAYA,KAAK,GAAGL,OAAO,EAAf;AACZ,aAAOK,KAAP;AACD;AAJuC,GAA1C;;AAOAL,EAAAA,OAAO,CAACS,OAAR,GAAkB,UAAUC,GAAV,EAAeC,WAAf,EAA4BC,UAA5B,EAAwC;AACxD,WAAOrB,OAAO,CAAC,CAACS,OAAO,CAACY,UAAD,CAAR,CAAD,CAAP,CAA+BH,OAA/B,CAAuCC,GAAvC,EAA4CC,WAA5C,CAAP;AACD,GAFD;;AAIA,SAAOX,OAAP;AACD,CArBD;AAuBA;;;;;;;;;;;;;AAWAT,OAAO,CAACsB,SAAR,GAAoBA,kBAApB;AAEA;;;;;;;;;;;;;;;;;;;AAkBAtB,OAAO,CAACuB,KAAR,GAAgBA,cAAhB;AAEA;;;;;;;;;AAQAvB,OAAO,CAACwB,MAAR,GAAiBA,eAAjB;AAEA;;;;;;;;;AAQAxB,OAAO,CAACyB,IAAR,GAAeA,aAAf;AAEA;;;;;;;;;;;AAUAzB,OAAO,CAAC0B,OAAR,GAAkB,UAAAC,QAAQ;AAAA,SAAI,IAAIC,gBAAJ,CAAYD,QAAZ,CAAJ;AAAA,CAA1B;AAEA;;;;;;;;;;;;AAUA3B,OAAO,CAAC6B,MAAR,GAAiB,UAAAF,QAAQ;AAAA,SAAI,IAAIG,eAAJ,CAAWH,QAAX,CAAJ;AAAA,CAAzB;AAEA;;;;;;;;;;;;AAUA3B,OAAO,CAAC+B,IAAR,GAAe,UAAAJ,QAAQ;AAAA,SAAI,IAAIK,oBAAJ,CAAgBL,QAAhB,CAAJ;AAAA,CAAvB;AAEA;;;;;;;;;;;;AAUA3B,OAAO,CAACiC,IAAR,GAAe,UAAAN,QAAQ;AAAA,SAAI,IAAIO,aAAJ,CAASP,QAAT,CAAJ;AAAA,CAAvB;AAEA;;;;;;;;;;;;AAUA3B,OAAO,CAACmC,IAAR,GAAe,UAAAR,QAAQ;AAAA,SAAI,IAAIS,aAAJ,CAAST,QAAT,CAAJ;AAAA,CAAvB;;eAEe3B,O","sourcesContent":["import Declaration from './declaration'\nimport Processor from './processor'\nimport stringify from './stringify'\nimport Comment from './comment'\nimport AtRule from './at-rule'\nimport vendor from './vendor'\nimport parse from './parse'\nimport list from './list'\nimport Rule from './rule'\nimport Root from './root'\n\n/**\n * Create a new {@link Processor} instance that will apply `plugins`\n * as CSS processors.\n *\n * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n *        See {@link Processor#use} for plugin format.\n *\n * @return {Processor} Processor to process multiple CSS.\n *\n * @example\n * import postcss from 'postcss'\n *\n * postcss(plugins).process(css, { from, to }).then(result => {\n *   console.log(result.css)\n * })\n *\n * @namespace postcss\n */\nfunction postcss (...plugins) {\n  if (plugins.length === 1 && Array.isArray(plugins[0])) {\n    plugins = plugins[0]\n  }\n  return new Processor(plugins)\n}\n\n/**\n * Creates a PostCSS plugin with a standard API.\n *\n * The newly-wrapped function will provide both the name and PostCSS\n * version of the plugin.\n *\n * ```js\n * const processor = postcss([replace])\n * processor.plugins[0].postcssPlugin  //=> 'postcss-replace'\n * processor.plugins[0].postcssVersion //=> '6.0.0'\n * ```\n *\n * The plugin function receives 2 arguments: {@link Root}\n * and {@link Result} instance. The function should mutate the provided\n * `Root` node. Alternatively, you can create a new `Root` node\n * and override the `result.root` property.\n *\n * ```js\n * const cleaner = postcss.plugin('postcss-cleaner', () => {\n *   return (root, result) => {\n *     result.root = postcss.root()\n *   }\n * })\n * ```\n *\n * As a convenience, plugins also expose a `process` method so that you can use\n * them as standalone tools.\n *\n * ```js\n * cleaner.process(css, processOpts, pluginOpts)\n * // This is equivalent to:\n * postcss([ cleaner(pluginOpts) ]).process(css, processOpts)\n * ```\n *\n * Asynchronous plugins should return a `Promise` instance.\n *\n * ```js\n * postcss.plugin('postcss-import', () => {\n *   return (root, result) => {\n *     return new Promise( (resolve, reject) => {\n *       fs.readFile('base.css', (base) => {\n *         root.prepend(base)\n *         resolve()\n *       })\n *     })\n *   }\n * })\n * ```\n *\n * Add warnings using the {@link Node#warn} method.\n * Send data to other plugins using the {@link Result#messages} array.\n *\n * ```js\n * postcss.plugin('postcss-caniuse-test', () => {\n *   return (root, result) => {\n *     root.walkDecls(decl => {\n *       if (!caniuse.support(decl.prop)) {\n *         decl.warn(result, 'Some browsers do not support ' + decl.prop)\n *       }\n *     })\n *   }\n * })\n * ```\n *\n * @param {string} name          PostCSS plugin name. Same as in `name`\n *                               property in `package.json`. It will be saved\n *                               in `plugin.postcssPlugin` property.\n * @param {function} initializer Will receive plugin options\n *                               and should return {@link pluginFunction}\n *\n * @return {Plugin} PostCSS plugin.\n */\npostcss.plugin = function plugin (name, initializer) {\n  function creator (...args) {\n    let transformer = initializer(...args)\n    transformer.postcssPlugin = name\n    transformer.postcssVersion = (new Processor()).version\n    return transformer\n  }\n\n  let cache\n  Object.defineProperty(creator, 'postcss', {\n    get () {\n      if (!cache) cache = creator()\n      return cache\n    }\n  })\n\n  creator.process = function (css, processOpts, pluginOpts) {\n    return postcss([creator(pluginOpts)]).process(css, processOpts)\n  }\n\n  return creator\n}\n\n/**\n * Default function to convert a node tree into a CSS string.\n *\n * @param {Node} node       Start node for stringifing. Usually {@link Root}.\n * @param {builder} builder Function to concatenate CSS from node’s parts\n *                          or generate string and source map.\n *\n * @return {void}\n *\n * @function\n */\npostcss.stringify = stringify\n\n/**\n * Parses source css and returns a new {@link Root} node,\n * which contains the source CSS nodes.\n *\n * @param {string|toString} css   String with input CSS or any object\n *                                with toString() method, like a Buffer\n * @param {processOptions} [opts] Options with only `from` and `map` keys.\n *\n * @return {Root} PostCSS AST.\n *\n * @example\n * // Simple CSS concatenation with source map support\n * const root1 = postcss.parse(css1, { from: file1 })\n * const root2 = postcss.parse(css2, { from: file2 })\n * root1.append(root2).toResult().css\n *\n * @function\n */\npostcss.parse = parse\n\n/**\n * Contains the {@link vendor} module.\n *\n * @type {vendor}\n *\n * @example\n * postcss.vendor.unprefixed('-moz-tab') //=> ['tab']\n */\npostcss.vendor = vendor\n\n/**\n * Contains the {@link list} module.\n *\n * @member {list}\n *\n * @example\n * postcss.list.space('5px calc(10% + 5px)') //=> ['5px', 'calc(10% + 5px)']\n */\npostcss.list = list\n\n/**\n * Creates a new {@link Comment} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Comment} New comment node\n *\n * @example\n * postcss.comment({ text: 'test' })\n */\npostcss.comment = defaults => new Comment(defaults)\n\n/**\n * Creates a new {@link AtRule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {AtRule} new at-rule node\n *\n * @example\n * postcss.atRule({ name: 'charset' }).toString() //=> \"@charset\"\n */\npostcss.atRule = defaults => new AtRule(defaults)\n\n/**\n * Creates a new {@link Declaration} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Declaration} new declaration node\n *\n * @example\n * postcss.decl({ prop: 'color', value: 'red' }).toString() //=> \"color: red\"\n */\npostcss.decl = defaults => new Declaration(defaults)\n\n/**\n * Creates a new {@link Rule} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Rule} new rule node\n *\n * @example\n * postcss.rule({ selector: 'a' }).toString() //=> \"a {\\n}\"\n */\npostcss.rule = defaults => new Rule(defaults)\n\n/**\n * Creates a new {@link Root} node.\n *\n * @param {object} [defaults] Properties for the new node.\n *\n * @return {Root} new root node.\n *\n * @example\n * postcss.root({ after: '\\n' }).toString() //=> \"\\n\"\n */\npostcss.root = defaults => new Root(defaults)\n\nexport default postcss\n"],"file":"postcss.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/previous-map.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/previous-map.js
new file mode 100644
index 00000000..588e8099
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/previous-map.js
@@ -0,0 +1,172 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _sourceMap = _interopRequireDefault(require("source-map"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function fromBase64(str) {
+  if (Buffer) {
+    return Buffer.from(str, 'base64').toString();
+  } else {
+    return window.atob(str);
+  }
+}
+/**
+ * Source map information from input CSS.
+ * For example, source map after Sass compiler.
+ *
+ * This class will automatically find source map in input CSS or in file system
+ * near input file (according `from` option).
+ *
+ * @example
+ * const root = postcss.parse(css, { from: 'a.sass.css' })
+ * root.input.map //=> PreviousMap
+ */
+
+
+var PreviousMap = /*#__PURE__*/function () {
+  /**
+   * @param {string}         css    Input CSS source.
+   * @param {processOptions} [opts] {@link Processor#process} options.
+   */
+  function PreviousMap(css, opts) {
+    this.loadAnnotation(css);
+    /**
+     * Was source map inlined by data-uri to input CSS.
+     *
+     * @type {boolean}
+     */
+
+    this.inline = this.startWith(this.annotation, 'data:');
+    var prev = opts.map ? opts.map.prev : undefined;
+    var text = this.loadMap(opts.from, prev);
+    if (text) this.text = text;
+  }
+  /**
+   * Create a instance of `SourceMapGenerator` class
+   * from the `source-map` library to work with source map information.
+   *
+   * It is lazy method, so it will create object only on first call
+   * and then it will use cache.
+   *
+   * @return {SourceMapGenerator} Object with source map information.
+   */
+
+
+  var _proto = PreviousMap.prototype;
+
+  _proto.consumer = function consumer() {
+    if (!this.consumerCache) {
+      this.consumerCache = new _sourceMap.default.SourceMapConsumer(this.text);
+    }
+
+    return this.consumerCache;
+  }
+  /**
+   * Does source map contains `sourcesContent` with input source text.
+   *
+   * @return {boolean} Is `sourcesContent` present.
+   */
+  ;
+
+  _proto.withContent = function withContent() {
+    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+  };
+
+  _proto.startWith = function startWith(string, start) {
+    if (!string) return false;
+    return string.substr(0, start.length) === start;
+  };
+
+  _proto.getAnnotationURL = function getAnnotationURL(sourceMapString) {
+    return sourceMapString.match(/\/\*\s*# sourceMappingURL=((?:(?!sourceMappingURL=).)*)\*\//)[1].trim();
+  };
+
+  _proto.loadAnnotation = function loadAnnotation(css) {
+    var annotations = css.match(/\/\*\s*# sourceMappingURL=(?:(?!sourceMappingURL=).)*\*\//gm);
+
+    if (annotations && annotations.length > 0) {
+      // Locate the last sourceMappingURL to avoid picking up
+      // sourceMappingURLs from comments, strings, etc.
+      var lastAnnotation = annotations[annotations.length - 1];
+
+      if (lastAnnotation) {
+        this.annotation = this.getAnnotationURL(lastAnnotation);
+      }
+    }
+  };
+
+  _proto.decodeInline = function decodeInline(text) {
+    var baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
+    var baseUri = /^data:application\/json;base64,/;
+    var uri = 'data:application/json,';
+
+    if (this.startWith(text, uri)) {
+      return decodeURIComponent(text.substr(uri.length));
+    }
+
+    if (baseCharsetUri.test(text) || baseUri.test(text)) {
+      return fromBase64(text.substr(RegExp.lastMatch.length));
+    }
+
+    var encoding = text.match(/data:application\/json;([^,]+),/)[1];
+    throw new Error('Unsupported source map encoding ' + encoding);
+  };
+
+  _proto.loadMap = function loadMap(file, prev) {
+    if (prev === false) return false;
+
+    if (prev) {
+      if (typeof prev === 'string') {
+        return prev;
+      } else if (typeof prev === 'function') {
+        var prevPath = prev(file);
+
+        if (prevPath && _fs.default.existsSync && _fs.default.existsSync(prevPath)) {
+          return _fs.default.readFileSync(prevPath, 'utf-8').toString().trim();
+        } else {
+          throw new Error('Unable to load previous source map: ' + prevPath.toString());
+        }
+      } else if (prev instanceof _sourceMap.default.SourceMapConsumer) {
+        return _sourceMap.default.SourceMapGenerator.fromSourceMap(prev).toString();
+      } else if (prev instanceof _sourceMap.default.SourceMapGenerator) {
+        return prev.toString();
+      } else if (this.isMap(prev)) {
+        return JSON.stringify(prev);
+      } else {
+        throw new Error('Unsupported previous source map format: ' + prev.toString());
+      }
+    } else if (this.inline) {
+      return this.decodeInline(this.annotation);
+    } else if (this.annotation) {
+      var map = this.annotation;
+      if (file) map = _path.default.join(_path.default.dirname(file), map);
+      this.root = _path.default.dirname(map);
+
+      if (_fs.default.existsSync && _fs.default.existsSync(map)) {
+        return _fs.default.readFileSync(map, 'utf-8').toString().trim();
+      } else {
+        return false;
+      }
+    }
+  };
+
+  _proto.isMap = function isMap(map) {
+    if (typeof map !== 'object') return false;
+    return typeof map.mappings === 'string' || typeof map._mappings === 'string';
+  };
+
+  return PreviousMap;
+}();
+
+var _default = PreviousMap;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["previous-map.es6"],"names":["fromBase64","str","Buffer","from","toString","window","atob","PreviousMap","css","opts","loadAnnotation","inline","startWith","annotation","prev","map","undefined","text","loadMap","consumer","consumerCache","mozilla","SourceMapConsumer","withContent","sourcesContent","length","string","start","substr","getAnnotationURL","sourceMapString","match","trim","annotations","lastAnnotation","decodeInline","baseCharsetUri","baseUri","uri","decodeURIComponent","test","RegExp","lastMatch","encoding","Error","file","prevPath","fs","existsSync","readFileSync","SourceMapGenerator","fromSourceMap","isMap","JSON","stringify","path","join","dirname","root","mappings","_mappings"],"mappings":"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","sourcesContent":["import mozilla from 'source-map'\nimport path from 'path'\nimport fs from 'fs'\n\nfunction fromBase64 (str) {\n  if (Buffer) {\n    return Buffer.from(str, 'base64').toString()\n  } else {\n    return window.atob(str)\n  }\n}\n\n/**\n * Source map information from input CSS.\n * For example, source map after Sass compiler.\n *\n * This class will automatically find source map in input CSS or in file system\n * near input file (according `from` option).\n *\n * @example\n * const root = postcss.parse(css, { from: 'a.sass.css' })\n * root.input.map //=> PreviousMap\n */\nclass PreviousMap {\n  /**\n   * @param {string}         css    Input CSS source.\n   * @param {processOptions} [opts] {@link Processor#process} options.\n   */\n  constructor (css, opts) {\n    this.loadAnnotation(css)\n    /**\n     * Was source map inlined by data-uri to input CSS.\n     *\n     * @type {boolean}\n     */\n    this.inline = this.startWith(this.annotation, 'data:')\n\n    let prev = opts.map ? opts.map.prev : undefined\n    let text = this.loadMap(opts.from, prev)\n    if (text) this.text = text\n  }\n\n  /**\n   * Create a instance of `SourceMapGenerator` class\n   * from the `source-map` library to work with source map information.\n   *\n   * It is lazy method, so it will create object only on first call\n   * and then it will use cache.\n   *\n   * @return {SourceMapGenerator} Object with source map information.\n   */\n  consumer () {\n    if (!this.consumerCache) {\n      this.consumerCache = new mozilla.SourceMapConsumer(this.text)\n    }\n    return this.consumerCache\n  }\n\n  /**\n   * Does source map contains `sourcesContent` with input source text.\n   *\n   * @return {boolean} Is `sourcesContent` present.\n   */\n  withContent () {\n    return !!(this.consumer().sourcesContent &&\n              this.consumer().sourcesContent.length > 0)\n  }\n\n  startWith (string, start) {\n    if (!string) return false\n    return string.substr(0, start.length) === start\n  }\n\n  getAnnotationURL (sourceMapString) {\n    return sourceMapString\n      .match(/\\/\\*\\s*# sourceMappingURL=((?:(?!sourceMappingURL=).)*)\\*\\//)[1]\n      .trim()\n  }\n\n  loadAnnotation (css) {\n    let annotations = css.match(\n      /\\/\\*\\s*# sourceMappingURL=(?:(?!sourceMappingURL=).)*\\*\\//gm\n    )\n\n    if (annotations && annotations.length > 0) {\n      // Locate the last sourceMappingURL to avoid picking up\n      // sourceMappingURLs from comments, strings, etc.\n      let lastAnnotation = annotations[annotations.length - 1]\n      if (lastAnnotation) {\n        this.annotation = this.getAnnotationURL(lastAnnotation)\n      }\n    }\n  }\n\n  decodeInline (text) {\n    let baseCharsetUri = /^data:application\\/json;charset=utf-?8;base64,/\n    let baseUri = /^data:application\\/json;base64,/\n    let uri = 'data:application/json,'\n\n    if (this.startWith(text, uri)) {\n      return decodeURIComponent(text.substr(uri.length))\n    }\n\n    if (baseCharsetUri.test(text) || baseUri.test(text)) {\n      return fromBase64(text.substr(RegExp.lastMatch.length))\n    }\n\n    let encoding = text.match(/data:application\\/json;([^,]+),/)[1]\n    throw new Error('Unsupported source map encoding ' + encoding)\n  }\n\n  loadMap (file, prev) {\n    if (prev === false) return false\n\n    if (prev) {\n      if (typeof prev === 'string') {\n        return prev\n      } else if (typeof prev === 'function') {\n        let prevPath = prev(file)\n        if (prevPath && fs.existsSync && fs.existsSync(prevPath)) {\n          return fs.readFileSync(prevPath, 'utf-8').toString().trim()\n        } else {\n          throw new Error(\n            'Unable to load previous source map: ' + prevPath.toString())\n        }\n      } else if (prev instanceof mozilla.SourceMapConsumer) {\n        return mozilla.SourceMapGenerator.fromSourceMap(prev).toString()\n      } else if (prev instanceof mozilla.SourceMapGenerator) {\n        return prev.toString()\n      } else if (this.isMap(prev)) {\n        return JSON.stringify(prev)\n      } else {\n        throw new Error(\n          'Unsupported previous source map format: ' + prev.toString())\n      }\n    } else if (this.inline) {\n      return this.decodeInline(this.annotation)\n    } else if (this.annotation) {\n      let map = this.annotation\n      if (file) map = path.join(path.dirname(file), map)\n\n      this.root = path.dirname(map)\n      if (fs.existsSync && fs.existsSync(map)) {\n        return fs.readFileSync(map, 'utf-8').toString().trim()\n      } else {\n        return false\n      }\n    }\n  }\n\n  isMap (map) {\n    if (typeof map !== 'object') return false\n    return typeof map.mappings === 'string' || typeof map._mappings === 'string'\n  }\n}\n\nexport default PreviousMap\n"],"file":"previous-map.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/processor.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/processor.js
new file mode 100644
index 00000000..b20084f4
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/processor.js
@@ -0,0 +1,264 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _lazyResult = _interopRequireDefault(require("./lazy-result"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/**
+ * Contains plugins to process CSS. Create one `Processor` instance,
+ * initialize its plugins, and then use that instance on numerous CSS files.
+ *
+ * @example
+ * const processor = postcss([autoprefixer, precss])
+ * processor.process(css1).then(result => console.log(result.css))
+ * processor.process(css2).then(result => console.log(result.css))
+ */
+var Processor = /*#__PURE__*/function () {
+  /**
+   * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.
+   *        See {@link Processor#use} for plugin format.
+   */
+  function Processor(plugins) {
+    if (plugins === void 0) {
+      plugins = [];
+    }
+
+    /**
+     * Current PostCSS version.
+     *
+     * @type {string}
+     *
+     * @example
+     * if (result.processor.version.split('.')[0] !== '6') {
+     *   throw new Error('This plugin works only with PostCSS 6')
+     * }
+     */
+    this.version = '7.0.39';
+    /**
+     * Plugins added to this processor.
+     *
+     * @type {pluginFunction[]}
+     *
+     * @example
+     * const processor = postcss([autoprefixer, precss])
+     * processor.plugins.length //=> 2
+     */
+
+    this.plugins = this.normalize(plugins);
+  }
+  /**
+   * Adds a plugin to be used as a CSS processor.
+   *
+   * PostCSS plugin can be in 4 formats:
+   * * A plugin created by {@link postcss.plugin} method.
+   * * A function. PostCSS will pass the function a @{link Root}
+   *   as the first argument and current {@link Result} instance
+   *   as the second.
+   * * An object with a `postcss` method. PostCSS will use that method
+   *   as described in #2.
+   * * Another {@link Processor} instance. PostCSS will copy plugins
+   *   from that instance into this one.
+   *
+   * Plugins can also be added by passing them as arguments when creating
+   * a `postcss` instance (see [`postcss(plugins)`]).
+   *
+   * Asynchronous plugins should return a `Promise` instance.
+   *
+   * @param {Plugin|pluginFunction|Processor} plugin PostCSS plugin
+   *                                                 or {@link Processor}
+   *                                                 with plugins.
+   *
+   * @example
+   * const processor = postcss()
+   *   .use(autoprefixer)
+   *   .use(precss)
+   *
+   * @return {Processes} Current processor to make methods chain.
+   */
+
+
+  var _proto = Processor.prototype;
+
+  _proto.use = function use(plugin) {
+    this.plugins = this.plugins.concat(this.normalize([plugin]));
+    return this;
+  }
+  /**
+   * Parses source CSS and returns a {@link LazyResult} Promise proxy.
+   * Because some plugins can be asynchronous it doesn’t make
+   * any transformations. Transformations will be applied
+   * in the {@link LazyResult} methods.
+   *
+   * @param {string|toString|Result} css String with input CSS or any object
+   *                                     with a `toString()` method,
+   *                                     like a Buffer. Optionally, send
+   *                                     a {@link Result} instance
+   *                                     and the processor will take
+   *                                     the {@link Root} from it.
+   * @param {processOptions} [opts]      Options.
+   *
+   * @return {LazyResult} Promise proxy.
+   *
+   * @example
+   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
+   *   .then(result => {
+   *      console.log(result.css)
+   *   })
+   */
+  ;
+
+  _proto.process = function (_process) {
+    function process(_x) {
+      return _process.apply(this, arguments);
+    }
+
+    process.toString = function () {
+      return _process.toString();
+    };
+
+    return process;
+  }(function (css, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    if (this.plugins.length === 0 && opts.parser === opts.stringifier) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (typeof console !== 'undefined' && console.warn) {
+          console.warn('You did not set any plugins, parser, or stringifier. ' + 'Right now, PostCSS does nothing. Pick plugins for your case ' + 'on https://www.postcss.parts/ and use them in postcss.config.js.');
+        }
+      }
+    }
+
+    return new _lazyResult.default(this, css, opts);
+  });
+
+  _proto.normalize = function normalize(plugins) {
+    var normalized = [];
+
+    for (var _iterator = _createForOfIteratorHelperLoose(plugins), _step; !(_step = _iterator()).done;) {
+      var i = _step.value;
+
+      if (i.postcss === true) {
+        var plugin = i();
+        throw new Error('PostCSS plugin ' + plugin.postcssPlugin + ' requires PostCSS 8.\n' + 'Migration guide for end-users:\n' + 'https://github.com/postcss/postcss/wiki/PostCSS-8-for-end-users');
+      }
+
+      if (i.postcss) i = i.postcss;
+
+      if (typeof i === 'object' && Array.isArray(i.plugins)) {
+        normalized = normalized.concat(i.plugins);
+      } else if (typeof i === 'function') {
+        normalized.push(i);
+      } else if (typeof i === 'object' && (i.parse || i.stringify)) {
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error('PostCSS syntaxes cannot be used as plugins. Instead, please use ' + 'one of the syntax/parser/stringifier options as outlined ' + 'in your PostCSS runner documentation.');
+        }
+      } else if (typeof i === 'object' && i.postcssPlugin) {
+        throw new Error('PostCSS plugin ' + i.postcssPlugin + ' requires PostCSS 8.\n' + 'Migration guide for end-users:\n' + 'https://github.com/postcss/postcss/wiki/PostCSS-8-for-end-users');
+      } else {
+        throw new Error(i + ' is not a PostCSS plugin');
+      }
+    }
+
+    return normalized;
+  };
+
+  return Processor;
+}();
+
+var _default = Processor;
+/**
+ * @callback builder
+ * @param {string} part          Part of generated CSS connected to this node.
+ * @param {Node}   node          AST node.
+ * @param {"start"|"end"} [type] Node’s part type.
+ */
+
+/**
+ * @callback parser
+ *
+ * @param {string|toString} css   String with input CSS or any object
+ *                                with toString() method, like a Buffer.
+ * @param {processOptions} [opts] Options with only `from` and `map` keys.
+ *
+ * @return {Root} PostCSS AST
+ */
+
+/**
+ * @callback stringifier
+ *
+ * @param {Node} node       Start node for stringifing. Usually {@link Root}.
+ * @param {builder} builder Function to concatenate CSS from node’s parts
+ *                          or generate string and source map.
+ *
+ * @return {void}
+ */
+
+/**
+ * @typedef {object} syntax
+ * @property {parser} parse          Function to generate AST by string.
+ * @property {stringifier} stringify Function to generate string by AST.
+ */
+
+/**
+ * @typedef {object} toString
+ * @property {function} toString
+ */
+
+/**
+ * @callback pluginFunction
+ * @param {Root} root     Parsed input CSS.
+ * @param {Result} result Result to set warnings or check other plugins.
+ */
+
+/**
+ * @typedef {object} Plugin
+ * @property {function} postcss PostCSS plugin function.
+ */
+
+/**
+ * @typedef {object} processOptions
+ * @property {string} from             The path of the CSS source file.
+ *                                     You should always set `from`,
+ *                                     because it is used in source map
+ *                                     generation and syntax error messages.
+ * @property {string} to               The path where you’ll put the output
+ *                                     CSS file. You should always set `to`
+ *                                     to generate correct source maps.
+ * @property {parser} parser           Function to generate AST by string.
+ * @property {stringifier} stringifier Class to generate string by AST.
+ * @property {syntax} syntax           Object with `parse` and `stringify`.
+ * @property {object} map              Source map options.
+ * @property {boolean} map.inline                    Does source map should
+ *                                                   be embedded in the output
+ *                                                   CSS as a base64-encoded
+ *                                                   comment.
+ * @property {string|object|false|function} map.prev Source map content
+ *                                                   from a previous
+ *                                                   processing step
+ *                                                   (for example, Sass).
+ *                                                   PostCSS will try to find
+ *                                                   previous map automatically,
+ *                                                   so you could disable it by
+ *                                                   `false` value.
+ * @property {boolean} map.sourcesContent            Does PostCSS should set
+ *                                                   the origin content to map.
+ * @property {string|false} map.annotation           Does PostCSS should set
+ *                                                   annotation comment to map.
+ * @property {string} map.from                       Override `from` in map’s
+ *                                                   sources`.
+ */
+
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["processor.es6"],"names":["Processor","plugins","version","normalize","use","plugin","concat","process","css","opts","length","parser","stringifier","env","NODE_ENV","console","warn","LazyResult","normalized","i","postcss","Error","postcssPlugin","Array","isArray","push","parse","stringify"],"mappings":"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","sourcesContent":["import LazyResult from './lazy-result'\n\n/**\n * Contains plugins to process CSS. Create one `Processor` instance,\n * initialize its plugins, and then use that instance on numerous CSS files.\n *\n * @example\n * const processor = postcss([autoprefixer, precss])\n * processor.process(css1).then(result => console.log(result.css))\n * processor.process(css2).then(result => console.log(result.css))\n */\nclass Processor {\n  /**\n   * @param {Array.<Plugin|pluginFunction>|Processor} plugins PostCSS plugins.\n   *        See {@link Processor#use} for plugin format.\n   */\n  constructor (plugins = []) {\n    /**\n     * Current PostCSS version.\n     *\n     * @type {string}\n     *\n     * @example\n     * if (result.processor.version.split('.')[0] !== '6') {\n     *   throw new Error('This plugin works only with PostCSS 6')\n     * }\n     */\n    this.version = '7.0.39'\n    /**\n     * Plugins added to this processor.\n     *\n     * @type {pluginFunction[]}\n     *\n     * @example\n     * const processor = postcss([autoprefixer, precss])\n     * processor.plugins.length //=> 2\n     */\n    this.plugins = this.normalize(plugins)\n  }\n\n  /**\n   * Adds a plugin to be used as a CSS processor.\n   *\n   * PostCSS plugin can be in 4 formats:\n   * * A plugin created by {@link postcss.plugin} method.\n   * * A function. PostCSS will pass the function a @{link Root}\n   *   as the first argument and current {@link Result} instance\n   *   as the second.\n   * * An object with a `postcss` method. PostCSS will use that method\n   *   as described in #2.\n   * * Another {@link Processor} instance. PostCSS will copy plugins\n   *   from that instance into this one.\n   *\n   * Plugins can also be added by passing them as arguments when creating\n   * a `postcss` instance (see [`postcss(plugins)`]).\n   *\n   * Asynchronous plugins should return a `Promise` instance.\n   *\n   * @param {Plugin|pluginFunction|Processor} plugin PostCSS plugin\n   *                                                 or {@link Processor}\n   *                                                 with plugins.\n   *\n   * @example\n   * const processor = postcss()\n   *   .use(autoprefixer)\n   *   .use(precss)\n   *\n   * @return {Processes} Current processor to make methods chain.\n   */\n  use (plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]))\n    return this\n  }\n\n  /**\n   * Parses source CSS and returns a {@link LazyResult} Promise proxy.\n   * Because some plugins can be asynchronous it doesn’t make\n   * any transformations. Transformations will be applied\n   * in the {@link LazyResult} methods.\n   *\n   * @param {string|toString|Result} css String with input CSS or any object\n   *                                     with a `toString()` method,\n   *                                     like a Buffer. Optionally, send\n   *                                     a {@link Result} instance\n   *                                     and the processor will take\n   *                                     the {@link Root} from it.\n   * @param {processOptions} [opts]      Options.\n   *\n   * @return {LazyResult} Promise proxy.\n   *\n   * @example\n   * processor.process(css, { from: 'a.css', to: 'a.out.css' })\n   *   .then(result => {\n   *      console.log(result.css)\n   *   })\n   */\n  process (css, opts = { }) {\n    if (this.plugins.length === 0 && opts.parser === opts.stringifier) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof console !== 'undefined' && console.warn) {\n          console.warn(\n            'You did not set any plugins, parser, or stringifier. ' +\n            'Right now, PostCSS does nothing. Pick plugins for your case ' +\n            'on https://www.postcss.parts/ and use them in postcss.config.js.'\n          )\n        }\n      }\n    }\n    return new LazyResult(this, css, opts)\n  }\n\n  normalize (plugins) {\n    let normalized = []\n    for (let i of plugins) {\n      if (i.postcss === true) {\n        let plugin = i()\n        throw new Error(\n          'PostCSS plugin ' + plugin.postcssPlugin + ' requires PostCSS 8.\\n' +\n          'Migration guide for end-users:\\n' +\n          'https://github.com/postcss/postcss/wiki/PostCSS-8-for-end-users'\n        )\n      }\n\n      if (i.postcss) i = i.postcss\n\n      if (typeof i === 'object' && Array.isArray(i.plugins)) {\n        normalized = normalized.concat(i.plugins)\n      } else if (typeof i === 'function') {\n        normalized.push(i)\n      } else if (typeof i === 'object' && (i.parse || i.stringify)) {\n        if (process.env.NODE_ENV !== 'production') {\n          throw new Error(\n            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +\n            'one of the syntax/parser/stringifier options as outlined ' +\n            'in your PostCSS runner documentation.'\n          )\n        }\n      } else if (typeof i === 'object' && i.postcssPlugin) {\n        throw new Error(\n          'PostCSS plugin ' + i.postcssPlugin + ' requires PostCSS 8.\\n' +\n          'Migration guide for end-users:\\n' +\n          'https://github.com/postcss/postcss/wiki/PostCSS-8-for-end-users'\n        )\n      } else {\n        throw new Error(i + ' is not a PostCSS plugin')\n      }\n    }\n    return normalized\n  }\n}\n\nexport default Processor\n\n/**\n * @callback builder\n * @param {string} part          Part of generated CSS connected to this node.\n * @param {Node}   node          AST node.\n * @param {\"start\"|\"end\"} [type] Node’s part type.\n */\n\n/**\n * @callback parser\n *\n * @param {string|toString} css   String with input CSS or any object\n *                                with toString() method, like a Buffer.\n * @param {processOptions} [opts] Options with only `from` and `map` keys.\n *\n * @return {Root} PostCSS AST\n */\n\n/**\n * @callback stringifier\n *\n * @param {Node} node       Start node for stringifing. Usually {@link Root}.\n * @param {builder} builder Function to concatenate CSS from node’s parts\n *                          or generate string and source map.\n *\n * @return {void}\n */\n\n/**\n * @typedef {object} syntax\n * @property {parser} parse          Function to generate AST by string.\n * @property {stringifier} stringify Function to generate string by AST.\n */\n\n/**\n * @typedef {object} toString\n * @property {function} toString\n */\n\n/**\n * @callback pluginFunction\n * @param {Root} root     Parsed input CSS.\n * @param {Result} result Result to set warnings or check other plugins.\n */\n\n/**\n * @typedef {object} Plugin\n * @property {function} postcss PostCSS plugin function.\n */\n\n/**\n * @typedef {object} processOptions\n * @property {string} from             The path of the CSS source file.\n *                                     You should always set `from`,\n *                                     because it is used in source map\n *                                     generation and syntax error messages.\n * @property {string} to               The path where you’ll put the output\n *                                     CSS file. You should always set `to`\n *                                     to generate correct source maps.\n * @property {parser} parser           Function to generate AST by string.\n * @property {stringifier} stringifier Class to generate string by AST.\n * @property {syntax} syntax           Object with `parse` and `stringify`.\n * @property {object} map              Source map options.\n * @property {boolean} map.inline                    Does source map should\n *                                                   be embedded in the output\n *                                                   CSS as a base64-encoded\n *                                                   comment.\n * @property {string|object|false|function} map.prev Source map content\n *                                                   from a previous\n *                                                   processing step\n *                                                   (for example, Sass).\n *                                                   PostCSS will try to find\n *                                                   previous map automatically,\n *                                                   so you could disable it by\n *                                                   `false` value.\n * @property {boolean} map.sourcesContent            Does PostCSS should set\n *                                                   the origin content to map.\n * @property {string|false} map.annotation           Does PostCSS should set\n *                                                   annotation comment to map.\n * @property {string} map.from                       Override `from` in map’s\n *                                                   sources`.\n */\n"],"file":"processor.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/result.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/result.js
new file mode 100644
index 00000000..7617ad2e
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/result.js
@@ -0,0 +1,213 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _warning = _interopRequireDefault(require("./warning"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+/**
+ * Provides the result of the PostCSS transformations.
+ *
+ * A Result instance is returned by {@link LazyResult#then}
+ * or {@link Root#toResult} methods.
+ *
+ * @example
+ * postcss([autoprefixer]).process(css).then(result => {
+ *  console.log(result.css)
+ * })
+ *
+ * @example
+ * const result2 = postcss.parse(css).toResult()
+ */
+var Result = /*#__PURE__*/function () {
+  /**
+   * @param {Processor} processor Processor used for this transformation.
+   * @param {Root}      root      Root node after all transformations.
+   * @param {processOptions} opts Options from the {@link Processor#process}
+   *                              or {@link Root#toResult}.
+   */
+  function Result(processor, root, opts) {
+    /**
+     * The Processor instance used for this transformation.
+     *
+     * @type {Processor}
+     *
+     * @example
+     * for (const plugin of result.processor.plugins) {
+     *   if (plugin.postcssPlugin === 'postcss-bad') {
+     *     throw 'postcss-good is incompatible with postcss-bad'
+     *   }
+     * })
+     */
+    this.processor = processor;
+    /**
+     * Contains messages from plugins (e.g., warnings or custom messages).
+     * Each message should have type and plugin properties.
+     *
+     * @type {Message[]}
+     *
+     * @example
+     * postcss.plugin('postcss-min-browser', () => {
+     *   return (root, result) => {
+     *     const browsers = detectMinBrowsersByCanIUse(root)
+     *     result.messages.push({
+     *       type: 'min-browser',
+     *       plugin: 'postcss-min-browser',
+     *       browsers
+     *     })
+     *   }
+     * })
+     */
+
+    this.messages = [];
+    /**
+     * Root node after all transformations.
+     *
+     * @type {Root}
+     *
+     * @example
+     * root.toResult().root === root
+     */
+
+    this.root = root;
+    /**
+     * Options from the {@link Processor#process} or {@link Root#toResult} call
+     * that produced this Result instance.
+     *
+     * @type {processOptions}
+     *
+     * @example
+     * root.toResult(opts).opts === opts
+     */
+
+    this.opts = opts;
+    /**
+     * A CSS string representing of {@link Result#root}.
+     *
+     * @type {string}
+     *
+     * @example
+     * postcss.parse('a{}').toResult().css //=> "a{}"
+     */
+
+    this.css = undefined;
+    /**
+     * An instance of `SourceMapGenerator` class from the `source-map` library,
+     * representing changes to the {@link Result#root} instance.
+     *
+     * @type {SourceMapGenerator}
+     *
+     * @example
+     * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
+     *
+     * @example
+     * if (result.map) {
+     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())
+     * }
+     */
+
+    this.map = undefined;
+  }
+  /**
+   * Returns for @{link Result#css} content.
+   *
+   * @example
+   * result + '' === result.css
+   *
+   * @return {string} String representing of {@link Result#root}.
+   */
+
+
+  var _proto = Result.prototype;
+
+  _proto.toString = function toString() {
+    return this.css;
+  }
+  /**
+   * Creates an instance of {@link Warning} and adds it
+   * to {@link Result#messages}.
+   *
+   * @param {string} text        Warning message.
+   * @param {Object} [opts]      Warning options.
+   * @param {Node}   opts.node   CSS node that caused the warning.
+   * @param {string} opts.word   Word in CSS source that caused the warning.
+   * @param {number} opts.index  Index in CSS node string that caused
+   *                             the warning.
+   * @param {string} opts.plugin Name of the plugin that created
+   *                             this warning. {@link Result#warn} fills
+   *                             this property automatically.
+   *
+   * @return {Warning} Created warning.
+   */
+  ;
+
+  _proto.warn = function warn(text, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    if (!opts.plugin) {
+      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
+        opts.plugin = this.lastPlugin.postcssPlugin;
+      }
+    }
+
+    var warning = new _warning.default(text, opts);
+    this.messages.push(warning);
+    return warning;
+  }
+  /**
+     * Returns warnings from plugins. Filters {@link Warning} instances
+     * from {@link Result#messages}.
+     *
+     * @example
+     * result.warnings().forEach(warn => {
+     *   console.warn(warn.toString())
+     * })
+     *
+     * @return {Warning[]} Warnings from plugins.
+     */
+  ;
+
+  _proto.warnings = function warnings() {
+    return this.messages.filter(function (i) {
+      return i.type === 'warning';
+    });
+  }
+  /**
+   * An alias for the {@link Result#css} property.
+   * Use it with syntaxes that generate non-CSS output.
+   *
+   * @type {string}
+   *
+   * @example
+   * result.css === result.content
+   */
+  ;
+
+  _createClass(Result, [{
+    key: "content",
+    get: function get() {
+      return this.css;
+    }
+  }]);
+
+  return Result;
+}();
+
+var _default = Result;
+/**
+ * @typedef  {object} Message
+ * @property {string} type   Message type.
+ * @property {string} plugin Source PostCSS plugin name.
+ */
+
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["result.es6"],"names":["Result","processor","root","opts","messages","css","undefined","map","toString","warn","text","plugin","lastPlugin","postcssPlugin","warning","Warning","push","warnings","filter","i","type"],"mappings":";;;;;AAAA;;;;;;;;AAEA;;;;;;;;;;;;;;IAcMA,M;AACJ;;;;;;AAMA,kBAAaC,SAAb,EAAwBC,IAAxB,EAA8BC,IAA9B,EAAoC;AAClC;;;;;;;;;;;;AAYA,SAAKF,SAAL,GAAiBA,SAAjB;AACA;;;;;;;;;;;;;;;;;;;AAkBA,SAAKG,QAAL,GAAgB,EAAhB;AACA;;;;;;;;;AAQA,SAAKF,IAAL,GAAYA,IAAZ;AACA;;;;;;;;;;AASA,SAAKC,IAAL,GAAYA,IAAZ;AACA;;;;;;;;;AAQA,SAAKE,GAAL,GAAWC,SAAX;AACA;;;;;;;;;;;;;;;AAcA,SAAKC,GAAL,GAAWD,SAAX;AACD;AAED;;;;;;;;;;;;SAQAE,Q,GAAA,oBAAY;AACV,WAAO,KAAKH,GAAZ;AACD;AAED;;;;;;;;;;;;;;;;;;SAgBAI,I,GAAA,cAAMC,IAAN,EAAYP,IAAZ,EAAwB;AAAA,QAAZA,IAAY;AAAZA,MAAAA,IAAY,GAAL,EAAK;AAAA;;AACtB,QAAI,CAACA,IAAI,CAACQ,MAAV,EAAkB;AAChB,UAAI,KAAKC,UAAL,IAAmB,KAAKA,UAAL,CAAgBC,aAAvC,EAAsD;AACpDV,QAAAA,IAAI,CAACQ,MAAL,GAAc,KAAKC,UAAL,CAAgBC,aAA9B;AACD;AACF;;AAED,QAAIC,OAAO,GAAG,IAAIC,gBAAJ,CAAYL,IAAZ,EAAkBP,IAAlB,CAAd;AACA,SAAKC,QAAL,CAAcY,IAAd,CAAmBF,OAAnB;AAEA,WAAOA,OAAP;AACD;AAED;;;;;;;;;;;;;SAWAG,Q,GAAA,oBAAY;AACV,WAAO,KAAKb,QAAL,CAAcc,MAAd,CAAqB,UAAAC,CAAC;AAAA,aAAIA,CAAC,CAACC,IAAF,KAAW,SAAf;AAAA,KAAtB,CAAP;AACD;AAED;;;;;;;;;;;;;wBASe;AACb,aAAO,KAAKf,GAAZ;AACD;;;;;;eAGYL,M;AAEf","sourcesContent":["import Warning from './warning'\n\n/**\n * Provides the result of the PostCSS transformations.\n *\n * A Result instance is returned by {@link LazyResult#then}\n * or {@link Root#toResult} methods.\n *\n * @example\n * postcss([autoprefixer]).process(css).then(result => {\n *  console.log(result.css)\n * })\n *\n * @example\n * const result2 = postcss.parse(css).toResult()\n */\nclass Result {\n  /**\n   * @param {Processor} processor Processor used for this transformation.\n   * @param {Root}      root      Root node after all transformations.\n   * @param {processOptions} opts Options from the {@link Processor#process}\n   *                              or {@link Root#toResult}.\n   */\n  constructor (processor, root, opts) {\n    /**\n     * The Processor instance used for this transformation.\n     *\n     * @type {Processor}\n     *\n     * @example\n     * for (const plugin of result.processor.plugins) {\n     *   if (plugin.postcssPlugin === 'postcss-bad') {\n     *     throw 'postcss-good is incompatible with postcss-bad'\n     *   }\n     * })\n     */\n    this.processor = processor\n    /**\n     * Contains messages from plugins (e.g., warnings or custom messages).\n     * Each message should have type and plugin properties.\n     *\n     * @type {Message[]}\n     *\n     * @example\n     * postcss.plugin('postcss-min-browser', () => {\n     *   return (root, result) => {\n     *     const browsers = detectMinBrowsersByCanIUse(root)\n     *     result.messages.push({\n     *       type: 'min-browser',\n     *       plugin: 'postcss-min-browser',\n     *       browsers\n     *     })\n     *   }\n     * })\n     */\n    this.messages = []\n    /**\n     * Root node after all transformations.\n     *\n     * @type {Root}\n     *\n     * @example\n     * root.toResult().root === root\n     */\n    this.root = root\n    /**\n     * Options from the {@link Processor#process} or {@link Root#toResult} call\n     * that produced this Result instance.\n     *\n     * @type {processOptions}\n     *\n     * @example\n     * root.toResult(opts).opts === opts\n     */\n    this.opts = opts\n    /**\n     * A CSS string representing of {@link Result#root}.\n     *\n     * @type {string}\n     *\n     * @example\n     * postcss.parse('a{}').toResult().css //=> \"a{}\"\n     */\n    this.css = undefined\n    /**\n     * An instance of `SourceMapGenerator` class from the `source-map` library,\n     * representing changes to the {@link Result#root} instance.\n     *\n     * @type {SourceMapGenerator}\n     *\n     * @example\n     * result.map.toJSON() //=> { version: 3, file: 'a.css', … }\n     *\n     * @example\n     * if (result.map) {\n     *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())\n     * }\n     */\n    this.map = undefined\n  }\n\n  /**\n   * Returns for @{link Result#css} content.\n   *\n   * @example\n   * result + '' === result.css\n   *\n   * @return {string} String representing of {@link Result#root}.\n   */\n  toString () {\n    return this.css\n  }\n\n  /**\n   * Creates an instance of {@link Warning} and adds it\n   * to {@link Result#messages}.\n   *\n   * @param {string} text        Warning message.\n   * @param {Object} [opts]      Warning options.\n   * @param {Node}   opts.node   CSS node that caused the warning.\n   * @param {string} opts.word   Word in CSS source that caused the warning.\n   * @param {number} opts.index  Index in CSS node string that caused\n   *                             the warning.\n   * @param {string} opts.plugin Name of the plugin that created\n   *                             this warning. {@link Result#warn} fills\n   *                             this property automatically.\n   *\n   * @return {Warning} Created warning.\n   */\n  warn (text, opts = { }) {\n    if (!opts.plugin) {\n      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {\n        opts.plugin = this.lastPlugin.postcssPlugin\n      }\n    }\n\n    let warning = new Warning(text, opts)\n    this.messages.push(warning)\n\n    return warning\n  }\n\n  /**\n     * Returns warnings from plugins. Filters {@link Warning} instances\n     * from {@link Result#messages}.\n     *\n     * @example\n     * result.warnings().forEach(warn => {\n     *   console.warn(warn.toString())\n     * })\n     *\n     * @return {Warning[]} Warnings from plugins.\n     */\n  warnings () {\n    return this.messages.filter(i => i.type === 'warning')\n  }\n\n  /**\n   * An alias for the {@link Result#css} property.\n   * Use it with syntaxes that generate non-CSS output.\n   *\n   * @type {string}\n   *\n   * @example\n   * result.css === result.content\n   */\n  get content () {\n    return this.css\n  }\n}\n\nexport default Result\n\n/**\n * @typedef  {object} Message\n * @property {string} type   Message type.\n * @property {string} plugin Source PostCSS plugin name.\n */\n"],"file":"result.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/root.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/root.js
new file mode 100644
index 00000000..864def26
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/root.js
@@ -0,0 +1,122 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _container = _interopRequireDefault(require("./container"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+/**
+ * Represents a CSS file and contains all its parsed nodes.
+ *
+ * @extends Container
+ *
+ * @example
+ * const root = postcss.parse('a{color:black} b{z-index:2}')
+ * root.type         //=> 'root'
+ * root.nodes.length //=> 2
+ */
+var Root = /*#__PURE__*/function (_Container) {
+  _inheritsLoose(Root, _Container);
+
+  function Root(defaults) {
+    var _this;
+
+    _this = _Container.call(this, defaults) || this;
+    _this.type = 'root';
+    if (!_this.nodes) _this.nodes = [];
+    return _this;
+  }
+
+  var _proto = Root.prototype;
+
+  _proto.removeChild = function removeChild(child, ignore) {
+    var index = this.index(child);
+
+    if (!ignore && index === 0 && this.nodes.length > 1) {
+      this.nodes[1].raws.before = this.nodes[index].raws.before;
+    }
+
+    return _Container.prototype.removeChild.call(this, child);
+  };
+
+  _proto.normalize = function normalize(child, sample, type) {
+    var nodes = _Container.prototype.normalize.call(this, child);
+
+    if (sample) {
+      if (type === 'prepend') {
+        if (this.nodes.length > 1) {
+          sample.raws.before = this.nodes[1].raws.before;
+        } else {
+          delete sample.raws.before;
+        }
+      } else if (this.first !== sample) {
+        for (var _iterator = _createForOfIteratorHelperLoose(nodes), _step; !(_step = _iterator()).done;) {
+          var node = _step.value;
+          node.raws.before = sample.raws.before;
+        }
+      }
+    }
+
+    return nodes;
+  }
+  /**
+   * Returns a {@link Result} instance representing the root’s CSS.
+   *
+   * @param {processOptions} [opts] Options with only `to` and `map` keys.
+   *
+   * @return {Result} Result with current root’s CSS.
+   *
+   * @example
+   * const root1 = postcss.parse(css1, { from: 'a.css' })
+   * const root2 = postcss.parse(css2, { from: 'b.css' })
+   * root1.append(root2)
+   * const result = root1.toResult({ to: 'all.css', map: true })
+   */
+  ;
+
+  _proto.toResult = function toResult(opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    var LazyResult = require('./lazy-result');
+
+    var Processor = require('./processor');
+
+    var lazy = new LazyResult(new Processor(), this, opts);
+    return lazy.stringify();
+  }
+  /**
+   * @memberof Root#
+   * @member {object} raws Information to generate byte-to-byte equal
+   *                       node string as it was in the origin input.
+   *
+   * Every parser saves its own properties,
+   * but the default CSS parser uses:
+   *
+   * * `after`: the space symbols after the last child to the end of file.
+   * * `semicolon`: is the last child has an (optional) semicolon.
+   *
+   * @example
+   * postcss.parse('a {}\n').raws //=> { after: '\n' }
+   * postcss.parse('a {}').raws   //=> { after: '' }
+   */
+  ;
+
+  return Root;
+}(_container.default);
+
+var _default = Root;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/rule.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/rule.js
new file mode 100644
index 00000000..b8281bd0
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/rule.js
@@ -0,0 +1,116 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _container = _interopRequireDefault(require("./container"));
+
+var _list = _interopRequireDefault(require("./list"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+/**
+ * Represents a CSS rule: a selector followed by a declaration block.
+ *
+ * @extends Container
+ *
+ * @example
+ * const root = postcss.parse('a{}')
+ * const rule = root.first
+ * rule.type       //=> 'rule'
+ * rule.toString() //=> 'a{}'
+ */
+var Rule = /*#__PURE__*/function (_Container) {
+  _inheritsLoose(Rule, _Container);
+
+  function Rule(defaults) {
+    var _this;
+
+    _this = _Container.call(this, defaults) || this;
+    _this.type = 'rule';
+    if (!_this.nodes) _this.nodes = [];
+    return _this;
+  }
+  /**
+   * An array containing the rule’s individual selectors.
+   * Groups of selectors are split at commas.
+   *
+   * @type {string[]}
+   *
+   * @example
+   * const root = postcss.parse('a, b { }')
+   * const rule = root.first
+   *
+   * rule.selector  //=> 'a, b'
+   * rule.selectors //=> ['a', 'b']
+   *
+   * rule.selectors = ['a', 'strong']
+   * rule.selector //=> 'a, strong'
+   */
+
+
+  _createClass(Rule, [{
+    key: "selectors",
+    get: function get() {
+      return _list.default.comma(this.selector);
+    },
+    set: function set(values) {
+      var match = this.selector ? this.selector.match(/,\s*/) : null;
+      var sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');
+      this.selector = values.join(sep);
+    }
+    /**
+     * @memberof Rule#
+     * @member {string} selector The rule’s full selector represented
+     *                           as a string.
+     *
+     * @example
+     * const root = postcss.parse('a, b { }')
+     * const rule = root.first
+     * rule.selector //=> 'a, b'
+     */
+
+    /**
+     * @memberof Rule#
+     * @member {object} raws Information to generate byte-to-byte equal
+     *                       node string as it was in the origin input.
+     *
+     * Every parser saves its own properties,
+     * but the default CSS parser uses:
+     *
+     * * `before`: the space symbols before the node. It also stores `*`
+     *   and `_` symbols before the declaration (IE hack).
+     * * `after`: the space symbols after the last child of the node
+     *   to the end of the node.
+     * * `between`: the symbols between the property and value
+     *   for declarations, selector and `{` for rules, or last parameter
+     *   and `{` for at-rules.
+     * * `semicolon`: contains `true` if the last child has
+     *   an (optional) semicolon.
+     * * `ownSemicolon`: contains `true` if there is semicolon after rule.
+     *
+     * PostCSS cleans selectors from comments and extra spaces,
+     * but it stores origin content in raws properties.
+     * As such, if you don’t change a declaration’s value,
+     * PostCSS will use the raw value with comments.
+     *
+     * @example
+     * const root = postcss.parse('a {\n  color:black\n}')
+     * root.first.first.raws //=> { before: '', between: ' ', after: '\n' }
+     */
+
+  }]);
+
+  return Rule;
+}(_container.default);
+
+var _default = Rule;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/stringifier.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/stringifier.js
new file mode 100644
index 00000000..0e99a417
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/stringifier.js
@@ -0,0 +1,362 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var DEFAULT_RAW = {
+  colon: ': ',
+  indent: '    ',
+  beforeDecl: '\n',
+  beforeRule: '\n',
+  beforeOpen: ' ',
+  beforeClose: '\n',
+  beforeComment: '\n',
+  after: '\n',
+  emptyBody: '',
+  commentLeft: ' ',
+  commentRight: ' ',
+  semicolon: false
+};
+
+function capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+
+var Stringifier = /*#__PURE__*/function () {
+  function Stringifier(builder) {
+    this.builder = builder;
+  }
+
+  var _proto = Stringifier.prototype;
+
+  _proto.stringify = function stringify(node, semicolon) {
+    this[node.type](node, semicolon);
+  };
+
+  _proto.root = function root(node) {
+    this.body(node);
+    if (node.raws.after) this.builder(node.raws.after);
+  };
+
+  _proto.comment = function comment(node) {
+    var left = this.raw(node, 'left', 'commentLeft');
+    var right = this.raw(node, 'right', 'commentRight');
+    this.builder('/*' + left + node.text + right + '*/', node);
+  };
+
+  _proto.decl = function decl(node, semicolon) {
+    var between = this.raw(node, 'between', 'colon');
+    var string = node.prop + between + this.rawValue(node, 'value');
+
+    if (node.important) {
+      string += node.raws.important || ' !important';
+    }
+
+    if (semicolon) string += ';';
+    this.builder(string, node);
+  };
+
+  _proto.rule = function rule(node) {
+    this.block(node, this.rawValue(node, 'selector'));
+
+    if (node.raws.ownSemicolon) {
+      this.builder(node.raws.ownSemicolon, node, 'end');
+    }
+  };
+
+  _proto.atrule = function atrule(node, semicolon) {
+    var name = '@' + node.name;
+    var params = node.params ? this.rawValue(node, 'params') : '';
+
+    if (typeof node.raws.afterName !== 'undefined') {
+      name += node.raws.afterName;
+    } else if (params) {
+      name += ' ';
+    }
+
+    if (node.nodes) {
+      this.block(node, name + params);
+    } else {
+      var end = (node.raws.between || '') + (semicolon ? ';' : '');
+      this.builder(name + params + end, node);
+    }
+  };
+
+  _proto.body = function body(node) {
+    var last = node.nodes.length - 1;
+
+    while (last > 0) {
+      if (node.nodes[last].type !== 'comment') break;
+      last -= 1;
+    }
+
+    var semicolon = this.raw(node, 'semicolon');
+
+    for (var i = 0; i < node.nodes.length; i++) {
+      var child = node.nodes[i];
+      var before = this.raw(child, 'before');
+      if (before) this.builder(before);
+      this.stringify(child, last !== i || semicolon);
+    }
+  };
+
+  _proto.block = function block(node, start) {
+    var between = this.raw(node, 'between', 'beforeOpen');
+    this.builder(start + between + '{', node, 'start');
+    var after;
+
+    if (node.nodes && node.nodes.length) {
+      this.body(node);
+      after = this.raw(node, 'after');
+    } else {
+      after = this.raw(node, 'after', 'emptyBody');
+    }
+
+    if (after) this.builder(after);
+    this.builder('}', node, 'end');
+  };
+
+  _proto.raw = function raw(node, own, detect) {
+    var value;
+    if (!detect) detect = own; // Already had
+
+    if (own) {
+      value = node.raws[own];
+      if (typeof value !== 'undefined') return value;
+    }
+
+    var parent = node.parent; // Hack for first rule in CSS
+
+    if (detect === 'before') {
+      if (!parent || parent.type === 'root' && parent.first === node) {
+        return '';
+      }
+    } // Floating child without parent
+
+
+    if (!parent) return DEFAULT_RAW[detect]; // Detect style by other nodes
+
+    var root = node.root();
+    if (!root.rawCache) root.rawCache = {};
+
+    if (typeof root.rawCache[detect] !== 'undefined') {
+      return root.rawCache[detect];
+    }
+
+    if (detect === 'before' || detect === 'after') {
+      return this.beforeAfter(node, detect);
+    } else {
+      var method = 'raw' + capitalize(detect);
+
+      if (this[method]) {
+        value = this[method](root, node);
+      } else {
+        root.walk(function (i) {
+          value = i.raws[own];
+          if (typeof value !== 'undefined') return false;
+        });
+      }
+    }
+
+    if (typeof value === 'undefined') value = DEFAULT_RAW[detect];
+    root.rawCache[detect] = value;
+    return value;
+  };
+
+  _proto.rawSemicolon = function rawSemicolon(root) {
+    var value;
+    root.walk(function (i) {
+      if (i.nodes && i.nodes.length && i.last.type === 'decl') {
+        value = i.raws.semicolon;
+        if (typeof value !== 'undefined') return false;
+      }
+    });
+    return value;
+  };
+
+  _proto.rawEmptyBody = function rawEmptyBody(root) {
+    var value;
+    root.walk(function (i) {
+      if (i.nodes && i.nodes.length === 0) {
+        value = i.raws.after;
+        if (typeof value !== 'undefined') return false;
+      }
+    });
+    return value;
+  };
+
+  _proto.rawIndent = function rawIndent(root) {
+    if (root.raws.indent) return root.raws.indent;
+    var value;
+    root.walk(function (i) {
+      var p = i.parent;
+
+      if (p && p !== root && p.parent && p.parent === root) {
+        if (typeof i.raws.before !== 'undefined') {
+          var parts = i.raws.before.split('\n');
+          value = parts[parts.length - 1];
+          value = value.replace(/[^\s]/g, '');
+          return false;
+        }
+      }
+    });
+    return value;
+  };
+
+  _proto.rawBeforeComment = function rawBeforeComment(root, node) {
+    var value;
+    root.walkComments(function (i) {
+      if (typeof i.raws.before !== 'undefined') {
+        value = i.raws.before;
+
+        if (value.indexOf('\n') !== -1) {
+          value = value.replace(/[^\n]+$/, '');
+        }
+
+        return false;
+      }
+    });
+
+    if (typeof value === 'undefined') {
+      value = this.raw(node, null, 'beforeDecl');
+    } else if (value) {
+      value = value.replace(/[^\s]/g, '');
+    }
+
+    return value;
+  };
+
+  _proto.rawBeforeDecl = function rawBeforeDecl(root, node) {
+    var value;
+    root.walkDecls(function (i) {
+      if (typeof i.raws.before !== 'undefined') {
+        value = i.raws.before;
+
+        if (value.indexOf('\n') !== -1) {
+          value = value.replace(/[^\n]+$/, '');
+        }
+
+        return false;
+      }
+    });
+
+    if (typeof value === 'undefined') {
+      value = this.raw(node, null, 'beforeRule');
+    } else if (value) {
+      value = value.replace(/[^\s]/g, '');
+    }
+
+    return value;
+  };
+
+  _proto.rawBeforeRule = function rawBeforeRule(root) {
+    var value;
+    root.walk(function (i) {
+      if (i.nodes && (i.parent !== root || root.first !== i)) {
+        if (typeof i.raws.before !== 'undefined') {
+          value = i.raws.before;
+
+          if (value.indexOf('\n') !== -1) {
+            value = value.replace(/[^\n]+$/, '');
+          }
+
+          return false;
+        }
+      }
+    });
+    if (value) value = value.replace(/[^\s]/g, '');
+    return value;
+  };
+
+  _proto.rawBeforeClose = function rawBeforeClose(root) {
+    var value;
+    root.walk(function (i) {
+      if (i.nodes && i.nodes.length > 0) {
+        if (typeof i.raws.after !== 'undefined') {
+          value = i.raws.after;
+
+          if (value.indexOf('\n') !== -1) {
+            value = value.replace(/[^\n]+$/, '');
+          }
+
+          return false;
+        }
+      }
+    });
+    if (value) value = value.replace(/[^\s]/g, '');
+    return value;
+  };
+
+  _proto.rawBeforeOpen = function rawBeforeOpen(root) {
+    var value;
+    root.walk(function (i) {
+      if (i.type !== 'decl') {
+        value = i.raws.between;
+        if (typeof value !== 'undefined') return false;
+      }
+    });
+    return value;
+  };
+
+  _proto.rawColon = function rawColon(root) {
+    var value;
+    root.walkDecls(function (i) {
+      if (typeof i.raws.between !== 'undefined') {
+        value = i.raws.between.replace(/[^\s:]/g, '');
+        return false;
+      }
+    });
+    return value;
+  };
+
+  _proto.beforeAfter = function beforeAfter(node, detect) {
+    var value;
+
+    if (node.type === 'decl') {
+      value = this.raw(node, null, 'beforeDecl');
+    } else if (node.type === 'comment') {
+      value = this.raw(node, null, 'beforeComment');
+    } else if (detect === 'before') {
+      value = this.raw(node, null, 'beforeRule');
+    } else {
+      value = this.raw(node, null, 'beforeClose');
+    }
+
+    var buf = node.parent;
+    var depth = 0;
+
+    while (buf && buf.type !== 'root') {
+      depth += 1;
+      buf = buf.parent;
+    }
+
+    if (value.indexOf('\n') !== -1) {
+      var indent = this.raw(node, null, 'indent');
+
+      if (indent.length) {
+        for (var step = 0; step < depth; step++) {
+          value += indent;
+        }
+      }
+    }
+
+    return value;
+  };
+
+  _proto.rawValue = function rawValue(node, prop) {
+    var value = node[prop];
+    var raw = node.raws[prop];
+
+    if (raw && raw.value === value) {
+      return raw.raw;
+    }
+
+    return value;
+  };
+
+  return Stringifier;
+}();
+
+var _default = Stringifier;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["stringifier.es6"],"names":["DEFAULT_RAW","colon","indent","beforeDecl","beforeRule","beforeOpen","beforeClose","beforeComment","after","emptyBody","commentLeft","commentRight","semicolon","capitalize","str","toUpperCase","slice","Stringifier","builder","stringify","node","type","root","body","raws","comment","left","raw","right","text","decl","between","string","prop","rawValue","important","rule","block","ownSemicolon","atrule","name","params","afterName","nodes","end","last","length","i","child","before","start","own","detect","value","parent","first","rawCache","beforeAfter","method","walk","rawSemicolon","rawEmptyBody","rawIndent","p","parts","split","replace","rawBeforeComment","walkComments","indexOf","rawBeforeDecl","walkDecls","rawBeforeRule","rawBeforeClose","rawBeforeOpen","rawColon","buf","depth","step"],"mappings":"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","sourcesContent":["const DEFAULT_RAW = {\n  colon: ': ',\n  indent: '    ',\n  beforeDecl: '\\n',\n  beforeRule: '\\n',\n  beforeOpen: ' ',\n  beforeClose: '\\n',\n  beforeComment: '\\n',\n  after: '\\n',\n  emptyBody: '',\n  commentLeft: ' ',\n  commentRight: ' ',\n  semicolon: false\n}\n\nfunction capitalize (str) {\n  return str[0].toUpperCase() + str.slice(1)\n}\n\nclass Stringifier {\n  constructor (builder) {\n    this.builder = builder\n  }\n\n  stringify (node, semicolon) {\n    this[node.type](node, semicolon)\n  }\n\n  root (node) {\n    this.body(node)\n    if (node.raws.after) this.builder(node.raws.after)\n  }\n\n  comment (node) {\n    let left = this.raw(node, 'left', 'commentLeft')\n    let right = this.raw(node, 'right', 'commentRight')\n    this.builder('/*' + left + node.text + right + '*/', node)\n  }\n\n  decl (node, semicolon) {\n    let between = this.raw(node, 'between', 'colon')\n    let string = node.prop + between + this.rawValue(node, 'value')\n\n    if (node.important) {\n      string += node.raws.important || ' !important'\n    }\n\n    if (semicolon) string += ';'\n    this.builder(string, node)\n  }\n\n  rule (node) {\n    this.block(node, this.rawValue(node, 'selector'))\n    if (node.raws.ownSemicolon) {\n      this.builder(node.raws.ownSemicolon, node, 'end')\n    }\n  }\n\n  atrule (node, semicolon) {\n    let name = '@' + node.name\n    let params = node.params ? this.rawValue(node, 'params') : ''\n\n    if (typeof node.raws.afterName !== 'undefined') {\n      name += node.raws.afterName\n    } else if (params) {\n      name += ' '\n    }\n\n    if (node.nodes) {\n      this.block(node, name + params)\n    } else {\n      let end = (node.raws.between || '') + (semicolon ? ';' : '')\n      this.builder(name + params + end, node)\n    }\n  }\n\n  body (node) {\n    let last = node.nodes.length - 1\n    while (last > 0) {\n      if (node.nodes[last].type !== 'comment') break\n      last -= 1\n    }\n\n    let semicolon = this.raw(node, 'semicolon')\n    for (let i = 0; i < node.nodes.length; i++) {\n      let child = node.nodes[i]\n      let before = this.raw(child, 'before')\n      if (before) this.builder(before)\n      this.stringify(child, last !== i || semicolon)\n    }\n  }\n\n  block (node, start) {\n    let between = this.raw(node, 'between', 'beforeOpen')\n    this.builder(start + between + '{', node, 'start')\n\n    let after\n    if (node.nodes && node.nodes.length) {\n      this.body(node)\n      after = this.raw(node, 'after')\n    } else {\n      after = this.raw(node, 'after', 'emptyBody')\n    }\n\n    if (after) this.builder(after)\n    this.builder('}', node, 'end')\n  }\n\n  raw (node, own, detect) {\n    let value\n    if (!detect) detect = own\n\n    // Already had\n    if (own) {\n      value = node.raws[own]\n      if (typeof value !== 'undefined') return value\n    }\n\n    let parent = node.parent\n\n    // Hack for first rule in CSS\n    if (detect === 'before') {\n      if (!parent || (parent.type === 'root' && parent.first === node)) {\n        return ''\n      }\n    }\n\n    // Floating child without parent\n    if (!parent) return DEFAULT_RAW[detect]\n\n    // Detect style by other nodes\n    let root = node.root()\n    if (!root.rawCache) root.rawCache = { }\n    if (typeof root.rawCache[detect] !== 'undefined') {\n      return root.rawCache[detect]\n    }\n\n    if (detect === 'before' || detect === 'after') {\n      return this.beforeAfter(node, detect)\n    } else {\n      let method = 'raw' + capitalize(detect)\n      if (this[method]) {\n        value = this[method](root, node)\n      } else {\n        root.walk(i => {\n          value = i.raws[own]\n          if (typeof value !== 'undefined') return false\n        })\n      }\n    }\n\n    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]\n\n    root.rawCache[detect] = value\n    return value\n  }\n\n  rawSemicolon (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length && i.last.type === 'decl') {\n        value = i.raws.semicolon\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawEmptyBody (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length === 0) {\n        value = i.raws.after\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawIndent (root) {\n    if (root.raws.indent) return root.raws.indent\n    let value\n    root.walk(i => {\n      let p = i.parent\n      if (p && p !== root && p.parent && p.parent === root) {\n        if (typeof i.raws.before !== 'undefined') {\n          let parts = i.raws.before.split('\\n')\n          value = parts[parts.length - 1]\n          value = value.replace(/[^\\s]/g, '')\n          return false\n        }\n      }\n    })\n    return value\n  }\n\n  rawBeforeComment (root, node) {\n    let value\n    root.walkComments(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.indexOf('\\n') !== -1) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (value) {\n      value = value.replace(/[^\\s]/g, '')\n    }\n    return value\n  }\n\n  rawBeforeDecl (root, node) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.indexOf('\\n') !== -1) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeRule')\n    } else if (value) {\n      value = value.replace(/[^\\s]/g, '')\n    }\n    return value\n  }\n\n  rawBeforeRule (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && (i.parent !== root || root.first !== i)) {\n        if (typeof i.raws.before !== 'undefined') {\n          value = i.raws.before\n          if (value.indexOf('\\n') !== -1) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/[^\\s]/g, '')\n    return value\n  }\n\n  rawBeforeClose (root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length > 0) {\n        if (typeof i.raws.after !== 'undefined') {\n          value = i.raws.after\n          if (value.indexOf('\\n') !== -1) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/[^\\s]/g, '')\n    return value\n  }\n\n  rawBeforeOpen (root) {\n    let value\n    root.walk(i => {\n      if (i.type !== 'decl') {\n        value = i.raws.between\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawColon (root) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.between !== 'undefined') {\n        value = i.raws.between.replace(/[^\\s:]/g, '')\n        return false\n      }\n    })\n    return value\n  }\n\n  beforeAfter (node, detect) {\n    let value\n    if (node.type === 'decl') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (node.type === 'comment') {\n      value = this.raw(node, null, 'beforeComment')\n    } else if (detect === 'before') {\n      value = this.raw(node, null, 'beforeRule')\n    } else {\n      value = this.raw(node, null, 'beforeClose')\n    }\n\n    let buf = node.parent\n    let depth = 0\n    while (buf && buf.type !== 'root') {\n      depth += 1\n      buf = buf.parent\n    }\n\n    if (value.indexOf('\\n') !== -1) {\n      let indent = this.raw(node, null, 'indent')\n      if (indent.length) {\n        for (let step = 0; step < depth; step++) value += indent\n      }\n    }\n\n    return value\n  }\n\n  rawValue (node, prop) {\n    let value = node[prop]\n    let raw = node.raws[prop]\n    if (raw && raw.value === value) {\n      return raw.raw\n    }\n\n    return value\n  }\n}\n\nexport default Stringifier\n"],"file":"stringifier.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/stringify.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/stringify.js
new file mode 100644
index 00000000..6629ec38
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/stringify.js
@@ -0,0 +1,18 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _stringifier = _interopRequireDefault(require("./stringifier"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function stringify(node, builder) {
+  var str = new _stringifier.default(builder);
+  str.stringify(node);
+}
+
+var _default = stringify;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0cmluZ2lmeS5lczYiXSwibmFtZXMiOlsic3RyaW5naWZ5Iiwibm9kZSIsImJ1aWxkZXIiLCJzdHIiLCJTdHJpbmdpZmllciJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTs7OztBQUVBLFNBQVNBLFNBQVQsQ0FBb0JDLElBQXBCLEVBQTBCQyxPQUExQixFQUFtQztBQUNqQyxNQUFJQyxHQUFHLEdBQUcsSUFBSUMsb0JBQUosQ0FBZ0JGLE9BQWhCLENBQVY7QUFDQUMsRUFBQUEsR0FBRyxDQUFDSCxTQUFKLENBQWNDLElBQWQ7QUFDRDs7ZUFFY0QsUyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBTdHJpbmdpZmllciBmcm9tICcuL3N0cmluZ2lmaWVyJ1xuXG5mdW5jdGlvbiBzdHJpbmdpZnkgKG5vZGUsIGJ1aWxkZXIpIHtcbiAgbGV0IHN0ciA9IG5ldyBTdHJpbmdpZmllcihidWlsZGVyKVxuICBzdHIuc3RyaW5naWZ5KG5vZGUpXG59XG5cbmV4cG9ydCBkZWZhdWx0IHN0cmluZ2lmeVxuIl0sImZpbGUiOiJzdHJpbmdpZnkuanMifQ==
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/terminal-highlight.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/terminal-highlight.js
new file mode 100644
index 00000000..11f84233
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/terminal-highlight.js
@@ -0,0 +1,84 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _picocolors = _interopRequireDefault(require("picocolors"));
+
+var _tokenize = _interopRequireDefault(require("./tokenize"));
+
+var _input = _interopRequireDefault(require("./input"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var HIGHLIGHT_THEME = {
+  brackets: _picocolors.default.cyan,
+  'at-word': _picocolors.default.cyan,
+  comment: _picocolors.default.gray,
+  string: _picocolors.default.green,
+  class: _picocolors.default.yellow,
+  call: _picocolors.default.cyan,
+  hash: _picocolors.default.magenta,
+  '(': _picocolors.default.cyan,
+  ')': _picocolors.default.cyan,
+  '{': _picocolors.default.yellow,
+  '}': _picocolors.default.yellow,
+  '[': _picocolors.default.yellow,
+  ']': _picocolors.default.yellow,
+  ':': _picocolors.default.yellow,
+  ';': _picocolors.default.yellow
+};
+
+function getTokenType(_ref, processor) {
+  var type = _ref[0],
+      value = _ref[1];
+
+  if (type === 'word') {
+    if (value[0] === '.') {
+      return 'class';
+    }
+
+    if (value[0] === '#') {
+      return 'hash';
+    }
+  }
+
+  if (!processor.endOfFile()) {
+    var next = processor.nextToken();
+    processor.back(next);
+    if (next[0] === 'brackets' || next[0] === '(') return 'call';
+  }
+
+  return type;
+}
+
+function terminalHighlight(css) {
+  var processor = (0, _tokenize.default)(new _input.default(css), {
+    ignoreErrors: true
+  });
+  var result = '';
+
+  var _loop = function _loop() {
+    var token = processor.nextToken();
+    var color = HIGHLIGHT_THEME[getTokenType(token, processor)];
+
+    if (color) {
+      result += token[1].split(/\r?\n/).map(function (i) {
+        return color(i);
+      }).join('\n');
+    } else {
+      result += token[1];
+    }
+  };
+
+  while (!processor.endOfFile()) {
+    _loop();
+  }
+
+  return result;
+}
+
+var _default = terminalHighlight;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/tokenize.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/tokenize.js
new file mode 100644
index 00000000..5b556bf5
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/tokenize.js
@@ -0,0 +1,295 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = tokenizer;
+var SINGLE_QUOTE = '\''.charCodeAt(0);
+var DOUBLE_QUOTE = '"'.charCodeAt(0);
+var BACKSLASH = '\\'.charCodeAt(0);
+var SLASH = '/'.charCodeAt(0);
+var NEWLINE = '\n'.charCodeAt(0);
+var SPACE = ' '.charCodeAt(0);
+var FEED = '\f'.charCodeAt(0);
+var TAB = '\t'.charCodeAt(0);
+var CR = '\r'.charCodeAt(0);
+var OPEN_SQUARE = '['.charCodeAt(0);
+var CLOSE_SQUARE = ']'.charCodeAt(0);
+var OPEN_PARENTHESES = '('.charCodeAt(0);
+var CLOSE_PARENTHESES = ')'.charCodeAt(0);
+var OPEN_CURLY = '{'.charCodeAt(0);
+var CLOSE_CURLY = '}'.charCodeAt(0);
+var SEMICOLON = ';'.charCodeAt(0);
+var ASTERISK = '*'.charCodeAt(0);
+var COLON = ':'.charCodeAt(0);
+var AT = '@'.charCodeAt(0);
+var RE_AT_END = /[ \n\t\r\f{}()'"\\;/[\]#]/g;
+var RE_WORD_END = /[ \n\t\r\f(){}:;@!'"\\\][#]|\/(?=\*)/g;
+var RE_BAD_BRACKET = /.[\\/("'\n]/;
+var RE_HEX_ESCAPE = /[a-f0-9]/i;
+
+function tokenizer(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var css = input.css.valueOf();
+  var ignore = options.ignoreErrors;
+  var code, next, quote, lines, last, content, escape;
+  var nextLine, nextOffset, escaped, escapePos, prev, n, currentToken;
+  var length = css.length;
+  var offset = -1;
+  var line = 1;
+  var pos = 0;
+  var buffer = [];
+  var returned = [];
+
+  function position() {
+    return pos;
+  }
+
+  function unclosed(what) {
+    throw input.error('Unclosed ' + what, line, pos - offset);
+  }
+
+  function endOfFile() {
+    return returned.length === 0 && pos >= length;
+  }
+
+  function nextToken(opts) {
+    if (returned.length) return returned.pop();
+    if (pos >= length) return;
+    var ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
+    code = css.charCodeAt(pos);
+
+    if (code === NEWLINE || code === FEED || code === CR && css.charCodeAt(pos + 1) !== NEWLINE) {
+      offset = pos;
+      line += 1;
+    }
+
+    switch (code) {
+      case NEWLINE:
+      case SPACE:
+      case TAB:
+      case CR:
+      case FEED:
+        next = pos;
+
+        do {
+          next += 1;
+          code = css.charCodeAt(next);
+
+          if (code === NEWLINE) {
+            offset = next;
+            line += 1;
+          }
+        } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
+
+        currentToken = ['space', css.slice(pos, next)];
+        pos = next - 1;
+        break;
+
+      case OPEN_SQUARE:
+      case CLOSE_SQUARE:
+      case OPEN_CURLY:
+      case CLOSE_CURLY:
+      case COLON:
+      case SEMICOLON:
+      case CLOSE_PARENTHESES:
+        var controlChar = String.fromCharCode(code);
+        currentToken = [controlChar, controlChar, line, pos - offset];
+        break;
+
+      case OPEN_PARENTHESES:
+        prev = buffer.length ? buffer.pop()[1] : '';
+        n = css.charCodeAt(pos + 1);
+
+        if (prev === 'url' && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
+          next = pos;
+
+          do {
+            escaped = false;
+            next = css.indexOf(')', next + 1);
+
+            if (next === -1) {
+              if (ignore || ignoreUnclosed) {
+                next = pos;
+                break;
+              } else {
+                unclosed('bracket');
+              }
+            }
+
+            escapePos = next;
+
+            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+              escapePos -= 1;
+              escaped = !escaped;
+            }
+          } while (escaped);
+
+          currentToken = ['brackets', css.slice(pos, next + 1), line, pos - offset, line, next - offset];
+          pos = next;
+        } else {
+          next = css.indexOf(')', pos + 1);
+          content = css.slice(pos, next + 1);
+
+          if (next === -1 || RE_BAD_BRACKET.test(content)) {
+            currentToken = ['(', '(', line, pos - offset];
+          } else {
+            currentToken = ['brackets', content, line, pos - offset, line, next - offset];
+            pos = next;
+          }
+        }
+
+        break;
+
+      case SINGLE_QUOTE:
+      case DOUBLE_QUOTE:
+        quote = code === SINGLE_QUOTE ? '\'' : '"';
+        next = pos;
+
+        do {
+          escaped = false;
+          next = css.indexOf(quote, next + 1);
+
+          if (next === -1) {
+            if (ignore || ignoreUnclosed) {
+              next = pos + 1;
+              break;
+            } else {
+              unclosed('string');
+            }
+          }
+
+          escapePos = next;
+
+          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+            escapePos -= 1;
+            escaped = !escaped;
+          }
+        } while (escaped);
+
+        content = css.slice(pos, next + 1);
+        lines = content.split('\n');
+        last = lines.length - 1;
+
+        if (last > 0) {
+          nextLine = line + last;
+          nextOffset = next - lines[last].length;
+        } else {
+          nextLine = line;
+          nextOffset = offset;
+        }
+
+        currentToken = ['string', css.slice(pos, next + 1), line, pos - offset, nextLine, next - nextOffset];
+        offset = nextOffset;
+        line = nextLine;
+        pos = next;
+        break;
+
+      case AT:
+        RE_AT_END.lastIndex = pos + 1;
+        RE_AT_END.test(css);
+
+        if (RE_AT_END.lastIndex === 0) {
+          next = css.length - 1;
+        } else {
+          next = RE_AT_END.lastIndex - 2;
+        }
+
+        currentToken = ['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];
+        pos = next;
+        break;
+
+      case BACKSLASH:
+        next = pos;
+        escape = true;
+
+        while (css.charCodeAt(next + 1) === BACKSLASH) {
+          next += 1;
+          escape = !escape;
+        }
+
+        code = css.charCodeAt(next + 1);
+
+        if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
+          next += 1;
+
+          if (RE_HEX_ESCAPE.test(css.charAt(next))) {
+            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
+              next += 1;
+            }
+
+            if (css.charCodeAt(next + 1) === SPACE) {
+              next += 1;
+            }
+          }
+        }
+
+        currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];
+        pos = next;
+        break;
+
+      default:
+        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
+          next = css.indexOf('*/', pos + 2) + 1;
+
+          if (next === 0) {
+            if (ignore || ignoreUnclosed) {
+              next = css.length;
+            } else {
+              unclosed('comment');
+            }
+          }
+
+          content = css.slice(pos, next + 1);
+          lines = content.split('\n');
+          last = lines.length - 1;
+
+          if (last > 0) {
+            nextLine = line + last;
+            nextOffset = next - lines[last].length;
+          } else {
+            nextLine = line;
+            nextOffset = offset;
+          }
+
+          currentToken = ['comment', content, line, pos - offset, nextLine, next - nextOffset];
+          offset = nextOffset;
+          line = nextLine;
+          pos = next;
+        } else {
+          RE_WORD_END.lastIndex = pos + 1;
+          RE_WORD_END.test(css);
+
+          if (RE_WORD_END.lastIndex === 0) {
+            next = css.length - 1;
+          } else {
+            next = RE_WORD_END.lastIndex - 2;
+          }
+
+          currentToken = ['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset];
+          buffer.push(currentToken);
+          pos = next;
+        }
+
+        break;
+    }
+
+    pos++;
+    return currentToken;
+  }
+
+  function back(token) {
+    returned.push(token);
+  }
+
+  return {
+    back: back,
+    nextToken: nextToken,
+    endOfFile: endOfFile,
+    position: position
+  };
+}
+
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["tokenize.es6"],"names":["SINGLE_QUOTE","charCodeAt","DOUBLE_QUOTE","BACKSLASH","SLASH","NEWLINE","SPACE","FEED","TAB","CR","OPEN_SQUARE","CLOSE_SQUARE","OPEN_PARENTHESES","CLOSE_PARENTHESES","OPEN_CURLY","CLOSE_CURLY","SEMICOLON","ASTERISK","COLON","AT","RE_AT_END","RE_WORD_END","RE_BAD_BRACKET","RE_HEX_ESCAPE","tokenizer","input","options","css","valueOf","ignore","ignoreErrors","code","next","quote","lines","last","content","escape","nextLine","nextOffset","escaped","escapePos","prev","n","currentToken","length","offset","line","pos","buffer","returned","position","unclosed","what","error","endOfFile","nextToken","opts","pop","ignoreUnclosed","slice","controlChar","String","fromCharCode","indexOf","test","split","lastIndex","charAt","push","back","token"],"mappings":"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","sourcesContent":["const SINGLE_QUOTE = '\\''.charCodeAt(0)\nconst DOUBLE_QUOTE = '\"'.charCodeAt(0)\nconst BACKSLASH = '\\\\'.charCodeAt(0)\nconst SLASH = '/'.charCodeAt(0)\nconst NEWLINE = '\\n'.charCodeAt(0)\nconst SPACE = ' '.charCodeAt(0)\nconst FEED = '\\f'.charCodeAt(0)\nconst TAB = '\\t'.charCodeAt(0)\nconst CR = '\\r'.charCodeAt(0)\nconst OPEN_SQUARE = '['.charCodeAt(0)\nconst CLOSE_SQUARE = ']'.charCodeAt(0)\nconst OPEN_PARENTHESES = '('.charCodeAt(0)\nconst CLOSE_PARENTHESES = ')'.charCodeAt(0)\nconst OPEN_CURLY = '{'.charCodeAt(0)\nconst CLOSE_CURLY = '}'.charCodeAt(0)\nconst SEMICOLON = ';'.charCodeAt(0)\nconst ASTERISK = '*'.charCodeAt(0)\nconst COLON = ':'.charCodeAt(0)\nconst AT = '@'.charCodeAt(0)\n\nconst RE_AT_END = /[ \\n\\t\\r\\f{}()'\"\\\\;/[\\]#]/g\nconst RE_WORD_END = /[ \\n\\t\\r\\f(){}:;@!'\"\\\\\\][#]|\\/(?=\\*)/g\nconst RE_BAD_BRACKET = /.[\\\\/(\"'\\n]/\nconst RE_HEX_ESCAPE = /[a-f0-9]/i\n\nexport default function tokenizer (input, options = {}) {\n  let css = input.css.valueOf()\n  let ignore = options.ignoreErrors\n\n  let code, next, quote, lines, last, content, escape\n  let nextLine, nextOffset, escaped, escapePos, prev, n, currentToken\n\n  let length = css.length\n  let offset = -1\n  let line = 1\n  let pos = 0\n  let buffer = []\n  let returned = []\n\n  function position () {\n    return pos\n  }\n\n  function unclosed (what) {\n    throw input.error('Unclosed ' + what, line, pos - offset)\n  }\n\n  function endOfFile () {\n    return returned.length === 0 && pos >= length\n  }\n\n  function nextToken (opts) {\n    if (returned.length) return returned.pop()\n    if (pos >= length) return\n\n    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false\n\n    code = css.charCodeAt(pos)\n    if (\n      code === NEWLINE || code === FEED ||\n      (code === CR && css.charCodeAt(pos + 1) !== NEWLINE)\n    ) {\n      offset = pos\n      line += 1\n    }\n\n    switch (code) {\n      case NEWLINE:\n      case SPACE:\n      case TAB:\n      case CR:\n      case FEED:\n        next = pos\n        do {\n          next += 1\n          code = css.charCodeAt(next)\n          if (code === NEWLINE) {\n            offset = next\n            line += 1\n          }\n        } while (\n          code === SPACE ||\n          code === NEWLINE ||\n          code === TAB ||\n          code === CR ||\n          code === FEED\n        )\n\n        currentToken = ['space', css.slice(pos, next)]\n        pos = next - 1\n        break\n\n      case OPEN_SQUARE:\n      case CLOSE_SQUARE:\n      case OPEN_CURLY:\n      case CLOSE_CURLY:\n      case COLON:\n      case SEMICOLON:\n      case CLOSE_PARENTHESES:\n        let controlChar = String.fromCharCode(code)\n        currentToken = [controlChar, controlChar, line, pos - offset]\n        break\n\n      case OPEN_PARENTHESES:\n        prev = buffer.length ? buffer.pop()[1] : ''\n        n = css.charCodeAt(pos + 1)\n        if (\n          prev === 'url' &&\n          n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE &&\n          n !== SPACE && n !== NEWLINE && n !== TAB &&\n          n !== FEED && n !== CR\n        ) {\n          next = pos\n          do {\n            escaped = false\n            next = css.indexOf(')', next + 1)\n            if (next === -1) {\n              if (ignore || ignoreUnclosed) {\n                next = pos\n                break\n              } else {\n                unclosed('bracket')\n              }\n            }\n            escapePos = next\n            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n              escapePos -= 1\n              escaped = !escaped\n            }\n          } while (escaped)\n\n          currentToken = ['brackets', css.slice(pos, next + 1),\n            line, pos - offset,\n            line, next - offset\n          ]\n\n          pos = next\n        } else {\n          next = css.indexOf(')', pos + 1)\n          content = css.slice(pos, next + 1)\n\n          if (next === -1 || RE_BAD_BRACKET.test(content)) {\n            currentToken = ['(', '(', line, pos - offset]\n          } else {\n            currentToken = ['brackets', content,\n              line, pos - offset,\n              line, next - offset\n            ]\n            pos = next\n          }\n        }\n\n        break\n\n      case SINGLE_QUOTE:\n      case DOUBLE_QUOTE:\n        quote = code === SINGLE_QUOTE ? '\\'' : '\"'\n        next = pos\n        do {\n          escaped = false\n          next = css.indexOf(quote, next + 1)\n          if (next === -1) {\n            if (ignore || ignoreUnclosed) {\n              next = pos + 1\n              break\n            } else {\n              unclosed('string')\n            }\n          }\n          escapePos = next\n          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n            escapePos -= 1\n            escaped = !escaped\n          }\n        } while (escaped)\n\n        content = css.slice(pos, next + 1)\n        lines = content.split('\\n')\n        last = lines.length - 1\n\n        if (last > 0) {\n          nextLine = line + last\n          nextOffset = next - lines[last].length\n        } else {\n          nextLine = line\n          nextOffset = offset\n        }\n\n        currentToken = ['string', css.slice(pos, next + 1),\n          line, pos - offset,\n          nextLine, next - nextOffset\n        ]\n\n        offset = nextOffset\n        line = nextLine\n        pos = next\n        break\n\n      case AT:\n        RE_AT_END.lastIndex = pos + 1\n        RE_AT_END.test(css)\n        if (RE_AT_END.lastIndex === 0) {\n          next = css.length - 1\n        } else {\n          next = RE_AT_END.lastIndex - 2\n        }\n\n        currentToken = ['at-word', css.slice(pos, next + 1),\n          line, pos - offset,\n          line, next - offset\n        ]\n\n        pos = next\n        break\n\n      case BACKSLASH:\n        next = pos\n        escape = true\n        while (css.charCodeAt(next + 1) === BACKSLASH) {\n          next += 1\n          escape = !escape\n        }\n        code = css.charCodeAt(next + 1)\n        if (\n          escape &&\n          code !== SLASH &&\n          code !== SPACE &&\n          code !== NEWLINE &&\n          code !== TAB &&\n          code !== CR &&\n          code !== FEED\n        ) {\n          next += 1\n          if (RE_HEX_ESCAPE.test(css.charAt(next))) {\n            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {\n              next += 1\n            }\n            if (css.charCodeAt(next + 1) === SPACE) {\n              next += 1\n            }\n          }\n        }\n\n        currentToken = ['word', css.slice(pos, next + 1),\n          line, pos - offset,\n          line, next - offset\n        ]\n\n        pos = next\n        break\n\n      default:\n        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {\n          next = css.indexOf('*/', pos + 2) + 1\n          if (next === 0) {\n            if (ignore || ignoreUnclosed) {\n              next = css.length\n            } else {\n              unclosed('comment')\n            }\n          }\n\n          content = css.slice(pos, next + 1)\n          lines = content.split('\\n')\n          last = lines.length - 1\n\n          if (last > 0) {\n            nextLine = line + last\n            nextOffset = next - lines[last].length\n          } else {\n            nextLine = line\n            nextOffset = offset\n          }\n\n          currentToken = ['comment', content,\n            line, pos - offset,\n            nextLine, next - nextOffset\n          ]\n\n          offset = nextOffset\n          line = nextLine\n          pos = next\n        } else {\n          RE_WORD_END.lastIndex = pos + 1\n          RE_WORD_END.test(css)\n          if (RE_WORD_END.lastIndex === 0) {\n            next = css.length - 1\n          } else {\n            next = RE_WORD_END.lastIndex - 2\n          }\n\n          currentToken = ['word', css.slice(pos, next + 1),\n            line, pos - offset,\n            line, next - offset\n          ]\n\n          buffer.push(currentToken)\n\n          pos = next\n        }\n\n        break\n    }\n\n    pos++\n    return currentToken\n  }\n\n  function back (token) {\n    returned.push(token)\n  }\n\n  return {\n    back,\n    nextToken,\n    endOfFile,\n    position\n  }\n}\n"],"file":"tokenize.js"}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/vendor.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/vendor.js
new file mode 100644
index 00000000..8abdeed4
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/vendor.js
@@ -0,0 +1,53 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Contains helpers for working with vendor prefixes.
+ *
+ * @example
+ * const vendor = postcss.vendor
+ *
+ * @namespace vendor
+ */
+var vendor = {
+  /**
+   * Returns the vendor prefix extracted from an input string.
+   *
+   * @param {string} prop String with or without vendor prefix.
+   *
+   * @return {string} vendor prefix or empty string
+   *
+   * @example
+   * postcss.vendor.prefix('-moz-tab-size') //=> '-moz-'
+   * postcss.vendor.prefix('tab-size')      //=> ''
+   */
+  prefix: function prefix(prop) {
+    var match = prop.match(/^(-\w+-)/);
+
+    if (match) {
+      return match[0];
+    }
+
+    return '';
+  },
+
+  /**
+     * Returns the input string stripped of its vendor prefix.
+     *
+     * @param {string} prop String with or without vendor prefix.
+     *
+     * @return {string} String name without vendor prefixes.
+     *
+     * @example
+     * postcss.vendor.unprefixed('-moz-tab-size') //=> 'tab-size'
+     */
+  unprefixed: function unprefixed(prop) {
+    return prop.replace(/^-\w+-/, '');
+  }
+};
+var _default = vendor;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/warn-once.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/warn-once.js
new file mode 100644
index 00000000..f04c7f21
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/warn-once.js
@@ -0,0 +1,17 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = warnOnce;
+var printed = {};
+
+function warnOnce(message) {
+  if (printed[message]) return;
+  printed[message] = true;
+
+  if (typeof console !== 'undefined' && console.warn) {
+    console.warn(message);
+  }
+}
+
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndhcm4tb25jZS5lczYiXSwibmFtZXMiOlsicHJpbnRlZCIsIndhcm5PbmNlIiwibWVzc2FnZSIsImNvbnNvbGUiLCJ3YXJuIl0sIm1hcHBpbmdzIjoiOzs7O0FBQUEsSUFBSUEsT0FBTyxHQUFHLEVBQWQ7O0FBRWUsU0FBU0MsUUFBVCxDQUFtQkMsT0FBbkIsRUFBNEI7QUFDekMsTUFBSUYsT0FBTyxDQUFDRSxPQUFELENBQVgsRUFBc0I7QUFDdEJGLEVBQUFBLE9BQU8sQ0FBQ0UsT0FBRCxDQUFQLEdBQW1CLElBQW5COztBQUVBLE1BQUksT0FBT0MsT0FBUCxLQUFtQixXQUFuQixJQUFrQ0EsT0FBTyxDQUFDQyxJQUE5QyxFQUFvRDtBQUNsREQsSUFBQUEsT0FBTyxDQUFDQyxJQUFSLENBQWFGLE9BQWI7QUFDRDtBQUNGIiwic291cmNlc0NvbnRlbnQiOlsibGV0IHByaW50ZWQgPSB7IH1cblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gd2Fybk9uY2UgKG1lc3NhZ2UpIHtcbiAgaWYgKHByaW50ZWRbbWVzc2FnZV0pIHJldHVyblxuICBwcmludGVkW21lc3NhZ2VdID0gdHJ1ZVxuXG4gIGlmICh0eXBlb2YgY29uc29sZSAhPT0gJ3VuZGVmaW5lZCcgJiYgY29uc29sZS53YXJuKSB7XG4gICAgY29uc29sZS53YXJuKG1lc3NhZ2UpXG4gIH1cbn1cbiJdLCJmaWxlIjoid2Fybi1vbmNlLmpzIn0=
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/warning.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/warning.js
new file mode 100644
index 00000000..ca385c91
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/lib/warning.js
@@ -0,0 +1,131 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Represents a plugin’s warning. It can be created using {@link Node#warn}.
+ *
+ * @example
+ * if (decl.important) {
+ *   decl.warn(result, 'Avoid !important', { word: '!important' })
+ * }
+ */
+var Warning = /*#__PURE__*/function () {
+  /**
+   * @param {string} text        Warning message.
+   * @param {Object} [opts]      Warning options.
+   * @param {Node}   opts.node   CSS node that caused the warning.
+   * @param {string} opts.word   Word in CSS source that caused the warning.
+   * @param {number} opts.index  Index in CSS node string that caused
+   *                             the warning.
+   * @param {string} opts.plugin Name of the plugin that created
+   *                             this warning. {@link Result#warn} fills
+   *                             this property automatically.
+   */
+  function Warning(text, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    /**
+     * Type to filter warnings from {@link Result#messages}.
+     * Always equal to `"warning"`.
+     *
+     * @type {string}
+     *
+     * @example
+     * const nonWarning = result.messages.filter(i => i.type !== 'warning')
+     */
+    this.type = 'warning';
+    /**
+     * The warning message.
+     *
+     * @type {string}
+     *
+     * @example
+     * warning.text //=> 'Try to avoid !important'
+     */
+
+    this.text = text;
+
+    if (opts.node && opts.node.source) {
+      var pos = opts.node.positionBy(opts);
+      /**
+       * Line in the input file with this warning’s source.
+       * @type {number}
+       *
+       * @example
+       * warning.line //=> 5
+       */
+
+      this.line = pos.line;
+      /**
+       * Column in the input file with this warning’s source.
+       *
+       * @type {number}
+       *
+       * @example
+       * warning.column //=> 6
+       */
+
+      this.column = pos.column;
+    }
+
+    for (var opt in opts) {
+      this[opt] = opts[opt];
+    }
+  }
+  /**
+   * Returns a warning position and message.
+   *
+   * @example
+   * warning.toString() //=> 'postcss-lint:a.css:10:14: Avoid !important'
+   *
+   * @return {string} Warning position and message.
+   */
+
+
+  var _proto = Warning.prototype;
+
+  _proto.toString = function toString() {
+    if (this.node) {
+      return this.node.error(this.text, {
+        plugin: this.plugin,
+        index: this.index,
+        word: this.word
+      }).message;
+    }
+
+    if (this.plugin) {
+      return this.plugin + ': ' + this.text;
+    }
+
+    return this.text;
+  }
+  /**
+   * @memberof Warning#
+   * @member {string} plugin The name of the plugin that created
+   *                         it will fill this property automatically.
+   *                         this warning. When you call {@link Node#warn}
+   *
+   * @example
+   * warning.plugin //=> 'postcss-important'
+   */
+
+  /**
+   * @memberof Warning#
+   * @member {Node} node Contains the CSS node that caused the warning.
+   *
+   * @example
+   * warning.node.toString() //=> 'color: white !important'
+   */
+  ;
+
+  return Warning;
+}();
+
+var _default = Warning;
+exports.default = _default;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/package.json b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/package.json
new file mode 100644
index 00000000..f2897ca4
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/postcss/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "postcss",
+  "version": "7.0.39",
+  "description": "Tool for transforming styles with JS plugins",
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "keywords": [
+    "css",
+    "postcss",
+    "rework",
+    "preprocessor",
+    "parser",
+    "source map",
+    "transform",
+    "manipulation",
+    "transpiler"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/postcss/"
+  },
+  "author": "Andrey Sitnik <andrey@sitnik.ru>",
+  "license": "MIT",
+  "homepage": "https://postcss.org/",
+  "repository": "postcss/postcss",
+  "dependencies": {
+    "picocolors": "^0.2.1",
+    "source-map": "^0.6.1"
+  },
+  "main": "lib/postcss",
+  "types": "lib/postcss.d.ts",
+  "browser": {
+    "./lib/terminal-highlight": false,
+    "fs": false
+  }
+}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/CHANGELOG.md b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/CHANGELOG.md
new file mode 100755
index 00000000..0a42c1bb
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/CHANGELOG.md
@@ -0,0 +1,167 @@
+# Changelog of `reduce-css-call`
+
+## 2.1.8 - 2020-01-08
+
+- Fix Parse error on custom property fallback ([#68](https://github.com/MoOx/reduce-css-calc/pull/68)) - @snowystinger)
+
+## 2.1.7 - 2019-10-22
+
+- Switch to a maintained jison fork ([#57](https://github.com/MoOx/reduce-css-calc/pull/57)) - @davidgovea)
+
+## 2.1.6 - 2019-01-11
+
+- Fixed: Incorrect calculation when subtracting (e.g. `calc(100% - calc(120px + 1em + 2em + 100px))`) ([#52](https://github.com/MoOx/reduce-css-calc/pull/53) - @sylvainpolletvillard)
+
+## 2.1.5 - 2018-09-20
+
+- [Avoid breaking when seeing ` constant()`` or `env()`](https://github.com/MoOx/reduce-css-calc/commit/409c9ba2cd5e06e7f8f679f7f0c3c3a14ff3e673) by @dlee
+
+## 2.1.4 - 2018-01-22
+
+- Prevent webpack parsing issue
+  (see https://github.com/zaach/jison/pull/352)
+
+## 2.1.3 - 2017-11-27
+
+- Fixed: Incorrect reduction for a specific case (e.g. `calc(1em + (1em - 5px))`) ([#43](https://github.com/MoOx/reduce-css-calc/pull/43) - @Justineo)
+
+## 2.1.2 - 2017-11-26
+
+- Fixed: Incorrect reduction of division with custom property (e.g. `calc(var(--foo) / 2)`) ([#41](https://github.com/MoOx/reduce-css-calc/issues/41) - @Semigradsky)
+
+## 2.1.1 - 2017-10-12
+
+- Fixed: Incorrect reduction of nested expression (e.g. `calc( (1em - calc( 10px + 1em)) / 2)`) ([#39](https://github.com/MoOx/reduce-css-calc/pull/39) - @gyoshev)
+
+## 2.1.0 - 2017-10-10
+
+- Added: Support for working in browsers without transpiling ([#36](https://github.com/MoOx/reduce-css-calc/pull/36) - @Semigradsky)
+- Fixed: `calc(100vw - (100vw - 100%))` does not evaluate to `100%` ([#35](https://github.com/MoOx/reduce-css-calc/pull/35) - @Semigradsky)
+
+## 2.0.5 - 2017-05-12
+
+- Fixed: Support division with a CSS variable.
+
+## 2.0.4 - 2017-05-09
+
+- Fixed: CSS variable regex was overly greedy and caused a crash in some
+  cases. ([#27](https://github.com/MoOx/reduce-css-calc/pull/27) - @andyjansson)
+
+## 2.0.3 - 2017-05-09
+
+- Fixed: Regression in handling decimals without having any numbers after
+  the decimal place (e.g. `10.px`).
+
+## 2.0.2 - 2017-05-08
+
+- Fixed: Regression in consecutive subtraction handling
+  ([#25](https://github.com/MoOx/reduce-css-calc/pull/25) - @andyjansson)
+
+## 2.0.1 - 2017-05-08
+
+- Fixed: Support for nested calc e.g. `calc(100% - calc(50px - 25px))`.
+- Fixed: Support for CSS variables e.g. `calc(var(--mouseX) * 1px)`.
+
+## 2.0.0 - 2017-05-08
+
+- Rewritten with a jison parser for more accurate value parsing.
+- Breaking: reduce-css-calc will now throw when trying to multiply or divide
+  by the same unit (e.g. `calc(200px * 20px)`), and also when trying to divide
+  by zero.
+- Added: Better handling of zero values (e.g. `calc(100vw / 2 - 6px + 0px)`
+  becomes `calc(100vw / 2 - 6px)`).
+- Added: Better handling of mixed time values (e.g. `calc(1s - 50ms)`
+  becomes `0.95s`).
+- Added: Inner parentheses calculation to simplify complex expressions (e.g.
+  `calc(14px + 6 * ((100vw - 320px) / 448))` becomes `calc(9.71px + 1.34vw)`
+  with precision set to `2`).
+- Fixed: `calc(1px + 1)` does not evaluate to `2px`.
+
+([#22](https://github.com/MoOx/reduce-css-calc/pull/22) - @andyjansson)
+
+## 1.3.0 - 2016-08-26
+
+- Added: calc identifier from unresolved nested expressions are removed for
+  better browser support
+  ([#19](https://github.com/MoOx/reduce-css-calc/pull/19) - @ben-eb)
+
+## 1.2.8 - 2016-08-26
+
+- Fixed: regression from 1.2.5 on calc() with value without leading 0
+  ([#17](https://github.com/MoOx/reduce-css-calc/pull/17) - @ben-eb)
+
+## 1.2.7 - 2016-08-22
+
+- Fixed: regression from 1.2.5 on calc() with value without leading 0
+  (@MoOx)
+
+## 1.2.6 - 2016-08-22
+
+- Fixed: regression from 1.2.5 on calc() on multiple lines
+  (@MoOx)
+
+## 1.2.5 - 2016-08-22
+
+- Fixed: security issue due to the usage of `eval()`.
+  This is to avoid an arbitrary code execution.
+  Now operations are resolved using
+  [`math-expression-evaluator`](https://github.com/redhivesoftware/math-expression-evaluator)
+
+## 1.2.4 - 2016-06-09
+
+- Fixed: zero values are not unitless anymore.
+  Browsers do not calculate calc() with 0 unitless values.
+  http://jsbin.com/punivivipo/edit?html,css,output
+  ([#11](https://github.com/MoOx/reduce-css-calc/pull/11))
+
+## 1.2.3 - 2016-04-28
+
+- Fixed: wrong rouding in some edge cases
+  ([#10](https://github.com/MoOx/reduce-css-calc/pull/10))
+
+## 1.2.2 - 2016-04-19
+
+- Fixed: Don't reduce expression containing CSS variables.
+  ([#9](https://github.com/MoOx/reduce-css-calc/pull/9))
+
+## 1.2.1 - 2016-02-22
+
+- Fixed: uppercase letters in units are now supported
+  ([#8](https://github.com/MoOx/reduce-css-calc/pull/8))
+
+## 1.2.0 - 2014-11-24
+
+- Decimal precision is now customisable as the `precision` option
+
+## 1.1.4 - 2014-11-12
+
+- 5 decimals rounding for everything
+
+## 1.1.3 - 2014-08-13
+
+- 5 decimals rounding for percentage
+
+## 1.1.2 - 2014-08-10
+
+- Prevent infinite loop by adding a `Call stack overflow`
+- Correctly ignore unrecognized values (safer evaluation for nested expressions,
+  see [postcss/postcss-calc#2](https://github.com/postcss/postcss-calc/issues/2))
+- Handle rounding issues (eg: 10% \* 20% now give 2%, not 2.0000000000000004%)
+
+## 1.1.1 - 2014-08-06
+
+- Fix issue when using mutiples differents prefixes in the same function
+
+## 1.1.0 - 2014-08-06
+
+- support more complex formulas
+- use `reduce-function-call`
+- better error message
+
+## 1.0.0 - 2014-08-04
+
+First release
+
+- based on [rework-calc](https://github.com/reworkcss/rework-calc) v1.1.0
+- add error if the calc() embed an empty calc() or empty ()
+- jscs + jshint added before tests
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/LICENSE b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/LICENSE
new file mode 100755
index 00000000..7cc9dd08
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Maxime Thirouin & Joakim Bengtson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/README.md b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/README.md
new file mode 100755
index 00000000..bc9e59fb
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/README.md
@@ -0,0 +1,76 @@
+# reduce-css-calc
+
+[![Build Status](https://travis-ci.org/MoOx/reduce-css-calc.svg)](https://travis-ci.org/MoOx/reduce-css-calc)
+
+> Reduce CSS calc() function to the maximum.
+
+Particularly useful for packages like [rework-calc](https://github.com/reworkcss/rework-calc) or [postcss-calc](https://github.com/postcss/postcss-calc).
+
+## Installation
+
+```console
+npm install reduce-css-calc
+```
+
+## Usage
+
+### `var reducedString = reduceCSSCalc(string, precision)`
+
+```javascript
+var reduceCSSCalc = require('reduce-css-calc')
+
+reduceCSSCalc("calc(1 + 1)")
+// 2
+
+reduceCSSCalc("calc((6 / 2) - (4 * 2) + 1)")
+// -4
+
+reduceCSSCalc("calc(1/3)")
+// 0.33333
+
+reduceCSSCalc("calc(1/3)", 10)
+// 0.3333333333
+
+reduceCSSCalc("calc(3rem * 2 - 1rem)")
+// 5rem
+
+reduceCSSCalc("calc(2 * 50%)")
+// 100%
+
+reduceCSSCalc("calc(120% * 50%)")
+// 60%
+
+reduceCSSCalc("a calc(1 + 1) b calc(1 - 1) c")
+// a 2 b 0 c
+
+reduceCSSCalc("calc(calc(calc(1rem * 0.75) * 1.5) - 1rem)")
+// 0.125rem
+
+reduceCSSCalc("calc(calc(calc(1rem * 0.75) * 1.5) - 1px)")
+// calc(1.125rem - 1px)
+
+reduceCSSCalc("-moz-calc(100px / 2)")
+// 50px
+
+reduceCSSCalc("-moz-calc(50% - 2em)")
+// -moz-calc(50% - 2em)
+```
+
+See [unit tests](src/__tests__/index.js) for others examples.
+
+---
+
+## Contributing
+
+Work on a branch, install dev-dependencies, respect coding style & run tests before submitting a bug fix or a feature.
+
+```console
+git clone https://github.com/MoOx/reduce-css-calc.git
+git checkout -b patch-1
+npm install
+npm test
+```
+
+## [Changelog](CHANGELOG.md)
+
+## [License](LICENSE-MIT)
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/index.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/index.js
new file mode 100644
index 00000000..0a69bf38
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/index.js
@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _postcssValueParser = require('postcss-value-parser');
+
+var _postcssValueParser2 = _interopRequireDefault(_postcssValueParser);
+
+var _parser = require('./parser');
+
+var _reducer = require('./lib/reducer');
+
+var _reducer2 = _interopRequireDefault(_reducer);
+
+var _stringifier = require('./lib/stringifier');
+
+var _stringifier2 = _interopRequireDefault(_stringifier);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// eslint-disable-line
+var MATCH_CALC = /((?:\-[a-z]+\-)?calc)/;
+
+exports.default = function (value) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
+
+  return (0, _postcssValueParser2.default)(value).walk(function (node) {
+    // skip anything which isn't a calc() function
+    if (node.type !== 'function' || !MATCH_CALC.test(node.value)) return;
+
+    // stringify calc expression and produce an AST
+    var contents = _postcssValueParser2.default.stringify(node.nodes);
+
+    // skip constant() and env()
+    if (contents.indexOf('constant') >= 0 || contents.indexOf('env') >= 0) return;
+
+    var ast = _parser.parser.parse(contents);
+
+    // reduce AST to its simplest form, that is, either to a single value
+    // or a simplified calc expression
+    var reducedAst = (0, _reducer2.default)(ast, precision);
+
+    // stringify AST and write it back
+    node.type = 'word';
+    node.value = (0, _stringifier2.default)(node.value, reducedAst, precision);
+  }, true).toString();
+};
+
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/convert.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/convert.js
new file mode 100644
index 00000000..3e5815ff
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/convert.js
@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _cssUnitConverter = require('css-unit-converter');
+
+var _cssUnitConverter2 = _interopRequireDefault(_cssUnitConverter);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function convertNodes(left, right, precision) {
+  switch (left.type) {
+    case 'LengthValue':
+    case 'AngleValue':
+    case 'TimeValue':
+    case 'FrequencyValue':
+    case 'ResolutionValue':
+      return convertAbsoluteLength(left, right, precision);
+    default:
+      return { left: left, right: right };
+  }
+}
+
+function convertAbsoluteLength(left, right, precision) {
+  if (right.type === left.type) {
+    right = {
+      type: left.type,
+      value: (0, _cssUnitConverter2.default)(right.value, right.unit, left.unit, precision),
+      unit: left.unit
+    };
+  }
+  return { left: left, right: right };
+}
+
+exports.default = convertNodes;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/reducer.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/reducer.js
new file mode 100644
index 00000000..a3d6cce9
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/reducer.js
@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flip = flip;
+
+var _convert = require("./convert");
+
+var _convert2 = _interopRequireDefault(_convert);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function reduce(node, precision) {
+  if (node.type === "MathExpression") return reduceMathExpression(node, precision);
+  if (node.type === "Calc") return reduce(node.value, precision);
+
+  return node;
+}
+
+function isEqual(left, right) {
+  return left.type === right.type && left.value === right.value;
+}
+
+function isValueType(type) {
+  switch (type) {
+    case 'LengthValue':
+    case 'AngleValue':
+    case 'TimeValue':
+    case 'FrequencyValue':
+    case 'ResolutionValue':
+    case 'EmValue':
+    case 'ExValue':
+    case 'ChValue':
+    case 'RemValue':
+    case 'VhValue':
+    case 'VwValue':
+    case 'VminValue':
+    case 'VmaxValue':
+    case 'PercentageValue':
+    case 'Value':
+      return true;
+  }
+  return false;
+}
+
+function convertMathExpression(node, precision) {
+  var nodes = (0, _convert2.default)(node.left, node.right, precision);
+  var left = reduce(nodes.left, precision);
+  var right = reduce(nodes.right, precision);
+
+  if (left.type === "MathExpression" && right.type === "MathExpression") {
+
+    if (left.operator === '/' && right.operator === '*' || left.operator === '-' && right.operator === '+' || left.operator === '*' && right.operator === '/' || left.operator === '+' && right.operator === '-') {
+
+      if (isEqual(left.right, right.right)) nodes = (0, _convert2.default)(left.left, right.left, precision);else if (isEqual(left.right, right.left)) nodes = (0, _convert2.default)(left.left, right.right, precision);
+
+      left = reduce(nodes.left, precision);
+      right = reduce(nodes.right, precision);
+    }
+  }
+
+  node.left = left;
+  node.right = right;
+  return node;
+}
+
+function flip(operator) {
+  return operator === '+' ? '-' : '+';
+}
+
+function flipValue(node) {
+  if (isValueType(node.type)) node.value = -node.value;else if (node.type == 'MathExpression') {
+    node.left = flipValue(node.left);
+    node.right = flipValue(node.right);
+  }
+  return node;
+}
+
+function reduceAddSubExpression(node, precision) {
+  var _node = node,
+      left = _node.left,
+      right = _node.right,
+      op = _node.operator;
+
+
+  if (left.type === 'CssVariable' || right.type === 'CssVariable') return node;
+
+  // something + 0 => something
+  // something - 0 => something
+  if (right.value === 0) return left;
+
+  // 0 + something => something
+  if (left.value === 0 && op === "+") return right;
+
+  // 0 - something => -something
+  if (left.value === 0 && op === "-") return flipValue(right);
+
+  // value + value
+  // value - value
+  if (left.type === right.type && isValueType(left.type)) {
+    node = Object.assign({}, left);
+    if (op === "+") node.value = left.value + right.value;else node.value = left.value - right.value;
+  }
+
+  // value <op> (expr)
+  if (isValueType(left.type) && (right.operator === '+' || right.operator === '-') && right.type === 'MathExpression') {
+    // value + (value + something) => (value + value) + something
+    // value + (value - something) => (value + value) - something
+    // value - (value + something) => (value - value) - something
+    // value - (value - something) => (value - value) + something
+    if (left.type === right.left.type) {
+      node = Object.assign({}, node);
+      node.left = reduce({
+        type: 'MathExpression',
+        operator: op,
+        left: left,
+        right: right.left
+      }, precision);
+      node.right = right.right;
+      node.operator = op === '-' ? flip(right.operator) : right.operator;
+      return reduce(node, precision);
+    }
+    // value + (something + value) => (value + value) + something
+    // value + (something - value) => (value - value) + something
+    // value - (something + value) => (value - value) - something
+    // value - (something - value) => (value + value) - something
+    else if (left.type === right.right.type) {
+        node = Object.assign({}, node);
+        node.left = reduce({
+          type: 'MathExpression',
+          operator: op === '-' ? flip(right.operator) : right.operator,
+          left: left,
+          right: right.right
+        }, precision);
+        node.right = right.left;
+        return reduce(node, precision);
+      }
+  }
+
+  // (expr) <op> value
+  if (left.type === 'MathExpression' && (left.operator === '+' || left.operator === '-') && isValueType(right.type)) {
+    // (value + something) + value => (value + value) + something
+    // (value - something) + value => (value + value) - something
+    // (value + something) - value => (value - value) + something
+    // (value - something) - value => (value - value) - something
+    if (right.type === left.left.type) {
+      node = Object.assign({}, left);
+      node.left = reduce({
+        type: 'MathExpression',
+        operator: op,
+        left: left.left,
+        right: right
+      }, precision);
+      return reduce(node, precision);
+    }
+    // (something + value) + value => something + (value + value)
+    // (something - value1) + value2 => something - (value2 - value1)
+    // (something + value) - value => something + (value - value)
+    // (something - value) - value => something - (value + value)
+    else if (right.type === left.right.type) {
+        node = Object.assign({}, left);
+        if (left.operator === '-') {
+          node.right = reduce({
+            type: 'MathExpression',
+            operator: op === '-' ? '+' : '-',
+            left: right,
+            right: left.right
+          }, precision);
+          node.operator = op === '-' ? '-' : '+';
+        } else {
+          node.right = reduce({
+            type: 'MathExpression',
+            operator: op,
+            left: left.right,
+            right: right
+          }, precision);
+        }
+        if (node.right.value < 0) {
+          node.right.value *= -1;
+          node.operator = node.operator === '-' ? '+' : '-';
+        }
+        return reduce(node, precision);
+      }
+  }
+  return node;
+}
+
+function reduceDivisionExpression(node, precision) {
+  if (!isValueType(node.right.type)) return node;
+
+  if (node.right.type !== 'Value') throw new Error("Cannot divide by \"" + node.right.unit + "\", number expected");
+
+  if (node.right.value === 0) throw new Error('Cannot divide by zero');
+
+  // (expr) / value
+  if (node.left.type === 'MathExpression') {
+    if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {
+      node.left.left.value /= node.right.value;
+      node.left.right.value /= node.right.value;
+      return reduce(node.left, precision);
+    }
+    return node;
+  }
+  // something / value
+  else if (isValueType(node.left.type)) {
+      node.left.value /= node.right.value;
+      return node.left;
+    }
+  return node;
+}
+
+function reduceMultiplicationExpression(node) {
+  // (expr) * value
+  if (node.left.type === 'MathExpression' && node.right.type === 'Value') {
+    if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {
+      node.left.left.value *= node.right.value;
+      node.left.right.value *= node.right.value;
+      return node.left;
+    }
+  }
+  // something * value
+  else if (isValueType(node.left.type) && node.right.type === 'Value') {
+      node.left.value *= node.right.value;
+      return node.left;
+    }
+    // value * (expr)
+    else if (node.left.type === 'Value' && node.right.type === 'MathExpression') {
+        if (isValueType(node.right.left.type) && isValueType(node.right.right.type)) {
+          node.right.left.value *= node.left.value;
+          node.right.right.value *= node.left.value;
+          return node.right;
+        }
+      }
+      // value * something
+      else if (node.left.type === 'Value' && isValueType(node.right.type)) {
+          node.right.value *= node.left.value;
+          return node.right;
+        }
+  return node;
+}
+
+function reduceMathExpression(node, precision) {
+  node = convertMathExpression(node, precision);
+
+  switch (node.operator) {
+    case "+":
+    case "-":
+      return reduceAddSubExpression(node, precision);
+    case "/":
+      return reduceDivisionExpression(node, precision);
+    case "*":
+      return reduceMultiplicationExpression(node);
+  }
+  return node;
+}
+
+exports.default = reduce;
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/stringifier.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/stringifier.js
new file mode 100644
index 00000000..92e76326
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/lib/stringifier.js
@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (calc, node, precision) {
+  var str = stringify(node, precision);
+
+  if (node.type === "MathExpression") {
+    // if calc expression couldn't be resolved to a single value, re-wrap it as
+    // a calc()
+    str = calc + "(" + str + ")";
+  }
+  return str;
+};
+
+var _reducer = require("./reducer");
+
+var order = {
+  "*": 0,
+  "/": 0,
+  "+": 1,
+  "-": 1
+};
+
+function round(value, prec) {
+  if (prec !== false) {
+    var precision = Math.pow(10, prec);
+    return Math.round(value * precision) / precision;
+  }
+  return value;
+}
+
+function stringify(node, prec) {
+  switch (node.type) {
+    case "MathExpression":
+      {
+        var left = node.left,
+            right = node.right,
+            op = node.operator;
+
+        var str = "";
+
+        if (left.type === 'MathExpression' && order[op] < order[left.operator]) str += "(" + stringify(left, prec) + ")";else str += stringify(left, prec);
+
+        str += " " + node.operator + " ";
+
+        if (right.type === 'MathExpression' && order[op] < order[right.operator]) {
+          str += "(" + stringify(right, prec) + ")";
+        } else if (right.type === 'MathExpression' && op === "-" && ["+", "-"].includes(right.operator)) {
+          // fix #52 : a-(b+c) = a-b-c
+          right.operator = (0, _reducer.flip)(right.operator);
+          str += stringify(right, prec);
+        } else {
+          str += stringify(right, prec);
+        }
+
+        return str;
+      }
+    case "Value":
+      return round(node.value, prec);
+    case 'CssVariable':
+      if (node.fallback) {
+        return "var(" + node.value + ", " + stringify(node.fallback, prec, true) + ")";
+      }
+      return "var(" + node.value + ")";
+    case 'Calc':
+      if (node.prefix) {
+        return "-" + node.prefix + "-calc(" + stringify(node.value, prec) + ")";
+      }
+      return "calc(" + stringify(node.value, prec) + ")";
+    default:
+      return round(node.value, prec) + node.unit;
+  }
+}
+
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/parser.js b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/parser.js
new file mode 100644
index 00000000..6d6847ff
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/dist/parser.js
@@ -0,0 +1,3858 @@
+
+/* parser generated by jison 0.6.1-215 */
+
+/*
+ * Returns a Parser object of the following structure:
+ *
+ *  Parser: {
+ *    yy: {}     The so-called "shared state" or rather the *source* of it;
+ *               the real "shared state" `yy` passed around to
+ *               the rule actions, etc. is a derivative/copy of this one,
+ *               not a direct reference!
+ *  }
+ *
+ *  Parser.prototype: {
+ *    yy: {},
+ *    EOF: 1,
+ *    TERROR: 2,
+ *
+ *    trace: function(errorMessage, ...),
+ *
+ *    JisonParserError: function(msg, hash),
+ *
+ *    quoteName: function(name),
+ *               Helper function which can be overridden by user code later on: put suitable
+ *               quotes around literal IDs in a description string.
+ *
+ *    originalQuoteName: function(name),
+ *               The basic quoteName handler provided by JISON.
+ *               `cleanupAfterParse()` will clean up and reset `quoteName()` to reference this function
+ *               at the end of the `parse()`.
+ *
+ *    describeSymbol: function(symbol),
+ *               Return a more-or-less human-readable description of the given symbol, when
+ *               available, or the symbol itself, serving as its own 'description' for lack
+ *               of something better to serve up.
+ *
+ *               Return NULL when the symbol is unknown to the parser.
+ *
+ *    symbols_: {associative list: name ==> number},
+ *    terminals_: {associative list: number ==> name},
+ *    nonterminals: {associative list: rule-name ==> {associative list: number ==> rule-alt}},
+ *    terminal_descriptions_: (if there are any) {associative list: number ==> description},
+ *    productions_: [...],
+ *
+ *    performAction: function parser__performAction(yytext, yyleng, yylineno, yyloc, yystate, yysp, yyvstack, yylstack, yystack, yysstack),
+ *
+ *               The function parameters and `this` have the following value/meaning:
+ *               - `this`    : reference to the `yyval` internal object, which has members (`$` and `_$`)
+ *                             to store/reference the rule value `$$` and location info `@$`.
+ *
+ *                 One important thing to note about `this` a.k.a. `yyval`: every *reduce* action gets
+ *                 to see the same object via the `this` reference, i.e. if you wish to carry custom
+ *                 data from one reduce action through to the next within a single parse run, then you
+ *                 may get nasty and use `yyval` a.k.a. `this` for storing you own semi-permanent data.
+ *
+ *                 `this.yy` is a direct reference to the `yy` shared state object.
+ *
+ *                 `%parse-param`-specified additional `parse()` arguments have been added to this `yy`
+ *                 object at `parse()` start and are therefore available to the action code via the
+ *                 same named `yy.xxxx` attributes (where `xxxx` represents a identifier name from
+ *                 the %parse-param` list.
+ *
+ *               - `yytext`  : reference to the lexer value which belongs to the last lexer token used
+ *                             to match this rule. This is *not* the look-ahead token, but the last token
+ *                             that's actually part of this rule.
+ *
+ *                 Formulated another way, `yytext` is the value of the token immediately preceeding
+ *                 the current look-ahead token.
+ *                 Caveats apply for rules which don't require look-ahead, such as epsilon rules.
+ *
+ *               - `yyleng`  : ditto as `yytext`, only now for the lexer.yyleng value.
+ *
+ *               - `yylineno`: ditto as `yytext`, only now for the lexer.yylineno value.
+ *
+ *               - `yyloc`   : ditto as `yytext`, only now for the lexer.yylloc lexer token location info.
+ *
+ *                               WARNING: since jison 0.4.18-186 this entry may be NULL/UNDEFINED instead
+ *                               of an empty object when no suitable location info can be provided.
+ *
+ *               - `yystate` : the current parser state number, used internally for dispatching and
+ *                               executing the action code chunk matching the rule currently being reduced.
+ *
+ *               - `yysp`    : the current state stack position (a.k.a. 'stack pointer')
+ *
+ *                 This one comes in handy when you are going to do advanced things to the parser
+ *                 stacks, all of which are accessible from your action code (see the next entries below).
+ *
+ *                 Also note that you can access this and other stack index values using the new double-hash
+ *                 syntax, i.e. `##$ === ##0 === yysp`, while `##1` is the stack index for all things
+ *                 related to the first rule term, just like you have `$1`, `@1` and `#1`.
+ *                 This is made available to write very advanced grammar action rules, e.g. when you want
+ *                 to investigate the parse state stack in your action code, which would, for example,
+ *                 be relevant when you wish to implement error diagnostics and reporting schemes similar
+ *                 to the work described here:
+ *
+ *                 + Pottier, F., 2016. Reachability and error diagnosis in LR(1) automata.
+ *                   In Journées Francophones des Languages Applicatifs.
+ *
+ *                 + Jeffery, C.L., 2003. Generating LR syntax error messages from examples.
+ *                   ACM Transactions on Programming Languages and Systems (TOPLAS), 25(5), pp.631–640.
+ *
+ *               - `yyrulelength`: the current rule's term count, i.e. the number of entries occupied on the stack.
+ *
+ *                 This one comes in handy when you are going to do advanced things to the parser
+ *                 stacks, all of which are accessible from your action code (see the next entries below).
+ *
+ *               - `yyvstack`: reference to the parser value stack. Also accessed via the `$1` etc.
+ *                             constructs.
+ *
+ *               - `yylstack`: reference to the parser token location stack. Also accessed via
+ *                             the `@1` etc. constructs.
+ *
+ *                             WARNING: since jison 0.4.18-186 this array MAY contain slots which are
+ *                             UNDEFINED rather than an empty (location) object, when the lexer/parser
+ *                             action code did not provide a suitable location info object when such a
+ *                             slot was filled!
+ *
+ *               - `yystack` : reference to the parser token id stack. Also accessed via the
+ *                             `#1` etc. constructs.
+ *
+ *                 Note: this is a bit of a **white lie** as we can statically decode any `#n` reference to
+ *                 its numeric token id value, hence that code wouldn't need the `yystack` but *you* might
+ *                 want access this array for your own purposes, such as error analysis as mentioned above!
+ *
+ *                 Note that this stack stores the current stack of *tokens*, that is the sequence of
+ *                 already parsed=reduced *nonterminals* (tokens representing rules) and *terminals*
+ *                 (lexer tokens *shifted* onto the stack until the rule they belong to is found and
+ *                 *reduced*.
+ *
+ *               - `yysstack`: reference to the parser state stack. This one carries the internal parser
+ *                             *states* such as the one in `yystate`, which are used to represent
+ *                             the parser state machine in the *parse table*. *Very* *internal* stuff,
+ *                             what can I say? If you access this one, you're clearly doing wicked things
+ *
+ *               - `...`     : the extra arguments you specified in the `%parse-param` statement in your
+ *                             grammar definition file.
+ *
+ *    table: [...],
+ *               State transition table
+ *               ----------------------
+ *
+ *               index levels are:
+ *               - `state`  --> hash table
+ *               - `symbol` --> action (number or array)
+ *
+ *                 If the `action` is an array, these are the elements' meaning:
+ *                 - index [0]: 1 = shift, 2 = reduce, 3 = accept
+ *                 - index [1]: GOTO `state`
+ *
+ *                 If the `action` is a number, it is the GOTO `state`
+ *
+ *    defaultActions: {...},
+ *
+ *    parseError: function(str, hash, ExceptionClass),
+ *    yyError: function(str, ...),
+ *    yyRecovering: function(),
+ *    yyErrOk: function(),
+ *    yyClearIn: function(),
+ *
+ *    constructParseErrorInfo: function(error_message, exception_object, expected_token_set, is_recoverable),
+ *               Helper function **which will be set up during the first invocation of the `parse()` method**.
+ *               Produces a new errorInfo 'hash object' which can be passed into `parseError()`.
+ *               See it's use in this parser kernel in many places; example usage:
+ *
+ *                   var infoObj = parser.constructParseErrorInfo('fail!', null,
+ *                                     parser.collect_expected_token_set(state), true);
+ *                   var retVal = parser.parseError(infoObj.errStr, infoObj, parser.JisonParserError);
+ *
+ *    originalParseError: function(str, hash, ExceptionClass),
+ *               The basic `parseError` handler provided by JISON.
+ *               `cleanupAfterParse()` will clean up and reset `parseError()` to reference this function
+ *               at the end of the `parse()`.
+ *
+ *    options: { ... parser %options ... },
+ *
+ *    parse: function(input[, args...]),
+ *               Parse the given `input` and return the parsed value (or `true` when none was provided by
+ *               the root action, in which case the parser is acting as a *matcher*).
+ *               You MAY use the additional `args...` parameters as per `%parse-param` spec of this grammar:
+ *               these extra `args...` are added verbatim to the `yy` object reference as member variables.
+ *
+ *               WARNING:
+ *               Parser's additional `args...` parameters (via `%parse-param`) MAY conflict with
+ *               any attributes already added to `yy` by the jison run-time;
+ *               when such a collision is detected an exception is thrown to prevent the generated run-time
+ *               from silently accepting this confusing and potentially hazardous situation!
+ *
+ *               The lexer MAY add its own set of additional parameters (via the `%parse-param` line in
+ *               the lexer section of the grammar spec): these will be inserted in the `yy` shared state
+ *               object and any collision with those will be reported by the lexer via a thrown exception.
+ *
+ *    cleanupAfterParse: function(resultValue, invoke_post_methods, do_not_nuke_errorinfos),
+ *               Helper function **which will be set up during the first invocation of the `parse()` method**.
+ *               This helper API is invoked at the end of the `parse()` call, unless an exception was thrown
+ *               and `%options no-try-catch` has been defined for this grammar: in that case this helper MAY
+ *               be invoked by calling user code to ensure the `post_parse` callbacks are invoked and
+ *               the internal parser gets properly garbage collected under these particular circumstances.
+ *
+ *    yyMergeLocationInfo: function(first_index, last_index, first_yylloc, last_yylloc, dont_look_back),
+ *               Helper function **which will be set up during the first invocation of the `parse()` method**.
+ *               This helper API can be invoked to calculate a spanning `yylloc` location info object.
+ *
+ *               Note: %epsilon rules MAY specify no `first_index` and `first_yylloc`, in which case
+ *               this function will attempt to obtain a suitable location marker by inspecting the location stack
+ *               backwards.
+ *
+ *               For more info see the documentation comment further below, immediately above this function's
+ *               implementation.
+ *
+ *    lexer: {
+ *        yy: {...},           A reference to the so-called "shared state" `yy` once
+ *                             received via a call to the `.setInput(input, yy)` lexer API.
+ *        EOF: 1,
+ *        ERROR: 2,
+ *        JisonLexerError: function(msg, hash),
+ *        parseError: function(str, hash, ExceptionClass),
+ *        setInput: function(input, [yy]),
+ *        input: function(),
+ *        unput: function(str),
+ *        more: function(),
+ *        reject: function(),
+ *        less: function(n),
+ *        pastInput: function(n),
+ *        upcomingInput: function(n),
+ *        showPosition: function(),
+ *        test_match: function(regex_match_array, rule_index, ...),
+ *        next: function(...),
+ *        lex: function(...),
+ *        begin: function(condition),
+ *        pushState: function(condition),
+ *        popState: function(),
+ *        topState: function(),
+ *        _currentRules: function(),
+ *        stateStackSize: function(),
+ *        cleanupAfterLex: function()
+ *
+ *        options: { ... lexer %options ... },
+ *
+ *        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START, ...),
+ *        rules: [...],
+ *        conditions: {associative list: name ==> set},
+ *    }
+ *  }
+ *
+ *
+ *  token location info (@$, _$, etc.): {
+ *    first_line: n,
+ *    last_line: n,
+ *    first_column: n,
+ *    last_column: n,
+ *    range: [start_number, end_number]
+ *               (where the numbers are indexes into the input string, zero-based)
+ *  }
+ *
+ * ---
+ *
+ * The `parseError` function receives a 'hash' object with these members for lexer and
+ * parser errors:
+ *
+ *  {
+ *    text:        (matched text)
+ *    token:       (the produced terminal token, if any)
+ *    token_id:    (the produced terminal token numeric ID, if any)
+ *    line:        (yylineno)
+ *    loc:         (yylloc)
+ *  }
+ *
+ * parser (grammar) errors will also provide these additional members:
+ *
+ *  {
+ *    expected:    (array describing the set of expected tokens;
+ *                  may be UNDEFINED when we cannot easily produce such a set)
+ *    state:       (integer (or array when the table includes grammar collisions);
+ *                  represents the current internal state of the parser kernel.
+ *                  can, for example, be used to pass to the `collect_expected_token_set()`
+ *                  API to obtain the expected token set)
+ *    action:      (integer; represents the current internal action which will be executed)
+ *    new_state:   (integer; represents the next/planned internal state, once the current
+ *                  action has executed)
+ *    recoverable: (boolean: TRUE when the parser MAY have an error recovery rule
+ *                  available for this particular error)
+ *    state_stack: (array: the current parser LALR/LR internal state stack; this can be used,
+ *                  for instance, for advanced error analysis and reporting)
+ *    value_stack: (array: the current parser LALR/LR internal `$$` value stack; this can be used,
+ *                  for instance, for advanced error analysis and reporting)
+ *    location_stack: (array: the current parser LALR/LR internal location stack; this can be used,
+ *                  for instance, for advanced error analysis and reporting)
+ *    yy:          (object: the current parser internal "shared state" `yy`
+ *                  as is also available in the rule actions; this can be used,
+ *                  for instance, for advanced error analysis and reporting)
+ *    lexer:       (reference to the current lexer instance used by the parser)
+ *    parser:      (reference to the current parser instance)
+ *  }
+ *
+ * while `this` will reference the current parser instance.
+ *
+ * When `parseError` is invoked by the lexer, `this` will still reference the related *parser*
+ * instance, while these additional `hash` fields will also be provided:
+ *
+ *  {
+ *    lexer:       (reference to the current lexer instance which reported the error)
+ *  }
+ *
+ * When `parseError` is invoked by the parser due to a **JavaScript exception** being fired
+ * from either the parser or lexer, `this` will still reference the related *parser*
+ * instance, while these additional `hash` fields will also be provided:
+ *
+ *  {
+ *    exception:   (reference to the exception thrown)
+ *  }
+ *
+ * Please do note that in the latter situation, the `expected` field will be omitted as
+ * this type of failure is assumed not to be due to *parse errors* but rather due to user
+ * action code in either parser or lexer failing unexpectedly.
+ *
+ * ---
+ *
+ * You can specify parser options by setting / modifying the `.yy` object of your Parser instance.
+ * These options are available:
+ *
+ * ### options which are global for all parser instances
+ *
+ *  Parser.pre_parse: function(yy)
+ *                 optional: you can specify a pre_parse() function in the chunk following
+ *                 the grammar, i.e. after the last `%%`.
+ *  Parser.post_parse: function(yy, retval, parseInfo) { return retval; }
+ *                 optional: you can specify a post_parse() function in the chunk following
+ *                 the grammar, i.e. after the last `%%`. When it does not return any value,
+ *                 the parser will return the original `retval`.
+ *
+ * ### options which can be set up per parser instance
+ *
+ *  yy: {
+ *      pre_parse:  function(yy)
+ *                 optional: is invoked before the parse cycle starts (and before the first
+ *                 invocation of `lex()`) but immediately after the invocation of
+ *                 `parser.pre_parse()`).
+ *      post_parse: function(yy, retval, parseInfo) { return retval; }
+ *                 optional: is invoked when the parse terminates due to success ('accept')
+ *                 or failure (even when exceptions are thrown).
+ *                 `retval` contains the return value to be produced by `Parser.parse()`;
+ *                 this function can override the return value by returning another.
+ *                 When it does not return any value, the parser will return the original
+ *                 `retval`.
+ *                 This function is invoked immediately before `parser.post_parse()`.
+ *
+ *      parseError: function(str, hash, ExceptionClass)
+ *                 optional: overrides the default `parseError` function.
+ *      quoteName: function(name),
+ *                 optional: overrides the default `quoteName` function.
+ *  }
+ *
+ *  parser.lexer.options: {
+ *      pre_lex:  function()
+ *                 optional: is invoked before the lexer is invoked to produce another token.
+ *                 `this` refers to the Lexer object.
+ *      post_lex: function(token) { return token; }
+ *                 optional: is invoked when the lexer has produced a token `token`;
+ *                 this function can override the returned token value by returning another.
+ *                 When it does not return any (truthy) value, the lexer will return
+ *                 the original `token`.
+ *                 `this` refers to the Lexer object.
+ *
+ *      ranges: boolean
+ *                 optional: `true` ==> token location info will include a .range[] member.
+ *      flex: boolean
+ *                 optional: `true` ==> flex-like lexing behaviour where the rules are tested
+ *                 exhaustively to find the longest match.
+ *      backtrack_lexer: boolean
+ *                 optional: `true` ==> lexer regexes are tested in order and for invoked;
+ *                 the lexer terminates the scan when a token is returned by the action code.
+ *      xregexp: boolean
+ *                 optional: `true` ==> lexer rule regexes are "extended regex format" requiring the
+ *                 `XRegExp` library. When this `%option` has not been specified at compile time, all lexer
+ *                 rule regexes have been written as standard JavaScript RegExp expressions.
+ *  }
+ */
+
+        
+    
+            var parser = (function () {
+
+
+// See also:
+// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508
+// but we keep the prototype.constructor and prototype.name assignment lines too for compatibility
+// with userland code which might access the derived class in a 'classic' way.
+function JisonParserError(msg, hash) {
+    Object.defineProperty(this, 'name', {
+        enumerable: false,
+        writable: false,
+        value: 'JisonParserError'
+    });
+
+    if (msg == null) msg = '???';
+
+    Object.defineProperty(this, 'message', {
+        enumerable: false,
+        writable: true,
+        value: msg
+    });
+
+    this.hash = hash;
+
+    var stacktrace;
+    if (hash && hash.exception instanceof Error) {
+        var ex2 = hash.exception;
+        this.message = ex2.message || msg;
+        stacktrace = ex2.stack;
+    }
+    if (!stacktrace) {
+        if (Error.hasOwnProperty('captureStackTrace')) {        // V8/Chrome engine
+            Error.captureStackTrace(this, this.constructor);
+        } else {
+            stacktrace = (new Error(msg)).stack;
+        }
+    }
+    if (stacktrace) {
+        Object.defineProperty(this, 'stack', {
+            enumerable: false,
+            writable: false,
+            value: stacktrace
+        });
+    }
+}
+
+if (typeof Object.setPrototypeOf === 'function') {
+    Object.setPrototypeOf(JisonParserError.prototype, Error.prototype);
+} else {
+    JisonParserError.prototype = Object.create(Error.prototype);
+}
+JisonParserError.prototype.constructor = JisonParserError;
+JisonParserError.prototype.name = 'JisonParserError';
+
+
+
+
+        // helper: reconstruct the productions[] table
+        function bp(s) {
+            var rv = [];
+            var p = s.pop;
+            var r = s.rule;
+            for (var i = 0, l = p.length; i < l; i++) {
+                rv.push([
+                    p[i],
+                    r[i]
+                ]);
+            }
+            return rv;
+        }
+    
+
+
+        // helper: reconstruct the defaultActions[] table
+        function bda(s) {
+            var rv = {};
+            var d = s.idx;
+            var g = s.goto;
+            for (var i = 0, l = d.length; i < l; i++) {
+                var j = d[i];
+                rv[j] = g[i];
+            }
+            return rv;
+        }
+    
+
+
+        // helper: reconstruct the 'goto' table
+        function bt(s) {
+            var rv = [];
+            var d = s.len;
+            var y = s.symbol;
+            var t = s.type;
+            var a = s.state;
+            var m = s.mode;
+            var g = s.goto;
+            for (var i = 0, l = d.length; i < l; i++) {
+                var n = d[i];
+                var q = {};
+                for (var j = 0; j < n; j++) {
+                    var z = y.shift();
+                    switch (t.shift()) {
+                    case 2:
+                        q[z] = [
+                            m.shift(),
+                            g.shift()
+                        ];
+                        break;
+
+                    case 0:
+                        q[z] = a.shift();
+                        break;
+
+                    default:
+                        // type === 1: accept
+                        q[z] = [
+                            3
+                        ];
+                    }
+                }
+                rv.push(q);
+            }
+            return rv;
+        }
+    
+
+
+        // helper: runlength encoding with increment step: code, length: step (default step = 0)
+        // `this` references an array
+        function s(c, l, a) {
+            a = a || 0;
+            for (var i = 0; i < l; i++) {
+                this.push(c);
+                c += a;
+            }
+        }
+
+        // helper: duplicate sequence from *relative* offset and length.
+        // `this` references an array
+        function c(i, l) {
+            i = this.length - i;
+            for (l += i; i < l; i++) {
+                this.push(this[i]);
+            }
+        }
+
+        // helper: unpack an array using helpers and data, all passed in an array argument 'a'.
+        function u(a) {
+            var rv = [];
+            for (var i = 0, l = a.length; i < l; i++) {
+                var e = a[i];
+                // Is this entry a helper function?
+                if (typeof e === 'function') {
+                    i++;
+                    e.apply(rv, a[i]);
+                } else {
+                    rv.push(e);
+                }
+            }
+            return rv;
+        }
+    
+
+var parser = {
+    // Code Generator Information Report
+    // ---------------------------------
+    //
+    // Options:
+    //
+    //   default action mode: ............. ["classic","merge"]
+    //   test-compile action mode: ........ "parser:*,lexer:*"
+    //   try..catch: ...................... true
+    //   default resolve on conflict: ..... true
+    //   on-demand look-ahead: ............ false
+    //   error recovery token skip maximum: 3
+    //   yyerror in parse actions is: ..... NOT recoverable,
+    //   yyerror in lexer actions and other non-fatal lexer are:
+    //   .................................. NOT recoverable,
+    //   debug grammar/output: ............ false
+    //   has partial LR conflict upgrade:   true
+    //   rudimentary token-stack support:   false
+    //   parser table compression mode: ... 2
+    //   export debug tables: ............. false
+    //   export *all* tables: ............. false
+    //   module type: ..................... commonjs
+    //   parser engine type: .............. lalr
+    //   output main() in the module: ..... true
+    //   has user-specified main(): ....... false
+    //   has user-specified require()/import modules for main():
+    //   .................................. false
+    //   number of expected conflicts: .... 0
+    //
+    //
+    // Parser Analysis flags:
+    //
+    //   no significant actions (parser is a language matcher only):
+    //   .................................. false
+    //   uses yyleng: ..................... false
+    //   uses yylineno: ................... false
+    //   uses yytext: ..................... false
+    //   uses yylloc: ..................... false
+    //   uses ParseError API: ............. false
+    //   uses YYERROR: .................... false
+    //   uses YYRECOVERING: ............... false
+    //   uses YYERROK: .................... false
+    //   uses YYCLEARIN: .................. false
+    //   tracks rule values: .............. true
+    //   assigns rule values: ............. true
+    //   uses location tracking: .......... false
+    //   assigns location: ................ false
+    //   uses yystack: .................... false
+    //   uses yysstack: ................... false
+    //   uses yysp: ....................... true
+    //   uses yyrulelength: ............... false
+    //   uses yyMergeLocationInfo API: .... false
+    //   has error recovery: .............. false
+    //   has error reporting: ............. false
+    //
+    // --------- END OF REPORT -----------
+
+trace: function no_op_trace() { },
+JisonParserError: JisonParserError,
+yy: {},
+options: {
+  type: "lalr",
+  hasPartialLrUpgradeOnConflict: true,
+  errorRecoveryTokenDiscardCount: 3
+},
+symbols_: {
+  "$accept": 0,
+  "$end": 1,
+  "ADD": 3,
+  "ANGLE": 16,
+  "CHS": 22,
+  "COMMA": 14,
+  "CSS_CPROP": 13,
+  "CSS_VAR": 12,
+  "DIV": 6,
+  "EMS": 20,
+  "EOF": 1,
+  "EXS": 21,
+  "FREQ": 18,
+  "LENGTH": 15,
+  "LPAREN": 7,
+  "MUL": 5,
+  "NESTED_CALC": 9,
+  "NUMBER": 11,
+  "PERCENTAGE": 28,
+  "PREFIX": 10,
+  "REMS": 23,
+  "RES": 19,
+  "RPAREN": 8,
+  "SUB": 4,
+  "TIME": 17,
+  "VHS": 24,
+  "VMAXS": 27,
+  "VMINS": 26,
+  "VWS": 25,
+  "css_value": 33,
+  "css_variable": 32,
+  "error": 2,
+  "expression": 29,
+  "math_expression": 30,
+  "value": 31
+},
+terminals_: {
+  1: "EOF",
+  2: "error",
+  3: "ADD",
+  4: "SUB",
+  5: "MUL",
+  6: "DIV",
+  7: "LPAREN",
+  8: "RPAREN",
+  9: "NESTED_CALC",
+  10: "PREFIX",
+  11: "NUMBER",
+  12: "CSS_VAR",
+  13: "CSS_CPROP",
+  14: "COMMA",
+  15: "LENGTH",
+  16: "ANGLE",
+  17: "TIME",
+  18: "FREQ",
+  19: "RES",
+  20: "EMS",
+  21: "EXS",
+  22: "CHS",
+  23: "REMS",
+  24: "VHS",
+  25: "VWS",
+  26: "VMINS",
+  27: "VMAXS",
+  28: "PERCENTAGE"
+},
+TERROR: 2,
+    EOF: 1,
+
+    // internals: defined here so the object *structure* doesn't get modified by parse() et al,
+    // thus helping JIT compilers like Chrome V8.
+    originalQuoteName: null,
+    originalParseError: null,
+    cleanupAfterParse: null,
+    constructParseErrorInfo: null,
+    yyMergeLocationInfo: null,
+
+    __reentrant_call_depth: 0,      // INTERNAL USE ONLY
+    __error_infos: [],              // INTERNAL USE ONLY: the set of parseErrorInfo objects created since the last cleanup
+    __error_recovery_infos: [],     // INTERNAL USE ONLY: the set of parseErrorInfo objects created since the last cleanup
+
+    // APIs which will be set up depending on user action code analysis:
+    //yyRecovering: 0,
+    //yyErrOk: 0,
+    //yyClearIn: 0,
+
+    // Helper APIs
+    // -----------
+
+    // Helper function which can be overridden by user code later on: put suitable quotes around
+    // literal IDs in a description string.
+    quoteName: function parser_quoteName(id_str) {
+        return '"' + id_str + '"';
+    },
+
+    // Return the name of the given symbol (terminal or non-terminal) as a string, when available.
+    //
+    // Return NULL when the symbol is unknown to the parser.
+    getSymbolName: function parser_getSymbolName(symbol) {
+        if (this.terminals_[symbol]) {
+            return this.terminals_[symbol];
+        }
+
+        // Otherwise... this might refer to a RULE token i.e. a non-terminal: see if we can dig that one up.
+        //
+        // An example of this may be where a rule's action code contains a call like this:
+        //
+        //      parser.getSymbolName(#$)
+        //
+        // to obtain a human-readable name of the current grammar rule.
+        var s = this.symbols_;
+        for (var key in s) {
+            if (s[key] === symbol) {
+                return key;
+            }
+        }
+        return null;
+    },
+
+    // Return a more-or-less human-readable description of the given symbol, when available,
+    // or the symbol itself, serving as its own 'description' for lack of something better to serve up.
+    //
+    // Return NULL when the symbol is unknown to the parser.
+    describeSymbol: function parser_describeSymbol(symbol) {
+        if (symbol !== this.EOF && this.terminal_descriptions_ && this.terminal_descriptions_[symbol]) {
+            return this.terminal_descriptions_[symbol];
+        }
+        else if (symbol === this.EOF) {
+            return 'end of input';
+        }
+        var id = this.getSymbolName(symbol);
+        if (id) {
+            return this.quoteName(id);
+        }
+        return null;
+    },
+
+    // Produce a (more or less) human-readable list of expected tokens at the point of failure.
+    //
+    // The produced list may contain token or token set descriptions instead of the tokens
+    // themselves to help turning this output into something that easier to read by humans
+    // unless `do_not_describe` parameter is set, in which case a list of the raw, *numeric*,
+    // expected terminals and nonterminals is produced.
+    //
+    // The returned list (array) will not contain any duplicate entries.
+    collect_expected_token_set: function parser_collect_expected_token_set(state, do_not_describe) {
+        var TERROR = this.TERROR;
+        var tokenset = [];
+        var check = {};
+        // Has this (error?) state been outfitted with a custom expectations description text for human consumption?
+        // If so, use that one instead of the less palatable token set.
+        if (!do_not_describe && this.state_descriptions_ && this.state_descriptions_[state]) {
+            return [
+                this.state_descriptions_[state]
+            ];
+        }
+        for (var p in this.table[state]) {
+            p = +p;
+            if (p !== TERROR) {
+                var d = do_not_describe ? p : this.describeSymbol(p);
+                if (d && !check[d]) {
+                    tokenset.push(d);
+                    check[d] = true;        // Mark this token description as already mentioned to prevent outputting duplicate entries.
+                }
+            }
+        }
+        return tokenset;
+    },
+productions_: bp({
+  pop: u([
+  29,
+  s,
+  [30, 10],
+  31,
+  31,
+  32,
+  32,
+  s,
+  [33, 15]
+]),
+  rule: u([
+  2,
+  s,
+  [3, 5],
+  4,
+  7,
+  s,
+  [1, 4],
+  2,
+  4,
+  6,
+  s,
+  [1, 14],
+  2
+])
+}),
+performAction: function parser__PerformAction(yystate /* action[1] */, yysp, yyvstack) {
+
+          /* this == yyval */
+
+          // the JS engine itself can go and remove these statements when `yy` turns out to be unused in any action code!
+          var yy = this.yy;
+          var yyparser = yy.parser;
+          var yylexer = yy.lexer;
+
+          
+
+          switch (yystate) {
+case 0:
+    /*! Production::    $accept : expression $end */
+
+    // default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,-,-,-,-):
+    this.$ = yyvstack[yysp - 1];
+    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,-,-,-,-)
+    break;
+
+case 1:
+    /*! Production::    expression : math_expression EOF */
+
+    // default action (generated by JISON mode classic/merge :: 2,VT,VA,-,-,-,-,-,-):
+    this.$ = yyvstack[yysp - 1];
+    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,-,-,-,-,-,-)
+    
+    
+    return yyvstack[yysp - 1];
+    break;
+
+case 2:
+    /*! Production::    math_expression : math_expression ADD math_expression */
+case 3:
+    /*! Production::    math_expression : math_expression SUB math_expression */
+case 4:
+    /*! Production::    math_expression : math_expression MUL math_expression */
+case 5:
+    /*! Production::    math_expression : math_expression DIV math_expression */
+
+    this.$ = { type: 'MathExpression', operator: yyvstack[yysp - 1], left: yyvstack[yysp - 2], right: yyvstack[yysp] };
+    break;
+
+case 6:
+    /*! Production::    math_expression : LPAREN math_expression RPAREN */
+
+    this.$ = yyvstack[yysp - 1];
+    break;
+
+case 7:
+    /*! Production::    math_expression : NESTED_CALC LPAREN math_expression RPAREN */
+
+    this.$ = { type: 'Calc', value: yyvstack[yysp - 1] };
+    break;
+
+case 8:
+    /*! Production::    math_expression : SUB PREFIX SUB NESTED_CALC LPAREN math_expression RPAREN */
+
+    this.$ = { type: 'Calc', value: yyvstack[yysp - 1], prefix: yyvstack[yysp - 5] };
+    break;
+
+case 9:
+    /*! Production::    math_expression : css_variable */
+case 10:
+    /*! Production::    math_expression : css_value */
+case 11:
+    /*! Production::    math_expression : value */
+
+    this.$ = yyvstack[yysp];
+    break;
+
+case 12:
+    /*! Production::    value : NUMBER */
+
+    this.$ = { type: 'Value', value: parseFloat(yyvstack[yysp]) };
+    break;
+
+case 13:
+    /*! Production::    value : SUB NUMBER */
+
+    this.$ = { type: 'Value', value: parseFloat(yyvstack[yysp]) * -1 };
+    break;
+
+case 14:
+    /*! Production::    css_variable : CSS_VAR LPAREN CSS_CPROP RPAREN */
+
+    this.$ = { type: 'CssVariable', value: yyvstack[yysp - 1] };
+    break;
+
+case 15:
+    /*! Production::    css_variable : CSS_VAR LPAREN CSS_CPROP COMMA math_expression RPAREN */
+
+    this.$ = { type: 'CssVariable', value: yyvstack[yysp - 3], fallback: yyvstack[yysp - 1] };
+    break;
+
+case 16:
+    /*! Production::    css_value : LENGTH */
+
+    this.$ = { type: 'LengthValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };
+    break;
+
+case 17:
+    /*! Production::    css_value : ANGLE */
+
+    this.$ = { type: 'AngleValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };
+    break;
+
+case 18:
+    /*! Production::    css_value : TIME */
+
+    this.$ = { type: 'TimeValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };
+    break;
+
+case 19:
+    /*! Production::    css_value : FREQ */
+
+    this.$ = { type: 'FrequencyValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };
+    break;
+
+case 20:
+    /*! Production::    css_value : RES */
+
+    this.$ = { type: 'ResolutionValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };
+    break;
+
+case 21:
+    /*! Production::    css_value : EMS */
+
+    this.$ = { type: 'EmValue', value: parseFloat(yyvstack[yysp]), unit: 'em' };
+    break;
+
+case 22:
+    /*! Production::    css_value : EXS */
+
+    this.$ = { type: 'ExValue', value: parseFloat(yyvstack[yysp]), unit: 'ex' };
+    break;
+
+case 23:
+    /*! Production::    css_value : CHS */
+
+    this.$ = { type: 'ChValue', value: parseFloat(yyvstack[yysp]), unit: 'ch' };
+    break;
+
+case 24:
+    /*! Production::    css_value : REMS */
+
+    this.$ = { type: 'RemValue', value: parseFloat(yyvstack[yysp]), unit: 'rem' };
+    break;
+
+case 25:
+    /*! Production::    css_value : VHS */
+
+    this.$ = { type: 'VhValue', value: parseFloat(yyvstack[yysp]), unit: 'vh' };
+    break;
+
+case 26:
+    /*! Production::    css_value : VWS */
+
+    this.$ = { type: 'VwValue', value: parseFloat(yyvstack[yysp]), unit: 'vw' };
+    break;
+
+case 27:
+    /*! Production::    css_value : VMINS */
+
+    this.$ = { type: 'VminValue', value: parseFloat(yyvstack[yysp]), unit: 'vmin' };
+    break;
+
+case 28:
+    /*! Production::    css_value : VMAXS */
+
+    this.$ = { type: 'VmaxValue', value: parseFloat(yyvstack[yysp]), unit: 'vmax' };
+    break;
+
+case 29:
+    /*! Production::    css_value : PERCENTAGE */
+
+    this.$ = { type: 'PercentageValue', value: parseFloat(yyvstack[yysp]), unit: '%' };
+    break;
+
+case 30:
+    /*! Production::    css_value : SUB css_value */
+
+    var prev = yyvstack[yysp]; prev.value *= -1; this.$ = prev;
+    break;
+
+}
+},
+table: bt({
+  len: u([
+  24,
+  1,
+  5,
+  23,
+  1,
+  18,
+  s,
+  [0, 3],
+  1,
+  s,
+  [0, 16],
+  s,
+  [23, 4],
+  c,
+  [28, 3],
+  0,
+  0,
+  16,
+  1,
+  6,
+  6,
+  s,
+  [0, 3],
+  5,
+  1,
+  2,
+  c,
+  [37, 3],
+  c,
+  [20, 3],
+  5,
+  0,
+  0
+]),
+  symbol: u([
+  4,
+  7,
+  9,
+  11,
+  12,
+  s,
+  [15, 19, 1],
+  1,
+  1,
+  s,
+  [3, 4, 1],
+  c,
+  [30, 19],
+  c,
+  [29, 4],
+  7,
+  4,
+  10,
+  11,
+  c,
+  [22, 14],
+  c,
+  [19, 3],
+  c,
+  [43, 22],
+  c,
+  [23, 69],
+  c,
+  [139, 4],
+  8,
+  c,
+  [51, 24],
+  4,
+  c,
+  [138, 15],
+  13,
+  c,
+  [186, 5],
+  8,
+  c,
+  [6, 6],
+  c,
+  [5, 5],
+  9,
+  8,
+  14,
+  c,
+  [159, 47],
+  c,
+  [60, 10]
+]),
+  type: u([
+  s,
+  [2, 19],
+  s,
+  [0, 5],
+  1,
+  s,
+  [2, 24],
+  s,
+  [0, 4],
+  c,
+  [22, 19],
+  c,
+  [43, 42],
+  c,
+  [23, 70],
+  c,
+  [28, 25],
+  c,
+  [45, 25],
+  c,
+  [113, 54]
+]),
+  state: u([
+  1,
+  2,
+  8,
+  6,
+  7,
+  30,
+  c,
+  [4, 3],
+  33,
+  37,
+  c,
+  [5, 3],
+  38,
+  c,
+  [4, 3],
+  39,
+  c,
+  [4, 3],
+  40,
+  c,
+  [4, 3],
+  42,
+  c,
+  [21, 4],
+  50,
+  c,
+  [5, 3],
+  51,
+  c,
+  [4, 3]
+]),
+  mode: u([
+  s,
+  [1, 179],
+  s,
+  [2, 3],
+  c,
+  [5, 5],
+  c,
+  [6, 4],
+  s,
+  [1, 57]
+]),
+  goto: u([
+  5,
+  3,
+  4,
+  24,
+  s,
+  [9, 15, 1],
+  s,
+  [25, 5, 1],
+  c,
+  [24, 19],
+  31,
+  35,
+  32,
+  34,
+  c,
+  [18, 14],
+  36,
+  c,
+  [38, 19],
+  c,
+  [19, 57],
+  c,
+  [118, 4],
+  41,
+  c,
+  [24, 19],
+  43,
+  35,
+  c,
+  [16, 14],
+  44,
+  s,
+  [2, 3],
+  28,
+  29,
+  2,
+  s,
+  [3, 3],
+  28,
+  29,
+  3,
+  c,
+  [53, 4],
+  s,
+  [45, 5, 1],
+  c,
+  [100, 42],
+  52,
+  c,
+  [5, 4],
+  53
+])
+}),
+defaultActions: bda({
+  idx: u([
+  6,
+  7,
+  8,
+  s,
+  [10, 16, 1],
+  33,
+  34,
+  39,
+  40,
+  41,
+  45,
+  47,
+  52,
+  53
+]),
+  goto: u([
+  9,
+  10,
+  11,
+  s,
+  [16, 14, 1],
+  12,
+  1,
+  30,
+  13,
+  s,
+  [4, 4, 1],
+  14,
+  15,
+  8
+])
+}),
+parseError: function parseError(str, hash, ExceptionClass) {
+    if (hash.recoverable) {
+        if (typeof this.trace === 'function') {
+            this.trace(str);
+        }
+        hash.destroy();             // destroy... well, *almost*!
+    } else {
+        if (typeof this.trace === 'function') {
+            this.trace(str);
+        }
+        if (!ExceptionClass) {
+            ExceptionClass = this.JisonParserError;
+        }
+        throw new ExceptionClass(str, hash);
+    }
+},
+parse: function parse(input) {
+    var self = this;
+    var stack = new Array(128);         // token stack: stores token which leads to state at the same index (column storage)
+    var sstack = new Array(128);        // state stack: stores states (column storage)
+
+    var vstack = new Array(128);        // semantic value stack
+
+    var table = this.table;
+    var sp = 0;                         // 'stack pointer': index into the stacks
+
+
+    
+
+
+    var symbol = 0;
+
+
+
+    var TERROR = this.TERROR;
+    var EOF = this.EOF;
+    var ERROR_RECOVERY_TOKEN_DISCARD_COUNT = (this.options.errorRecoveryTokenDiscardCount | 0) || 3;
+    var NO_ACTION = [0, 54 /* === table.length :: ensures that anyone using this new state will fail dramatically! */];
+
+    var lexer;
+    if (this.__lexer__) {
+        lexer = this.__lexer__;
+    } else {
+        lexer = this.__lexer__ = Object.create(this.lexer);
+    }
+
+    var sharedState_yy = {
+        parseError: undefined,
+        quoteName: undefined,
+        lexer: undefined,
+        parser: undefined,
+        pre_parse: undefined,
+        post_parse: undefined,
+        pre_lex: undefined,
+        post_lex: undefined      // WARNING: must be written this way for the code expanders to work correctly in both ES5 and ES6 modes!
+    };
+
+    var ASSERT;
+    if (typeof assert !== 'function') {
+        ASSERT = function JisonAssert(cond, msg) {
+            if (!cond) {
+                throw new Error('assertion failed: ' + (msg || '***'));
+            }
+        };
+    } else {
+        ASSERT = assert;
+    }
+
+    this.yyGetSharedState = function yyGetSharedState() {
+        return sharedState_yy;
+    };
+
+
+
+
+
+
+
+
+    function shallow_copy_noclobber(dst, src) {
+        for (var k in src) {
+            if (typeof dst[k] === 'undefined' && Object.prototype.hasOwnProperty.call(src, k)) {
+                dst[k] = src[k];
+            }
+        }
+    }
+
+    // copy state
+    shallow_copy_noclobber(sharedState_yy, this.yy);
+
+    sharedState_yy.lexer = lexer;
+    sharedState_yy.parser = this;
+
+
+
+
+
+
+    // Does the shared state override the default `parseError` that already comes with this instance?
+    if (typeof sharedState_yy.parseError === 'function') {
+        this.parseError = function parseErrorAlt(str, hash, ExceptionClass) {
+            if (!ExceptionClass) {
+                ExceptionClass = this.JisonParserError;
+            }
+            return sharedState_yy.parseError.call(this, str, hash, ExceptionClass);
+        };
+    } else {
+        this.parseError = this.originalParseError;
+    }
+
+    // Does the shared state override the default `quoteName` that already comes with this instance?
+    if (typeof sharedState_yy.quoteName === 'function') {
+        this.quoteName = function quoteNameAlt(id_str) {
+            return sharedState_yy.quoteName.call(this, id_str);
+        };
+    } else {
+        this.quoteName = this.originalQuoteName;
+    }
+
+    // set up the cleanup function; make it an API so that external code can re-use this one in case of
+    // calamities or when the `%options no-try-catch` option has been specified for the grammar, in which
+    // case this parse() API method doesn't come with a `finally { ... }` block any more!
+    //
+    // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,
+    //       or else your `sharedState`, etc. references will be *wrong*!
+    this.cleanupAfterParse = function parser_cleanupAfterParse(resultValue, invoke_post_methods, do_not_nuke_errorinfos) {
+        var rv;
+
+        if (invoke_post_methods) {
+            var hash;
+
+            if (sharedState_yy.post_parse || this.post_parse) {
+                // create an error hash info instance: we re-use this API in a **non-error situation**
+                // as this one delivers all parser internals ready for access by userland code.
+                hash = this.constructParseErrorInfo(null /* no error! */, null /* no exception! */, null, false);
+            }
+
+            if (sharedState_yy.post_parse) {
+                rv = sharedState_yy.post_parse.call(this, sharedState_yy, resultValue, hash);
+                if (typeof rv !== 'undefined') resultValue = rv;
+            }
+            if (this.post_parse) {
+                rv = this.post_parse.call(this, sharedState_yy, resultValue, hash);
+                if (typeof rv !== 'undefined') resultValue = rv;
+            }
+
+            // cleanup:
+            if (hash && hash.destroy) {
+                hash.destroy();
+            }
+        }
+
+        if (this.__reentrant_call_depth > 1) return resultValue;        // do not (yet) kill the sharedState when this is a reentrant run.
+
+        // clean up the lingering lexer structures as well:
+        if (lexer.cleanupAfterLex) {
+            lexer.cleanupAfterLex(do_not_nuke_errorinfos);
+        }
+
+        // prevent lingering circular references from causing memory leaks:
+        if (sharedState_yy) {
+            sharedState_yy.lexer = undefined;
+            sharedState_yy.parser = undefined;
+            if (lexer.yy === sharedState_yy) {
+                lexer.yy = undefined;
+            }
+        }
+        sharedState_yy = undefined;
+        this.parseError = this.originalParseError;
+        this.quoteName = this.originalQuoteName;
+
+        // nuke the vstack[] array at least as that one will still reference obsoleted user values.
+        // To be safe, we nuke the other internal stack columns as well...
+        stack.length = 0;               // fastest way to nuke an array without overly bothering the GC
+        sstack.length = 0;
+
+        vstack.length = 0;
+        sp = 0;
+
+        // nuke the error hash info instances created during this run.
+        // Userland code must COPY any data/references
+        // in the error hash instance(s) it is more permanently interested in.
+        if (!do_not_nuke_errorinfos) {
+            for (var i = this.__error_infos.length - 1; i >= 0; i--) {
+                var el = this.__error_infos[i];
+                if (el && typeof el.destroy === 'function') {
+                    el.destroy();
+                }
+            }
+            this.__error_infos.length = 0;
+
+
+        }
+
+        return resultValue;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,
+    //       or else your `lexer`, `sharedState`, etc. references will be *wrong*!
+    this.constructParseErrorInfo = function parser_constructParseErrorInfo(msg, ex, expected, recoverable) {
+        var pei = {
+            errStr: msg,
+            exception: ex,
+            text: lexer.match,
+            value: lexer.yytext,
+            token: this.describeSymbol(symbol) || symbol,
+            token_id: symbol,
+            line: lexer.yylineno,
+
+            expected: expected,
+            recoverable: recoverable,
+            state: state,
+            action: action,
+            new_state: newState,
+            symbol_stack: stack,
+            state_stack: sstack,
+            value_stack: vstack,
+
+            stack_pointer: sp,
+            yy: sharedState_yy,
+            lexer: lexer,
+            parser: this,
+
+            // and make sure the error info doesn't stay due to potential
+            // ref cycle via userland code manipulations.
+            // These would otherwise all be memory leak opportunities!
+            //
+            // Note that only array and object references are nuked as those
+            // constitute the set of elements which can produce a cyclic ref.
+            // The rest of the members is kept intact as they are harmless.
+            destroy: function destructParseErrorInfo() {
+                // remove cyclic references added to error info:
+                // info.yy = null;
+                // info.lexer = null;
+                // info.value = null;
+                // info.value_stack = null;
+                // ...
+                var rec = !!this.recoverable;
+                for (var key in this) {
+                    if (this.hasOwnProperty(key) && typeof key === 'object') {
+                        this[key] = undefined;
+                    }
+                }
+                this.recoverable = rec;
+            }
+        };
+        // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!
+        this.__error_infos.push(pei);
+        return pei;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+    function getNonTerminalFromCode(symbol) {
+        var tokenName = self.getSymbolName(symbol);
+        if (!tokenName) {
+            tokenName = symbol;
+        }
+        return tokenName;
+    }
+
+
+    function stdLex() {
+        var token = lexer.lex();
+        // if token isn't its numeric value, convert
+        if (typeof token !== 'number') {
+            token = self.symbols_[token] || token;
+        }
+
+        return token || EOF;
+    }
+
+    function fastLex() {
+        var token = lexer.fastLex();
+        // if token isn't its numeric value, convert
+        if (typeof token !== 'number') {
+            token = self.symbols_[token] || token;
+        }
+
+        return token || EOF;
+    }
+
+    var lex = stdLex;
+
+
+    var state, action, r, t;
+    var yyval = {
+        $: true,
+        _$: undefined,
+        yy: sharedState_yy
+    };
+    var p;
+    var yyrulelen;
+    var this_production;
+    var newState;
+    var retval = false;
+
+
+    try {
+        this.__reentrant_call_depth++;
+
+        lexer.setInput(input, sharedState_yy);
+
+        // NOTE: we *assume* no lexer pre/post handlers are set up *after* 
+        // this initial `setInput()` call: hence we can now check and decide
+        // whether we'll go with the standard, slower, lex() API or the
+        // `fast_lex()` one:
+        if (typeof lexer.canIUse === 'function') {
+            var lexerInfo = lexer.canIUse();
+            if (lexerInfo.fastLex && typeof fastLex === 'function') {
+                lex = fastLex;
+            }
+        } 
+
+
+
+        vstack[sp] = null;
+        sstack[sp] = 0;
+        stack[sp] = 0;
+        ++sp;
+
+
+
+
+
+        if (this.pre_parse) {
+            this.pre_parse.call(this, sharedState_yy);
+        }
+        if (sharedState_yy.pre_parse) {
+            sharedState_yy.pre_parse.call(this, sharedState_yy);
+        }
+
+        newState = sstack[sp - 1];
+        for (;;) {
+            // retrieve state number from top of stack
+            state = newState;               // sstack[sp - 1];
+
+            // use default actions if available
+            if (this.defaultActions[state]) {
+                action = 2;
+                newState = this.defaultActions[state];
+            } else {
+                // The single `==` condition below covers both these `===` comparisons in a single
+                // operation:
+                //
+                //     if (symbol === null || typeof symbol === 'undefined') ...
+                if (!symbol) {
+                    symbol = lex();
+                }
+                // read action for current state and first input
+                t = (table[state] && table[state][symbol]) || NO_ACTION;
+                newState = t[1];
+                action = t[0];
+
+
+
+
+
+
+
+
+
+
+
+                // handle parse error
+                if (!action) {
+                    var errStr;
+                    var errSymbolDescr = (this.describeSymbol(symbol) || symbol);
+                    var expected = this.collect_expected_token_set(state);
+
+                    // Report error
+                    if (typeof lexer.yylineno === 'number') {
+                        errStr = 'Parse error on line ' + (lexer.yylineno + 1) + ': ';
+                    } else {
+                        errStr = 'Parse error: ';
+                    }
+                    if (typeof lexer.showPosition === 'function') {
+                        errStr += '\n' + lexer.showPosition(79 - 10, 10) + '\n';
+                    }
+                    if (expected.length) {
+                        errStr += 'Expecting ' + expected.join(', ') + ', got unexpected ' + errSymbolDescr;
+                    } else {
+                        errStr += 'Unexpected ' + errSymbolDescr;
+                    }
+                    // we cannot recover from the error!
+                    p = this.constructParseErrorInfo(errStr, null, expected, false);
+                    r = this.parseError(p.errStr, p, this.JisonParserError);
+                    if (typeof r !== 'undefined') {
+                        retval = r;
+                    }
+                    break;
+                }
+
+
+            }
+
+
+
+
+
+
+
+
+
+
+            switch (action) {
+            // catch misc. parse failures:
+            default:
+                // this shouldn't happen, unless resolve defaults are off
+                if (action instanceof Array) {
+                    p = this.constructParseErrorInfo('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol, null, null, false);
+                    r = this.parseError(p.errStr, p, this.JisonParserError);
+                    if (typeof r !== 'undefined') {
+                        retval = r;
+                    }
+                    break;
+                }
+                // Another case of better safe than sorry: in case state transitions come out of another error recovery process
+                // or a buggy LUT (LookUp Table):
+                p = this.constructParseErrorInfo('Parsing halted. No viable error recovery approach available due to internal system failure.', null, null, false);
+                r = this.parseError(p.errStr, p, this.JisonParserError);
+                if (typeof r !== 'undefined') {
+                    retval = r;
+                }
+                break;
+
+            // shift:
+            case 1:
+                stack[sp] = symbol;
+                vstack[sp] = lexer.yytext;
+
+                sstack[sp] = newState; // push state
+
+                ++sp;
+                symbol = 0;
+
+
+
+
+                // Pick up the lexer details for the current symbol as that one is not 'look-ahead' any more:
+
+
+
+
+                continue;
+
+            // reduce:
+            case 2:
+
+
+
+                this_production = this.productions_[newState - 1];  // `this.productions_[]` is zero-based indexed while states start from 1 upwards...
+                yyrulelen = this_production[1];
+
+
+
+
+
+
+
+
+
+
+                r = this.performAction.call(yyval, newState, sp - 1, vstack);
+
+                if (typeof r !== 'undefined') {
+                    retval = r;
+                    break;
+                }
+
+                // pop off stack
+                sp -= yyrulelen;
+
+                // don't overwrite the `symbol` variable: use a local var to speed things up:
+                var ntsymbol = this_production[0];    // push nonterminal (reduce)
+                stack[sp] = ntsymbol;
+                vstack[sp] = yyval.$;
+
+                // goto new state = table[STATE][NONTERMINAL]
+                newState = table[sstack[sp - 1]][ntsymbol];
+                sstack[sp] = newState;
+                ++sp;
+
+
+
+
+
+
+
+
+
+                continue;
+
+            // accept:
+            case 3:
+                if (sp !== -2) {
+                    retval = true;
+                    // Return the `$accept` rule's `$$` result, if available.
+                    //
+                    // Also note that JISON always adds this top-most `$accept` rule (with implicit,
+                    // default, action):
+                    //
+                    //     $accept: <startSymbol> $end
+                    //                  %{ $$ = $1; @$ = @1; %}
+                    //
+                    // which, combined with the parse kernel's `$accept` state behaviour coded below,
+                    // will produce the `$$` value output of the <startSymbol> rule as the parse result,
+                    // IFF that result is *not* `undefined`. (See also the parser kernel code.)
+                    //
+                    // In code:
+                    //
+                    //                  %{
+                    //                      @$ = @1;            // if location tracking support is included
+                    //                      if (typeof $1 !== 'undefined')
+                    //                          return $1;
+                    //                      else
+                    //                          return true;           // the default parse result if the rule actions don't produce anything
+                    //                  %}
+                    sp--;
+                    if (typeof vstack[sp] !== 'undefined') {
+                        retval = vstack[sp];
+                    }
+                }
+                break;
+            }
+
+            // break out of loop: we accept or fail with error
+            break;
+        }
+    } catch (ex) {
+        // report exceptions through the parseError callback too, but keep the exception intact
+        // if it is a known parser or lexer error which has been thrown by parseError() already:
+        if (ex instanceof this.JisonParserError) {
+            throw ex;
+        }
+        else if (lexer && typeof lexer.JisonLexerError === 'function' && ex instanceof lexer.JisonLexerError) {
+            throw ex;
+        }
+
+        p = this.constructParseErrorInfo('Parsing aborted due to exception.', ex, null, false);
+        retval = false;
+        r = this.parseError(p.errStr, p, this.JisonParserError);
+        if (typeof r !== 'undefined') {
+            retval = r;
+        }
+    } finally {
+        retval = this.cleanupAfterParse(retval, true, true);
+        this.__reentrant_call_depth--;
+    }   // /finally
+
+    return retval;
+}
+};
+parser.originalParseError = parser.parseError;
+parser.originalQuoteName = parser.quoteName;
+/* lexer generated by jison-lex 0.6.1-215 */
+
+/*
+ * Returns a Lexer object of the following structure:
+ *
+ *  Lexer: {
+ *    yy: {}     The so-called "shared state" or rather the *source* of it;
+ *               the real "shared state" `yy` passed around to
+ *               the rule actions, etc. is a direct reference!
+ *
+ *               This "shared context" object was passed to the lexer by way of 
+ *               the `lexer.setInput(str, yy)` API before you may use it.
+ *
+ *               This "shared context" object is passed to the lexer action code in `performAction()`
+ *               so userland code in the lexer actions may communicate with the outside world 
+ *               and/or other lexer rules' actions in more or less complex ways.
+ *
+ *  }
+ *
+ *  Lexer.prototype: {
+ *    EOF: 1,
+ *    ERROR: 2,
+ *
+ *    yy:        The overall "shared context" object reference.
+ *
+ *    JisonLexerError: function(msg, hash),
+ *
+ *    performAction: function lexer__performAction(yy, yyrulenumber, YY_START),
+ *
+ *               The function parameters and `this` have the following value/meaning:
+ *               - `this`    : reference to the `lexer` instance. 
+ *                               `yy_` is an alias for `this` lexer instance reference used internally.
+ *
+ *               - `yy`      : a reference to the `yy` "shared state" object which was passed to the lexer
+ *                             by way of the `lexer.setInput(str, yy)` API before.
+ *
+ *                             Note:
+ *                             The extra arguments you specified in the `%parse-param` statement in your
+ *                             **parser** grammar definition file are passed to the lexer via this object
+ *                             reference as member variables.
+ *
+ *               - `yyrulenumber`   : index of the matched lexer rule (regex), used internally.
+ *
+ *               - `YY_START`: the current lexer "start condition" state.
+ *
+ *    parseError: function(str, hash, ExceptionClass),
+ *
+ *    constructLexErrorInfo: function(error_message, is_recoverable),
+ *               Helper function.
+ *               Produces a new errorInfo 'hash object' which can be passed into `parseError()`.
+ *               See it's use in this lexer kernel in many places; example usage:
+ *
+ *                   var infoObj = lexer.constructParseErrorInfo('fail!', true);
+ *                   var retVal = lexer.parseError(infoObj.errStr, infoObj, lexer.JisonLexerError);
+ *
+ *    options: { ... lexer %options ... },
+ *
+ *    lex: function(),
+ *               Produce one token of lexed input, which was passed in earlier via the `lexer.setInput()` API.
+ *               You MAY use the additional `args...` parameters as per `%parse-param` spec of the **lexer** grammar:
+ *               these extra `args...` are added verbatim to the `yy` object reference as member variables.
+ *
+ *               WARNING:
+ *               Lexer's additional `args...` parameters (via lexer's `%parse-param`) MAY conflict with
+ *               any attributes already added to `yy` by the **parser** or the jison run-time; 
+ *               when such a collision is detected an exception is thrown to prevent the generated run-time 
+ *               from silently accepting this confusing and potentially hazardous situation! 
+ *
+ *    cleanupAfterLex: function(do_not_nuke_errorinfos),
+ *               Helper function.
+ *
+ *               This helper API is invoked when the **parse process** has completed: it is the responsibility
+ *               of the **parser** (or the calling userland code) to invoke this method once cleanup is desired. 
+ *
+ *               This helper may be invoked by user code to ensure the internal lexer gets properly garbage collected.
+ *
+ *    setInput: function(input, [yy]),
+ *
+ *
+ *    input: function(),
+ *
+ *
+ *    unput: function(str),
+ *
+ *
+ *    more: function(),
+ *
+ *
+ *    reject: function(),
+ *
+ *
+ *    less: function(n),
+ *
+ *
+ *    pastInput: function(n),
+ *
+ *
+ *    upcomingInput: function(n),
+ *
+ *
+ *    showPosition: function(),
+ *
+ *
+ *    test_match: function(regex_match_array, rule_index),
+ *
+ *
+ *    next: function(),
+ *
+ *
+ *    begin: function(condition),
+ *
+ *
+ *    pushState: function(condition),
+ *
+ *
+ *    popState: function(),
+ *
+ *
+ *    topState: function(),
+ *
+ *
+ *    _currentRules: function(),
+ *
+ *
+ *    stateStackSize: function(),
+ *
+ *
+ *    performAction: function(yy, yy_, yyrulenumber, YY_START),
+ *
+ *
+ *    rules: [...],
+ *
+ *
+ *    conditions: {associative list: name ==> set},
+ *  }
+ *
+ *
+ *  token location info (`yylloc`): {
+ *    first_line: n,
+ *    last_line: n,
+ *    first_column: n,
+ *    last_column: n,
+ *    range: [start_number, end_number]
+ *               (where the numbers are indexes into the input string, zero-based)
+ *  }
+ *
+ * ---
+ *
+ * The `parseError` function receives a 'hash' object with these members for lexer errors:
+ *
+ *  {
+ *    text:        (matched text)
+ *    token:       (the produced terminal token, if any)
+ *    token_id:    (the produced terminal token numeric ID, if any)
+ *    line:        (yylineno)
+ *    loc:         (yylloc)
+ *    recoverable: (boolean: TRUE when the parser MAY have an error recovery rule
+ *                  available for this particular error)
+ *    yy:          (object: the current parser internal "shared state" `yy`
+ *                  as is also available in the rule actions; this can be used,
+ *                  for instance, for advanced error analysis and reporting)
+ *    lexer:       (reference to the current lexer instance used by the parser)
+ *  }
+ *
+ * while `this` will reference the current lexer instance.
+ *
+ * When `parseError` is invoked by the lexer, the default implementation will
+ * attempt to invoke `yy.parser.parseError()`; when this callback is not provided
+ * it will try to invoke `yy.parseError()` instead. When that callback is also not
+ * provided, a `JisonLexerError` exception will be thrown containing the error
+ * message and `hash`, as constructed by the `constructLexErrorInfo()` API.
+ *
+ * Note that the lexer's `JisonLexerError` error class is passed via the
+ * `ExceptionClass` argument, which is invoked to construct the exception
+ * instance to be thrown, so technically `parseError` will throw the object
+ * produced by the `new ExceptionClass(str, hash)` JavaScript expression.
+ *
+ * ---
+ *
+ * You can specify lexer options by setting / modifying the `.options` object of your Lexer instance.
+ * These options are available:
+ *
+ * (Options are permanent.)
+ *  
+ *  yy: {
+ *      parseError: function(str, hash, ExceptionClass)
+ *                 optional: overrides the default `parseError` function.
+ *  }
+ *
+ *  lexer.options: {
+ *      pre_lex:  function()
+ *                 optional: is invoked before the lexer is invoked to produce another token.
+ *                 `this` refers to the Lexer object.
+ *      post_lex: function(token) { return token; }
+ *                 optional: is invoked when the lexer has produced a token `token`;
+ *                 this function can override the returned token value by returning another.
+ *                 When it does not return any (truthy) value, the lexer will return
+ *                 the original `token`.
+ *                 `this` refers to the Lexer object.
+ *
+ * WARNING: the next set of options are not meant to be changed. They echo the abilities of
+ * the lexer as per when it was compiled!
+ *
+ *      ranges: boolean
+ *                 optional: `true` ==> token location info will include a .range[] member.
+ *      flex: boolean
+ *                 optional: `true` ==> flex-like lexing behaviour where the rules are tested
+ *                 exhaustively to find the longest match.
+ *      backtrack_lexer: boolean
+ *                 optional: `true` ==> lexer regexes are tested in order and for invoked;
+ *                 the lexer terminates the scan when a token is returned by the action code.
+ *      xregexp: boolean
+ *                 optional: `true` ==> lexer rule regexes are "extended regex format" requiring the
+ *                 `XRegExp` library. When this %option has not been specified at compile time, all lexer
+ *                 rule regexes have been written as standard JavaScript RegExp expressions.
+ *  }
+ */
+
+
+var lexer = function() {
+  /**
+   * See also:
+   * http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508
+   * but we keep the prototype.constructor and prototype.name assignment lines too for compatibility
+   * with userland code which might access the derived class in a 'classic' way.
+   *
+   * @public
+   * @constructor
+   * @nocollapse
+   */
+  function JisonLexerError(msg, hash) {
+    Object.defineProperty(this, 'name', {
+      enumerable: false,
+      writable: false,
+      value: 'JisonLexerError'
+    });
+
+    if (msg == null)
+      msg = '???';
+
+    Object.defineProperty(this, 'message', {
+      enumerable: false,
+      writable: true,
+      value: msg
+    });
+
+    this.hash = hash;
+    var stacktrace;
+
+    if (hash && hash.exception instanceof Error) {
+      var ex2 = hash.exception;
+      this.message = ex2.message || msg;
+      stacktrace = ex2.stack;
+    }
+
+    if (!stacktrace) {
+      if (Error.hasOwnProperty('captureStackTrace')) {
+        // V8
+        Error.captureStackTrace(this, this.constructor);
+      } else {
+        stacktrace = new Error(msg).stack;
+      }
+    }
+
+    if (stacktrace) {
+      Object.defineProperty(this, 'stack', {
+        enumerable: false,
+        writable: false,
+        value: stacktrace
+      });
+    }
+  }
+
+  if (typeof Object.setPrototypeOf === 'function') {
+    Object.setPrototypeOf(JisonLexerError.prototype, Error.prototype);
+  } else {
+    JisonLexerError.prototype = Object.create(Error.prototype);
+  }
+
+  JisonLexerError.prototype.constructor = JisonLexerError;
+  JisonLexerError.prototype.name = 'JisonLexerError';
+
+  var lexer = {
+    
+// Code Generator Information Report
+// ---------------------------------
+//
+// Options:
+//
+//   backtracking: .................... false
+//   location.ranges: ................. false
+//   location line+column tracking: ... true
+//
+//
+// Forwarded Parser Analysis flags:
+//
+//   uses yyleng: ..................... false
+//   uses yylineno: ................... false
+//   uses yytext: ..................... false
+//   uses yylloc: ..................... false
+//   uses lexer values: ............... true / true
+//   location tracking: ............... false
+//   location assignment: ............. false
+//
+//
+// Lexer Analysis flags:
+//
+//   uses yyleng: ..................... ???
+//   uses yylineno: ................... ???
+//   uses yytext: ..................... ???
+//   uses yylloc: ..................... ???
+//   uses ParseError API: ............. ???
+//   uses yyerror: .................... ???
+//   uses location tracking & editing:  ???
+//   uses more() API: ................. ???
+//   uses unput() API: ................ ???
+//   uses reject() API: ............... ???
+//   uses less() API: ................. ???
+//   uses display APIs pastInput(), upcomingInput(), showPosition():
+//        ............................. ???
+//   uses describeYYLLOC() API: ....... ???
+//
+// --------- END OF REPORT -----------
+
+EOF: 1,
+    ERROR: 2,
+
+    // JisonLexerError: JisonLexerError,        /// <-- injected by the code generator
+
+    // options: {},                             /// <-- injected by the code generator
+
+    // yy: ...,                                 /// <-- injected by setInput()
+
+    __currentRuleSet__: null,                   /// INTERNAL USE ONLY: internal rule set cache for the current lexer state  
+
+    __error_infos: [],                          /// INTERNAL USE ONLY: the set of lexErrorInfo objects created since the last cleanup  
+    __decompressed: false,                      /// INTERNAL USE ONLY: mark whether the lexer instance has been 'unfolded' completely and is now ready for use  
+    done: false,                                /// INTERNAL USE ONLY  
+    _backtrack: false,                          /// INTERNAL USE ONLY  
+    _input: '',                                 /// INTERNAL USE ONLY  
+    _more: false,                               /// INTERNAL USE ONLY  
+    _signaled_error_token: false,               /// INTERNAL USE ONLY  
+    conditionStack: [],                         /// INTERNAL USE ONLY; managed via `pushState()`, `popState()`, `topState()` and `stateStackSize()`  
+    match: '',                                  /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks input which has been matched so far for the lexer token under construction. `match` is identical to `yytext` except that this one still contains the matched input string after `lexer.performAction()` has been invoked, where userland code MAY have changed/replaced the `yytext` value entirely!  
+    matched: '',                                /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks entire input which has been matched so far  
+    matches: false,                             /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks RE match result for last (successful) match attempt  
+    yytext: '',                                 /// ADVANCED USE ONLY: tracks input which has been matched so far for the lexer token under construction; this value is transferred to the parser as the 'token value' when the parser consumes the lexer token produced through a call to the `lex()` API.  
+    offset: 0,                                  /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks the 'cursor position' in the input string, i.e. the number of characters matched so far  
+    yyleng: 0,                                  /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: length of matched input for the token under construction (`yytext`)  
+    yylineno: 0,                                /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: 'line number' at which the token under construction is located  
+    yylloc: null,                               /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks location info (lines + columns) for the token under construction  
+
+    /**
+     * INTERNAL USE: construct a suitable error info hash object instance for `parseError`.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    constructLexErrorInfo: function lexer_constructLexErrorInfo(msg, recoverable, show_input_position) {
+      msg = '' + msg;
+
+      // heuristic to determine if the error message already contains a (partial) source code dump
+      // as produced by either `showPosition()` or `prettyPrintRange()`:
+      if (show_input_position == undefined) {
+        show_input_position = !(msg.indexOf('\n') > 0 && msg.indexOf('^') > 0);
+      }
+
+      if (this.yylloc && show_input_position) {
+        if (typeof this.prettyPrintRange === 'function') {
+          var pretty_src = this.prettyPrintRange(this.yylloc);
+
+          if (!/\n\s*$/.test(msg)) {
+            msg += '\n';
+          }
+
+          msg += '\n  Erroneous area:\n' + this.prettyPrintRange(this.yylloc);
+        } else if (typeof this.showPosition === 'function') {
+          var pos_str = this.showPosition();
+
+          if (pos_str) {
+            if (msg.length && msg[msg.length - 1] !== '\n' && pos_str[0] !== '\n') {
+              msg += '\n' + pos_str;
+            } else {
+              msg += pos_str;
+            }
+          }
+        }
+      }
+
+      /** @constructor */
+      var pei = {
+        errStr: msg,
+        recoverable: !!recoverable,
+        text: this.match,           // This one MAY be empty; userland code should use the `upcomingInput` API to obtain more text which follows the 'lexer cursor position'...  
+        token: null,
+        line: this.yylineno,
+        loc: this.yylloc,
+        yy: this.yy,
+        lexer: this,
+
+        /**
+         * and make sure the error info doesn't stay due to potential
+         * ref cycle via userland code manipulations.
+         * These would otherwise all be memory leak opportunities!
+         * 
+         * Note that only array and object references are nuked as those
+         * constitute the set of elements which can produce a cyclic ref.
+         * The rest of the members is kept intact as they are harmless.
+         * 
+         * @public
+         * @this {LexErrorInfo}
+         */
+        destroy: function destructLexErrorInfo() {
+          // remove cyclic references added to error info:
+          // info.yy = null;
+          // info.lexer = null;
+          // ...
+          var rec = !!this.recoverable;
+
+          for (var key in this) {
+            if (this.hasOwnProperty(key) && typeof key === 'object') {
+              this[key] = undefined;
+            }
+          }
+
+          this.recoverable = rec;
+        }
+      };
+
+      // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!
+      this.__error_infos.push(pei);
+
+      return pei;
+    },
+
+    /**
+     * handler which is invoked when a lexer error occurs.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    parseError: function lexer_parseError(str, hash, ExceptionClass) {
+      if (!ExceptionClass) {
+        ExceptionClass = this.JisonLexerError;
+      }
+
+      if (this.yy) {
+        if (this.yy.parser && typeof this.yy.parser.parseError === 'function') {
+          return this.yy.parser.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;
+        } else if (typeof this.yy.parseError === 'function') {
+          return this.yy.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;
+        }
+      }
+
+      throw new ExceptionClass(str, hash);
+    },
+
+    /**
+     * method which implements `yyerror(str, ...args)` functionality for use inside lexer actions.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    yyerror: function yyError(str /*, ...args */) {
+      var lineno_msg = '';
+
+      if (this.yylloc) {
+        lineno_msg = ' on line ' + (this.yylineno + 1);
+      }
+
+      var p = this.constructLexErrorInfo(
+        'Lexical error' + lineno_msg + ': ' + str,
+        this.options.lexerErrorsAreRecoverable
+      );
+
+      // Add any extra args to the hash under the name `extra_error_attributes`:
+      var args = Array.prototype.slice.call(arguments, 1);
+
+      if (args.length) {
+        p.extra_error_attributes = args;
+      }
+
+      return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
+    },
+
+    /**
+     * final cleanup function for when we have completed lexing the input;
+     * make it an API so that external code can use this one once userland
+     * code has decided it's time to destroy any lingering lexer error
+     * hash object instances and the like: this function helps to clean
+     * up these constructs, which *may* carry cyclic references which would
+     * otherwise prevent the instances from being properly and timely
+     * garbage-collected, i.e. this function helps prevent memory leaks!
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    cleanupAfterLex: function lexer_cleanupAfterLex(do_not_nuke_errorinfos) {
+      // prevent lingering circular references from causing memory leaks:
+      this.setInput('', {});
+
+      // nuke the error hash info instances created during this run.
+      // Userland code must COPY any data/references
+      // in the error hash instance(s) it is more permanently interested in.
+      if (!do_not_nuke_errorinfos) {
+        for (var i = this.__error_infos.length - 1; i >= 0; i--) {
+          var el = this.__error_infos[i];
+
+          if (el && typeof el.destroy === 'function') {
+            el.destroy();
+          }
+        }
+
+        this.__error_infos.length = 0;
+      }
+
+      return this;
+    },
+
+    /**
+     * clear the lexer token context; intended for internal use only
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    clear: function lexer_clear() {
+      this.yytext = '';
+      this.yyleng = 0;
+      this.match = '';
+
+      // - DO NOT reset `this.matched`
+      this.matches = false;
+
+      this._more = false;
+      this._backtrack = false;
+      var col = (this.yylloc ? this.yylloc.last_column : 0);
+
+      this.yylloc = {
+        first_line: this.yylineno + 1,
+        first_column: col,
+        last_line: this.yylineno + 1,
+        last_column: col,
+        range: [this.offset, this.offset]
+      };
+    },
+
+    /**
+     * resets the lexer, sets new input
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    setInput: function lexer_setInput(input, yy) {
+      this.yy = yy || this.yy || {};
+
+      // also check if we've fully initialized the lexer instance,
+      // including expansion work to be done to go from a loaded
+      // lexer to a usable lexer:
+      if (!this.__decompressed) {
+        // step 1: decompress the regex list:
+        var rules = this.rules;
+
+        for (var i = 0, len = rules.length; i < len; i++) {
+          var rule_re = rules[i];
+
+          // compression: is the RE an xref to another RE slot in the rules[] table?
+          if (typeof rule_re === 'number') {
+            rules[i] = rules[rule_re];
+          }
+        }
+
+        // step 2: unfold the conditions[] set to make these ready for use:
+        var conditions = this.conditions;
+
+        for (var k in conditions) {
+          var spec = conditions[k];
+          var rule_ids = spec.rules;
+          var len = rule_ids.length;
+          var rule_regexes = new Array(len + 1);             // slot 0 is unused; we use a 1-based index approach here to keep the hottest code in `lexer_next()` fast and simple! 
+          var rule_new_ids = new Array(len + 1);
+
+          for (var i = 0; i < len; i++) {
+            var idx = rule_ids[i];
+            var rule_re = rules[idx];
+            rule_regexes[i + 1] = rule_re;
+            rule_new_ids[i + 1] = idx;
+          }
+
+          spec.rules = rule_new_ids;
+          spec.__rule_regexes = rule_regexes;
+          spec.__rule_count = len;
+        }
+
+        this.__decompressed = true;
+      }
+
+      this._input = input || '';
+      this.clear();
+      this._signaled_error_token = false;
+      this.done = false;
+      this.yylineno = 0;
+      this.matched = '';
+      this.conditionStack = ['INITIAL'];
+      this.__currentRuleSet__ = null;
+
+      this.yylloc = {
+        first_line: 1,
+        first_column: 0,
+        last_line: 1,
+        last_column: 0,
+        range: [0, 0]
+      };
+
+      this.offset = 0;
+      return this;
+    },
+
+    /**
+     * edit the remaining input via user-specified callback.
+     * This can be used to forward-adjust the input-to-parse, 
+     * e.g. inserting macro expansions and alike in the
+     * input which has yet to be lexed.
+     * The behaviour of this API contrasts the `unput()` et al
+     * APIs as those act on the *consumed* input, while this
+     * one allows one to manipulate the future, without impacting
+     * the current `yyloc` cursor location or any history. 
+     * 
+     * Use this API to help implement C-preprocessor-like
+     * `#include` statements, etc.
+     * 
+     * The provided callback must be synchronous and is
+     * expected to return the edited input (string).
+     *
+     * The `cpsArg` argument value is passed to the callback
+     * as-is.
+     *
+     * `callback` interface: 
+     * `function callback(input, cpsArg)`
+     * 
+     * - `input` will carry the remaining-input-to-lex string
+     *   from the lexer.
+     * - `cpsArg` is `cpsArg` passed into this API.
+     * 
+     * The `this` reference for the callback will be set to
+     * reference this lexer instance so that userland code
+     * in the callback can easily and quickly access any lexer
+     * API. 
+     *
+     * When the callback returns a non-string-type falsey value,
+     * we assume the callback did not edit the input and we
+     * will using the input as-is.
+     *
+     * When the callback returns a non-string-type value, it
+     * is converted to a string for lexing via the `"" + retval`
+     * operation. (See also why: http://2ality.com/2012/03/converting-to-string.html 
+     * -- that way any returned object's `toValue()` and `toString()`
+     * methods will be invoked in a proper/desirable order.)
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    editRemainingInput: function lexer_editRemainingInput(callback, cpsArg) {
+      var rv = callback.call(this, this._input, cpsArg);
+
+      if (typeof rv !== 'string') {
+        if (rv) {
+          this._input = '' + rv;
+        } 
+        // else: keep `this._input` as is.  
+      } else {
+        this._input = rv;
+      }
+
+      return this;
+    },
+
+    /**
+     * consumes and returns one char from the input
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    input: function lexer_input() {
+      if (!this._input) {
+        //this.done = true;    -- don't set `done` as we want the lex()/next() API to be able to produce one custom EOF token match after this anyhow. (lexer can match special <<EOF>> tokens and perform user action code for a <<EOF>> match, but only does so *once*)
+        return null;
+      }
+
+      var ch = this._input[0];
+      this.yytext += ch;
+      this.yyleng++;
+      this.offset++;
+      this.match += ch;
+      this.matched += ch;
+
+      // Count the linenumber up when we hit the LF (or a stand-alone CR).
+      // On CRLF, the linenumber is incremented when you fetch the CR or the CRLF combo
+      // and we advance immediately past the LF as well, returning both together as if
+      // it was all a single 'character' only.
+      var slice_len = 1;
+
+      var lines = false;
+
+      if (ch === '\n') {
+        lines = true;
+      } else if (ch === '\r') {
+        lines = true;
+        var ch2 = this._input[1];
+
+        if (ch2 === '\n') {
+          slice_len++;
+          ch += ch2;
+          this.yytext += ch2;
+          this.yyleng++;
+          this.offset++;
+          this.match += ch2;
+          this.matched += ch2;
+          this.yylloc.range[1]++;
+        }
+      }
+
+      if (lines) {
+        this.yylineno++;
+        this.yylloc.last_line++;
+        this.yylloc.last_column = 0;
+      } else {
+        this.yylloc.last_column++;
+      }
+
+      this.yylloc.range[1]++;
+      this._input = this._input.slice(slice_len);
+      return ch;
+    },
+
+    /**
+     * unshifts one char (or an entire string) into the input
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    unput: function lexer_unput(ch) {
+      var len = ch.length;
+      var lines = ch.split(/(?:\r\n?|\n)/g);
+      this._input = ch + this._input;
+      this.yytext = this.yytext.substr(0, this.yytext.length - len);
+      this.yyleng = this.yytext.length;
+      this.offset -= len;
+      this.match = this.match.substr(0, this.match.length - len);
+      this.matched = this.matched.substr(0, this.matched.length - len);
+
+      if (lines.length > 1) {
+        this.yylineno -= lines.length - 1;
+        this.yylloc.last_line = this.yylineno + 1;
+
+        // Get last entirely matched line into the `pre_lines[]` array's
+        // last index slot; we don't mind when other previously 
+        // matched lines end up in the array too. 
+        var pre = this.match;
+
+        var pre_lines = pre.split(/(?:\r\n?|\n)/g);
+
+        if (pre_lines.length === 1) {
+          pre = this.matched;
+          pre_lines = pre.split(/(?:\r\n?|\n)/g);
+        }
+
+        this.yylloc.last_column = pre_lines[pre_lines.length - 1].length;
+      } else {
+        this.yylloc.last_column -= len;
+      }
+
+      this.yylloc.range[1] = this.yylloc.range[0] + this.yyleng;
+      this.done = false;
+      return this;
+    },
+
+    /**
+     * cache matched text and append it on next action
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    more: function lexer_more() {
+      this._more = true;
+      return this;
+    },
+
+    /**
+     * signal the lexer that this rule fails to match the input, so the
+     * next matching rule (regex) should be tested instead.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    reject: function lexer_reject() {
+      if (this.options.backtrack_lexer) {
+        this._backtrack = true;
+      } else {
+        // when the `parseError()` call returns, we MUST ensure that the error is registered.
+        // We accomplish this by signaling an 'error' token to be produced for the current
+        // `.lex()` run.
+        var lineno_msg = '';
+
+        if (this.yylloc) {
+          lineno_msg = ' on line ' + (this.yylineno + 1);
+        }
+
+        var p = this.constructLexErrorInfo(
+          'Lexical error' + lineno_msg + ': You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).',
+          false
+        );
+
+        this._signaled_error_token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
+      }
+
+      return this;
+    },
+
+    /**
+     * retain first n characters of the match
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    less: function lexer_less(n) {
+      return this.unput(this.match.slice(n));
+    },
+
+    /**
+     * return (part of the) already matched input, i.e. for error
+     * messages.
+     * 
+     * Limit the returned string length to `maxSize` (default: 20).
+     * 
+     * Limit the returned string to the `maxLines` number of lines of
+     * input (default: 1).
+     * 
+     * Negative limit values equal *unlimited*.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    pastInput: function lexer_pastInput(maxSize, maxLines) {
+      var past = this.matched.substring(0, this.matched.length - this.match.length);
+
+      if (maxSize < 0)
+        maxSize = past.length;
+      else if (!maxSize)
+        maxSize = 20;
+
+      if (maxLines < 0)
+        maxLines = past.length;          // can't ever have more input lines than this! 
+      else if (!maxLines)
+        maxLines = 1;
+
+      // `substr` anticipation: treat \r\n as a single character and take a little
+      // more than necessary so that we can still properly check against maxSize
+      // after we've transformed and limited the newLines in here:
+      past = past.substr(-maxSize * 2 - 2);
+
+      // now that we have a significantly reduced string to process, transform the newlines
+      // and chop them, then limit them:
+      var a = past.replace(/\r\n|\r/g, '\n').split('\n');
+
+      a = a.slice(-maxLines);
+      past = a.join('\n');
+
+      // When, after limiting to maxLines, we still have too much to return,
+      // do add an ellipsis prefix...
+      if (past.length > maxSize) {
+        past = '...' + past.substr(-maxSize);
+      }
+
+      return past;
+    },
+
+    /**
+     * return (part of the) upcoming input, i.e. for error messages.
+     * 
+     * Limit the returned string length to `maxSize` (default: 20).
+     * 
+     * Limit the returned string to the `maxLines` number of lines of input (default: 1).
+     * 
+     * Negative limit values equal *unlimited*.
+     *
+     * > ### NOTE ###
+     * >
+     * > *"upcoming input"* is defined as the whole of the both
+     * > the *currently lexed* input, together with any remaining input
+     * > following that. *"currently lexed"* input is the input 
+     * > already recognized by the lexer but not yet returned with
+     * > the lexer token. This happens when you are invoking this API
+     * > from inside any lexer rule action code block. 
+     * >
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    upcomingInput: function lexer_upcomingInput(maxSize, maxLines) {
+      var next = this.match;
+
+      if (maxSize < 0)
+        maxSize = next.length + this._input.length;
+      else if (!maxSize)
+        maxSize = 20;
+
+      if (maxLines < 0)
+        maxLines = maxSize;          // can't ever have more input lines than this! 
+      else if (!maxLines)
+        maxLines = 1;
+
+      // `substring` anticipation: treat \r\n as a single character and take a little
+      // more than necessary so that we can still properly check against maxSize
+      // after we've transformed and limited the newLines in here:
+      if (next.length < maxSize * 2 + 2) {
+        next += this._input.substring(0, maxSize * 2 + 2);   // substring is faster on Chrome/V8 
+      }
+
+      // now that we have a significantly reduced string to process, transform the newlines
+      // and chop them, then limit them:
+      var a = next.replace(/\r\n|\r/g, '\n').split('\n');
+
+      a = a.slice(0, maxLines);
+      next = a.join('\n');
+
+      // When, after limiting to maxLines, we still have too much to return,
+      // do add an ellipsis postfix...
+      if (next.length > maxSize) {
+        next = next.substring(0, maxSize) + '...';
+      }
+
+      return next;
+    },
+
+    /**
+     * return a string which displays the character position where the
+     * lexing error occurred, i.e. for error messages
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    showPosition: function lexer_showPosition(maxPrefix, maxPostfix) {
+      var pre = this.pastInput(maxPrefix).replace(/\s/g, ' ');
+      var c = new Array(pre.length + 1).join('-');
+      return pre + this.upcomingInput(maxPostfix).replace(/\s/g, ' ') + '\n' + c + '^';
+    },
+
+    /**
+     * return an YYLLOC info object derived off the given context (actual, preceding, following, current).
+     * Use this method when the given `actual` location is not guaranteed to exist (i.e. when
+     * it MAY be NULL) and you MUST have a valid location info object anyway:
+     * then we take the given context of the `preceding` and `following` locations, IFF those are available,
+     * and reconstruct the `actual` location info from those.
+     * If this fails, the heuristic is to take the `current` location, IFF available.
+     * If this fails as well, we assume the sought location is at/around the current lexer position
+     * and then produce that one as a response. DO NOTE that these heuristic/derived location info
+     * values MAY be inaccurate!
+     *
+     * NOTE: `deriveLocationInfo()` ALWAYS produces a location info object *copy* of `actual`, not just
+     * a *reference* hence all input location objects can be assumed to be 'constant' (function has no side-effects).
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    deriveLocationInfo: function lexer_deriveYYLLOC(actual, preceding, following, current) {
+      var loc = {
+        first_line: 1,
+        first_column: 0,
+        last_line: 1,
+        last_column: 0,
+        range: [0, 0]
+      };
+
+      if (actual) {
+        loc.first_line = actual.first_line | 0;
+        loc.last_line = actual.last_line | 0;
+        loc.first_column = actual.first_column | 0;
+        loc.last_column = actual.last_column | 0;
+
+        if (actual.range) {
+          loc.range[0] = actual.range[0] | 0;
+          loc.range[1] = actual.range[1] | 0;
+        }
+      }
+
+      if (loc.first_line <= 0 || loc.last_line < loc.first_line) {
+        // plan B: heuristic using preceding and following:
+        if (loc.first_line <= 0 && preceding) {
+          loc.first_line = preceding.last_line | 0;
+          loc.first_column = preceding.last_column | 0;
+
+          if (preceding.range) {
+            loc.range[0] = actual.range[1] | 0;
+          }
+        }
+
+        if ((loc.last_line <= 0 || loc.last_line < loc.first_line) && following) {
+          loc.last_line = following.first_line | 0;
+          loc.last_column = following.first_column | 0;
+
+          if (following.range) {
+            loc.range[1] = actual.range[0] | 0;
+          }
+        }
+
+        // plan C?: see if the 'current' location is useful/sane too:
+        if (loc.first_line <= 0 && current && (loc.last_line <= 0 || current.last_line <= loc.last_line)) {
+          loc.first_line = current.first_line | 0;
+          loc.first_column = current.first_column | 0;
+
+          if (current.range) {
+            loc.range[0] = current.range[0] | 0;
+          }
+        }
+
+        if (loc.last_line <= 0 && current && (loc.first_line <= 0 || current.first_line >= loc.first_line)) {
+          loc.last_line = current.last_line | 0;
+          loc.last_column = current.last_column | 0;
+
+          if (current.range) {
+            loc.range[1] = current.range[1] | 0;
+          }
+        }
+      }
+
+      // sanitize: fix last_line BEFORE we fix first_line as we use the 'raw' value of the latter
+      // or plan D heuristics to produce a 'sensible' last_line value:
+      if (loc.last_line <= 0) {
+        if (loc.first_line <= 0) {
+          loc.first_line = this.yylloc.first_line;
+          loc.last_line = this.yylloc.last_line;
+          loc.first_column = this.yylloc.first_column;
+          loc.last_column = this.yylloc.last_column;
+          loc.range[0] = this.yylloc.range[0];
+          loc.range[1] = this.yylloc.range[1];
+        } else {
+          loc.last_line = this.yylloc.last_line;
+          loc.last_column = this.yylloc.last_column;
+          loc.range[1] = this.yylloc.range[1];
+        }
+      }
+
+      if (loc.first_line <= 0) {
+        loc.first_line = loc.last_line;
+        loc.first_column = 0;  // loc.last_column; 
+        loc.range[1] = loc.range[0];
+      }
+
+      if (loc.first_column < 0) {
+        loc.first_column = 0;
+      }
+
+      if (loc.last_column < 0) {
+        loc.last_column = (loc.first_column > 0 ? loc.first_column : 80);
+      }
+
+      return loc;
+    },
+
+    /**
+     * return a string which displays the lines & columns of input which are referenced 
+     * by the given location info range, plus a few lines of context.
+     * 
+     * This function pretty-prints the indicated section of the input, with line numbers 
+     * and everything!
+     * 
+     * This function is very useful to provide highly readable error reports, while
+     * the location range may be specified in various flexible ways:
+     * 
+     * - `loc` is the location info object which references the area which should be
+     *   displayed and 'marked up': these lines & columns of text are marked up by `^`
+     *   characters below each character in the entire input range.
+     * 
+     * - `context_loc` is the *optional* location info object which instructs this
+     *   pretty-printer how much *leading* context should be displayed alongside
+     *   the area referenced by `loc`. This can help provide context for the displayed
+     *   error, etc.
+     * 
+     *   When this location info is not provided, a default context of 3 lines is
+     *   used.
+     * 
+     * - `context_loc2` is another *optional* location info object, which serves
+     *   a similar purpose to `context_loc`: it specifies the amount of *trailing*
+     *   context lines to display in the pretty-print output.
+     * 
+     *   When this location info is not provided, a default context of 1 line only is
+     *   used.
+     * 
+     * Special Notes:
+     * 
+     * - when the `loc`-indicated range is very large (about 5 lines or more), then
+     *   only the first and last few lines of this block are printed while a
+     *   `...continued...` message will be printed between them.
+     * 
+     *   This serves the purpose of not printing a huge amount of text when the `loc`
+     *   range happens to be huge: this way a manageable & readable output results
+     *   for arbitrary large ranges.
+     * 
+     * - this function can display lines of input which whave not yet been lexed.
+     *   `prettyPrintRange()` can access the entire input!
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    prettyPrintRange: function lexer_prettyPrintRange(loc, context_loc, context_loc2) {
+      loc = this.deriveLocationInfo(loc, context_loc, context_loc2);
+      const CONTEXT = 3;
+      const CONTEXT_TAIL = 1;
+      const MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT = 2;
+      var input = this.matched + this._input;
+      var lines = input.split('\n');
+      var l0 = Math.max(1, (context_loc ? context_loc.first_line : loc.first_line - CONTEXT));
+      var l1 = Math.max(1, (context_loc2 ? context_loc2.last_line : loc.last_line + CONTEXT_TAIL));
+      var lineno_display_width = 1 + Math.log10(l1 | 1) | 0;
+      var ws_prefix = new Array(lineno_display_width).join(' ');
+      var nonempty_line_indexes = [];
+
+      var rv = lines.slice(l0 - 1, l1 + 1).map(function injectLineNumber(line, index) {
+        var lno = index + l0;
+        var lno_pfx = (ws_prefix + lno).substr(-lineno_display_width);
+        var rv = lno_pfx + ': ' + line;
+        var errpfx = new Array(lineno_display_width + 1).join('^');
+        var offset = 2 + 1;
+        var len = 0;
+
+        if (lno === loc.first_line) {
+          offset += loc.first_column;
+
+          len = Math.max(
+            2,
+            ((lno === loc.last_line ? loc.last_column : line.length)) - loc.first_column + 1
+          );
+        } else if (lno === loc.last_line) {
+          len = Math.max(2, loc.last_column + 1);
+        } else if (lno > loc.first_line && lno < loc.last_line) {
+          len = Math.max(2, line.length + 1);
+        }
+
+        if (len) {
+          var lead = new Array(offset).join('.');
+          var mark = new Array(len).join('^');
+          rv += '\n' + errpfx + lead + mark;
+
+          if (line.trim().length > 0) {
+            nonempty_line_indexes.push(index);
+          }
+        }
+
+        rv = rv.replace(/\t/g, ' ');
+        return rv;
+      });
+
+      // now make sure we don't print an overly large amount of error area: limit it 
+      // to the top and bottom line count:
+      if (nonempty_line_indexes.length > 2 * MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT) {
+        var clip_start = nonempty_line_indexes[MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT - 1] + 1;
+        var clip_end = nonempty_line_indexes[nonempty_line_indexes.length - MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT] - 1;
+        var intermediate_line = new Array(lineno_display_width + 1).join(' ') + '  (...continued...)';
+        intermediate_line += '\n' + new Array(lineno_display_width + 1).join('-') + '  (---------------)';
+        rv.splice(clip_start, clip_end - clip_start + 1, intermediate_line);
+      }
+
+      return rv.join('\n');
+    },
+
+    /**
+     * helper function, used to produce a human readable description as a string, given
+     * the input `yylloc` location object.
+     * 
+     * Set `display_range_too` to TRUE to include the string character index position(s)
+     * in the description if the `yylloc.range` is available.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    describeYYLLOC: function lexer_describe_yylloc(yylloc, display_range_too) {
+      var l1 = yylloc.first_line;
+      var l2 = yylloc.last_line;
+      var c1 = yylloc.first_column;
+      var c2 = yylloc.last_column;
+      var dl = l2 - l1;
+      var dc = c2 - c1;
+      var rv;
+
+      if (dl === 0) {
+        rv = 'line ' + l1 + ', ';
+
+        if (dc <= 1) {
+          rv += 'column ' + c1;
+        } else {
+          rv += 'columns ' + c1 + ' .. ' + c2;
+        }
+      } else {
+        rv = 'lines ' + l1 + '(column ' + c1 + ') .. ' + l2 + '(column ' + c2 + ')';
+      }
+
+      if (yylloc.range && display_range_too) {
+        var r1 = yylloc.range[0];
+        var r2 = yylloc.range[1] - 1;
+
+        if (r2 <= r1) {
+          rv += ' {String Offset: ' + r1 + '}';
+        } else {
+          rv += ' {String Offset range: ' + r1 + ' .. ' + r2 + '}';
+        }
+      }
+
+      return rv;
+    },
+
+    /**
+     * test the lexed token: return FALSE when not a match, otherwise return token.
+     * 
+     * `match` is supposed to be an array coming out of a regex match, i.e. `match[0]`
+     * contains the actually matched text string.
+     * 
+     * Also move the input cursor forward and update the match collectors:
+     * 
+     * - `yytext`
+     * - `yyleng`
+     * - `match`
+     * - `matches`
+     * - `yylloc`
+     * - `offset`
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    test_match: function lexer_test_match(match, indexed_rule) {
+      var token, lines, backup, match_str, match_str_len;
+
+      if (this.options.backtrack_lexer) {
+        // save context
+        backup = {
+          yylineno: this.yylineno,
+
+          yylloc: {
+            first_line: this.yylloc.first_line,
+            last_line: this.yylloc.last_line,
+            first_column: this.yylloc.first_column,
+            last_column: this.yylloc.last_column,
+            range: this.yylloc.range.slice(0)
+          },
+
+          yytext: this.yytext,
+          match: this.match,
+          matches: this.matches,
+          matched: this.matched,
+          yyleng: this.yyleng,
+          offset: this.offset,
+          _more: this._more,
+          _input: this._input,
+
+          //_signaled_error_token: this._signaled_error_token,
+          yy: this.yy,
+
+          conditionStack: this.conditionStack.slice(0),
+          done: this.done
+        };
+      }
+
+      match_str = match[0];
+      match_str_len = match_str.length;
+
+      // if (match_str.indexOf('\n') !== -1 || match_str.indexOf('\r') !== -1) {
+      lines = match_str.split(/(?:\r\n?|\n)/g);
+
+      if (lines.length > 1) {
+        this.yylineno += lines.length - 1;
+        this.yylloc.last_line = this.yylineno + 1;
+        this.yylloc.last_column = lines[lines.length - 1].length;
+      } else {
+        this.yylloc.last_column += match_str_len;
+      }
+
+      // }
+      this.yytext += match_str;
+
+      this.match += match_str;
+      this.matched += match_str;
+      this.matches = match;
+      this.yyleng = this.yytext.length;
+      this.yylloc.range[1] += match_str_len;
+
+      // previous lex rules MAY have invoked the `more()` API rather than producing a token:
+      // those rules will already have moved this `offset` forward matching their match lengths,
+      // hence we must only add our own match length now:
+      this.offset += match_str_len;
+
+      this._more = false;
+      this._backtrack = false;
+      this._input = this._input.slice(match_str_len);
+
+      // calling this method:
+      //
+      //   function lexer__performAction(yy, yyrulenumber, YY_START) {...}
+      token = this.performAction.call(
+        this,
+        this.yy,
+        indexed_rule,
+        this.conditionStack[this.conditionStack.length - 1] /* = YY_START */
+      );
+
+      // otherwise, when the action codes are all simple return token statements:
+      //token = this.simpleCaseActionClusters[indexed_rule];
+
+      if (this.done && this._input) {
+        this.done = false;
+      }
+
+      if (token) {
+        return token;
+      } else if (this._backtrack) {
+        // recover context
+        for (var k in backup) {
+          this[k] = backup[k];
+        }
+
+        this.__currentRuleSet__ = null;
+        return false;  // rule action called reject() implying the next rule should be tested instead. 
+      } else if (this._signaled_error_token) {
+        // produce one 'error' token as `.parseError()` in `reject()`
+        // did not guarantee a failure signal by throwing an exception!
+        token = this._signaled_error_token;
+
+        this._signaled_error_token = false;
+        return token;
+      }
+
+      return false;
+    },
+
+    /**
+     * return next match in input
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    next: function lexer_next() {
+      if (this.done) {
+        this.clear();
+        return this.EOF;
+      }
+
+      if (!this._input) {
+        this.done = true;
+      }
+
+      var token, match, tempMatch, index;
+
+      if (!this._more) {
+        this.clear();
+      }
+
+      var spec = this.__currentRuleSet__;
+
+      if (!spec) {
+        // Update the ruleset cache as we apparently encountered a state change or just started lexing.
+        // The cache is set up for fast lookup -- we assume a lexer will switch states much less often than it will
+        // invoke the `lex()` token-producing API and related APIs, hence caching the set for direct access helps
+        // speed up those activities a tiny bit.
+        spec = this.__currentRuleSet__ = this._currentRules();
+
+        // Check whether a *sane* condition has been pushed before: this makes the lexer robust against
+        // user-programmer bugs such as https://github.com/zaach/jison-lex/issues/19
+        if (!spec || !spec.rules) {
+          var lineno_msg = '';
+
+          if (this.options.trackPosition) {
+            lineno_msg = ' on line ' + (this.yylineno + 1);
+          }
+
+          var p = this.constructLexErrorInfo(
+            'Internal lexer engine error' + lineno_msg + ': The lex grammar programmer pushed a non-existing condition name "' + this.topState() + '"; this is a fatal error and should be reported to the application programmer team!',
+            false
+          );
+
+          // produce one 'error' token until this situation has been resolved, most probably by parse termination!
+          return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
+        }
+      }
+
+      var rule_ids = spec.rules;
+      var regexes = spec.__rule_regexes;
+      var len = spec.__rule_count;
+
+      // Note: the arrays are 1-based, while `len` itself is a valid index,
+      // hence the non-standard less-or-equal check in the next loop condition!
+      for (var i = 1; i <= len; i++) {
+        tempMatch = this._input.match(regexes[i]);
+
+        if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+          match = tempMatch;
+          index = i;
+
+          if (this.options.backtrack_lexer) {
+            token = this.test_match(tempMatch, rule_ids[i]);
+
+            if (token !== false) {
+              return token;
+            } else if (this._backtrack) {
+              match = undefined;
+              continue;  // rule action called reject() implying a rule MISmatch. 
+            } else {
+              // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+              return false;
+            }
+          } else if (!this.options.flex) {
+            break;
+          }
+        }
+      }
+
+      if (match) {
+        token = this.test_match(match, rule_ids[index]);
+
+        if (token !== false) {
+          return token;
+        }
+
+        // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+        return false;
+      }
+
+      if (!this._input) {
+        this.done = true;
+        this.clear();
+        return this.EOF;
+      } else {
+        var lineno_msg = '';
+
+        if (this.options.trackPosition) {
+          lineno_msg = ' on line ' + (this.yylineno + 1);
+        }
+
+        var p = this.constructLexErrorInfo(
+          'Lexical error' + lineno_msg + ': Unrecognized text.',
+          this.options.lexerErrorsAreRecoverable
+        );
+
+        var pendingInput = this._input;
+        var activeCondition = this.topState();
+        var conditionStackDepth = this.conditionStack.length;
+        token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
+
+        if (token === this.ERROR) {
+          // we can try to recover from a lexer error that `parseError()` did not 'recover' for us
+          // by moving forward at least one character at a time IFF the (user-specified?) `parseError()`
+          // has not consumed/modified any pending input or changed state in the error handler:
+          if (!this.matches && // and make sure the input has been modified/consumed ...
+          pendingInput === this._input && // ...or the lexer state has been modified significantly enough
+          // to merit a non-consuming error handling action right now.
+          activeCondition === this.topState() && conditionStackDepth === this.conditionStack.length) {
+            this.input();
+          }
+        }
+
+        return token;
+      }
+    },
+
+    /**
+     * return next match that has a token
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    lex: function lexer_lex() {
+      var r;
+
+      // allow the PRE/POST handlers set/modify the return token for maximum flexibility of the generated lexer:
+      if (typeof this.pre_lex === 'function') {
+        r = this.pre_lex.call(this, 0);
+      }
+
+      if (typeof this.options.pre_lex === 'function') {
+        // (also account for a userdef function which does not return any value: keep the token as is)
+        r = this.options.pre_lex.call(this, r) || r;
+      }
+
+      if (this.yy && typeof this.yy.pre_lex === 'function') {
+        // (also account for a userdef function which does not return any value: keep the token as is)
+        r = this.yy.pre_lex.call(this, r) || r;
+      }
+
+      while (!r) {
+        r = this.next();
+      }
+
+      if (this.yy && typeof this.yy.post_lex === 'function') {
+        // (also account for a userdef function which does not return any value: keep the token as is)
+        r = this.yy.post_lex.call(this, r) || r;
+      }
+
+      if (typeof this.options.post_lex === 'function') {
+        // (also account for a userdef function which does not return any value: keep the token as is)
+        r = this.options.post_lex.call(this, r) || r;
+      }
+
+      if (typeof this.post_lex === 'function') {
+        // (also account for a userdef function which does not return any value: keep the token as is)
+        r = this.post_lex.call(this, r) || r;
+      }
+
+      return r;
+    },
+
+    /**
+     * return next match that has a token. Identical to the `lex()` API but does not invoke any of the 
+     * `pre_lex()` nor any of the `post_lex()` callbacks.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    fastLex: function lexer_fastLex() {
+      var r;
+
+      while (!r) {
+        r = this.next();
+      }
+
+      return r;
+    },
+
+    /**
+     * return info about the lexer state that can help a parser or other lexer API user to use the
+     * most efficient means available. This API is provided to aid run-time performance for larger
+     * systems which employ this lexer.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    canIUse: function lexer_canIUse() {
+      var rv = {
+        fastLex: !(typeof this.pre_lex === 'function' || typeof this.options.pre_lex === 'function' || this.yy && typeof this.yy.pre_lex === 'function' || this.yy && typeof this.yy.post_lex === 'function' || typeof this.options.post_lex === 'function' || typeof this.post_lex === 'function') && typeof this.fastLex === 'function'
+      };
+
+      return rv;
+    },
+
+    /**
+     * backwards compatible alias for `pushState()`;
+     * the latter is symmetrical with `popState()` and we advise to use
+     * those APIs in any modern lexer code, rather than `begin()`.
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    begin: function lexer_begin(condition) {
+      return this.pushState(condition);
+    },
+
+    /**
+     * activates a new lexer condition state (pushes the new lexer
+     * condition state onto the condition stack)
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    pushState: function lexer_pushState(condition) {
+      this.conditionStack.push(condition);
+      this.__currentRuleSet__ = null;
+      return this;
+    },
+
+    /**
+     * pop the previously active lexer condition state off the condition
+     * stack
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    popState: function lexer_popState() {
+      var n = this.conditionStack.length - 1;
+
+      if (n > 0) {
+        this.__currentRuleSet__ = null;
+        return this.conditionStack.pop();
+      } else {
+        return this.conditionStack[0];
+      }
+    },
+
+    /**
+     * return the currently active lexer condition state; when an index
+     * argument is provided it produces the N-th previous condition state,
+     * if available
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    topState: function lexer_topState(n) {
+      n = this.conditionStack.length - 1 - Math.abs(n || 0);
+
+      if (n >= 0) {
+        return this.conditionStack[n];
+      } else {
+        return 'INITIAL';
+      }
+    },
+
+    /**
+     * (internal) determine the lexer rule set which is active for the
+     * currently active lexer condition state
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    _currentRules: function lexer__currentRules() {
+      if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
+        return this.conditions[this.conditionStack[this.conditionStack.length - 1]];
+      } else {
+        return this.conditions['INITIAL'];
+      }
+    },
+
+    /**
+     * return the number of states currently on the stack
+     * 
+     * @public
+     * @this {RegExpLexer}
+     */
+    stateStackSize: function lexer_stateStackSize() {
+      return this.conditionStack.length;
+    },
+
+    options: {
+      trackPosition: true
+    },
+
+    JisonLexerError: JisonLexerError,
+
+    performAction: function lexer__performAction(yy, yyrulenumber, YY_START) {
+      var yy_ = this;
+      var YYSTATE = YY_START;
+
+      switch (yyrulenumber) {
+      case 1:
+        /*! Conditions:: INITIAL */
+        /*! Rule::       \s+ */
+        /* skip whitespace */
+        break;
+
+      default:
+        return this.simpleCaseActionClusters[yyrulenumber];
+      }
+    },
+
+    simpleCaseActionClusters: {
+      /*! Conditions:: INITIAL */
+      /*! Rule::       (--[0-9a-z-A-Z-]*) */
+      0: 13,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       \* */
+      2: 5,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       \/ */
+      3: 6,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       \+ */
+      4: 3,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       - */
+      5: 4,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)px\b */
+      6: 15,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)cm\b */
+      7: 15,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)mm\b */
+      8: 15,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)in\b */
+      9: 15,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)pt\b */
+      10: 15,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)pc\b */
+      11: 15,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)deg\b */
+      12: 16,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)grad\b */
+      13: 16,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)rad\b */
+      14: 16,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)turn\b */
+      15: 16,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)s\b */
+      16: 17,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)ms\b */
+      17: 17,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)Hz\b */
+      18: 18,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)kHz\b */
+      19: 18,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)dpi\b */
+      20: 19,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)dpcm\b */
+      21: 19,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)dppx\b */
+      22: 19,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)em\b */
+      23: 20,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)ex\b */
+      24: 21,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)ch\b */
+      25: 22,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)rem\b */
+      26: 23,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)vw\b */
+      27: 25,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)vh\b */
+      28: 24,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)vmin\b */
+      29: 26,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)vmax\b */
+      30: 27,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)% */
+      31: 28,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([0-9]+(\.[0-9]*)?|\.[0-9]+)\b */
+      32: 11,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       (calc) */
+      33: 9,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       (var) */
+      34: 12,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       ([a-z]+) */
+      35: 10,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       \( */
+      36: 7,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       \) */
+      37: 8,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       , */
+      38: 14,
+
+      /*! Conditions:: INITIAL */
+      /*! Rule::       $ */
+      39: 1
+    },
+
+    rules: [
+      /*  0: */  /^(?:(--[\d\-A-Za-z]*))/,
+      /*  1: */  /^(?:\s+)/,
+      /*  2: */  /^(?:\*)/,
+      /*  3: */  /^(?:\/)/,
+      /*  4: */  /^(?:\+)/,
+      /*  5: */  /^(?:-)/,
+      /*  6: */  /^(?:(\d+(\.\d*)?|\.\d+)px\b)/,
+      /*  7: */  /^(?:(\d+(\.\d*)?|\.\d+)cm\b)/,
+      /*  8: */  /^(?:(\d+(\.\d*)?|\.\d+)mm\b)/,
+      /*  9: */  /^(?:(\d+(\.\d*)?|\.\d+)in\b)/,
+      /* 10: */  /^(?:(\d+(\.\d*)?|\.\d+)pt\b)/,
+      /* 11: */  /^(?:(\d+(\.\d*)?|\.\d+)pc\b)/,
+      /* 12: */  /^(?:(\d+(\.\d*)?|\.\d+)deg\b)/,
+      /* 13: */  /^(?:(\d+(\.\d*)?|\.\d+)grad\b)/,
+      /* 14: */  /^(?:(\d+(\.\d*)?|\.\d+)rad\b)/,
+      /* 15: */  /^(?:(\d+(\.\d*)?|\.\d+)turn\b)/,
+      /* 16: */  /^(?:(\d+(\.\d*)?|\.\d+)s\b)/,
+      /* 17: */  /^(?:(\d+(\.\d*)?|\.\d+)ms\b)/,
+      /* 18: */  /^(?:(\d+(\.\d*)?|\.\d+)Hz\b)/,
+      /* 19: */  /^(?:(\d+(\.\d*)?|\.\d+)kHz\b)/,
+      /* 20: */  /^(?:(\d+(\.\d*)?|\.\d+)dpi\b)/,
+      /* 21: */  /^(?:(\d+(\.\d*)?|\.\d+)dpcm\b)/,
+      /* 22: */  /^(?:(\d+(\.\d*)?|\.\d+)dppx\b)/,
+      /* 23: */  /^(?:(\d+(\.\d*)?|\.\d+)em\b)/,
+      /* 24: */  /^(?:(\d+(\.\d*)?|\.\d+)ex\b)/,
+      /* 25: */  /^(?:(\d+(\.\d*)?|\.\d+)ch\b)/,
+      /* 26: */  /^(?:(\d+(\.\d*)?|\.\d+)rem\b)/,
+      /* 27: */  /^(?:(\d+(\.\d*)?|\.\d+)vw\b)/,
+      /* 28: */  /^(?:(\d+(\.\d*)?|\.\d+)vh\b)/,
+      /* 29: */  /^(?:(\d+(\.\d*)?|\.\d+)vmin\b)/,
+      /* 30: */  /^(?:(\d+(\.\d*)?|\.\d+)vmax\b)/,
+      /* 31: */  /^(?:(\d+(\.\d*)?|\.\d+)%)/,
+      /* 32: */  /^(?:(\d+(\.\d*)?|\.\d+)\b)/,
+      /* 33: */  /^(?:(calc))/,
+      /* 34: */  /^(?:(var))/,
+      /* 35: */  /^(?:([a-z]+))/,
+      /* 36: */  /^(?:\()/,
+      /* 37: */  /^(?:\))/,
+      /* 38: */  /^(?:,)/,
+      /* 39: */  /^(?:$)/
+    ],
+
+    conditions: {
+      'INITIAL': {
+        rules: [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17,
+          18,
+          19,
+          20,
+          21,
+          22,
+          23,
+          24,
+          25,
+          26,
+          27,
+          28,
+          29,
+          30,
+          31,
+          32,
+          33,
+          34,
+          35,
+          36,
+          37,
+          38,
+          39
+        ],
+
+        inclusive: true
+      }
+    }
+  };
+
+  return lexer;
+}();
+parser.lexer = lexer;
+
+
+
+function Parser() {
+  this.yy = {};
+}
+Parser.prototype = parser;
+parser.Parser = Parser;
+
+return new Parser();
+})();
+
+        
+
+
+if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
+  exports.parser = parser;
+  exports.Parser = parser.Parser;
+  exports.parse = function () {
+    return parser.parse.apply(parser, arguments);
+  };
+  
+}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/package.json b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/package.json
new file mode 100644
index 00000000..e68caf24
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/node_modules/reduce-css-calc/package.json
@@ -0,0 +1,49 @@
+{
+  "name": "reduce-css-calc",
+  "version": "2.1.8",
+  "description": "Reduce CSS calc() function to the maximum",
+  "keywords": [
+    "css",
+    "calculation",
+    "calc"
+  ],
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublish": "npm run build && del-cli dist/__tests__",
+    "build": "del-cli dist && cross-env BABEL_ENV=publish babel src --out-dir dist && jison parser.jison -o dist/parser.js",
+    "pretest": "eslint src && npm run build",
+    "test": "ava dist/__tests__/",
+    "release": "npmpub"
+  },
+  "author": "Maxime Thirouin",
+  "license": "MIT",
+  "repository": "https://github.com/MoOx/reduce-css-calc.git",
+  "devDependencies": {
+    "ava": "^0.18.2",
+    "babel-cli": "^6.18.0",
+    "babel-core": "^6.21.0",
+    "babel-eslint": "^7.1.1",
+    "babel-plugin-add-module-exports": "^0.2.1",
+    "babel-preset-env": "^1.6.0",
+    "babel-register": "^6.18.0",
+    "cross-env": "^3.1.4",
+    "del-cli": "^0.2.1",
+    "eslint": "^3.12.2",
+    "eslint-config-i-am-meticulous": "^6.0.1",
+    "eslint-plugin-babel": "^4.0.0",
+    "eslint-plugin-import": "^2.2.0",
+    "jison-gho": "^0.6.1-216",
+    "npmpub": "^5.0.0"
+  },
+  "dependencies": {
+    "css-unit-converter": "^1.1.1",
+    "postcss-value-parser": "^3.3.0"
+  },
+  "eslintConfig": {
+    "parser": "babel-eslint",
+    "extends": "eslint-config-i-am-meticulous"
+  }
+}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-calc/package.json b/node_modules/postcss-fixes/node_modules/postcss-calc/package.json
new file mode 100644
index 00000000..c23cc0c1
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-calc/package.json
@@ -0,0 +1,54 @@
+{
+  "name": "postcss-calc",
+  "version": "6.0.2",
+  "description": "PostCSS plugin to reduce calc()",
+  "keywords": [
+    "css",
+    "postcss",
+    "postcss-plugin",
+    "calculation",
+    "calc"
+  ],
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepublish": "npm run build && del-cli dist/__tests__",
+    "build": "del-cli dist && cross-env BABEL_ENV=publish babel src --out-dir dist",
+    "pretest": "eslint src && npm run build",
+    "test": "ava src/__tests__/"
+  },
+  "author": "Maxime Thirouin",
+  "license": "MIT",
+  "repository": "https://github.com/postcss/postcss-calc.git",
+  "eslintConfig": {
+    "parser": "babel-eslint",
+    "extends": "eslint-config-i-am-meticulous"
+  },
+  "devDependencies": {
+    "ava": "^0.19.1",
+    "babel-cli": "^6.18.0",
+    "babel-core": "^6.21.0",
+    "babel-eslint": "^7.1.1",
+    "babel-plugin-add-module-exports": "^0.2.1",
+    "babel-preset-env": "^1.4.0",
+    "babel-register": "^6.18.0",
+    "cross-env": "^4.0.0",
+    "del-cli": "^0.2.1",
+    "eslint": "^3.12.2",
+    "eslint-config-i-am-meticulous": "^6.0.1",
+    "eslint-plugin-babel": "^4.0.0",
+    "eslint-plugin-import": "^2.2.0"
+  },
+  "dependencies": {
+    "css-unit-converter": "^1.1.1",
+    "postcss": "^7.0.2",
+    "postcss-selector-parser": "^2.2.2",
+    "reduce-css-calc": "^2.0.0"
+  },
+  "ava": {
+    "require": "babel-register"
+  }
+}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/API.md b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/API.md
new file mode 100644
index 00000000..3386d547
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/API.md
@@ -0,0 +1,624 @@
+# API Documentation
+
+*Please use only this documented API when working with the parser. Methods
+not documented here are subject to change at any point.*
+
+## `parser` function
+
+This is the module's main entry point.
+
+```js
+var parser = require('postcss-selector-parser');
+```
+
+### `parser([transform])`
+
+Creates a new `processor` instance
+
+```js
+var processor = parser();
+
+// or, with optional transform function
+var transform = function (selectors) {
+    selectors.eachUniversal(function (selector) {
+        selector.remove();
+    });
+};
+
+var processor = parser(transform)
+
+// Example
+var result = processor.process('*.class').result;
+// => .class
+```
+
+[See processor documentation](#processor)
+
+Arguments:
+
+* `transform (function)`: Provide a function to work with the parsed AST.
+
+### `parser.attribute([props])`
+
+Creates a new attribute selector.
+
+```js
+parser.attribute({attribute: 'href'});
+// => [href]
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.className([props])`
+
+Creates a new class selector.
+
+```js
+parser.className({value: 'button'});
+// => .button
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.combinator([props])`
+
+Creates a new selector combinator.
+
+```js
+parser.combinator({value: '+'});
+// => +
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.comment([props])`
+
+Creates a new comment.
+
+```js
+parser.comment({value: '/* Affirmative, Dave. I read you. */'});
+// => /* Affirmative, Dave. I read you. */
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.id([props])`
+
+Creates a new id selector.
+
+```js
+parser.id({value: 'search'});
+// => #search
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.nesting([props])`
+
+Creates a new nesting selector.
+
+```js
+parser.nesting();
+// => &
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.pseudo([props])`
+
+Creates a new pseudo selector.
+
+```js
+parser.pseudo({value: '::before'});
+// => ::before
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.root([props])`
+
+Creates a new root node.
+
+```js
+parser.root();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.selector([props])`
+
+Creates a new selector node.
+
+```js
+parser.selector();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.string([props])`
+
+Creates a new string node.
+
+```js
+parser.string();
+// => (empty)
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.tag([props])`
+
+Creates a new tag selector.
+
+```js
+parser.tag({value: 'button'});
+// => button
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+### `parser.universal([props])`
+
+Creates a new universal selector.
+
+```js
+parser.universal();
+// => *
+```
+
+Arguments:
+
+* `props (object)`: The new node's properties.
+
+## Node types
+
+### `node.type`
+
+A string representation of the selector type. It can be one of the following;
+`attribute`, `class`, `combinator`, `comment`, `id`, `nesting`, `pseudo`,
+`root`, `selector`, `string`, `tag`, or `universal`. Note that for convenience,
+these constants are exposed on the main `parser` as uppercased keys. So for
+example you can get `id` by querying `parser.ID`.
+
+```js
+parser.attribute({attribute: 'href'}).type;
+// => 'attribute'
+```
+
+### `node.parent`
+
+Returns the parent node.
+
+```js
+root.nodes[0].parent === root;
+```
+
+### `node.toString()`, `String(node)`, or `'' + node`
+
+Returns a string representation of the node.
+
+```js
+var id = parser.id({value: 'search'});
+console.log(String(id));
+// => #search
+```
+
+### `node.next()` & `node.prev()`
+
+Returns the next/previous child of the parent node.
+
+```js
+var next = id.next();
+if (next && next.type !== 'combinator') {
+    throw new Error('Qualified IDs are not allowed!');
+}
+```
+
+### `node.replaceWith(node)`
+
+Replace a node with another.
+
+```js
+var attr = selectors.first.first;
+var className = parser.className({value: 'test'});
+attr.replaceWith(className);
+```
+
+Arguments:
+
+* `node`: The node to substitute the original with.
+
+### `node.remove()`
+
+Removes the node from its parent node.
+
+```js
+if (node.type === 'id') {
+    node.remove();
+}
+```
+
+### `node.clone()`
+
+Returns a copy of a node, detached from any parent containers that the
+original might have had.
+
+```js
+var cloned = parser.id({value: 'search'});
+String(cloned);
+
+// => #search
+```
+
+### `node.spaces`
+
+Extra whitespaces around the node will be moved into `node.spaces.before` and
+`node.spaces.after`. So for example, these spaces will be moved as they have
+no semantic meaning:
+
+```css
+      h1     ,     h2   {}
+```
+
+However, *combinating* spaces will form a `combinator` node:
+
+```css
+h1        h2 {}
+```
+
+A `combinator` node may only have the `spaces` property set if the combinator
+value is a non-whitespace character, such as `+`, `~` or `>`. Otherwise, the
+combinator value will contain all of the spaces between selectors.
+
+### `node.source`
+
+An object describing the node's start/end, line/column source position.
+
+Within the following CSS, the `.bar` class node ...
+
+```css
+.foo,
+  .bar {}
+```
+
+... will contain the following `source` object.
+
+```js
+source: {
+    start: {
+        line: 2,
+        column: 3
+    },
+    end: {
+        line: 2,
+        column: 6
+    }
+}
+```
+
+### `node.sourceIndex`
+
+The zero-based index of the node within the original source string.
+
+Within the following CSS, the `.baz` class node will have a `sourceIndex` of `12`.
+
+```css
+.foo, .bar, .baz {}
+```
+
+## Container types
+
+The `root`, `selector`, and `pseudo` nodes have some helper methods for working
+with their children.
+
+### `container.nodes`
+
+An array of the container's children.
+
+```js
+// Input: h1 h2
+selectors.at(0).nodes.length   // => 3
+selectors.at(0).nodes[0].value // => 'h1'
+selectors.at(0).nodes[1].value // => ' '
+```
+
+### `container.first` & `container.last`
+
+The first/last child of the container.
+
+```js
+selector.first === selector.nodes[0];
+selector.last === selector.nodes[selector.nodes.length - 1];
+```
+
+### `container.at(index)`
+
+Returns the node at position `index`.
+
+```js
+selector.at(0) === selector.first;
+selector.at(0) === selector.nodes[0];
+```
+
+Arguments:
+
+* `index`: The index of the node to return.
+
+### `container.index(node)`
+
+Return the index of the node within its container.
+
+```js
+selector.index(selector.nodes[2]) // => 2
+```
+
+Arguments:
+
+* `node`: A node within the current container.
+
+### `container.length`
+
+Proxy to the length of the container's nodes.
+
+```js
+container.length === container.nodes.length
+```
+
+### `container` Array iterators
+
+The container class provides proxies to certain Array methods; these are:
+
+* `container.map === container.nodes.map`
+* `container.reduce === container.nodes.reduce`
+* `container.every === container.nodes.every`
+* `container.some === container.nodes.some`
+* `container.filter === container.nodes.filter`
+* `container.sort === container.nodes.sort`
+
+Note that these methods only work on a container's immediate children; recursive
+iteration is provided by `container.walk`.
+
+### `container.each(callback)`
+
+Iterate the container's immediate children, calling `callback` for each child.
+You may return `false` within the callback to break the iteration.
+
+```js
+var className;
+selectors.each(function (selector, index) {
+    if (selector.type === 'class') {
+        className = selector.value;
+        return false;
+    }
+});
+```
+
+Note that unlike `Array#forEach()`, this iterator is safe to use whilst adding
+or removing nodes from the container.
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+  and `index` arguments.
+
+### `container.walk(callback)`
+
+Like `container#each`, but will also iterate child nodes as long as they are
+`container` types.
+
+```js
+selectors.walk(function (selector, index) {
+    // all nodes
+});
+```
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+  and `index` arguments.
+
+This iterator is safe to use whilst mutating `container.nodes`,
+like `container#each`.
+
+### `container.walk` proxies
+
+The container class provides proxy methods for iterating over types of nodes,
+so that it is easier to write modules that target specific selectors. Those
+methods are:
+
+* `container.walkAttributes`
+* `container.walkClasses`
+* `container.walkCombinators`
+* `container.walkComments`
+* `container.walkIds`
+* `container.walkNesting`
+* `container.walkPseudos`
+* `container.walkTags`
+* `container.walkUniversals`
+
+### `container.split(callback)`
+
+This method allows you to split a group of nodes by returning `true` from
+a callback. It returns an array of arrays, where each inner array corresponds
+to the groups that you created via the callback.
+
+```js
+// (input) => h1 h2>>h3
+var list = selectors.first.split((selector) => {
+    return selector.type === 'combinator';
+});
+
+// (node values) => [['h1', ' '], ['h2', '>>'], ['h3']]
+```
+
+Arguments:
+
+* `callback (function)`: A function to call for each node, which receives `node`
+  as an argument.
+
+### `container.prepend(node)` & `container.append(node)`
+
+Add a node to the start/end of the container. Note that doing so will set
+the parent property of the node to this container.
+
+```js
+var id = parser.id({value: 'search'});
+selector.append(id);
+```
+
+Arguments:
+
+* `node`: The node to add.
+
+### `container.insertBefore(old, new)` & `container.insertAfter(old, new)`
+
+Add a node before or after an existing node in a container:
+
+```js
+selectors.walk(function (selector) {
+    if (selector.type !== 'class') {
+        var className = parser.className({value: 'theme-name'});
+        selector.parent.insertAfter(selector, className);
+    }
+});
+```
+
+Arguments:
+
+* `old`: The existing node in the container.
+* `new`: The new node to add before/after the existing node.
+
+### `container.removeChild(node)`
+
+Remove the node from the container. Note that you can also use
+`node.remove()` if you would like to remove just a single node.
+
+```js
+selector.length // => 2
+selector.remove(id)
+selector.length // => 1;
+id.parent       // undefined
+```
+
+Arguments:
+
+* `node`: The node to remove.
+
+### `container.removeAll()` or `container.empty()`
+
+Remove all children from the container.
+
+```js
+selector.removeAll();
+selector.length // => 0
+```
+
+## Root nodes
+
+A root node represents a comma separated list of selectors. Indeed, all
+a root's `toString()` method does is join its selector children with a ','.
+Other than this, it has no special functionality and acts like a container.
+
+### `root.trailingComma`
+
+This will be set to `true` if the input has a trailing comma, in order to
+support parsing of legacy CSS hacks.
+
+## Selector nodes
+
+A selector node represents a single compound selector. For example, this
+selector string `h1 h2 h3, [href] > p`, is represented as two selector nodes.
+It has no special functionality of its own.
+
+## Pseudo nodes
+
+A pseudo selector extends a container node; if it has any parameters of its
+own (such as `h1:not(h2, h3)`), they will be its children. Note that the pseudo
+`value` will always contain the colons preceding the pseudo identifier. This
+is so that both `:before` and `::before` are properly represented in the AST.
+
+## Attribute nodes
+
+### `attribute.quoted`
+
+Returns `true` if the attribute's value is wrapped in quotation marks, false if it is not.
+Remains `undefined` if there is no attribute value.
+
+```css
+[href=foo] /* false */
+[href='foo'] /* true */
+[href="foo"] /* true */
+[href] /* undefined */
+```
+
+### `attribute.raws.unquoted`
+
+Returns the unquoted content of the attribute's value.
+Remains `undefined` if there is no attribute value.
+
+```css
+[href=foo] /* foo */
+[href='foo'] /* foo */
+[href="foo"] /* foo */
+[href] /* undefined */
+```
+
+### `attribute.raws.insensitive`
+
+If there is an `i` specifying case insensitivity, returns that `i` along with the whitespace
+around it.
+
+```css
+[id=Bar i ] /* " i " */
+[id=Bar   i  ] /* "   i  " */
+```
+
+## `processor`
+
+### `process(cssText, [options])`
+
+Processes the `cssText`, returning the parsed output
+
+```js
+var processor = parser();
+
+var result = processor.process(' .class').result;
+// =>  .class
+
+// To have the parser normalize whitespace values, utilize the options
+var result = processor.process('  .class  ', {lossless: false}).result;
+// => .class
+```
+
+Arguments:
+
+* `cssText (string)`: The css to be parsed.
+* `[options] (object)`: Process options
+
+Options:
+
+* `lossless (boolean)`: false to normalize the selector whitespace, defaults to true
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/CHANGELOG.md b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/CHANGELOG.md
new file mode 100644
index 00000000..34995769
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/CHANGELOG.md
@@ -0,0 +1,157 @@
+# 2.2.3
+
+* Resolves an issue where the parser would not reduce multiple spaces between an
+  ampersand and another simple selector in lossy mode (thanks to @adam-26).
+
+# 2.2.2
+
+* No longer hangs on an unescaped semicolon; instead the parser will throw
+  an exception for these cases.
+
+# 2.2.1
+
+* Allows a consumer to specify whitespace tokens when creating a new Node
+  (thanks to @Semigradsky).
+
+# 2.2.0
+
+* Added a new option to normalize whitespace when parsing the selector string
+  (thanks to @adam-26).
+
+# 2.1.1
+
+* Better unquoted value handling within attribute selectors
+  (thanks to @evilebottnawi).
+
+# 2.1.0
+
+* Added: Use string constants for all node types & expose them on the main
+  parser instance (thanks to @Aweary).
+
+# 2.0.0
+
+This release contains the following breaking changes:
+
+* Renamed all `eachInside` iterators to `walk`. For example, `eachTag` is now
+  `walkTags`, and `eachInside` is now `walk`.
+* Renamed `Node#removeSelf()` to `Node#remove()`.
+* Renamed `Container#remove()` to `Container#removeChild()`.
+* Renamed `Node#raw` to `Node#raws` (thanks to @davidtheclark).
+* Now parses `&` as the *nesting* selector, rather than a *tag* selector.
+* Fixes misinterpretation of Sass interpolation (e.g. `#{foo}`) as an
+  id selector (thanks to @davidtheclark).
+
+and;
+
+* Fixes parsing of attribute selectors with equals signs in them
+  (e.g. `[data-attr="foo=bar"]`) (thanks to @montmanu).
+* Adds `quoted` and `raw.unquoted` properties to attribute nodes
+  (thanks to @davidtheclark).
+
+# 1.3.3
+
+* Fixes an infinite loop on `)` and `]` tokens when they had no opening pairs.
+  Now postcss-selector-parser will throw when it encounters these lone tokens.
+
+# 1.3.2
+
+* Now uses plain integers rather than `str.charCodeAt(0)` for compiled builds.
+
+# 1.3.1
+
+* Update flatten to v1.x (thanks to @shinnn).
+
+# 1.3.0
+
+* Adds a new node type, `String`, to fix a crash on selectors such as
+  `foo:bar("test")`.
+
+# 1.2.1
+
+* Fixes a crash when the parser encountered a trailing combinator.
+
+# 1.2.0
+
+* A more descriptive error is thrown when the parser expects to find a
+  pseudo-class/pseudo-element (thanks to @ashelley).
+* Adds support for line/column locations for selector nodes, as well as a
+  `Node#sourceIndex` method (thanks to @davidtheclark).
+
+# 1.1.4
+
+* Fixes a crash when a selector started with a `>` combinator. The module will
+  now no longer throw if a selector has a leading/trailing combinator node.
+
+# 1.1.3
+
+* Fixes a crash on `@` tokens.
+
+# 1.1.2
+
+* Fixes an infinite loop caused by using parentheses in a non-pseudo element
+  context.
+
+# 1.1.1
+
+* Fixes a crash when a backslash ended a selector string.
+
+# 1.1.0
+
+* Adds support for replacing multiple nodes at once with `replaceWith`
+  (thanks to @jonathantneal).
+* Parser no longer throws on sequential IDs and trailing commas, to support
+  parsing of selector hacks.
+
+# 1.0.1
+
+* Fixes using `insertAfter` and `insertBefore` during iteration.
+
+# 1.0.0
+
+* Adds `clone` and `replaceWith` methods to nodes.
+* Adds `insertBefore` and `insertAfter` to containers.
+* Stabilises API.
+
+# 0.0.5
+
+* Fixes crash on extra whitespace inside a pseudo selector's parentheses.
+* Adds sort function to the container class.
+* Enables the parser to pass its input through without transforming.
+* Iteration-safe `each` and `eachInside`.
+
+# 0.0.4
+
+* Tidy up redundant duplication.
+* Fixes a bug where the parser would loop infinitely on universal selectors
+  inside pseudo selectors.
+* Adds `length` getter and `eachInside`, `map`, `reduce` to the container class.
+* When a selector has been removed from the tree, the root node will no longer
+  cast it to a string.
+* Adds node type iterators to the container class (e.g. `eachComment`).
+* Adds filter function to the container class.
+* Adds split function to the container class.
+* Create new node types by doing `parser.id(opts)` etc.
+* Adds support for pseudo classes anywhere in the selector.
+
+# 0.0.3
+
+* Adds `next` and `prev` to the node class.
+* Adds `first` and `last` getters to the container class.
+* Adds `every` and `some` iterators to the container class.
+* Add `empty` alias for `removeAll`.
+* Combinators are now types of node.
+* Fixes the at method so that it is not an alias for `index`.
+* Tidy up creation of new nodes in the parser.
+* Refactors how namespaces are handled for consistency & less redundant code.
+* Refactors AST to use `nodes` exclusively, and eliminates excessive nesting.
+* Fixes nested pseudo parsing.
+* Fixes whitespace parsing.
+
+# 0.0.2
+
+* Adds support for namespace selectors.
+* Adds support for selectors joined by escaped spaces - such as `.\31\ 0`.
+
+# 0.0.1
+
+* Initial release.
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/LICENSE-MIT b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/LICENSE-MIT
new file mode 100644
index 00000000..fd0e863a
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/LICENSE-MIT
@@ -0,0 +1,22 @@
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/README.md b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/README.md
new file mode 100644
index 00000000..aa52db36
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/README.md
@@ -0,0 +1,46 @@
+# postcss-selector-parser [![Build Status](https://travis-ci.org/postcss/postcss-selector-parser.svg?branch=master)](https://travis-ci.org/postcss/postcss-selector-parser)
+
+> Selector parser with built in methods for working with selector strings.
+
+## Install
+
+With [npm](https://npmjs.com/package/postcss-selector-parser) do:
+
+```
+npm install postcss-selector-parser
+```
+
+## Quick Start
+
+```js
+var parser = require('postcss-selector-parser');
+var transform = function (selectors) {
+    selectors.eachInside(function (selector) {
+        // do something with the selector
+        console.log(String(selector))
+    });
+};
+
+var transformed = parser(transform).process('h1, h2, h3').result;
+```
+
+To normalize selector whitespace:
+
+```js
+var parser = require('postcss-selector-parser');
+var normalized = parser().process('h1, h2, h3', {lossless:false}).result;
+// -> h1,h2,h3
+```
+
+## API
+
+Please see [API.md](API.md).
+
+## Credits
+
+* Huge thanks to Andrey Sitnik (@ai) for work on PostCSS which helped
+  accelerate this module's development.
+
+## License
+
+MIT
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/index.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/index.js
new file mode 100644
index 00000000..62400258
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/index.js
@@ -0,0 +1,114 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _processor = require('./processor');
+
+var _processor2 = _interopRequireDefault(_processor);
+
+var _attribute = require('./selectors/attribute');
+
+var _attribute2 = _interopRequireDefault(_attribute);
+
+var _className = require('./selectors/className');
+
+var _className2 = _interopRequireDefault(_className);
+
+var _combinator = require('./selectors/combinator');
+
+var _combinator2 = _interopRequireDefault(_combinator);
+
+var _comment = require('./selectors/comment');
+
+var _comment2 = _interopRequireDefault(_comment);
+
+var _id = require('./selectors/id');
+
+var _id2 = _interopRequireDefault(_id);
+
+var _nesting = require('./selectors/nesting');
+
+var _nesting2 = _interopRequireDefault(_nesting);
+
+var _pseudo = require('./selectors/pseudo');
+
+var _pseudo2 = _interopRequireDefault(_pseudo);
+
+var _root = require('./selectors/root');
+
+var _root2 = _interopRequireDefault(_root);
+
+var _selector = require('./selectors/selector');
+
+var _selector2 = _interopRequireDefault(_selector);
+
+var _string = require('./selectors/string');
+
+var _string2 = _interopRequireDefault(_string);
+
+var _tag = require('./selectors/tag');
+
+var _tag2 = _interopRequireDefault(_tag);
+
+var _universal = require('./selectors/universal');
+
+var _universal2 = _interopRequireDefault(_universal);
+
+var _types = require('./selectors/types');
+
+var types = _interopRequireWildcard(_types);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parser = function parser(processor) {
+    return new _processor2.default(processor);
+};
+
+parser.attribute = function (opts) {
+    return new _attribute2.default(opts);
+};
+parser.className = function (opts) {
+    return new _className2.default(opts);
+};
+parser.combinator = function (opts) {
+    return new _combinator2.default(opts);
+};
+parser.comment = function (opts) {
+    return new _comment2.default(opts);
+};
+parser.id = function (opts) {
+    return new _id2.default(opts);
+};
+parser.nesting = function (opts) {
+    return new _nesting2.default(opts);
+};
+parser.pseudo = function (opts) {
+    return new _pseudo2.default(opts);
+};
+parser.root = function (opts) {
+    return new _root2.default(opts);
+};
+parser.selector = function (opts) {
+    return new _selector2.default(opts);
+};
+parser.string = function (opts) {
+    return new _string2.default(opts);
+};
+parser.tag = function (opts) {
+    return new _tag2.default(opts);
+};
+parser.universal = function (opts) {
+    return new _universal2.default(opts);
+};
+
+Object.keys(types).forEach(function (type) {
+    if (type === '__esModule') {
+        return;
+    }
+    parser[type] = types[type]; // eslint-disable-line
+});
+
+exports.default = parser;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/parser.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/parser.js
new file mode 100644
index 00000000..18beadbb
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/parser.js
@@ -0,0 +1,643 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _flatten = require('flatten');
+
+var _flatten2 = _interopRequireDefault(_flatten);
+
+var _indexesOf = require('indexes-of');
+
+var _indexesOf2 = _interopRequireDefault(_indexesOf);
+
+var _uniq = require('uniq');
+
+var _uniq2 = _interopRequireDefault(_uniq);
+
+var _root = require('./selectors/root');
+
+var _root2 = _interopRequireDefault(_root);
+
+var _selector = require('./selectors/selector');
+
+var _selector2 = _interopRequireDefault(_selector);
+
+var _className = require('./selectors/className');
+
+var _className2 = _interopRequireDefault(_className);
+
+var _comment = require('./selectors/comment');
+
+var _comment2 = _interopRequireDefault(_comment);
+
+var _id = require('./selectors/id');
+
+var _id2 = _interopRequireDefault(_id);
+
+var _tag = require('./selectors/tag');
+
+var _tag2 = _interopRequireDefault(_tag);
+
+var _string = require('./selectors/string');
+
+var _string2 = _interopRequireDefault(_string);
+
+var _pseudo = require('./selectors/pseudo');
+
+var _pseudo2 = _interopRequireDefault(_pseudo);
+
+var _attribute = require('./selectors/attribute');
+
+var _attribute2 = _interopRequireDefault(_attribute);
+
+var _universal = require('./selectors/universal');
+
+var _universal2 = _interopRequireDefault(_universal);
+
+var _combinator = require('./selectors/combinator');
+
+var _combinator2 = _interopRequireDefault(_combinator);
+
+var _nesting = require('./selectors/nesting');
+
+var _nesting2 = _interopRequireDefault(_nesting);
+
+var _sortAscending = require('./sortAscending');
+
+var _sortAscending2 = _interopRequireDefault(_sortAscending);
+
+var _tokenize = require('./tokenize');
+
+var _tokenize2 = _interopRequireDefault(_tokenize);
+
+var _types = require('./selectors/types');
+
+var types = _interopRequireWildcard(_types);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Parser = function () {
+    function Parser(input) {
+        _classCallCheck(this, Parser);
+
+        this.input = input;
+        this.lossy = input.options.lossless === false;
+        this.position = 0;
+        this.root = new _root2.default();
+
+        var selectors = new _selector2.default();
+        this.root.append(selectors);
+
+        this.current = selectors;
+        if (this.lossy) {
+            this.tokens = (0, _tokenize2.default)({ safe: input.safe, css: input.css.trim() });
+        } else {
+            this.tokens = (0, _tokenize2.default)(input);
+        }
+
+        return this.loop();
+    }
+
+    Parser.prototype.attribute = function attribute() {
+        var str = '';
+        var attr = void 0;
+        var startingToken = this.currToken;
+        this.position++;
+        while (this.position < this.tokens.length && this.currToken[0] !== ']') {
+            str += this.tokens[this.position][1];
+            this.position++;
+        }
+        if (this.position === this.tokens.length && !~str.indexOf(']')) {
+            this.error('Expected a closing square bracket.');
+        }
+        var parts = str.split(/((?:[*~^$|]?=))([^]*)/);
+        var namespace = parts[0].split(/(\|)/g);
+        var attributeProps = {
+            operator: parts[1],
+            value: parts[2],
+            source: {
+                start: {
+                    line: startingToken[2],
+                    column: startingToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: startingToken[4]
+        };
+        if (namespace.length > 1) {
+            if (namespace[0] === '') {
+                namespace[0] = true;
+            }
+            attributeProps.attribute = this.parseValue(namespace[2]);
+            attributeProps.namespace = this.parseNamespace(namespace[0]);
+        } else {
+            attributeProps.attribute = this.parseValue(parts[0]);
+        }
+        attr = new _attribute2.default(attributeProps);
+
+        if (parts[2]) {
+            var insensitive = parts[2].split(/(\s+i\s*?)$/);
+            var trimmedValue = insensitive[0].trim();
+            attr.value = this.lossy ? trimmedValue : insensitive[0];
+            if (insensitive[1]) {
+                attr.insensitive = true;
+                if (!this.lossy) {
+                    attr.raws.insensitive = insensitive[1];
+                }
+            }
+            attr.quoted = trimmedValue[0] === '\'' || trimmedValue[0] === '"';
+            attr.raws.unquoted = attr.quoted ? trimmedValue.slice(1, -1) : trimmedValue;
+        }
+        this.newNode(attr);
+        this.position++;
+    };
+
+    Parser.prototype.combinator = function combinator() {
+        if (this.currToken[1] === '|') {
+            return this.namespace();
+        }
+        var node = new _combinator2.default({
+            value: '',
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: this.currToken[4]
+        });
+        while (this.position < this.tokens.length && this.currToken && (this.currToken[0] === 'space' || this.currToken[0] === 'combinator')) {
+            if (this.nextToken && this.nextToken[0] === 'combinator') {
+                node.spaces.before = this.parseSpace(this.currToken[1]);
+                node.source.start.line = this.nextToken[2];
+                node.source.start.column = this.nextToken[3];
+                node.source.end.column = this.nextToken[3];
+                node.source.end.line = this.nextToken[2];
+                node.sourceIndex = this.nextToken[4];
+            } else if (this.prevToken && this.prevToken[0] === 'combinator') {
+                node.spaces.after = this.parseSpace(this.currToken[1]);
+            } else if (this.currToken[0] === 'combinator') {
+                node.value = this.currToken[1];
+            } else if (this.currToken[0] === 'space') {
+                node.value = this.parseSpace(this.currToken[1], ' ');
+            }
+            this.position++;
+        }
+        return this.newNode(node);
+    };
+
+    Parser.prototype.comma = function comma() {
+        if (this.position === this.tokens.length - 1) {
+            this.root.trailingComma = true;
+            this.position++;
+            return;
+        }
+        var selectors = new _selector2.default();
+        this.current.parent.append(selectors);
+        this.current = selectors;
+        this.position++;
+    };
+
+    Parser.prototype.comment = function comment() {
+        var node = new _comment2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[4],
+                    column: this.currToken[5]
+                }
+            },
+            sourceIndex: this.currToken[6]
+        });
+        this.newNode(node);
+        this.position++;
+    };
+
+    Parser.prototype.error = function error(message) {
+        throw new this.input.error(message); // eslint-disable-line new-cap
+    };
+
+    Parser.prototype.missingBackslash = function missingBackslash() {
+        return this.error('Expected a backslash preceding the semicolon.');
+    };
+
+    Parser.prototype.missingParenthesis = function missingParenthesis() {
+        return this.error('Expected opening parenthesis.');
+    };
+
+    Parser.prototype.missingSquareBracket = function missingSquareBracket() {
+        return this.error('Expected opening square bracket.');
+    };
+
+    Parser.prototype.namespace = function namespace() {
+        var before = this.prevToken && this.prevToken[1] || true;
+        if (this.nextToken[0] === 'word') {
+            this.position++;
+            return this.word(before);
+        } else if (this.nextToken[0] === '*') {
+            this.position++;
+            return this.universal(before);
+        }
+    };
+
+    Parser.prototype.nesting = function nesting() {
+        this.newNode(new _nesting2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: this.currToken[4]
+        }));
+        this.position++;
+    };
+
+    Parser.prototype.parentheses = function parentheses() {
+        var last = this.current.last;
+        if (last && last.type === types.PSEUDO) {
+            var selector = new _selector2.default();
+            var cache = this.current;
+            last.append(selector);
+            this.current = selector;
+            var balanced = 1;
+            this.position++;
+            while (this.position < this.tokens.length && balanced) {
+                if (this.currToken[0] === '(') {
+                    balanced++;
+                }
+                if (this.currToken[0] === ')') {
+                    balanced--;
+                }
+                if (balanced) {
+                    this.parse();
+                } else {
+                    selector.parent.source.end.line = this.currToken[2];
+                    selector.parent.source.end.column = this.currToken[3];
+                    this.position++;
+                }
+            }
+            if (balanced) {
+                this.error('Expected closing parenthesis.');
+            }
+            this.current = cache;
+        } else {
+            var _balanced = 1;
+            this.position++;
+            last.value += '(';
+            while (this.position < this.tokens.length && _balanced) {
+                if (this.currToken[0] === '(') {
+                    _balanced++;
+                }
+                if (this.currToken[0] === ')') {
+                    _balanced--;
+                }
+                last.value += this.parseParenthesisToken(this.currToken);
+                this.position++;
+            }
+            if (_balanced) {
+                this.error('Expected closing parenthesis.');
+            }
+        }
+    };
+
+    Parser.prototype.pseudo = function pseudo() {
+        var _this = this;
+
+        var pseudoStr = '';
+        var startingToken = this.currToken;
+        while (this.currToken && this.currToken[0] === ':') {
+            pseudoStr += this.currToken[1];
+            this.position++;
+        }
+        if (!this.currToken) {
+            return this.error('Expected pseudo-class or pseudo-element');
+        }
+        if (this.currToken[0] === 'word') {
+            var pseudo = void 0;
+            this.splitWord(false, function (first, length) {
+                pseudoStr += first;
+                pseudo = new _pseudo2.default({
+                    value: pseudoStr,
+                    source: {
+                        start: {
+                            line: startingToken[2],
+                            column: startingToken[3]
+                        },
+                        end: {
+                            line: _this.currToken[4],
+                            column: _this.currToken[5]
+                        }
+                    },
+                    sourceIndex: startingToken[4]
+                });
+                _this.newNode(pseudo);
+                if (length > 1 && _this.nextToken && _this.nextToken[0] === '(') {
+                    _this.error('Misplaced parenthesis.');
+                }
+            });
+        } else {
+            this.error('Unexpected "' + this.currToken[0] + '" found.');
+        }
+    };
+
+    Parser.prototype.space = function space() {
+        var token = this.currToken;
+        // Handle space before and after the selector
+        if (this.position === 0 || this.prevToken[0] === ',' || this.prevToken[0] === '(') {
+            this.spaces = this.parseSpace(token[1]);
+            this.position++;
+        } else if (this.position === this.tokens.length - 1 || this.nextToken[0] === ',' || this.nextToken[0] === ')') {
+            this.current.last.spaces.after = this.parseSpace(token[1]);
+            this.position++;
+        } else {
+            this.combinator();
+        }
+    };
+
+    Parser.prototype.string = function string() {
+        var token = this.currToken;
+        this.newNode(new _string2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: token[2],
+                    column: token[3]
+                },
+                end: {
+                    line: token[4],
+                    column: token[5]
+                }
+            },
+            sourceIndex: token[6]
+        }));
+        this.position++;
+    };
+
+    Parser.prototype.universal = function universal(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && nextToken[1] === '|') {
+            this.position++;
+            return this.namespace();
+        }
+        this.newNode(new _universal2.default({
+            value: this.currToken[1],
+            source: {
+                start: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                },
+                end: {
+                    line: this.currToken[2],
+                    column: this.currToken[3]
+                }
+            },
+            sourceIndex: this.currToken[4]
+        }), namespace);
+        this.position++;
+    };
+
+    Parser.prototype.splitWord = function splitWord(namespace, firstCallback) {
+        var _this2 = this;
+
+        var nextToken = this.nextToken;
+        var word = this.currToken[1];
+        while (nextToken && nextToken[0] === 'word') {
+            this.position++;
+            var current = this.currToken[1];
+            word += current;
+            if (current.lastIndexOf('\\') === current.length - 1) {
+                var next = this.nextToken;
+                if (next && next[0] === 'space') {
+                    word += this.parseSpace(next[1], ' ');
+                    this.position++;
+                }
+            }
+            nextToken = this.nextToken;
+        }
+        var hasClass = (0, _indexesOf2.default)(word, '.');
+        var hasId = (0, _indexesOf2.default)(word, '#');
+        // Eliminate Sass interpolations from the list of id indexes
+        var interpolations = (0, _indexesOf2.default)(word, '#{');
+        if (interpolations.length) {
+            hasId = hasId.filter(function (hashIndex) {
+                return !~interpolations.indexOf(hashIndex);
+            });
+        }
+        var indices = (0, _sortAscending2.default)((0, _uniq2.default)((0, _flatten2.default)([[0], hasClass, hasId])));
+        indices.forEach(function (ind, i) {
+            var index = indices[i + 1] || word.length;
+            var value = word.slice(ind, index);
+            if (i === 0 && firstCallback) {
+                return firstCallback.call(_this2, value, indices.length);
+            }
+            var node = void 0;
+            if (~hasClass.indexOf(ind)) {
+                node = new _className2.default({
+                    value: value.slice(1),
+                    source: {
+                        start: {
+                            line: _this2.currToken[2],
+                            column: _this2.currToken[3] + ind
+                        },
+                        end: {
+                            line: _this2.currToken[4],
+                            column: _this2.currToken[3] + (index - 1)
+                        }
+                    },
+                    sourceIndex: _this2.currToken[6] + indices[i]
+                });
+            } else if (~hasId.indexOf(ind)) {
+                node = new _id2.default({
+                    value: value.slice(1),
+                    source: {
+                        start: {
+                            line: _this2.currToken[2],
+                            column: _this2.currToken[3] + ind
+                        },
+                        end: {
+                            line: _this2.currToken[4],
+                            column: _this2.currToken[3] + (index - 1)
+                        }
+                    },
+                    sourceIndex: _this2.currToken[6] + indices[i]
+                });
+            } else {
+                node = new _tag2.default({
+                    value: value,
+                    source: {
+                        start: {
+                            line: _this2.currToken[2],
+                            column: _this2.currToken[3] + ind
+                        },
+                        end: {
+                            line: _this2.currToken[4],
+                            column: _this2.currToken[3] + (index - 1)
+                        }
+                    },
+                    sourceIndex: _this2.currToken[6] + indices[i]
+                });
+            }
+            _this2.newNode(node, namespace);
+        });
+        this.position++;
+    };
+
+    Parser.prototype.word = function word(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && nextToken[1] === '|') {
+            this.position++;
+            return this.namespace();
+        }
+        return this.splitWord(namespace);
+    };
+
+    Parser.prototype.loop = function loop() {
+        while (this.position < this.tokens.length) {
+            this.parse(true);
+        }
+        return this.root;
+    };
+
+    Parser.prototype.parse = function parse(throwOnParenthesis) {
+        switch (this.currToken[0]) {
+            case 'space':
+                this.space();
+                break;
+            case 'comment':
+                this.comment();
+                break;
+            case '(':
+                this.parentheses();
+                break;
+            case ')':
+                if (throwOnParenthesis) {
+                    this.missingParenthesis();
+                }
+                break;
+            case '[':
+                this.attribute();
+                break;
+            case ']':
+                this.missingSquareBracket();
+                break;
+            case 'at-word':
+            case 'word':
+                this.word();
+                break;
+            case ':':
+                this.pseudo();
+                break;
+            case ';':
+                this.missingBackslash();
+                break;
+            case ',':
+                this.comma();
+                break;
+            case '*':
+                this.universal();
+                break;
+            case '&':
+                this.nesting();
+                break;
+            case 'combinator':
+                this.combinator();
+                break;
+            case 'string':
+                this.string();
+                break;
+        }
+    };
+
+    /**
+     * Helpers
+     */
+
+    Parser.prototype.parseNamespace = function parseNamespace(namespace) {
+        if (this.lossy && typeof namespace === 'string') {
+            var trimmed = namespace.trim();
+            if (!trimmed.length) {
+                return true;
+            }
+
+            return trimmed;
+        }
+
+        return namespace;
+    };
+
+    Parser.prototype.parseSpace = function parseSpace(space, replacement) {
+        return this.lossy ? replacement || '' : space;
+    };
+
+    Parser.prototype.parseValue = function parseValue(value) {
+        return this.lossy && value && typeof value === 'string' ? value.trim() : value;
+    };
+
+    Parser.prototype.parseParenthesisToken = function parseParenthesisToken(token) {
+        if (!this.lossy) {
+            return token[1];
+        }
+
+        if (token[0] === 'space') {
+            return this.parseSpace(token[1], ' ');
+        }
+
+        return this.parseValue(token[1]);
+    };
+
+    Parser.prototype.newNode = function newNode(node, namespace) {
+        if (namespace) {
+            node.namespace = this.parseNamespace(namespace);
+        }
+        if (this.spaces) {
+            node.spaces.before = this.spaces;
+            this.spaces = '';
+        }
+        return this.current.append(node);
+    };
+
+    _createClass(Parser, [{
+        key: 'currToken',
+        get: function get() {
+            return this.tokens[this.position];
+        }
+    }, {
+        key: 'nextToken',
+        get: function get() {
+            return this.tokens[this.position + 1];
+        }
+    }, {
+        key: 'prevToken',
+        get: function get() {
+            return this.tokens[this.position - 1];
+        }
+    }]);
+
+    return Parser;
+}();
+
+exports.default = Parser;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/processor.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/processor.js
new file mode 100644
index 00000000..087618ce
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/processor.js
@@ -0,0 +1,49 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _parser = require('./parser');
+
+var _parser2 = _interopRequireDefault(_parser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Processor = function () {
+    function Processor(func) {
+        _classCallCheck(this, Processor);
+
+        this.func = func || function noop() {};
+        return this;
+    }
+
+    Processor.prototype.process = function process(selectors) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+        var input = new _parser2.default({
+            css: selectors,
+            error: function error(e) {
+                throw new Error(e);
+            },
+            options: options
+        });
+        this.res = input;
+        this.func(input);
+        return this;
+    };
+
+    _createClass(Processor, [{
+        key: 'result',
+        get: function get() {
+            return String(this.res);
+        }
+    }]);
+
+    return Processor;
+}();
+
+exports.default = Processor;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/attribute.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/attribute.js
new file mode 100644
index 00000000..4ea74c12
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/attribute.js
@@ -0,0 +1,54 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Attribute = function (_Namespace) {
+    _inherits(Attribute, _Namespace);
+
+    function Attribute(opts) {
+        _classCallCheck(this, Attribute);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.ATTRIBUTE;
+        _this.raws = {};
+        return _this;
+    }
+
+    Attribute.prototype.toString = function toString() {
+        var selector = [this.spaces.before, '[', this.ns, this.attribute];
+
+        if (this.operator) {
+            selector.push(this.operator);
+        }
+        if (this.value) {
+            selector.push(this.value);
+        }
+        if (this.raws.insensitive) {
+            selector.push(this.raws.insensitive);
+        } else if (this.insensitive) {
+            selector.push(' i');
+        }
+        selector.push(']');
+        return selector.concat(this.spaces.after).join('');
+    };
+
+    return Attribute;
+}(_namespace2.default);
+
+exports.default = Attribute;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/className.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/className.js
new file mode 100644
index 00000000..d7bff16b
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/className.js
@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ClassName = function (_Namespace) {
+    _inherits(ClassName, _Namespace);
+
+    function ClassName(opts) {
+        _classCallCheck(this, ClassName);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.CLASS;
+        return _this;
+    }
+
+    ClassName.prototype.toString = function toString() {
+        return [this.spaces.before, this.ns, String('.' + this.value), this.spaces.after].join('');
+    };
+
+    return ClassName;
+}(_namespace2.default);
+
+exports.default = ClassName;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/combinator.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/combinator.js
new file mode 100644
index 00000000..673dc750
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/combinator.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Combinator = function (_Node) {
+    _inherits(Combinator, _Node);
+
+    function Combinator(opts) {
+        _classCallCheck(this, Combinator);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.COMBINATOR;
+        return _this;
+    }
+
+    return Combinator;
+}(_node2.default);
+
+exports.default = Combinator;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/comment.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/comment.js
new file mode 100644
index 00000000..6d96556e
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/comment.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Comment = function (_Node) {
+    _inherits(Comment, _Node);
+
+    function Comment(opts) {
+        _classCallCheck(this, Comment);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.COMMENT;
+        return _this;
+    }
+
+    return Comment;
+}(_node2.default);
+
+exports.default = Comment;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/container.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/container.js
new file mode 100644
index 00000000..bc9ec00c
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/container.js
@@ -0,0 +1,338 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+var types = _interopRequireWildcard(_types);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Container = function (_Node) {
+    _inherits(Container, _Node);
+
+    function Container(opts) {
+        _classCallCheck(this, Container);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        if (!_this.nodes) {
+            _this.nodes = [];
+        }
+        return _this;
+    }
+
+    Container.prototype.append = function append(selector) {
+        selector.parent = this;
+        this.nodes.push(selector);
+        return this;
+    };
+
+    Container.prototype.prepend = function prepend(selector) {
+        selector.parent = this;
+        this.nodes.unshift(selector);
+        return this;
+    };
+
+    Container.prototype.at = function at(index) {
+        return this.nodes[index];
+    };
+
+    Container.prototype.index = function index(child) {
+        if (typeof child === 'number') {
+            return child;
+        }
+        return this.nodes.indexOf(child);
+    };
+
+    Container.prototype.removeChild = function removeChild(child) {
+        child = this.index(child);
+        this.at(child).parent = undefined;
+        this.nodes.splice(child, 1);
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (index >= child) {
+                this.indexes[id] = index - 1;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.removeAll = function removeAll() {
+        for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+                if (_i >= _iterator.length) break;
+                _ref = _iterator[_i++];
+            } else {
+                _i = _iterator.next();
+                if (_i.done) break;
+                _ref = _i.value;
+            }
+
+            var node = _ref;
+
+            node.parent = undefined;
+        }
+        this.nodes = [];
+        return this;
+    };
+
+    Container.prototype.empty = function empty() {
+        return this.removeAll();
+    };
+
+    Container.prototype.insertAfter = function insertAfter(oldNode, newNode) {
+        var oldIndex = this.index(oldNode);
+        this.nodes.splice(oldIndex + 1, 0, newNode);
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (oldIndex <= index) {
+                this.indexes[id] = index + this.nodes.length;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.insertBefore = function insertBefore(oldNode, newNode) {
+        var oldIndex = this.index(oldNode);
+        this.nodes.splice(oldIndex, 0, newNode);
+
+        var index = void 0;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (oldIndex <= index) {
+                this.indexes[id] = index + this.nodes.length;
+            }
+        }
+
+        return this;
+    };
+
+    Container.prototype.each = function each(callback) {
+        if (!this.lastEach) {
+            this.lastEach = 0;
+        }
+        if (!this.indexes) {
+            this.indexes = {};
+        }
+
+        this.lastEach++;
+        var id = this.lastEach;
+        this.indexes[id] = 0;
+
+        if (!this.length) {
+            return undefined;
+        }
+
+        var index = void 0,
+            result = void 0;
+        while (this.indexes[id] < this.length) {
+            index = this.indexes[id];
+            result = callback(this.at(index), index);
+            if (result === false) {
+                break;
+            }
+
+            this.indexes[id] += 1;
+        }
+
+        delete this.indexes[id];
+
+        if (result === false) {
+            return false;
+        }
+    };
+
+    Container.prototype.walk = function walk(callback) {
+        return this.each(function (node, i) {
+            var result = callback(node, i);
+
+            if (result !== false && node.length) {
+                result = node.walk(callback);
+            }
+
+            if (result === false) {
+                return false;
+            }
+        });
+    };
+
+    Container.prototype.walkAttributes = function walkAttributes(callback) {
+        var _this2 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.ATTRIBUTE) {
+                return callback.call(_this2, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkClasses = function walkClasses(callback) {
+        var _this3 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.CLASS) {
+                return callback.call(_this3, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkCombinators = function walkCombinators(callback) {
+        var _this4 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.COMBINATOR) {
+                return callback.call(_this4, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkComments = function walkComments(callback) {
+        var _this5 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.COMMENT) {
+                return callback.call(_this5, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkIds = function walkIds(callback) {
+        var _this6 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.ID) {
+                return callback.call(_this6, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkNesting = function walkNesting(callback) {
+        var _this7 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.NESTING) {
+                return callback.call(_this7, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkPseudos = function walkPseudos(callback) {
+        var _this8 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.PSEUDO) {
+                return callback.call(_this8, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkTags = function walkTags(callback) {
+        var _this9 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.TAG) {
+                return callback.call(_this9, selector);
+            }
+        });
+    };
+
+    Container.prototype.walkUniversals = function walkUniversals(callback) {
+        var _this10 = this;
+
+        return this.walk(function (selector) {
+            if (selector.type === types.UNIVERSAL) {
+                return callback.call(_this10, selector);
+            }
+        });
+    };
+
+    Container.prototype.split = function split(callback) {
+        var _this11 = this;
+
+        var current = [];
+        return this.reduce(function (memo, node, index) {
+            var split = callback.call(_this11, node);
+            current.push(node);
+            if (split) {
+                memo.push(current);
+                current = [];
+            } else if (index === _this11.length - 1) {
+                memo.push(current);
+            }
+            return memo;
+        }, []);
+    };
+
+    Container.prototype.map = function map(callback) {
+        return this.nodes.map(callback);
+    };
+
+    Container.prototype.reduce = function reduce(callback, memo) {
+        return this.nodes.reduce(callback, memo);
+    };
+
+    Container.prototype.every = function every(callback) {
+        return this.nodes.every(callback);
+    };
+
+    Container.prototype.some = function some(callback) {
+        return this.nodes.some(callback);
+    };
+
+    Container.prototype.filter = function filter(callback) {
+        return this.nodes.filter(callback);
+    };
+
+    Container.prototype.sort = function sort(callback) {
+        return this.nodes.sort(callback);
+    };
+
+    Container.prototype.toString = function toString() {
+        return this.map(String).join('');
+    };
+
+    _createClass(Container, [{
+        key: 'first',
+        get: function get() {
+            return this.at(0);
+        }
+    }, {
+        key: 'last',
+        get: function get() {
+            return this.at(this.length - 1);
+        }
+    }, {
+        key: 'length',
+        get: function get() {
+            return this.nodes.length;
+        }
+    }]);
+
+    return Container;
+}(_node2.default);
+
+exports.default = Container;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/id.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/id.js
new file mode 100644
index 00000000..4538dcf8
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/id.js
@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ID = function (_Namespace) {
+    _inherits(ID, _Namespace);
+
+    function ID(opts) {
+        _classCallCheck(this, ID);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.ID;
+        return _this;
+    }
+
+    ID.prototype.toString = function toString() {
+        return [this.spaces.before, this.ns, String('#' + this.value), this.spaces.after].join('');
+    };
+
+    return ID;
+}(_namespace2.default);
+
+exports.default = ID;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/namespace.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/namespace.js
new file mode 100644
index 00000000..5121b2d4
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/namespace.js
@@ -0,0 +1,45 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Namespace = function (_Node) {
+    _inherits(Namespace, _Node);
+
+    function Namespace() {
+        _classCallCheck(this, Namespace);
+
+        return _possibleConstructorReturn(this, _Node.apply(this, arguments));
+    }
+
+    Namespace.prototype.toString = function toString() {
+        return [this.spaces.before, this.ns, String(this.value), this.spaces.after].join('');
+    };
+
+    _createClass(Namespace, [{
+        key: 'ns',
+        get: function get() {
+            var n = this.namespace;
+            return n ? (typeof n === 'string' ? n : '') + '|' : '';
+        }
+    }]);
+
+    return Namespace;
+}(_node2.default);
+
+exports.default = Namespace;
+;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/nesting.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/nesting.js
new file mode 100644
index 00000000..c3264b07
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/nesting.js
@@ -0,0 +1,36 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Nesting = function (_Node) {
+    _inherits(Nesting, _Node);
+
+    function Nesting(opts) {
+        _classCallCheck(this, Nesting);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.NESTING;
+        _this.value = '&';
+        return _this;
+    }
+
+    return Nesting;
+}(_node2.default);
+
+exports.default = Nesting;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/node.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/node.js
new file mode 100644
index 00000000..30f45fd4
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/node.js
@@ -0,0 +1,102 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var cloneNode = function cloneNode(obj, parent) {
+    if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object') {
+        return obj;
+    }
+
+    var cloned = new obj.constructor();
+
+    for (var i in obj) {
+        if (!obj.hasOwnProperty(i)) {
+            continue;
+        }
+        var value = obj[i];
+        var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
+
+        if (i === 'parent' && type === 'object') {
+            if (parent) {
+                cloned[i] = parent;
+            }
+        } else if (value instanceof Array) {
+            cloned[i] = value.map(function (j) {
+                return cloneNode(j, cloned);
+            });
+        } else {
+            cloned[i] = cloneNode(value, cloned);
+        }
+    }
+
+    return cloned;
+};
+
+var _class = function () {
+    function _class() {
+        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        _classCallCheck(this, _class);
+
+        for (var key in opts) {
+            this[key] = opts[key];
+        }
+        var _opts$spaces = opts.spaces;
+        _opts$spaces = _opts$spaces === undefined ? {} : _opts$spaces;
+        var _opts$spaces$before = _opts$spaces.before,
+            before = _opts$spaces$before === undefined ? '' : _opts$spaces$before,
+            _opts$spaces$after = _opts$spaces.after,
+            after = _opts$spaces$after === undefined ? '' : _opts$spaces$after;
+
+        this.spaces = { before: before, after: after };
+    }
+
+    _class.prototype.remove = function remove() {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        this.parent = undefined;
+        return this;
+    };
+
+    _class.prototype.replaceWith = function replaceWith() {
+        if (this.parent) {
+            for (var index in arguments) {
+                this.parent.insertBefore(this, arguments[index]);
+            }
+            this.remove();
+        }
+        return this;
+    };
+
+    _class.prototype.next = function next() {
+        return this.parent.at(this.parent.index(this) + 1);
+    };
+
+    _class.prototype.prev = function prev() {
+        return this.parent.at(this.parent.index(this) - 1);
+    };
+
+    _class.prototype.clone = function clone() {
+        var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var cloned = cloneNode(this);
+        for (var name in overrides) {
+            cloned[name] = overrides[name];
+        }
+        return cloned;
+    };
+
+    _class.prototype.toString = function toString() {
+        return [this.spaces.before, String(this.value), this.spaces.after].join('');
+    };
+
+    return _class;
+}();
+
+exports.default = _class;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/pseudo.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
new file mode 100644
index 00000000..709cc224
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
@@ -0,0 +1,40 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Pseudo = function (_Container) {
+    _inherits(Pseudo, _Container);
+
+    function Pseudo(opts) {
+        _classCallCheck(this, Pseudo);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.PSEUDO;
+        return _this;
+    }
+
+    Pseudo.prototype.toString = function toString() {
+        var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
+        return [this.spaces.before, String(this.value), params, this.spaces.after].join('');
+    };
+
+    return Pseudo;
+}(_container2.default);
+
+exports.default = Pseudo;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/root.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/root.js
new file mode 100644
index 00000000..d8865b5b
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/root.js
@@ -0,0 +1,43 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Root = function (_Container) {
+    _inherits(Root, _Container);
+
+    function Root(opts) {
+        _classCallCheck(this, Root);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.ROOT;
+        return _this;
+    }
+
+    Root.prototype.toString = function toString() {
+        var str = this.reduce(function (memo, selector) {
+            var sel = String(selector);
+            return sel ? memo + sel + ',' : '';
+        }, '').slice(0, -1);
+        return this.trailingComma ? str + ',' : str;
+    };
+
+    return Root;
+}(_container2.default);
+
+exports.default = Root;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/selector.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/selector.js
new file mode 100644
index 00000000..e2187662
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/selector.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _container = require('./container');
+
+var _container2 = _interopRequireDefault(_container);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Selector = function (_Container) {
+    _inherits(Selector, _Container);
+
+    function Selector(opts) {
+        _classCallCheck(this, Selector);
+
+        var _this = _possibleConstructorReturn(this, _Container.call(this, opts));
+
+        _this.type = _types.SELECTOR;
+        return _this;
+    }
+
+    return Selector;
+}(_container2.default);
+
+exports.default = Selector;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/string.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/string.js
new file mode 100644
index 00000000..d644e7d1
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/string.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _node = require('./node');
+
+var _node2 = _interopRequireDefault(_node);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var String = function (_Node) {
+    _inherits(String, _Node);
+
+    function String(opts) {
+        _classCallCheck(this, String);
+
+        var _this = _possibleConstructorReturn(this, _Node.call(this, opts));
+
+        _this.type = _types.STRING;
+        return _this;
+    }
+
+    return String;
+}(_node2.default);
+
+exports.default = String;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/tag.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/tag.js
new file mode 100644
index 00000000..a1f2848a
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/tag.js
@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Tag = function (_Namespace) {
+    _inherits(Tag, _Namespace);
+
+    function Tag(opts) {
+        _classCallCheck(this, Tag);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.TAG;
+        return _this;
+    }
+
+    return Tag;
+}(_namespace2.default);
+
+exports.default = Tag;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/types.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/types.js
new file mode 100644
index 00000000..aa73ac9a
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/types.js
@@ -0,0 +1,15 @@
+'use strict';
+
+exports.__esModule = true;
+var TAG = exports.TAG = 'tag';
+var STRING = exports.STRING = 'string';
+var SELECTOR = exports.SELECTOR = 'selector';
+var ROOT = exports.ROOT = 'root';
+var PSEUDO = exports.PSEUDO = 'pseudo';
+var NESTING = exports.NESTING = 'nesting';
+var ID = exports.ID = 'id';
+var COMMENT = exports.COMMENT = 'comment';
+var COMBINATOR = exports.COMBINATOR = 'combinator';
+var CLASS = exports.CLASS = 'class';
+var ATTRIBUTE = exports.ATTRIBUTE = 'attribute';
+var UNIVERSAL = exports.UNIVERSAL = 'universal';
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/universal.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/universal.js
new file mode 100644
index 00000000..f4a35ff5
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/selectors/universal.js
@@ -0,0 +1,36 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _namespace = require('./namespace');
+
+var _namespace2 = _interopRequireDefault(_namespace);
+
+var _types = require('./types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Universal = function (_Namespace) {
+    _inherits(Universal, _Namespace);
+
+    function Universal(opts) {
+        _classCallCheck(this, Universal);
+
+        var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts));
+
+        _this.type = _types.UNIVERSAL;
+        _this.value = '*';
+        return _this;
+    }
+
+    return Universal;
+}(_namespace2.default);
+
+exports.default = Universal;
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/sortAscending.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/sortAscending.js
new file mode 100644
index 00000000..17a2eb4e
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/sortAscending.js
@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = sortAscending;
+function sortAscending(list) {
+    return list.sort(function (a, b) {
+        return a - b;
+    });
+};
+module.exports = exports["default"];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/tokenize.js b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/tokenize.js
new file mode 100644
index 00000000..acc73b05
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/dist/tokenize.js
@@ -0,0 +1,231 @@
+'use strict';
+
+exports.__esModule = true;
+exports.default = tokenize;
+var singleQuote = 39,
+    doubleQuote = 34,
+    backslash = 92,
+    slash = 47,
+    newline = 10,
+    space = 32,
+    feed = 12,
+    tab = 9,
+    cr = 13,
+    plus = 43,
+    gt = 62,
+    tilde = 126,
+    pipe = 124,
+    comma = 44,
+    openBracket = 40,
+    closeBracket = 41,
+    openSq = 91,
+    closeSq = 93,
+    semicolon = 59,
+    asterisk = 42,
+    colon = 58,
+    ampersand = 38,
+    at = 64,
+    atEnd = /[ \n\t\r\{\(\)'"\\;/]/g,
+    wordEnd = /[ \n\t\r\(\)\*:;@!&'"\+\|~>,\[\]\\]|\/(?=\*)/g;
+
+function tokenize(input) {
+    var tokens = [];
+    var css = input.css.valueOf();
+
+    var code = void 0,
+        next = void 0,
+        quote = void 0,
+        lines = void 0,
+        last = void 0,
+        content = void 0,
+        escape = void 0,
+        nextLine = void 0,
+        nextOffset = void 0,
+        escaped = void 0,
+        escapePos = void 0;
+
+    var length = css.length;
+    var offset = -1;
+    var line = 1;
+    var pos = 0;
+
+    var unclosed = function unclosed(what, end) {
+        if (input.safe) {
+            css += end;
+            next = css.length - 1;
+        } else {
+            throw input.error('Unclosed ' + what, line, pos - offset, pos);
+        }
+    };
+
+    while (pos < length) {
+        code = css.charCodeAt(pos);
+
+        if (code === newline) {
+            offset = pos;
+            line += 1;
+        }
+
+        switch (code) {
+            case newline:
+            case space:
+            case tab:
+            case cr:
+            case feed:
+                next = pos;
+                do {
+                    next += 1;
+                    code = css.charCodeAt(next);
+                    if (code === newline) {
+                        offset = next;
+                        line += 1;
+                    }
+                } while (code === space || code === newline || code === tab || code === cr || code === feed);
+
+                tokens.push(['space', css.slice(pos, next), line, pos - offset, pos]);
+                pos = next - 1;
+                break;
+
+            case plus:
+            case gt:
+            case tilde:
+            case pipe:
+                next = pos;
+                do {
+                    next += 1;
+                    code = css.charCodeAt(next);
+                } while (code === plus || code === gt || code === tilde || code === pipe);
+                tokens.push(['combinator', css.slice(pos, next), line, pos - offset, pos]);
+                pos = next - 1;
+                break;
+
+            case asterisk:
+                tokens.push(['*', '*', line, pos - offset, pos]);
+                break;
+
+            case ampersand:
+                tokens.push(['&', '&', line, pos - offset, pos]);
+                break;
+
+            case comma:
+                tokens.push([',', ',', line, pos - offset, pos]);
+                break;
+
+            case openSq:
+                tokens.push(['[', '[', line, pos - offset, pos]);
+                break;
+
+            case closeSq:
+                tokens.push([']', ']', line, pos - offset, pos]);
+                break;
+
+            case colon:
+                tokens.push([':', ':', line, pos - offset, pos]);
+                break;
+
+            case semicolon:
+                tokens.push([';', ';', line, pos - offset, pos]);
+                break;
+
+            case openBracket:
+                tokens.push(['(', '(', line, pos - offset, pos]);
+                break;
+
+            case closeBracket:
+                tokens.push([')', ')', line, pos - offset, pos]);
+                break;
+
+            case singleQuote:
+            case doubleQuote:
+                quote = code === singleQuote ? "'" : '"';
+                next = pos;
+                do {
+                    escaped = false;
+                    next = css.indexOf(quote, next + 1);
+                    if (next === -1) {
+                        unclosed('quote', quote);
+                    }
+                    escapePos = next;
+                    while (css.charCodeAt(escapePos - 1) === backslash) {
+                        escapePos -= 1;
+                        escaped = !escaped;
+                    }
+                } while (escaped);
+
+                tokens.push(['string', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                pos = next;
+                break;
+
+            case at:
+                atEnd.lastIndex = pos + 1;
+                atEnd.test(css);
+                if (atEnd.lastIndex === 0) {
+                    next = css.length - 1;
+                } else {
+                    next = atEnd.lastIndex - 2;
+                }
+                tokens.push(['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                pos = next;
+                break;
+
+            case backslash:
+                next = pos;
+                escape = true;
+                while (css.charCodeAt(next + 1) === backslash) {
+                    next += 1;
+                    escape = !escape;
+                }
+                code = css.charCodeAt(next + 1);
+                if (escape && code !== slash && code !== space && code !== newline && code !== tab && code !== cr && code !== feed) {
+                    next += 1;
+                }
+                tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                pos = next;
+                break;
+
+            default:
+                if (code === slash && css.charCodeAt(pos + 1) === asterisk) {
+                    next = css.indexOf('*/', pos + 2) + 1;
+                    if (next === 0) {
+                        unclosed('comment', '*/');
+                    }
+
+                    content = css.slice(pos, next + 1);
+                    lines = content.split('\n');
+                    last = lines.length - 1;
+
+                    if (last > 0) {
+                        nextLine = line + last;
+                        nextOffset = next - lines[last].length;
+                    } else {
+                        nextLine = line;
+                        nextOffset = offset;
+                    }
+
+                    tokens.push(['comment', content, line, pos - offset, nextLine, next - nextOffset, pos]);
+
+                    offset = nextOffset;
+                    line = nextLine;
+                    pos = next;
+                } else {
+                    wordEnd.lastIndex = pos + 1;
+                    wordEnd.test(css);
+                    if (wordEnd.lastIndex === 0) {
+                        next = css.length - 1;
+                    } else {
+                        next = wordEnd.lastIndex - 2;
+                    }
+
+                    tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]);
+                    pos = next;
+                }
+
+                break;
+        }
+
+        pos++;
+    }
+
+    return tokens;
+}
+module.exports = exports['default'];
\ No newline at end of file
diff --git a/node_modules/postcss-fixes/node_modules/postcss-selector-parser/package.json b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/package.json
new file mode 100644
index 00000000..f4a59597
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-selector-parser/package.json
@@ -0,0 +1,64 @@
+{
+  "name": "postcss-selector-parser",
+  "version": "2.2.3",
+  "devDependencies": {
+    "ava": "^0.17.0",
+    "babel-cli": "^6.4.0",
+    "babel-core": "^6.4.0",
+    "babel-plugin-add-module-exports": "^0.2.0",
+    "babel-plugin-precompile-charcodes": "^1.0.0",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-preset-es2015-loose": "^7.0.0",
+    "babel-preset-stage-0": "^6.3.13",
+    "babel-register": "^6.9.0",
+    "coveralls": "^2.11.6",
+    "del-cli": "^0.2.0",
+    "eslint": "^3.0.0",
+    "eslint-config-cssnano": "^3.0.0",
+    "eslint-plugin-babel": "^3.3.0",
+    "eslint-plugin-import": "^1.10.2",
+    "glob": "^7.0.3",
+    "minimist": "^1.2.0",
+    "nyc": "^10.0.0"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "API.md",
+    "CHANGELOG.md",
+    "LICENSE-MIT",
+    "dist"
+  ],
+  "scripts": {
+    "pretest": "eslint src",
+    "prepublish": "del-cli dist && BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/",
+    "report": "nyc report --reporter=html",
+    "test": "nyc ava src/__tests__/*.js",
+    "test-012": "nyc ava src/__tests__/*.js"
+  },
+  "dependencies": {
+    "flatten": "^1.0.2",
+    "indexes-of": "^1.0.1",
+    "uniq": "^1.0.1"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/postcss/postcss-selector-parser",
+  "author": {
+    "name": "Ben Briggs",
+    "email": "beneb.info@gmail.com",
+    "url": "http://beneb.info"
+  },
+  "repository": "postcss/postcss-selector-parser",
+  "ava": {
+    "require": "babel-register",
+    "concurrency": 5
+  },
+  "nyc": {
+    "exclude": [
+      "node_modules",
+      "**/__tests__"
+    ]
+  },
+  "eslintConfig": {
+    "extends": "cssnano"
+  }
+}
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/LICENSE b/node_modules/postcss-fixes/node_modules/postcss-value-parser/LICENSE
new file mode 100644
index 00000000..6dcaefcb
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) Bogdan Chadkin <trysound@yandex.ru>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/README.md b/node_modules/postcss-fixes/node_modules/postcss-value-parser/README.md
new file mode 100644
index 00000000..0f3be478
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/README.md
@@ -0,0 +1,253 @@
+# postcss-value-parser
+
+[![Travis CI](https://travis-ci.org/TrySound/postcss-value-parser.svg)](https://travis-ci.org/TrySound/postcss-value-parser)
+
+Transforms CSS declaration values and at-rule parameters into a tree of nodes, and provides a simple traversal API.
+
+## Usage
+
+```js
+var valueParser = require('postcss-value-parser');
+var cssBackgroundValue = 'url(foo.png) no-repeat 40px 73%';
+var parsedValue = valueParser(cssBackgroundValue);
+// parsedValue exposes an API described below,
+// e.g. parsedValue.walk(..), parsedValue.toString(), etc.
+```
+
+For example, parsing the value `rgba(233, 45, 66, .5)` will return the following:
+
+```js
+{
+  nodes: [
+    {
+      type: 'function',
+      value: 'rgba',
+      before: '',
+      after: '',
+      nodes: [
+        { type: 'word', value: '233' },
+        { type: 'div', value: ',', before: '', after: ' ' },
+        { type: 'word', value: '45' },
+        { type: 'div', value: ',', before: '', after: ' ' },
+        { type: 'word', value: '66' },
+        { type: 'div', value: ',', before: ' ', after: '' },
+        { type: 'word', value: '.5' }
+      ]
+    }
+  ]
+}
+```
+
+If you wanted to convert each `rgba()` value in `sourceCSS` to a hex value, you could do so like this:
+
+```js
+var valueParser = require('postcss-value-parser');
+
+var parsed = valueParser(sourceCSS);
+
+// walk() will visit all the of the nodes in the tree,
+// invoking the callback for each.
+parsed.walk(function (node) {
+
+  // Since we only want to transform rgba() values,
+  // we can ignore anything else.
+  if (node.type !== 'function' && node.value !== 'rgba') return;
+
+  // We can make an array of the rgba() arguments to feed to a
+  // convertToHex() function
+  var color = node.nodes.filter(function (node) {
+    return node.type === 'word';
+  }).map(function (node) {
+    return Number(node.value);
+  }); // [233, 45, 66, .5]
+
+  // Now we will transform the existing rgba() function node
+  // into a word node with the hex value
+  node.type = 'word';
+  node.value = convertToHex(color);
+})
+
+parsed.toString(); // #E92D42
+```
+
+## Nodes
+
+Each node is an object with these common properties:
+
+- **type**: The type of node (`word`, `string`, `div`, `space`, `comment`, or `function`).
+  Each type is documented below.
+- **value**: Each node has a `value` property; but what exactly `value` means
+  is specific to the node type. Details are documented for each type below.
+- **sourceIndex**: The starting index of the node within the original source
+  string. For example, given the source string `10px 20px`, the `word` node
+  whose value is `20px` will have a `sourceIndex` of `5`.
+
+### word
+
+The catch-all node type that includes keywords (e.g. `no-repeat`),
+quantities (e.g. `20px`, `75%`, `1.5`), and hex colors (e.g. `#e6e6e6`).
+
+Node-specific properties:
+
+- **value**: The "word" itself.
+
+### string
+
+A quoted string value, e.g. `"something"` in `content: "something";`.
+
+Node-specific properties:
+
+- **value**: The text content of the string.
+- **quote**: The quotation mark surrounding the string, either `"` or `'`.
+- **unclosed**: `true` if the string was not closed properly. e.g. `"unclosed string  `.
+
+### div
+
+A divider, for example
+
+- `,` in `animation-duration: 1s, 2s, 3s`
+- `/` in `border-radius: 10px / 23px`
+- `:` in `(min-width: 700px)`
+
+Node-specific properties:
+
+- **value**: The divider character. Either `,`, `/`, or `:` (see examples above).
+- **before**: Whitespace before the divider.
+- **after**: Whitespace after the divider.
+
+### space
+
+Whitespace used as a separator, e.g. ` ` occurring twice in `border: 1px solid black;`.
+
+Node-specific properties:
+
+- **value**: The whitespace itself.
+
+### comment
+
+A CSS comment starts with `/*` and ends with `*/`
+
+Node-specific properties:
+
+- **value**: The comment value without `/*` and `*/`
+- **unclosed**: `true` if the comment was not closed properly. e.g. `/* comment without an end  `.
+
+### function
+
+A CSS function, e.g. `rgb(0,0,0)` or `url(foo.bar)`.
+
+Function nodes have nodes nested within them: the function arguments.
+
+Additional properties:
+
+- **value**: The name of the function, e.g. `rgb` in `rgb(0,0,0)`.
+- **before**: Whitespace after the opening parenthesis and before the first argument,
+  e.g. `  ` in `rgb(  0,0,0)`.
+- **after**: Whitespace before the closing parenthesis and after the last argument,
+  e.g. `  ` in `rgb(0,0,0  )`.
+- **nodes**: More nodes representing the arguments to the function.
+- **unclosed**: `true` if the parentheses was not closed properly. e.g. `( unclosed-function  `.
+
+Media features surrounded by parentheses are considered functions with an
+empty value. For example, `(min-width: 700px)` parses to these nodes:
+
+```js
+[
+  {
+    type: 'function', value: '', before: '', after: '',
+    nodes: [
+      { type: 'word', value: 'min-width' },
+      { type: 'div', value: ':', before: '', after: ' ' },
+      { type: 'word', value: '700px' }
+    ]
+  }
+]
+```
+
+`url()` functions can be parsed a little bit differently depending on
+whether the first character in the argument is a quotation mark.
+
+`url( /gfx/img/bg.jpg )` parses to:
+
+```js
+{ type: 'function', sourceIndex: 0, value: 'url', before: ' ', after: ' ', nodes: [
+    { type: 'word', sourceIndex: 5, value: '/gfx/img/bg.jpg' }
+] }
+```
+
+`url( "/gfx/img/bg.jpg" )`, on the other hand, parses to:
+
+```js
+{ type: 'function', sourceIndex: 0, value: 'url', before: ' ', after: ' ', nodes: [
+     type: 'string', sourceIndex: 5, quote: '"', value: '/gfx/img/bg.jpg' },
+] }
+```
+
+## API
+
+```
+var valueParser = require('postcss-value-parser');
+```
+
+### valueParser.unit(quantity)
+
+Parses `quantity`, distinguishing the number from the unit. Returns an object like the following:
+
+```js
+// Given 2rem
+{
+  number: '2',
+  unit: 'rem'
+}
+```
+
+If the `quantity` argument cannot be parsed as a number, returns `false`.
+
+*This function does not parse complete values*: you cannot pass it `1px solid black` and expect `px` as
+the unit. Instead, you should pass it single quantities only. Parse `1px solid black`, then pass it
+the stringified `1px` node (a `word` node) to parse the number and unit.
+
+### valueParser.stringify(nodes[, custom])
+
+Stringifies a node or array of nodes.
+
+The `custom` function is called for each `node`; return a string to override the default behaviour.
+
+### valueParser.walk(nodes, callback[, bubble])
+
+Walks each provided node, recursively walking all descendent nodes within functions.
+
+Returning `false` in the `callback` will prevent traversal of descendent nodes (within functions).
+You can use this feature to for shallow iteration, walking over only the *immediate* children.
+*Note: This only applies if `bubble` is `false` (which is the default).*
+
+By default, the tree is walked from the outermost node inwards.
+To reverse the direction, pass `true` for the `bubble` argument.
+
+The `callback` is invoked with three arguments: `callback(node, index, nodes)`.
+
+- `node`: The current node.
+- `index`: The index of the current node.
+- `nodes`: The complete nodes array passed to `walk()`.
+
+Returns the `valueParser` instance.
+
+### var parsed = valueParser(value)
+
+Returns the parsed node tree.
+
+### parsed.nodes
+
+The array of nodes.
+
+### parsed.toString()
+
+Stringifies the node tree.
+
+### parsed.walk(callback[, bubble])
+
+Walks each node inside `parsed.nodes`. See the documentation for `valueParser.walk()` above.
+
+# License
+
+MIT © [Bogdan Chadkin](mailto:trysound@yandex.ru)
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/index.js b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/index.js
new file mode 100644
index 00000000..f9ac0e68
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/index.js
@@ -0,0 +1,28 @@
+var parse = require("./parse");
+var walk = require("./walk");
+var stringify = require("./stringify");
+
+function ValueParser(value) {
+  if (this instanceof ValueParser) {
+    this.nodes = parse(value);
+    return this;
+  }
+  return new ValueParser(value);
+}
+
+ValueParser.prototype.toString = function() {
+  return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+};
+
+ValueParser.prototype.walk = function(cb, bubble) {
+  walk(this.nodes, cb, bubble);
+  return this;
+};
+
+ValueParser.unit = require("./unit");
+
+ValueParser.walk = walk;
+
+ValueParser.stringify = stringify;
+
+module.exports = ValueParser;
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/parse.js b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/parse.js
new file mode 100644
index 00000000..50d1fe9c
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/parse.js
@@ -0,0 +1,251 @@
+var openParentheses = "(".charCodeAt(0);
+var closeParentheses = ")".charCodeAt(0);
+var singleQuote = "'".charCodeAt(0);
+var doubleQuote = '"'.charCodeAt(0);
+var backslash = "\\".charCodeAt(0);
+var slash = "/".charCodeAt(0);
+var comma = ",".charCodeAt(0);
+var colon = ":".charCodeAt(0);
+var star = "*".charCodeAt(0);
+
+module.exports = function(input) {
+  var tokens = [];
+  var value = input;
+
+  var next, quote, prev, token, escape, escapePos, whitespacePos;
+  var pos = 0;
+  var code = value.charCodeAt(pos);
+  var max = value.length;
+  var stack = [{ nodes: tokens }];
+  var balanced = 0;
+  var parent;
+
+  var name = "";
+  var before = "";
+  var after = "";
+
+  while (pos < max) {
+    // Whitespaces
+    if (code <= 32) {
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      token = value.slice(pos, next);
+
+      prev = tokens[tokens.length - 1];
+      if (code === closeParentheses && balanced) {
+        after = token;
+      } else if (prev && prev.type === "div") {
+        prev.after = token;
+      } else if (
+        code === comma ||
+        code === colon ||
+        (code === slash && value.charCodeAt(next + 1) !== star)
+      ) {
+        before = token;
+      } else {
+        tokens.push({
+          type: "space",
+          sourceIndex: pos,
+          value: token
+        });
+      }
+
+      pos = next;
+
+      // Quotes
+    } else if (code === singleQuote || code === doubleQuote) {
+      next = pos;
+      quote = code === singleQuote ? "'" : '"';
+      token = {
+        type: "string",
+        sourceIndex: pos,
+        quote: quote
+      };
+      do {
+        escape = false;
+        next = value.indexOf(quote, next + 1);
+        if (~next) {
+          escapePos = next;
+          while (value.charCodeAt(escapePos - 1) === backslash) {
+            escapePos -= 1;
+            escape = !escape;
+          }
+        } else {
+          value += quote;
+          next = value.length - 1;
+          token.unclosed = true;
+        }
+      } while (escape);
+      token.value = value.slice(pos + 1, next);
+
+      tokens.push(token);
+      pos = next + 1;
+      code = value.charCodeAt(pos);
+
+      // Comments
+    } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+      token = {
+        type: "comment",
+        sourceIndex: pos
+      };
+
+      next = value.indexOf("*/", pos);
+      if (next === -1) {
+        token.unclosed = true;
+        next = value.length;
+      }
+
+      token.value = value.slice(pos + 2, next);
+      tokens.push(token);
+
+      pos = next + 2;
+      code = value.charCodeAt(pos);
+
+      // Dividers
+    } else if (code === slash || code === comma || code === colon) {
+      token = value[pos];
+
+      tokens.push({
+        type: "div",
+        sourceIndex: pos - before.length,
+        value: token,
+        before: before,
+        after: ""
+      });
+      before = "";
+
+      pos += 1;
+      code = value.charCodeAt(pos);
+
+      // Open parentheses
+    } else if (openParentheses === code) {
+      // Whitespaces after open parentheses
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      token = {
+        type: "function",
+        sourceIndex: pos - name.length,
+        value: name,
+        before: value.slice(pos + 1, next)
+      };
+      pos = next;
+
+      if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+        next -= 1;
+        do {
+          escape = false;
+          next = value.indexOf(")", next + 1);
+          if (~next) {
+            escapePos = next;
+            while (value.charCodeAt(escapePos - 1) === backslash) {
+              escapePos -= 1;
+              escape = !escape;
+            }
+          } else {
+            value += ")";
+            next = value.length - 1;
+            token.unclosed = true;
+          }
+        } while (escape);
+        // Whitespaces before closed
+        whitespacePos = next;
+        do {
+          whitespacePos -= 1;
+          code = value.charCodeAt(whitespacePos);
+        } while (code <= 32);
+        if (pos !== whitespacePos + 1) {
+          token.nodes = [
+            {
+              type: "word",
+              sourceIndex: pos,
+              value: value.slice(pos, whitespacePos + 1)
+            }
+          ];
+        } else {
+          token.nodes = [];
+        }
+        if (token.unclosed && whitespacePos + 1 !== next) {
+          token.after = "";
+          token.nodes.push({
+            type: "space",
+            sourceIndex: whitespacePos + 1,
+            value: value.slice(whitespacePos + 1, next)
+          });
+        } else {
+          token.after = value.slice(whitespacePos + 1, next);
+        }
+        pos = next + 1;
+        code = value.charCodeAt(pos);
+        tokens.push(token);
+      } else {
+        balanced += 1;
+        token.after = "";
+        tokens.push(token);
+        stack.push(token);
+        tokens = token.nodes = [];
+        parent = token;
+      }
+      name = "";
+
+      // Close parentheses
+    } else if (closeParentheses === code && balanced) {
+      pos += 1;
+      code = value.charCodeAt(pos);
+
+      parent.after = after;
+      after = "";
+      balanced -= 1;
+      stack.pop();
+      parent = stack[balanced];
+      tokens = parent.nodes;
+
+      // Words
+    } else {
+      next = pos;
+      do {
+        if (code === backslash) {
+          next += 1;
+        }
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (
+        next < max &&
+        !(
+          code <= 32 ||
+          code === singleQuote ||
+          code === doubleQuote ||
+          code === comma ||
+          code === colon ||
+          code === slash ||
+          code === openParentheses ||
+          (code === closeParentheses && balanced)
+        )
+      );
+      token = value.slice(pos, next);
+
+      if (openParentheses === code) {
+        name = token;
+      } else {
+        tokens.push({
+          type: "word",
+          sourceIndex: pos,
+          value: token
+        });
+      }
+
+      pos = next;
+    }
+  }
+
+  for (pos = stack.length - 1; pos; pos -= 1) {
+    stack[pos].unclosed = true;
+  }
+
+  return stack[0].nodes;
+};
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/stringify.js b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/stringify.js
new file mode 100644
index 00000000..5f2c845a
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/stringify.js
@@ -0,0 +1,48 @@
+function stringifyNode(node, custom) {
+  var type = node.type;
+  var value = node.value;
+  var buf;
+  var customResult;
+
+  if (custom && (customResult = custom(node)) !== undefined) {
+    return customResult;
+  } else if (type === "word" || type === "space") {
+    return value;
+  } else if (type === "string") {
+    buf = node.quote || "";
+    return buf + value + (node.unclosed ? "" : buf);
+  } else if (type === "comment") {
+    return "/*" + value + (node.unclosed ? "" : "*/");
+  } else if (type === "div") {
+    return (node.before || "") + value + (node.after || "");
+  } else if (Array.isArray(node.nodes)) {
+    buf = stringify(node.nodes);
+    if (type !== "function") {
+      return buf;
+    }
+    return (
+      value +
+      "(" +
+      (node.before || "") +
+      buf +
+      (node.after || "") +
+      (node.unclosed ? "" : ")")
+    );
+  }
+  return value;
+}
+
+function stringify(nodes, custom) {
+  var result, i;
+
+  if (Array.isArray(nodes)) {
+    result = "";
+    for (i = nodes.length - 1; ~i; i -= 1) {
+      result = stringifyNode(nodes[i], custom) + result;
+    }
+    return result;
+  }
+  return stringifyNode(nodes, custom);
+}
+
+module.exports = stringify;
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/unit.js b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/unit.js
new file mode 100644
index 00000000..06a1f667
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/unit.js
@@ -0,0 +1,49 @@
+var minus = "-".charCodeAt(0);
+var plus = "+".charCodeAt(0);
+var dot = ".".charCodeAt(0);
+var exp = "e".charCodeAt(0);
+var EXP = "E".charCodeAt(0);
+
+module.exports = function(value) {
+  var pos = 0;
+  var length = value.length;
+  var dotted = false;
+  var sciPos = -1;
+  var containsNumber = false;
+  var code;
+
+  while (pos < length) {
+    code = value.charCodeAt(pos);
+
+    if (code >= 48 && code <= 57) {
+      containsNumber = true;
+    } else if (code === exp || code === EXP) {
+      if (sciPos > -1) {
+        break;
+      }
+      sciPos = pos;
+    } else if (code === dot) {
+      if (dotted) {
+        break;
+      }
+      dotted = true;
+    } else if (code === plus || code === minus) {
+      if (pos !== 0) {
+        break;
+      }
+    } else {
+      break;
+    }
+
+    pos += 1;
+  }
+
+  if (sciPos + 1 === pos) pos--;
+
+  return containsNumber
+    ? {
+        number: value.slice(0, pos),
+        unit: value.slice(pos)
+      }
+    : false;
+};
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/walk.js b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/walk.js
new file mode 100644
index 00000000..7666c5b1
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/lib/walk.js
@@ -0,0 +1,22 @@
+module.exports = function walk(nodes, cb, bubble) {
+  var i, max, node, result;
+
+  for (i = 0, max = nodes.length; i < max; i += 1) {
+    node = nodes[i];
+    if (!bubble) {
+      result = cb(node, i, nodes);
+    }
+
+    if (
+      result !== false &&
+      node.type === "function" &&
+      Array.isArray(node.nodes)
+    ) {
+      walk(node.nodes, cb, bubble);
+    }
+
+    if (bubble) {
+      cb(node, i, nodes);
+    }
+  }
+};
diff --git a/node_modules/postcss-fixes/node_modules/postcss-value-parser/package.json b/node_modules/postcss-fixes/node_modules/postcss-value-parser/package.json
new file mode 100644
index 00000000..14ae1dc7
--- /dev/null
+++ b/node_modules/postcss-fixes/node_modules/postcss-value-parser/package.json
@@ -0,0 +1,58 @@
+{
+  "name": "postcss-value-parser",
+  "version": "3.3.1",
+  "description": "Transforms css values and at-rule params into the tree",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "devDependencies": {
+    "eslint": "^5.6.1",
+    "husky": "^1.0.0",
+    "lint-staged": "^7.3.0",
+    "prettier": "^1.4.4",
+    "tap-spec": "^5.0.0",
+    "tape": "^4.2.0"
+  },
+  "scripts": {
+    "lint:prettier": "prettier '**/*.js' --list-different",
+    "lint:js": "eslint . --cache",
+    "lint": "yarn lint:js && yarn lint:prettier",
+    "pretest": "yarn lint",
+    "test": "tape test/*.js | tap-spec"
+  },
+  "eslintConfig": {
+    "env": {
+      "es6": true,
+      "node": true
+    },
+    "extends": "eslint:recommended"
+  },
+  "lint-staged": {
+    "*.js": [
+      "eslint",
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "author": "Bogdan Chadkin <trysound@yandex.ru>",
+  "license": "MIT",
+  "homepage": "https://github.com/TrySound/postcss-value-parser",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TrySound/postcss-value-parser.git"
+  },
+  "keywords": [
+    "postcss",
+    "value",
+    "parser"
+  ],
+  "bugs": {
+    "url": "https://github.com/TrySound/postcss-value-parser/issues"
+  }
+}