Add stylelint dependency
This also adds CC-BY-4.0 to the list of accepted licenses.
DISABLE_THIRD_PARTY_CHECK=update dependencies
Bug: chromium:1083142
Change-Id: I8612de2fba52dae32eeb71af79d5aacfde52142b
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/2220097
Reviewed-by: Paul Lewis <aerotwist@chromium.org>
Commit-Queue: Mathias Bynens <mathias@chromium.org>
diff --git a/node_modules/postcss-selector-parser/API.md b/node_modules/postcss-selector-parser/API.md
new file mode 100644
index 0000000..ceee157
--- /dev/null
+++ b/node_modules/postcss-selector-parser/API.md
@@ -0,0 +1,873 @@
+# 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
+const parser = require('postcss-selector-parser');
+```
+
+### `parser([transform], [options])`
+
+Creates a new `processor` instance
+
+```js
+const processor = parser();
+```
+
+Or, with optional transform function
+
+```js
+const transform = selectors => {
+ selectors.walkUniversals(selector => {
+ selector.remove();
+ });
+};
+
+const processor = parser(transform)
+
+// Example
+const result = processor.processSync('*.class');
+// => .class
+```
+
+[See processor documentation](#processor)
+
+Arguments:
+
+* `transform (function)`: Provide a function to work with the parsed AST.
+* `options (object)`: Provide default options for all calls on the returned `Processor`.
+
+### `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.
+
+Notes:
+* **Descendant Combinators** The value of descendant combinators created by the
+ parser always just a single space (`" "`). For descendant selectors with no
+ comments, additional space is now stored in `node.spaces.before`. Depending
+ on the location of comments, additional spaces may be stored in
+ `node.raws.spaces.before`, `node.raws.spaces.after`, or `node.raws.value`.
+* **Named Combinators** Although, nonstandard and unlikely to ever become a standard,
+ named combinators like `/deep/` and `/for/` are parsed as combinators. The
+ `node.value` is name after being unescaped and normalized as lowercase. The
+ original value for the combinator name is stored in `node.raws.value`.
+
+
+### `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
+const id = parser.id({value: 'search'});
+console.log(String(id));
+// => #search
+```
+
+### `node.next()` & `node.prev()`
+
+Returns the next/previous child of the parent node.
+
+```js
+const 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
+const attr = selectors.first.first;
+const 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
+const cloned = parser.id({value: 'search'});
+String(cloned);
+
+// => #search
+```
+
+### `node.isAtPosition(line, column)`
+
+Return a `boolean` indicating whether this node includes the character at the
+position of the given line and column. Returns `undefined` if the nodes lack
+sufficient source metadata to determine the position.
+
+Arguments:
+
+* `line`: 1-index based line number relative to the start of the selector.
+* `column`: 1-index based column number relative to the start of the selector.
+
+### `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 {}
+```
+
+For descendent selectors, the value is always a single space.
+
+```css
+h1 h2 {}
+```
+
+Additional whitespace is found in either the `node.spaces.before` and `node.spaces.after` depending on the presence of comments or other whitespace characters. If the actual whitespace does not start or end with a single space, the node's raw value is set to the actual space(s) found in the source.
+
+### `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.atPosition(line, column)`
+
+Returns the node at the source 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
+let className;
+selectors.each((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((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
+const 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
+const 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(selector => {
+ if (selector.type !== 'class') {
+ const 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 complex 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.qualifiedAttribute`
+
+Returns the attribute name qualified with the namespace if one is given.
+
+### `attribute.offsetOf(part)`
+
+ Returns the offset of the attribute part specified relative to the
+ start of the node of the output string. This is useful in raising
+ error messages about a specific part of the attribute, especially
+ in combination with `attribute.sourceIndex`.
+
+ Returns `-1` if the name is invalid or the value doesn't exist in this
+ attribute.
+
+ The legal values for `part` are:
+
+ * `"ns"` - alias for "namespace"
+ * `"namespace"` - the namespace if it exists.
+ * `"attribute"` - the attribute name
+ * `"attributeNS"` - the start of the attribute or its namespace
+ * `"operator"` - the match operator of the attribute
+ * `"value"` - The value (string or identifier)
+ * `"insensitive"` - the case insensitivity flag
+
+### `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.spaces`
+
+Like `node.spaces` with the `before` and `after` values containing the spaces
+around the element, the parts of the attribute can also have spaces before
+and after them. The for each of `attribute`, `operator`, `value` and
+`insensitive` there is corresponding property of the same nam in
+`node.spaces` that has an optional `before` or `after` string containing only
+whitespace.
+
+Note that corresponding values in `attributes.raws.spaces` contain values
+including any comments. If set, these values will override the
+`attribute.spaces` value. Take care to remove them if changing
+`attribute.spaces`.
+
+### `attribute.raws`
+
+The raws object stores comments and other information necessary to re-render
+the node exactly as it was in the source.
+
+If a comment is embedded within the identifiers for the `namespace`, `attribute`
+or `value` then a property is placed in the raws for that value containing the full source of the propery including comments.
+
+If a comment is embedded within the space between parts of the attribute
+then the raw for that space is set accordingly.
+
+Setting an attribute's property `raws` value to be deleted.
+
+For now, changing the spaces required also updating or removing any of the
+raws values that override them.
+
+Example: `[ /*before*/ href /* after-attr */ = /* after-operator */ te/*inside-value*/st/* wow */ /*omg*/i/*bbq*/ /*whodoesthis*/]` would parse as:
+
+```js
+{
+ attribute: "href",
+ operatator: "=",
+ value: "test",
+ spaces: {
+ before: '',
+ after: '',
+ attribute: { before: ' ', after: ' ' },
+ operator: { after: ' ' },
+ value: { after: ' ' },
+ insensitive: { after: ' ' }
+ },
+ raws: {
+ spaces: {
+ attribute: { before: ' /*before*/ ', after: ' /* after-attr */ ' },
+ operator: { after: ' /* after-operator */ ' },
+ value: { after: '/* wow */ /*omg*/' },
+ insensitive: { after: '/*bbq*/ /*whodoesthis*/' }
+ },
+ unquoted: 'test',
+ value: 'te/*inside-value*/st'
+ }
+}
+```
+
+## `Processor`
+
+### `ProcessorOptions`
+
+* `lossless` - When `true`, whitespace is preserved. Defaults to `true`.
+* `updateSelector` - When `true`, if any processor methods are passed a postcss
+ `Rule` node instead of a string, then that Rule's selector is updated
+ with the results of the processing. Defaults to `true`.
+
+### `process|processSync(selectors, [options])`
+
+Processes the `selectors`, returning a string from the result of processing.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+**Example:**
+
+```js
+const parser = require("postcss-selector-parser");
+const processor = parser();
+
+let result = processor.processSync(' .class');
+console.log(result);
+// => .class
+
+// Asynchronous operation
+let promise = processor.process(' .class').then(result => {
+ console.log(result)
+ // => .class
+});
+
+// To have the parser normalize whitespace values, utilize the options
+result = processor.processSync(' .class ', {lossless: false});
+console.log(result);
+// => .class
+
+// For better syntax errors, pass a PostCSS Rule node.
+const postcss = require('postcss');
+rule = postcss.rule({selector: ' #foo > a, .class '});
+processor.process(rule, {lossless: false, updateSelector: true}).then(result => {
+ console.log(result);
+ // => #foo>a,.class
+ console.log("rule:", rule.selector);
+ // => rule: #foo>a,.class
+})
+```
+
+Arguments:
+
+* `selectors (string|postcss.Rule)`: Either a selector string or a PostCSS Rule
+ node.
+* `[options] (object)`: Process options
+
+
+### `ast|astSync(selectors, [options])`
+
+Like `process()` and `processSync()` but after
+processing the `selectors` these methods return the `Root` node of the result
+instead of a string.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+### `transform|transformSync(selectors, [options])`
+
+Like `process()` and `processSync()` but after
+processing the `selectors` these methods return the value returned by the
+processor callback.
+
+Note: when the `updateSelector` option is set, the rule's selector
+will be updated with the resulting string.
+
+### Error Handling Within Selector Processors
+
+The root node passed to the selector processor callback
+has a method `error(message, options)` that returns an
+error object. This method should always be used to raise
+errors relating to the syntax of selectors. The options
+to this method are passed to postcss's error constructor
+([documentation](http://api.postcss.org/Container.html#error)).
+
+#### Async Error Example
+
+```js
+let processor = (root) => {
+ return new Promise((resolve, reject) => {
+ root.walkClasses((classNode) => {
+ if (/^(.*)[-_]/.test(classNode.value)) {
+ let msg = "classes may not have underscores or dashes in them";
+ reject(root.error(msg, {
+ index: classNode.sourceIndex + RegExp.$1.length + 1,
+ word: classNode.value
+ }));
+ }
+ });
+ resolve();
+ });
+};
+
+const postcss = require("postcss");
+const parser = require("postcss-selector-parser");
+const selectorProcessor = parser(processor);
+const plugin = postcss.plugin('classValidator', (options) => {
+ return (root) => {
+ let promises = [];
+ root.walkRules(rule => {
+ promises.push(selectorProcessor.process(rule));
+ });
+ return Promise.all(promises);
+ };
+});
+postcss(plugin()).process(`
+.foo-bar {
+ color: red;
+}
+`.trim(), {from: 'test.css'}).catch((e) => console.error(e.toString()));
+
+// CssSyntaxError: classValidator: ./test.css:1:5: classes may not have underscores or dashes in them
+//
+// > 1 | .foo-bar {
+// | ^
+// 2 | color: red;
+// 3 | }
+```
+
+#### Synchronous Error Example
+
+```js
+let processor = (root) => {
+ root.walkClasses((classNode) => {
+ if (/.*[-_]/.test(classNode.value)) {
+ let msg = "classes may not have underscores or dashes in them";
+ throw root.error(msg, {
+ index: classNode.sourceIndex,
+ word: classNode.value
+ });
+ }
+ });
+};
+
+const postcss = require("postcss");
+const parser = require("postcss-selector-parser");
+const selectorProcessor = parser(processor);
+const plugin = postcss.plugin('classValidator', (options) => {
+ return (root) => {
+ root.walkRules(rule => {
+ selectorProcessor.processSync(rule);
+ });
+ };
+});
+postcss(plugin()).process(`
+.foo-bar {
+ color: red;
+}
+`.trim(), {from: 'test.css'}).catch((e) => console.error(e.toString()));
+
+// CssSyntaxError: classValidator: ./test.css:1:5: classes may not have underscores or dashes in them
+//
+// > 1 | .foo-bar {
+// | ^
+// 2 | color: red;
+// 3 | }
+```
diff --git a/node_modules/postcss-selector-parser/CHANGELOG.md b/node_modules/postcss-selector-parser/CHANGELOG.md
new file mode 100644
index 0000000..8aeec16
--- /dev/null
+++ b/node_modules/postcss-selector-parser/CHANGELOG.md
@@ -0,0 +1,479 @@
+# 6.0.2
+
+- Fixed an issue with parsing and stringifying an empty attribute value
+
+# 6.0.1
+
+- Fixed an issue with unicode surrogate pair parsing
+
+# 6.0.0
+
+- Updated: `cssesc` to 3.0.0 (major)
+- Fixed: Issues with escaped `id` and `class` selectors
+
+# 5.0.0
+
+- Allow escaped dot within class name.
+- Update PostCSS to 7.0.7 (patch)
+
+# 5.0.0-rc.4
+
+- Fixed an issue where comments immediately after an insensitive (in attribute)
+ were not parsed correctly.
+- Updated `cssesc` to 2.0.0 (major).
+- Removed outdated integration tests.
+- Added tests for custom selectors, tags with attributes, the universal
+ selector with pseudos, and tokens after combinators.
+
+# 5.0.0-rc.1
+
+To ease adoption of the v5.0 release, we have relaxed the node version
+check performed by npm at installation time to allow for node 4, which
+remains officially unsupported, but likely to continue working for the
+time being.
+
+# 5.0.0-rc.0
+
+This release has **BREAKING CHANGES** that were required to fix regressions
+in 4.0.0 and to make the Combinator Node API consistent for all combinator
+types. Please read carefully.
+
+## Summary of Changes
+
+* The way a descendent combinator that isn't a single space character (E.g. `.a .b`) is stored in the AST has changed.
+* Named Combinators (E.g. `.a /for/ .b`) are now properly parsed as a combinator.
+* It is now possible to look up a node based on the source location of a character in that node and to query nodes if they contain some character.
+* Several bug fixes that caused the parser to hang and run out of memory when a `/` was encountered have been fixed.
+* The minimum supported version of Node is now `v6.0.0`.
+
+### Changes to the Descendent Combinator
+
+In prior releases, the value of a descendant combinator with multiple spaces included all the spaces.
+
+* `.a .b`: Extra spaces are now stored as space before.
+ - Old & Busted:
+ - `combinator.value === " "`
+ - New hotness:
+ - `combinator.value === " " && combinator.spaces.before === " "`
+* `.a /*comment*/.b`: A comment at the end of the combinator causes extra space to become after space.
+ - Old & Busted:
+ - `combinator.value === " "`
+ - `combinator.raws.value === " /*comment/"`
+ - New hotness:
+ - `combinator.value === " "`
+ - `combinator.spaces.after === " "`
+ - `combinator.raws.spaces.after === " /*comment*/"`
+* `.a<newline>.b`: whitespace that doesn't start or end with a single space character is stored as a raw value.
+ - Old & Busted:
+ - `combinator.value === "\n"`
+ - `combinator.raws.value === undefined`
+ - New hotness:
+ - `combinator.value === " "`
+ - `combinator.raws.value === "\n"`
+
+### Support for "Named Combinators"
+
+Although, nonstandard and unlikely to ever become a standard, combinators like `/deep/` and `/for/` are now properly supported.
+
+Because they've been taken off the standardization track, there is no spec-official name for combinators of the form `/<ident>/`. However, I talked to [Tab Atkins](https://twitter.com/tabatkins) and we agreed to call them "named combinators" so now they are called that.
+
+Before this release such named combinators were parsed without intention and generated three nodes of type `"tag"` where the first and last nodes had a value of `"/"`.
+
+* `.a /for/ .b` is parsed as a combinator.
+ - Old & Busted:
+ - `root.nodes[0].nodes[1].type === "tag"`
+ - `root.nodes[0].nodes[1].value === "/"`
+ - New hotness:
+ - `root.nodes[0].nodes[1].type === "combinator"`
+ - `root.nodes[0].nodes[1].value === "/for/"`
+* `.a /F\6fR/ .b` escapes are handled and uppercase is normalized.
+ - Old & Busted:
+ - `root.nodes[0].nodes[2].type === "tag"`
+ - `root.nodes[0].nodes[2].value === "F\\6fR"`
+ - New hotness:
+ - `root.nodes[0].nodes[1].type === "combinator"`
+ - `root.nodes[0].nodes[1].value === "/for/"`
+ - `root.nodes[0].nodes[1].raws.value === "/F\\6fR/"`
+
+### Source position checks and lookups
+
+A new API was added to look up a node based on the source location.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+// You can find the most specific node for any given character
+let combinator = selectorParser.astSync(".a > .b").atPosition(1,4);
+combinator.toString() === " > ";
+// You can check if a node includes a specific character
+// Whitespace surrounding the node that is owned by that node
+// is included in the check.
+[2,3,4,5,6].map(column => combinator.isAtPosition(1, column));
+// => [false, true, true, true, false]
+```
+
+# 4.0.0
+
+This release has **BREAKING CHANGES** that were required to fix bugs regarding values with escape sequences. Please read carefully.
+
+* **Identifiers with escapes** - CSS escape sequences are now hidden from the public API by default.
+ The normal value of a node like a class name or ID, or an aspect of a node such as attribute
+ selector's value, is unescaped. Escapes representing Non-ascii characters are unescaped into
+ unicode characters. For example: `bu\tton, .\31 00, #i\2764\FE0Fu, [attr="value is \"quoted\""]`
+ will parse respectively to the values `button`, `100`, `i❤️u`, `value is "quoted"`.
+ The original escape sequences for these values can be found in the corresponding property name
+ in `node.raws`. Where possible, deprecation warnings were added, but the nature
+ of escape handling makes it impossible to detect what is escaped or not. Our expectation is
+ that most users are neither expecting nor handling escape sequences in their use of this library,
+ and so for them, this is a bug fix. Users who are taking care to handle escapes correctly can
+ now update their code to remove the escape handling and let us do it for them.
+
+* **Mutating values with escapes** - When you make an update to a node property that has escape handling
+ The value is assumed to be unescaped, and any special characters are escaped automatically and
+ the corresponding `raws` value is immediately updated. This can result in changes to the original
+ escape format. Where the exact value of the escape sequence is important there are methods that
+ allow both values to be set in conjunction. There are a number of new convenience methods for
+ manipulating values that involve escapes, especially for attributes values where the quote mark
+ is involved. See https://github.com/postcss/postcss-selector-parser/pull/133 for an extensive
+ write-up on these changes.
+
+
+**Upgrade/API Example**
+
+In `3.x` there was no unescape handling and internal consistency of several properties was the caller's job to maintain. It was very easy for the developer
+to create a CSS file that did not parse correctly when some types of values
+were in use.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+let attr = selectorParser.attribute({attribute: "id", operator: "=", value: "a-value"});
+attr.value; // => "a-value"
+attr.toString(); // => [id=a-value]
+// Add quotes to an attribute's value.
+// All these values have to be set by the caller to be consistent:
+// no internal consistency is maintained.
+attr.raws.unquoted = attr.value
+attr.value = "'" + attr.value + "'";
+attr.value; // => "'a-value'"
+attr.quoted = true;
+attr.toString(); // => "[id='a-value']"
+```
+
+In `4.0` there is a convenient API for setting and mutating values
+that may need escaping. Especially for attributes.
+
+```js
+const selectorParser = require("postcss-selector-parser");
+
+// The constructor requires you specify the exact escape sequence
+let className = selectorParser.className({value: "illegal class name", raws: {value: "illegal\\ class\\ name"}});
+className.toString(); // => '.illegal\\ class\\ name'
+
+// So it's better to set the value as a property
+className = selectorParser.className();
+// Most properties that deal with identifiers work like this
+className.value = "escape for me";
+className.value; // => 'escape for me'
+className.toString(); // => '.escape\\ for\\ me'
+
+// emoji and all non-ascii are escaped to ensure it works in every css file.
+className.value = "😱🦄😍";
+className.value; // => '😱🦄😍'
+className.toString(); // => '.\\1F631\\1F984\\1F60D'
+
+// you can control the escape sequence if you want, or do bad bad things
+className.setPropertyAndEscape('value', 'xxxx', 'yyyy');
+className.value; // => "xxxx"
+className.toString(); // => ".yyyy"
+
+// Pass a value directly through to the css output without escaping it.
+className.setPropertyWithoutEscape('value', '$REPLACE_ME$');
+className.value; // => "$REPLACE_ME$"
+className.toString(); // => ".$REPLACE_ME$"
+
+// The biggest changes are to the Attribute class
+// passing quoteMark explicitly is required to avoid a deprecation warning.
+let attr = selectorParser.attribute({attribute: "id", operator: "=", value: "a-value", quoteMark: null});
+attr.toString(); // => "[id=a-value]"
+// Get the value with quotes on it and any necessary escapes.
+// This is the same as reading attr.value in 3.x.
+attr.getQuotedValue(); // => "a-value";
+attr.quoteMark; // => null
+
+// Add quotes to an attribute's value.
+attr.quoteMark = "'"; // This is all that's required.
+attr.toString(); // => "[id='a-value']"
+attr.quoted; // => true
+// The value is still the same, only the quotes have changed.
+attr.value; // => a-value
+attr.getQuotedValue(); // => "'a-value'";
+
+// deprecated assignment, no warning because there's no escapes
+attr.value = "new-value";
+// no quote mark is needed so it is removed
+attr.getQuotedValue(); // => "new-value";
+
+// deprecated assignment,
+attr.value = "\"a 'single quoted' value\"";
+// > (node:27859) DeprecationWarning: Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.
+attr.getQuotedValue(); // => '"a \'single quoted\' value"';
+// quote mark inferred from first and last characters.
+attr.quoteMark; // => '"'
+
+// setValue takes options to make manipulating the value simple.
+attr.setValue('foo', {smart: true});
+// foo doesn't require any escapes or quotes.
+attr.toString(); // => '[id=foo]'
+attr.quoteMark; // => null
+
+// An explicit quote mark can be specified
+attr.setValue('foo', {quoteMark: '"'});
+attr.toString(); // => '[id="foo"]'
+
+// preserves quote mark by default
+attr.setValue('bar');
+attr.toString(); // => '[id="bar"]'
+attr.quoteMark = null;
+attr.toString(); // => '[id=bar]'
+
+// with no arguments, it preserves quote mark even when it's not a great idea
+attr.setValue('a value \n that should be quoted');
+attr.toString(); // => '[id=a\\ value\\ \\A\\ that\\ should\\ be\\ quoted]'
+
+// smart preservation with a specified default
+attr.setValue('a value \n that should be quoted', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => "[id='a value \\A that should be quoted']"
+attr.quoteMark = '"';
+// => '[id="a value \\A that should be quoted"]'
+
+// this keeps double quotes because it wants to quote the value and the existing value has double quotes.
+attr.setValue('this should be quoted', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => '[id="this should be quoted"]'
+
+// picks single quotes because the value has double quotes
+attr.setValue('a "double quoted" value', {smart: true, preferCurrentQuoteMark: true, quoteMark: "'"});
+// => "[id='a "double quoted" value']"
+
+// setPropertyAndEscape lets you do anything you want. Even things that are a bad idea and illegal.
+attr.setPropertyAndEscape('value', 'xxxx', 'the password is 42');
+attr.value; // => "xxxx"
+attr.toString(); // => "[id=the password is 42]"
+
+// Pass a value directly through to the css output without escaping it.
+attr.setPropertyWithoutEscape('value', '$REPLACEMENT$');
+attr.value; // => "$REPLACEMENT$"
+attr.toString(); // => "[id=$REPLACEMENT$]"
+```
+
+# 3.1.2
+
+* Fix: Removed dot-prop dependency since it's no longer written in es5.
+
+# 3.1.1
+
+* Fix: typescript definitions weren't in the published package.
+
+# 3.1.0
+
+* Fixed numerous bugs in attribute nodes relating to the handling of comments
+ and whitespace. There's significant changes to `attrNode.spaces` and `attrNode.raws` since the `3.0.0` release.
+* Added `Attribute#offsetOf(part)` to get the offset location of
+ attribute parts like `"operator"` and `"value"`. This is most
+ often added to `Attribute#sourceIndex` for error reporting.
+
+# 3.0.0
+
+## Breaking changes
+
+* Some tweaks to the tokenizer/attribute selector parsing mean that whitespace
+ locations might be slightly different to the 2.x code.
+* Better attribute selector parsing with more validation; postcss-selector-parser
+ no longer uses regular expressions to parse attribute selectors.
+* Added an async API (thanks to @jacobp100); the default `process` API is now
+ async, and the sync API is now accessed through `processSync` instead.
+* `process()` and `processSync()` now return a string instead of the Processor
+ instance.
+* Tweaks handling of Less interpolation (thanks to @jwilsson).
+* Removes support for Node 0.12.
+
+## Other changes
+
+* `ast()` and `astSync()` methods have been added to the `Processor`. These
+ return the `Root` node of the selectors after processing them.
+* `transform()` and `transformSync()` methods have been added to the
+ `Processor`. These return the value returned by the processor callback
+ after processing the selectors.
+* Set the parent when inserting a node (thanks to @chriseppstein).
+* Correctly adjust indices when using insertBefore/insertAfter (thanks to @tivac).
+* Fixes handling of namespaces with qualified tag selectors.
+* `process`, `ast` and `transform` (and their sync variants) now accept a
+ `postcss` rule node. When provided, better errors are generated and selector
+ processing is automatically set back to the rule selector (unless the `updateSelector` option is set to `false`.)
+* Now more memory efficient when tokenizing selectors.
+
+### Upgrade hints
+
+The pattern of:
+
+`rule.selector = processor.process(rule.selector).result.toString();`
+
+is now:
+
+`processor.processSync(rule)`
+
+# 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-selector-parser/LICENSE-MIT b/node_modules/postcss-selector-parser/LICENSE-MIT
new file mode 100644
index 0000000..fd0e863
--- /dev/null
+++ b/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-selector-parser/README.md b/node_modules/postcss-selector-parser/README.md
new file mode 100644
index 0000000..18a01c5
--- /dev/null
+++ b/node_modules/postcss-selector-parser/README.md
@@ -0,0 +1,49 @@
+# postcss-selector-parser [](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
+const parser = require('postcss-selector-parser');
+const transform = selectors => {
+ selectors.walk(selector => {
+ // do something with the selector
+ console.log(String(selector))
+ });
+};
+
+const transformed = parser(transform).processSync('h1, h2, h3');
+```
+
+To normalize selector whitespace:
+
+```js
+const parser = require('postcss-selector-parser');
+const normalized = parser().processSync('h1, h2, h3', {lossless: false});
+// -> h1,h2,h3
+```
+
+Async support is provided through `parser.process` and will resolve a Promise
+with the resulting selector string.
+
+## 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-selector-parser/dist/__tests__/attributes.js b/node_modules/postcss-selector-parser/dist/__tests__/attributes.js
new file mode 100644
index 0000000..a7b275f
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/attributes.js
@@ -0,0 +1,477 @@
+"use strict";
+
+var _process = _interopRequireDefault(require("process"));
+
+var _attribute = _interopRequireDefault(require("../selectors/attribute"));
+
+var _helpers = require("./util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+_process.default.throwDeprecation = true;
+(0, _helpers.test)('attribute selector', '[href]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'attribute');
+ t.falsy(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('attribute selector spaces (before)', '[ href]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.attribute.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'attribute');
+ t.falsy(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('attribute selector spaces (after)', '[href ]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.attribute.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'attribute');
+ t.falsy(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('attribute selector spaces with namespace (both)', '[ foo|bar ]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].ns, 'foo');
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'bar');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.attribute.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.attribute.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'attribute');
+ t.falsy(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('attribute selector spaces (both)', '[ href ]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.attribute.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.attribute.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'attribute');
+ t.falsy(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('multiple attribute selectors', '[href][class][name]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'class');
+ t.deepEqual(tree.nodes[0].nodes[2].attribute, 'name');
+});
+(0, _helpers.test)('select elements with or without a namespace', '[*|href]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, '*');
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+});
+(0, _helpers.test)('namespace with escapes', '[\\31 \\#\\32 |href]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[0];
+ t.deepEqual(attr.namespace, '1#2');
+ t.deepEqual(attr.raws.namespace, '\\31 \\#\\32 ');
+ attr.namespace = "foo";
+ t.deepEqual(attr.namespace, 'foo');
+ t.deepEqual(attr.raws.namespace, undefined);
+ attr.namespace = "1";
+ t.deepEqual(attr.namespace, '1');
+ t.deepEqual(attr.raws.namespace, '\\31');
+});
+(0, _helpers.test)('attribute selector with a empty value', '[href=""]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, '');
+ t.true(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('attribute selector with a value', '[name=james]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'name');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'james');
+ t.falsy(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('attribute selector with quoted value', '[name="james"]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[0];
+ t.deepEqual(attr.attribute, 'name');
+ t.deepEqual(attr.operator, '=');
+ t.deepEqual(attr.value, 'james');
+ t.deepEqual(attr.quoteMark, '"');
+ t.truthy(attr.quoted);
+ t.deepEqual(attr.getQuotedValue(), '"james"');
+});
+(0, _helpers.test)('attribute selector with escaped quote', '[title="Something \\"weird\\""]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[0];
+ t.deepEqual(attr.value, 'Something "weird"');
+ t.deepEqual(attr.getQuotedValue(), '\"Something \\"weird\\"\"');
+ t.deepEqual(attr.getQuotedValue({
+ smart: true
+ }), '\'Something "weird"\'');
+ t.deepEqual(attr.getQuotedValue({
+ quoteMark: null
+ }), 'Something\\ \\"weird\\"');
+ t.deepEqual(attr.quoteMark, '"');
+ t.truthy(attr.quoted);
+ t.deepEqual(attr.raws.value, '"Something \\"weird\\""');
+ t.deepEqual(tree.toString(), '[title="Something \\"weird\\""]');
+});
+(0, _helpers.test)('attribute selector with escaped colon', '[ng\\:cloak]', function (t, tree) {
+ t.deepEqual(tree.toString(), '[ng\\:cloak]');
+ var attr = tree.nodes[0].nodes[0];
+ t.deepEqual(attr.raws.attribute, 'ng\\:cloak');
+ t.deepEqual(attr.attribute, 'ng:cloak');
+});
+(0, _helpers.test)('attribute selector with short hex escape', '[ng\\3a cloak]', function (t, tree) {
+ t.deepEqual(tree.toString(), '[ng\\3a cloak]');
+ var attr = tree.nodes[0].nodes[0];
+ t.deepEqual(attr.raws.attribute, 'ng\\3a cloak');
+ t.deepEqual(attr.attribute, 'ng:cloak');
+});
+(0, _helpers.test)('attribute selector with hex escape', '[ng\\00003acloak]', function (t, tree) {
+ t.deepEqual(tree.toString(), '[ng\\00003acloak]');
+ var attr = tree.nodes[0].nodes[0];
+ t.deepEqual(attr.raws.attribute, 'ng\\00003acloak');
+ t.deepEqual(attr.attribute, 'ng:cloak');
+});
+(0, _helpers.test)('assign attribute name requiring escape', '[ng\\:cloak]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[0];
+ attr.attribute = "ng:foo";
+ t.deepEqual(attr.raws.attribute, 'ng\\:foo');
+ t.deepEqual(attr.attribute, 'ng:foo');
+ t.deepEqual(tree.toString(), '[ng\\:foo]');
+});
+(0, _helpers.test)('multiple attribute selectors + combinator', '[href][class][name] h1 > h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[2].attribute, 'name');
+ t.deepEqual(tree.nodes[0].nodes[3].value, ' ');
+ t.deepEqual(tree.nodes[0].nodes[5].value, '>');
+ t.deepEqual(tree.nodes[0].nodes[6].value, 'h2');
+});
+(0, _helpers.test)('attribute, class, combinator', '[href] > h2.test', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '>');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+ t.deepEqual(tree.nodes[0].nodes[3].value, 'test');
+});
+(0, _helpers.test)('attribute selector with quoted value & combinator', '[name="james"] > h1', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'james');
+ t.deepEqual(tree.nodes[0].nodes[0].quoteMark, '"');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '>');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h1');
+});
+(0, _helpers.test)('multiple quoted attribute selectors', '[href*="test.com"][rel=\'external\'][id][class~="test"] > [name]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test.com');
+ t.is(tree.nodes[0].nodes[0].quoteMark, '"');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'rel');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'external');
+ t.is(tree.nodes[0].nodes[1].quoteMark, "'");
+ t.deepEqual(tree.nodes[0].nodes[2].attribute, 'id');
+ t.falsy(tree.nodes[0].nodes[2].value, 'should not have a value');
+ t.is(tree.nodes[0].nodes[2].quoteMark, undefined, 'should not have a quoteMark set');
+ t.deepEqual(tree.nodes[0].nodes[3].attribute, 'class');
+ t.deepEqual(tree.nodes[0].nodes[3].value, 'test');
+ t.deepEqual(tree.nodes[0].nodes[3].quoteMark, '"');
+ t.deepEqual(tree.nodes[0].nodes[4].value, '>');
+ t.deepEqual(tree.nodes[0].nodes[5].attribute, 'name');
+ t.falsy(tree.nodes[0].nodes[5].value, 'should not have a value');
+ t.is(tree.nodes[0].nodes[5].quoteMark, undefined, 'should not have a quoteMark set');
+});
+(0, _helpers.test)('more attribute operators', '[href*=test],[href^=test],[href$=test],[href|=test]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '*=');
+ t.deepEqual(tree.nodes[1].nodes[0].operator, '^=');
+ t.deepEqual(tree.nodes[2].nodes[0].operator, '$=');
+ t.deepEqual(tree.nodes[3].nodes[0].operator, '|=');
+});
+(0, _helpers.test)('attribute selector with quoted value containing "="', '[data-weird-attr="Something=weird"]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'Something=weird');
+ t.is(tree.nodes[0].nodes[0].quoteMark, '"');
+ t.deepEqual(tree.nodes[0].nodes[0].getQuotedValue(), '"Something=weird"');
+});
+var selector = '[data-weird-attr*="Something=weird"],' + '[data-weird-attr^="Something=weird"],' + '[data-weird-attr$="Something=weird"],' + '[data-weird-attr|="Something=weird"]';
+(0, _helpers.test)('more attribute selector with quoted value containing "="', selector, function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '*=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'Something=weird');
+ t.deepEqual(tree.nodes[1].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[1].nodes[0].operator, '^=');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'Something=weird');
+ t.deepEqual(tree.nodes[2].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[2].nodes[0].operator, '$=');
+ t.deepEqual(tree.nodes[2].nodes[0].value, 'Something=weird');
+ t.deepEqual(tree.nodes[3].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[3].nodes[0].operator, '|=');
+ t.deepEqual(tree.nodes[3].nodes[0].value, 'Something=weird');
+});
+(0, _helpers.test)('attribute selector with quoted value containing multiple "="', '[data-weird-attr="Something=weird SomethingElse=weirder"]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'Something=weird SomethingElse=weirder');
+});
+selector = '[data-weird-attr*="Something=weird SomethingElse=weirder"],' + '[data-weird-attr^="Something=weird SomethingElse=weirder"],' + '[data-weird-attr$="Something=weird SomethingElse=weirder"],' + '[data-weird-attr|="Something=weird SomethingElse=weirder"]';
+(0, _helpers.test)('more attribute selector with quoted value containing multiple "="', selector, function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '*=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'Something=weird SomethingElse=weirder');
+ t.deepEqual(tree.nodes[1].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[1].nodes[0].operator, '^=');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'Something=weird SomethingElse=weirder');
+ t.deepEqual(tree.nodes[2].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[2].nodes[0].operator, '$=');
+ t.deepEqual(tree.nodes[2].nodes[0].value, 'Something=weird SomethingElse=weirder');
+ t.deepEqual(tree.nodes[3].nodes[0].attribute, 'data-weird-attr');
+ t.deepEqual(tree.nodes[3].nodes[0].operator, '|=');
+ t.deepEqual(tree.nodes[3].nodes[0].value, 'Something=weird SomethingElse=weirder');
+});
+(0, _helpers.test)('multiple attribute selectors with quoted value containing "="', '[data-weird-foo="foo=weird"][data-weird-bar="bar=weird"]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo=weird');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[0].nodes[1].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'bar=weird');
+});
+(0, _helpers.test)('multiple attribute selectors with value containing escaped "="', '[data-weird-foo=foo\\=weird][data-weird-bar=bar\\3d weird]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo=weird');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[0].nodes[1].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'bar=weird');
+});
+selector = '[data-weird-foo*="foo2=weirder"][data-weird-bar*="bar2=weirder"],' + '[data-weird-foo^="foo2=weirder"][data-weird-bar^="bar2=weirder"],' + '[data-weird-foo$="foo2=weirder"][data-weird-bar$="bar2=weirder"],' + '[data-weird-foo|="foo2=weirder"][data-weird-bar|="bar2=weirder"]';
+(0, _helpers.test)('more multiple attribute selectors with quoted value containing "="', selector, function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '*=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo2=weirder');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[0].nodes[1].operator, '*=');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'bar2=weirder');
+ t.deepEqual(tree.nodes[1].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[1].nodes[0].operator, '^=');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'foo2=weirder');
+ t.deepEqual(tree.nodes[1].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[1].nodes[1].operator, '^=');
+ t.deepEqual(tree.nodes[1].nodes[1].value, 'bar2=weirder');
+ t.deepEqual(tree.nodes[2].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[2].nodes[0].operator, '$=');
+ t.deepEqual(tree.nodes[2].nodes[0].value, 'foo2=weirder');
+ t.deepEqual(tree.nodes[2].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[2].nodes[1].operator, '$=');
+ t.deepEqual(tree.nodes[2].nodes[1].value, 'bar2=weirder');
+ t.deepEqual(tree.nodes[3].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[3].nodes[0].operator, '|=');
+ t.deepEqual(tree.nodes[3].nodes[0].value, 'foo2=weirder');
+ t.deepEqual(tree.nodes[3].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[3].nodes[1].operator, '|=');
+ t.deepEqual(tree.nodes[3].nodes[1].value, 'bar2=weirder');
+});
+(0, _helpers.test)('multiple attribute selectors with quoted value containing multiple "="', '[data-weird-foo="foo1=weirder foo2=weirder"][data-weird-bar="bar1=weirder bar2=weirder"]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo1=weirder foo2=weirder');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[0].nodes[1].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'bar1=weirder bar2=weirder');
+});
+selector = '[data-weird-foo*="foo1=weirder foo2=weirder"][data-weird-bar*="bar1=weirder bar2=weirder"],' + '[data-weird-foo^="foo1=weirder foo2=weirder"][data-weird-bar^="bar1=weirder bar2=weirder"],' + '[data-weird-foo$="foo1=weirder foo2=weirder"][data-weird-bar$="bar1=weirder bar2=weirder"],' + '[data-weird-foo|="foo1=weirder foo2=weirder"][data-weird-bar|="bar1=weirder bar2=weirder"]';
+(0, _helpers.test)('more multiple attribute selectors with quoted value containing multiple "="', selector, function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '*=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo1=weirder foo2=weirder');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[0].nodes[1].operator, '*=');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'bar1=weirder bar2=weirder');
+ t.deepEqual(tree.nodes[1].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[1].nodes[0].operator, '^=');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'foo1=weirder foo2=weirder');
+ t.deepEqual(tree.nodes[1].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[1].nodes[1].operator, '^=');
+ t.deepEqual(tree.nodes[1].nodes[1].value, 'bar1=weirder bar2=weirder');
+ t.deepEqual(tree.nodes[2].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[2].nodes[0].operator, '$=');
+ t.deepEqual(tree.nodes[2].nodes[0].value, 'foo1=weirder foo2=weirder');
+ t.deepEqual(tree.nodes[2].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[2].nodes[1].operator, '$=');
+ t.deepEqual(tree.nodes[2].nodes[1].value, 'bar1=weirder bar2=weirder');
+ t.deepEqual(tree.nodes[3].nodes[0].attribute, 'data-weird-foo');
+ t.deepEqual(tree.nodes[3].nodes[0].operator, '|=');
+ t.deepEqual(tree.nodes[3].nodes[0].value, 'foo1=weirder foo2=weirder');
+ t.deepEqual(tree.nodes[3].nodes[1].attribute, 'data-weird-bar');
+ t.deepEqual(tree.nodes[3].nodes[1].operator, '|=');
+ t.deepEqual(tree.nodes[3].nodes[1].value, 'bar1=weirder bar2=weirder');
+});
+(0, _helpers.test)('spaces in attribute selectors', 'h1[ href *= "test" ]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[1];
+ t.deepEqual(attr.attribute, 'href');
+ t.deepEqual(attr.spaces.attribute.before, ' ');
+ t.deepEqual(attr.spaces.attribute.after, ' ');
+ t.deepEqual(attr.operator, '*=');
+ t.deepEqual(attr.spaces.operator.after, ' ');
+ t.deepEqual(attr.value, 'test');
+ t.deepEqual(attr.spaces.value.after, ' ');
+ t.truthy(tree.nodes[0].nodes[1].quoted);
+});
+(0, _helpers.test)('insensitive attribute selector 1', '[href="test" i]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test');
+ t.deepEqual(tree.nodes[0].nodes[0].insensitive, true);
+ t.deepEqual(tree.nodes[0].nodes[0].insensitive, true);
+});
+(0, _helpers.test)('insensitive attribute selector with a empty value', '[href="" i]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, '');
+ t.deepEqual(tree.nodes[0].nodes[0].insensitive, true);
+ t.true(tree.nodes[0].nodes[0].quoted);
+});
+(0, _helpers.test)('insensitive attribute selector 2', '[href=TEsT i ]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'TEsT');
+ t.deepEqual(tree.nodes[0].nodes[0].insensitive, true);
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.value.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.insensitive.after, ' ');
+});
+(0, _helpers.test)('insensitive attribute selector 3', '[href=test i]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test');
+ t.deepEqual(tree.nodes[0].nodes[0].insensitive, true);
+});
+(0, _helpers.test)('capitalized insensitive attribute selector 3', '[href=test I]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test');
+ t.deepEqual(tree.nodes[0].nodes[0].insensitive, true);
+});
+(0, _helpers.test)('extraneous non-combinating whitespace', ' [href] , [class] ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.after, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].attribute, 'class');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.after, ' ');
+});
+(0, _helpers.test)('comments within attribute selectors', '[href/* wow */=/* wow */test]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.attribute, 'href/* wow */');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.operator, '=/* wow */');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test');
+});
+(0, _helpers.test)('comments within attribute selectors (2)', '[/* wow */href=test/* wow */]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.spaces.attribute.before, '/* wow */');
+ t.deepEqual(tree.nodes[0].nodes[0].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'test/* wow */');
+});
+(0, _helpers.test)('comments within attribute selectors (3)', '[href=test/* wow */i]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'testi');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'test/* wow */i');
+ t.falsy(tree.nodes[0].nodes[0].insensitive);
+});
+(0, _helpers.test)('comments within attribute selectors (4)', '[ /*before*/ href /* after-attr */ = /* after-operator */ te/*inside-value*/st/* wow */ /*omg*/i/*bbq*/ /*whodoesthis*/]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[0];
+ t.deepEqual(attr.attribute, 'href');
+ t.deepEqual(attr.value, 'test');
+ t.deepEqual(attr.getQuotedValue(), 'test');
+ t.deepEqual(attr.raws.value, 'te/*inside-value*/st');
+ t.deepEqual(attr.raws.spaces.value.after, '/* wow */ /*omg*/');
+ t.truthy(attr.insensitive);
+ t.deepEqual(attr.offsetOf("attribute"), 13);
+ t.deepEqual(attr.offsetOf("operator"), 35);
+ t.deepEqual(attr.offsetOf("insensitive"), 95);
+ t.deepEqual(attr.raws.spaces.insensitive.after, '/*bbq*/ /*whodoesthis*/');
+ attr.value = "foo";
+ t.is(attr.raws.value, undefined);
+});
+(0, _helpers.test)('non standard modifiers', '[href="foo" y]', function (t, tree) {
+ var attr = tree.atPosition(1, 13);
+ t.deepEqual(attr.insensitive, false);
+ t.deepEqual(attr.insensitiveFlag, '');
+ t.deepEqual(attr.raws.insensitiveFlag, 'y');
+ t.deepEqual(tree.toString(), '[href="foo" y]');
+});
+(0, _helpers.test)('comment after insensitive(non space)', '[href="foo" i/**/]', function (t, tree) {
+ // https://github.com/postcss/postcss-selector-parser/issues/150
+ var attr = tree.atPosition(1, 13);
+ t.deepEqual(attr.insensitive, true);
+ t.deepEqual(attr.insensitiveFlag, 'i');
+ t.is(attr.raws.insensitiveFlag, undefined);
+ t.deepEqual(attr.raws.spaces.insensitive.after, '/**/');
+ t.deepEqual(tree.toString(), '[href="foo" i/**/]');
+});
+(0, _helpers.test)('comment after insensitive(space after)', '[href="foo" i/**/ ]', function (t, tree) {
+ var attr = tree.atPosition(1, 13);
+ t.deepEqual(attr.insensitive, true);
+ t.deepEqual(attr.insensitiveFlag, 'i');
+ t.deepEqual(attr.raws.spaces.insensitive.after, '/**/ ');
+ t.deepEqual(tree.toString(), '[href="foo" i/**/ ]');
+});
+(0, _helpers.test)('comment after insensitive(space before)', '[href="foo" i /**/]', function (t, tree) {
+ var attr = tree.atPosition(1, 13);
+ t.deepEqual(attr.insensitive, true);
+ t.deepEqual(attr.insensitiveFlag, 'i');
+ t.deepEqual(attr.raws.spaces.insensitive.after, ' /**/');
+ t.deepEqual(tree.toString(), '[href="foo" i /**/]');
+});
+var testDeprecation = (0, _helpers.nodeVersionAtLeast)('7.0.0') || (0, _helpers.nodeVersionBefore)('6.0.0') ? _helpers.test : _helpers.test.skip;
+testDeprecation('deprecated constructor', '', function (t) {
+ t.throws(function () {
+ return new _attribute.default({
+ value: '"foo"',
+ attribute: "data-bar"
+ });
+ }, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+});
+testDeprecation('deprecated get of raws.unquoted ', '', function (t) {
+ t.throws(function () {
+ var attr = new _attribute.default({
+ value: 'foo',
+ quoteMark: '"',
+ attribute: "data-bar"
+ });
+ return attr.raws.unquoted;
+ }, "attr.raws.unquoted is deprecated. Call attr.value instead.");
+});
+testDeprecation('deprecated set of raws.unquoted ', '', function (t) {
+ t.throws(function () {
+ var attr = new _attribute.default({
+ value: 'foo',
+ quoteMark: '"',
+ attribute: "data-bar"
+ });
+ attr.raws.unquoted = 'fooooo';
+ }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.");
+});
+testDeprecation('smart quotes', '[data-foo=bar]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[0];
+ attr.setValue('changed', {
+ quoteMark: '"'
+ });
+ t.deepEqual(attr.toString(), '[data-foo="changed"]');
+ attr.setValue('changed again', {
+ quoteMark: "'",
+ preferCurrentQuoteMark: true
+ });
+ t.deepEqual(attr.toString(), '[data-foo="changed again"]');
+ attr.setValue('smart-ident', {
+ smart: true
+ });
+ t.deepEqual(attr.toString(), '[data-foo=smart-ident]');
+ attr.setValue('smart quoted', {
+ smart: true
+ });
+ t.deepEqual(attr.toString(), '[data-foo=smart\\ quoted]');
+ attr.setValue('smart quoted three spaces', {
+ smart: true
+ });
+ t.deepEqual(attr.toString(), '[data-foo="smart quoted three spaces"]');
+ attr.setValue('smart quoted three spaces', {
+ smart: true,
+ quoteMark: "'"
+ });
+ t.deepEqual(attr.toString(), "[data-foo='smart quoted three spaces']");
+ attr.setValue("smart with 'single quotes'", {
+ smart: true
+ });
+ t.deepEqual(attr.toString(), "[data-foo=\"smart with 'single quotes'\"]");
+ attr.setValue('smart with "double quotes"', {
+ smart: true
+ });
+ t.deepEqual(attr.toString(), "[data-foo='smart with \"double quotes\"']");
+});
+testDeprecation('set Attribute#quoteMark', '[data-foo=bar]', function (t, tree) {
+ var attr = tree.nodes[0].nodes[0];
+ attr.quoteMark = '"';
+ t.deepEqual(attr.toString(), '[data-foo="bar"]');
+ attr.quoteMark = "'";
+ t.deepEqual(attr.toString(), "[data-foo='bar']");
+ attr.quoteMark = null;
+ t.deepEqual(attr.toString(), "[data-foo=bar]");
+ attr.value = "has space";
+ t.deepEqual(attr.toString(), "[data-foo=has\\ space]");
+ attr.quoteMark = '"';
+ t.deepEqual(attr.toString(), '[data-foo="has space"]');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/classes.js b/node_modules/postcss-selector-parser/dist/__tests__/classes.js
new file mode 100644
index 0000000..003d6b3
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/classes.js
@@ -0,0 +1,216 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('class name', '.one', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'one');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('multiple class names', '.one.two.three', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'one');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'two');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'three');
+});
+(0, _helpers.test)('qualified class', 'button.btn-primary', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'class');
+});
+(0, _helpers.test)('escaped numbers in class name', '.\\31\\ 0', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].value, '1 0');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\31\\ 0');
+});
+(0, _helpers.test)('extraneous non-combinating whitespace', ' .h1 , .h2 ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.after, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'h2');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.after, ' ');
+});
+(0, _helpers.test)('Less interpolation within a class', '.foo@{bar}', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes.length, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo@{bar}');
+});
+(0, _helpers.test)('ClassName#set value', ".fo\\o", function (t, selectors) {
+ var className = selectors.first.first;
+ t.deepEqual(className.raws, {
+ value: "fo\\o"
+ });
+ className.value = "bar";
+ t.deepEqual(className.raws, {});
+});
+(0, _helpers.test)('escaped dot in class name', '.foo\\.bar', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo.bar');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'foo\\.bar');
+});
+(0, _helpers.test)('class selector with escaping', '.♥', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '♥');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('class selector with escaping (1)', '.©', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '©');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('class selector with escaping (2)', '.“‘’”', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '“‘’”');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('class selector with escaping (3)', '.☺☃', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '☺☃');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('class selector with escaping (4)', '.⌘⌥', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '⌘⌥');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('class selector with escaping (5)', '.𝄞♪♩♫♬', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '𝄞♪♩♫♬');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('class selector with escaping (6)', '.💩', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '💩');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('class selector with escaping (7)', '.\\?', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '?');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\?');
+});
+(0, _helpers.test)('class selector with escaping (8)', '.\\@', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '@');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\@');
+});
+(0, _helpers.test)('class selector with escaping (9)', '.\\.', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '.');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\.');
+});
+(0, _helpers.test)('class selector with escaping (10)', '.\\3A \\)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':)');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A \\)');
+});
+(0, _helpers.test)('class selector with escaping (11)', '.\\3A \\`\\(', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':`(');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A \\`\\(');
+});
+(0, _helpers.test)('class selector with escaping (12)', '.\\31 23', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '123');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\31 23');
+});
+(0, _helpers.test)('class selector with escaping (13)', '.\\31 a2b3c', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '1a2b3c');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\31 a2b3c');
+});
+(0, _helpers.test)('class selector with escaping (14)', '.\\<p\\>', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '<p>');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\<p\\>');
+});
+(0, _helpers.test)('class selector with escaping (15)', '.\\<\\>\\<\\<\\<\\>\\>\\<\\>', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '<><<<>><>');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\<\\>\\<\\<\\<\\>\\>\\<\\>');
+});
+(0, _helpers.test)('class selector with escaping (16)', '.\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\[\\>\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\>\\+\\<\\<\\<\\<\\-\\]\\>\\+\\+\\.\\>\\+\\.\\+\\+\\+\\+\\+\\+\\+\\.\\.\\+\\+\\+\\.\\>\\+\\+\\.\\<\\<\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\.\\>\\.\\+\\+\\+\\.\\-\\-\\-\\-\\-\\-\\.\\-\\-\\-\\-\\-\\-\\-\\-\\.\\>\\+\\.\\>\\.', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\[\\>\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\>\\+\\<\\<\\<\\<\\-\\]\\>\\+\\+\\.\\>\\+\\.\\+\\+\\+\\+\\+\\+\\+\\.\\.\\+\\+\\+\\.\\>\\+\\+\\.\\<\\<\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\.\\>\\.\\+\\+\\+\\.\\-\\-\\-\\-\\-\\-\\.\\-\\-\\-\\-\\-\\-\\-\\-\\.\\>\\+\\.\\>\\.');
+});
+(0, _helpers.test)('class selector with escaping (17)', '.\\#', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '#');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#');
+});
+(0, _helpers.test)('class selector with escaping (18)', '.\\#\\#', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '##');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#\\#');
+});
+(0, _helpers.test)('class selector with escaping (19)', '.\\#\\.\\#\\.\\#', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '#.#.#');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#\\.\\#\\.\\#');
+});
+(0, _helpers.test)('class selector with escaping (20)', '.\\_', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '_');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\_');
+});
+(0, _helpers.test)('class selector with escaping (21)', '.\\{\\}', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '{}');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\{\\}');
+});
+(0, _helpers.test)('class selector with escaping (22)', '.\\#fake\\-id', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '#fake-id');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#fake\\-id');
+});
+(0, _helpers.test)('class selector with escaping (23)', '.foo\\.bar', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo.bar');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'foo\\.bar');
+});
+(0, _helpers.test)('class selector with escaping (24)', '.\\3A hover', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':hover');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A hover');
+});
+(0, _helpers.test)('class selector with escaping (25)', '.\\3A hover\\3A focus\\3A active', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':hover:focus:active');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A hover\\3A focus\\3A active');
+});
+(0, _helpers.test)('class selector with escaping (26)', '.\\[attr\\=value\\]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '[attr=value]');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\[attr\\=value\\]');
+});
+(0, _helpers.test)('class selector with escaping (27)', '.f\\/o\\/o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f/o/o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\/o\\/o');
+});
+(0, _helpers.test)('class selector with escaping (28)', '.f\\\\o\\\\o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f\\o\\o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\\\o\\\\o');
+});
+(0, _helpers.test)('class selector with escaping (29)', '.f\\*o\\*o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f*o*o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\*o\\*o');
+});
+(0, _helpers.test)('class selector with escaping (30)', '.f\\!o\\!o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f!o!o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\!o\\!o');
+});
+(0, _helpers.test)('class selector with escaping (31)', '.f\\\'o\\\'o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f\'o\'o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\\'o\\\'o');
+});
+(0, _helpers.test)('class selector with escaping (32)', '.f\\~o\\~o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f~o~o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\~o\\~o');
+});
+(0, _helpers.test)('class selector with escaping (33)', '.f\\+o\\+o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f+o+o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\+o\\+o');
+});
+(0, _helpers.test)('class selector with escaping (34)', '.\\1D306', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '𝌆');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\1D306');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/combinators.js b/node_modules/postcss-selector-parser/dist/__tests__/combinators.js
new file mode 100644
index 0000000..93de971
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/combinators.js
@@ -0,0 +1,148 @@
+"use strict";
+
+var _types = require("../selectors/types");
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('multiple combinating spaces', 'h1 h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].toString(), ' ');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+});
+(0, _helpers.test)('column combinator', '.selected||td', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'selected');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '||');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'td');
+});
+(0, _helpers.test)('column combinator (2)', '.selected || td', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'selected');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '||');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'td');
+});
+(0, _helpers.test)('descendant combinator', 'h1 h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ' ');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+});
+(0, _helpers.test)('multiple descendant combinators', 'h1 h2 h3 h4', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, ' ', 'should have a combinator');
+ t.deepEqual(tree.nodes[0].nodes[3].value, ' ', 'should have a combinator');
+ t.deepEqual(tree.nodes[0].nodes[5].value, ' ', 'should have a combinator');
+});
+(0, _helpers.test)('adjacent sibling combinator', 'h1~h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '~');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+});
+(0, _helpers.test)('adjacent sibling combinator (2)', 'h1 ~h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '~');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+});
+(0, _helpers.test)('adjacent sibling combinator (3)', 'h1~ h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '~');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+});
+(0, _helpers.test)('adjacent sibling combinator (4)', 'h1 ~ h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '~');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+});
+(0, _helpers.test)('adjacent sibling combinator (5)', 'h1~h2~h3', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '~');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'h2');
+ t.deepEqual(tree.nodes[0].nodes[3].value, '~');
+ t.deepEqual(tree.nodes[0].nodes[4].value, 'h3');
+});
+(0, _helpers.test)('piercing combinator', '.a >>> .b', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'a');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '>>>');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'b');
+});
+(0, _helpers.test)('named combinators', 'a /deep/ b', function (t, tree) {
+ var nodes = tree.nodes[0].nodes;
+ t.deepEqual(nodes[0].value, 'a');
+ t.deepEqual(nodes[1].type, _types.COMBINATOR);
+ t.deepEqual(nodes[1].toString(), ' /deep/ ');
+ t.deepEqual(nodes[1].value, '/deep/');
+ t.deepEqual(nodes[2].value, 'b');
+});
+(0, _helpers.test)('named combinators with escapes', 'a /dee\\p/ b', function (t, tree) {
+ var nodes = tree.nodes[0].nodes;
+ t.deepEqual(nodes[0].value, 'a');
+ t.deepEqual(nodes[1].type, _types.COMBINATOR);
+ t.deepEqual(nodes[1].toString(), ' /dee\\p/ ');
+ t.deepEqual(nodes[1].value, '/deep/');
+ t.deepEqual(nodes[2].value, 'b');
+});
+(0, _helpers.test)('named combinators with escapes and uppercase', 'a /DeE\\p/ b', function (t, tree) {
+ var nodes = tree.nodes[0].nodes;
+ t.deepEqual(nodes[0].value, 'a');
+ t.deepEqual(nodes[1].type, _types.COMBINATOR);
+ t.deepEqual(nodes[1].toString(), ' /DeE\\p/ ');
+ t.deepEqual(nodes[1].value, '/deep/');
+ t.deepEqual(nodes[2].value, 'b');
+});
+(0, _helpers.test)('multiple combinators', 'h1~h2>h3', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, '~', 'should have a combinator');
+ t.deepEqual(tree.nodes[0].nodes[3].value, '>', 'should have a combinator');
+});
+(0, _helpers.test)('multiple combinators with whitespaces', 'h1 + h2 > h3', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, '+', 'should have a combinator');
+ t.deepEqual(tree.nodes[0].nodes[3].value, '>', 'should have a combinator');
+});
+(0, _helpers.test)('multiple combinators with whitespaces (2)', 'h1+ h2 >h3', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, '+', 'should have a combinator');
+ t.deepEqual(tree.nodes[0].nodes[3].value, '>', 'should have a combinator');
+});
+(0, _helpers.test)('trailing combinator & spaces', 'p + ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'p', 'should be a paragraph');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '+', 'should have a combinator');
+});
+(0, _helpers.test)('trailing sibling combinator', 'p ~', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'p', 'should be a paragraph');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '~', 'should have a combinator');
+});
+(0, _helpers.test)('ending in comment has no trailing combinator', ".bar /* comment 3 */", function (t, tree) {
+ var nodeTypes = tree.nodes[0].map(function (n) {
+ return n.type;
+ });
+ t.deepEqual(nodeTypes, ["class"]);
+});
+(0, _helpers.test)('The combinating space is not a space character', ".bar\n.baz", function (t, tree) {
+ var nodeTypes = tree.nodes[0].map(function (n) {
+ return n.type;
+ });
+ t.deepEqual(nodeTypes, ["class", "combinator", "class"]);
+ t.deepEqual(tree.nodes[0].nodes[1].value, ' ', 'should have a combinator');
+ t.deepEqual(tree.nodes[0].nodes[1].raws.value, '\n', 'should have a raw combinator value');
+});
+(0, _helpers.test)('with spaces and a comment has only one combinator', ".bar /* comment 3 */ > .foo", function (t, tree) {
+ var nodeTypes = tree.nodes[0].map(function (n) {
+ return n.type;
+ });
+ t.deepEqual(nodeTypes, ["class", "combinator", "class"]);
+});
+(0, _helpers.test)('with a meaningful comment in the middle of a compound selector', "div/* wtf */.foo", function (t, tree) {
+ var nodeTypes = tree.nodes[0].map(function (n) {
+ return n.type;
+ });
+ t.deepEqual(nodeTypes, ["tag", "comment", "class"]);
+});
+(0, _helpers.test)('with a comment in the middle of a descendant selector', "div/* wtf */ .foo", function (t, tree) {
+ var nodeTypes = tree.nodes[0].map(function (n) {
+ return n.type;
+ });
+ t.deepEqual(nodeTypes, ["tag", "comment", "combinator", "class"]);
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/comments.js b/node_modules/postcss-selector-parser/dist/__tests__/comments.js
new file mode 100644
index 0000000..83463b5
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/comments.js
@@ -0,0 +1,38 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('comments', '/*test comment*/h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '/*test comment*/');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'h2');
+});
+(0, _helpers.test)('comments (2)', '.a /*test comment*/label', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'combinator');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].rawSpaceAfter, ' /*test comment*/');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'tag');
+});
+(0, _helpers.test)('comments (3)', '.a /*test comment*/ label', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'combinator');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].rawSpaceBefore, ' /*test comment*/ ');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'tag');
+});
+(0, _helpers.test)('multiple comments and other things', 'h1/*test*/h2/*test*/.test/*test*/', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag', 'should have a tag');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'comment', 'should have a comment');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'tag', 'should have a tag');
+ t.deepEqual(tree.nodes[0].nodes[3].type, 'comment', 'should have a comment');
+ t.deepEqual(tree.nodes[0].nodes[4].type, 'class', 'should have a class name');
+ t.deepEqual(tree.nodes[0].nodes[5].type, 'comment', 'should have a comment');
+});
+(0, _helpers.test)('ending in comment', ".bar /* comment 3 */", function (t, tree) {
+ var classname = tree.nodes[0].nodes[0];
+ t.deepEqual(classname.type, 'class', 'should have a tag');
+ t.deepEqual(classname.spaces.after, ' ');
+ t.deepEqual(classname.raws.spaces.after, ' /* comment 3 */');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/container.js b/node_modules/postcss-selector-parser/dist/__tests__/container.js
new file mode 100644
index 0000000..ff1bb71
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/container.js
@@ -0,0 +1,393 @@
+"use strict";
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _ = _interopRequireDefault(require(".."));
+
+var _helpers = require("./util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _ava.default)('container#append', function (t) {
+ var out = (0, _helpers.parse)('h1', function (selectors) {
+ var selector = selectors.first;
+ var clone = selector.first.clone({
+ value: 'h2'
+ });
+ selectors.append(clone);
+ });
+ t.deepEqual(out, 'h1,h2');
+});
+(0, _ava.default)('container#prepend', function (t) {
+ var out = (0, _helpers.parse)('h2', function (selectors) {
+ var selector = selectors.first;
+ var clone = selector.first.clone({
+ value: 'h1'
+ });
+ selectors.prepend(clone);
+ });
+ t.deepEqual(out, 'h1,h2');
+});
+(0, _ava.default)('container#each', function (t) {
+ var str = '';
+ (0, _helpers.parse)('h1, h2:not(h3, h4)', function (selectors) {
+ selectors.each(function (selector) {
+ if (selector.first.type === 'tag') {
+ str += selector.first.value;
+ }
+ });
+ });
+ t.deepEqual(str, 'h1h2');
+});
+(0, _ava.default)('container#each (safe iteration)', function (t) {
+ var out = (0, _helpers.parse)('.x, .y', function (selectors) {
+ selectors.each(function (selector) {
+ selector.parent.insertBefore(selector, _.default.className({
+ value: 'b'
+ }));
+ selector.parent.insertAfter(selector, _.default.className({
+ value: 'a'
+ }));
+ });
+ });
+ t.deepEqual(out, '.b,.x,.a,.b, .y,.a');
+});
+(0, _ava.default)('container#each (early exit)', function (t) {
+ var str = '';
+ (0, _helpers.parse)('h1, h2, h3, h4', function (selectors) {
+ var eachReturn = selectors.each(function (selector) {
+ var tag = selector.first.value;
+ str += tag;
+ return tag !== 'h2';
+ });
+ t.false(eachReturn);
+ });
+ t.deepEqual(str, 'h1h2');
+});
+(0, _ava.default)('container#walk', function (t) {
+ var str = '';
+ (0, _helpers.parse)('h1, h2:not(h3, h4)', function (selectors) {
+ selectors.walk(function (selector) {
+ if (selector.type === 'tag') {
+ str += selector.value;
+ }
+ });
+ });
+ t.deepEqual(str, 'h1h2h3h4');
+});
+(0, _ava.default)('container#walk (safe iteration)', function (t) {
+ var out = (0, _helpers.parse)('[class] + *[href] *:not(*.green)', function (selectors) {
+ selectors.walkUniversals(function (selector) {
+ var next = selector.next();
+
+ if (next && next.type !== 'combinator') {
+ selector.remove();
+ }
+ });
+ });
+ t.deepEqual(out, '[class] + [href] :not(.green)');
+});
+(0, _ava.default)('container#walk (early exit)', function (t) {
+ var str = '';
+ (0, _helpers.parse)('h1, h2:not(h3, h4)', function (selectors) {
+ var walkReturn = selectors.walk(function (selector) {
+ if (selector.type === 'tag') {
+ var tag = selector.value;
+ str += tag;
+ return tag !== 'h3';
+ }
+ });
+ t.false(walkReturn);
+ });
+ t.deepEqual(str, 'h1h2h3');
+});
+(0, _ava.default)('container#walkAttribute', function (t) {
+ var out = (0, _helpers.parse)('[href][class].class', function (selectors) {
+ selectors.walkAttributes(function (attr) {
+ if (attr.attribute === 'class') {
+ attr.remove();
+ }
+ });
+ });
+ t.deepEqual(out, '[href].class');
+});
+(0, _ava.default)('container#walkClass', function (t) {
+ var out = (0, _helpers.parse)('.one, .two, .three:not(.four, .five)', function (selectors) {
+ selectors.walkClasses(function (className) {
+ className.value = className.value.slice(0, 1);
+ });
+ });
+ t.deepEqual(out, '.o, .t, .t:not(.f, .f)');
+});
+(0, _ava.default)('container#walkCombinator', function (t) {
+ var out = (0, _helpers.parse)('h1 h2 h3 h4', function (selectors) {
+ selectors.walkCombinators(function (comment) {
+ comment.remove();
+ });
+ });
+ t.deepEqual(out, 'h1h2h3h4');
+});
+(0, _ava.default)('container#walkComment', function (t) {
+ var out = (0, _helpers.parse)('.one/*test*/.two', function (selectors) {
+ selectors.walkComments(function (comment) {
+ comment.remove();
+ });
+ });
+ t.deepEqual(out, '.one.two');
+});
+(0, _ava.default)('container#walkId', function (t) {
+ var out = (0, _helpers.parse)('h1#one, h2#two', function (selectors) {
+ selectors.walkIds(function (id) {
+ id.value = id.value.slice(0, 1);
+ });
+ });
+ t.deepEqual(out, 'h1#o, h2#t');
+});
+(0, _ava.default)('container#walkNesting', function (t) {
+ var out = (0, _helpers.parse)('& h1', function (selectors) {
+ selectors.walkNesting(function (node) {
+ node.replaceWith(_.default.tag({
+ value: 'body'
+ }));
+ });
+ });
+ t.deepEqual(out, 'body h1');
+});
+(0, _ava.default)('container#walkPseudo', function (t) {
+ var out = (0, _helpers.parse)('a:before, a:after', function (selectors) {
+ selectors.walkPseudos(function (pseudo) {
+ pseudo.value = pseudo.value.slice(0, 2);
+ });
+ });
+ t.deepEqual(out, 'a:b, a:a');
+});
+(0, _ava.default)('container#walkTag', function (t) {
+ var out = (0, _helpers.parse)('1 2 3', function (selectors) {
+ selectors.walkTags(function (tag) {
+ tag.value = 'h' + tag.value;
+ });
+ });
+ t.deepEqual(out, 'h1 h2 h3');
+});
+(0, _ava.default)('container#walkUniversal', function (t) {
+ var out = (0, _helpers.parse)('*.class,*.class,*.class', function (selectors) {
+ selectors.walkUniversals(function (universal) {
+ universal.remove();
+ });
+ });
+ t.deepEqual(out, '.class,.class,.class');
+});
+(0, _ava.default)('container#map', function (t) {
+ (0, _helpers.parse)('1 2 3', function (selectors) {
+ var arr = selectors.first.map(function (selector) {
+ if (/[0-9]/.test(selector.value)) {
+ return 'h' + selector.value;
+ }
+
+ return selector.value;
+ });
+ t.deepEqual(arr, ['h1', ' ', 'h2', ' ', 'h3']);
+ });
+});
+(0, _ava.default)('container#every', function (t) {
+ (0, _helpers.parse)('.one.two.three', function (selectors) {
+ var allClasses = selectors.first.every(function (selector) {
+ return selector.type === 'class';
+ });
+ t.truthy(allClasses);
+ });
+});
+(0, _ava.default)('container#some', function (t) {
+ (0, _helpers.parse)('one#two.three', function (selectors) {
+ var someClasses = selectors.first.some(function (selector) {
+ return selector.type === 'class';
+ });
+ t.truthy(someClasses);
+ });
+});
+(0, _ava.default)('container#reduce', function (t) {
+ (0, _helpers.parse)('h1, h2, h3, h4', function (selectors) {
+ var str = selectors.reduce(function (memo, selector) {
+ if (selector.first.type === 'tag') {
+ memo += selector.first.value;
+ }
+
+ return memo;
+ }, '');
+ t.deepEqual(str, 'h1h2h3h4');
+ });
+});
+(0, _ava.default)('container#filter', function (t) {
+ (0, _helpers.parse)('h1, h2, c1, c2', function (selectors) {
+ var ast = selectors.filter(function (selector) {
+ return ~selector.first.value.indexOf('h');
+ });
+ t.deepEqual(String(ast), 'h1, h2');
+ });
+});
+(0, _ava.default)('container#split', function (t) {
+ (0, _helpers.parse)('h1 h2 >> h3', function (selectors) {
+ var list = selectors.first.split(function (selector) {
+ return selector.value === '>>';
+ }).map(function (group) {
+ return group.map(String);
+ });
+ t.deepEqual(list, [['h1', ' ', 'h2', ' >> '], ['h3']]);
+ t.deepEqual(list.length, 2);
+ });
+});
+(0, _ava.default)('container#sort', function (t) {
+ var out = (0, _helpers.parse)('h2,h3,h1,h4', function (selectors) {
+ selectors.sort(function (a, b) {
+ return a.first.value.slice(-1) - b.first.value.slice(-1);
+ });
+ });
+ t.deepEqual(out, 'h1,h2,h3,h4');
+});
+(0, _ava.default)('container#at', function (t) {
+ (0, _helpers.parse)('h1, h2, h3', function (selectors) {
+ t.deepEqual(selectors.at(1).first.value, 'h2');
+ });
+});
+(0, _ava.default)('container#first, container#last', function (t) {
+ (0, _helpers.parse)('h1, h2, h3, h4', function (selectors) {
+ t.deepEqual(selectors.first.first.value, 'h1');
+ t.deepEqual(selectors.last.last.value, 'h4');
+ });
+});
+(0, _ava.default)('container#index', function (t) {
+ (0, _helpers.parse)('h1 h2 h3', function (selectors) {
+ var middle = selectors.first.at(1);
+ t.deepEqual(selectors.first.index(middle), 1);
+ });
+});
+(0, _ava.default)('container#length', function (t) {
+ (0, _helpers.parse)('h1, h2, h3', function (selectors) {
+ t.deepEqual(selectors.length, 3);
+ });
+});
+(0, _ava.default)('container#removeChild', function (t) {
+ var out = (0, _helpers.parse)('h1.class h2.class h3.class', function (selectors) {
+ selectors.walk(function (selector) {
+ if (selector.type === 'class') {
+ selector.parent.removeChild(selector);
+ }
+ });
+ });
+ t.deepEqual(out, 'h1 h2 h3');
+});
+(0, _ava.default)('container#removeAll, container#empty', function (t) {
+ var wipe = function wipe(method) {
+ return function (selectors) {
+ return selectors[method]();
+ };
+ };
+
+ var out1 = (0, _helpers.parse)('h1 h2, h2 h3, h3 h4', wipe('empty'));
+ var out2 = (0, _helpers.parse)('h1 h2, h2 h3, h3 h4', wipe('removeAll'));
+ t.deepEqual(out1, '');
+ t.deepEqual(out2, '');
+});
+(0, _ava.default)('container#insertBefore', function (t) {
+ var out = (0, _helpers.parse)('h2', function (selectors) {
+ var selector = selectors.first;
+ var clone = selector.first.clone({
+ value: 'h1'
+ });
+ selectors.insertBefore(selector, clone);
+ });
+ t.deepEqual(out, 'h1,h2');
+});
+(0, _ava.default)('container#insertBefore and node#remove', function (t) {
+ var out = (0, _helpers.parse)('h2', function (selectors) {
+ var selector = selectors.first;
+
+ var newSel = _.default.tag({
+ value: 'h1'
+ });
+
+ selectors.insertBefore(selector, newSel);
+ newSel.remove();
+ });
+ t.deepEqual(out, 'h2');
+});
+(0, _ava.default)('container#insertAfter', function (t) {
+ var out = (0, _helpers.parse)('h1', function (selectors) {
+ var selector = selectors.first;
+ var clone = selector.first.clone({
+ value: 'h2'
+ });
+ selectors.insertAfter(selector, clone);
+ });
+ t.deepEqual(out, 'h1,h2');
+});
+(0, _ava.default)('container#insertAfter and node#remove', function (t) {
+ var out = (0, _helpers.parse)('h2', function (selectors) {
+ var selector = selectors.first;
+
+ var newSel = _.default.tag({
+ value: 'h1'
+ });
+
+ selectors.insertAfter(selector, newSel);
+ newSel.remove();
+ });
+ t.deepEqual(out, 'h2');
+});
+(0, _ava.default)('container#insertAfter (during iteration)', function (t) {
+ var out = (0, _helpers.parse)('h1, h2, h3', function (selectors) {
+ selectors.walkTags(function (selector) {
+ var attribute = _.default.attribute({
+ attribute: 'class'
+ });
+
+ selector.parent.insertAfter(selector, attribute);
+ });
+ });
+ t.deepEqual(out, 'h1[class], h2[class], h3[class]');
+});
+(0, _ava.default)('Container#atPosition first pseudo', function (t) {
+ (0, _helpers.parse)(':not(.foo),\n#foo > :matches(ol, ul)', function (root) {
+ var node = root.atPosition(1, 1);
+ t.deepEqual(node.type, "pseudo");
+ t.deepEqual(node.toString(), ":not(.foo)");
+ });
+});
+(0, _ava.default)('Container#atPosition class in pseudo', function (t) {
+ (0, _helpers.parse)(':not(.foo),\n#foo > :matches(ol, ul)', function (root) {
+ var node = root.atPosition(1, 6);
+ t.deepEqual(node.type, "class");
+ t.deepEqual(node.toString(), ".foo");
+ });
+});
+(0, _ava.default)('Container#atPosition id in second selector', function (t) {
+ (0, _helpers.parse)(':not(.foo),\n#foo > :matches(ol, ul)', function (root) {
+ var node = root.atPosition(2, 1);
+ t.deepEqual(node.type, "id");
+ t.deepEqual(node.toString(), "\n#foo");
+ });
+});
+(0, _ava.default)('Container#atPosition combinator in second selector', function (t) {
+ (0, _helpers.parse)(':not(.foo),\n#foo > :matches(ol, ul)', function (root) {
+ var node = root.atPosition(2, 6);
+ t.deepEqual(node.type, "combinator");
+ t.deepEqual(node.toString(), " > ");
+ var nodeSpace = root.atPosition(2, 5);
+ t.deepEqual(nodeSpace.type, "selector");
+ t.deepEqual(nodeSpace.toString(), "\n#foo > :matches(ol, ul)");
+ });
+});
+(0, _ava.default)('Container#atPosition tag in second selector pseudo', function (t) {
+ (0, _helpers.parse)(':not(.foo),\n#foo > :matches(ol, ul)', function (root) {
+ var node = root.atPosition(2, 17);
+ t.deepEqual(node.type, "tag");
+ t.deepEqual(node.toString(), "ol");
+ });
+});
+(0, _ava.default)('Container#atPosition comma in second selector pseudo', function (t) {
+ (0, _helpers.parse)(':not(.foo),\n#foo > :matches(ol, ul)', function (root) {
+ var node = root.atPosition(2, 19);
+ t.deepEqual(node.type, "pseudo");
+ t.deepEqual(node.toString(), ":matches(ol, ul)");
+ });
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/escapes.js b/node_modules/postcss-selector-parser/dist/__tests__/escapes.js
new file mode 100644
index 0000000..cebabd9
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/escapes.js
@@ -0,0 +1,19 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('escaped semicolon in class', '.\\;', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ';');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\;');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+});
+(0, _helpers.test)('escaped semicolon in id', '#\\;', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ';');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\;');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+}); // This is a side-effect of allowing media queries to be parsed. Not sure it shouldn't just be an error.
+
+(0, _helpers.test)('bare parens capture contents as a string', '(h1)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '(h1)');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'string');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/exceptions.js b/node_modules/postcss-selector-parser/dist/__tests__/exceptions.js
new file mode 100644
index 0000000..5f7c41c
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/exceptions.js
@@ -0,0 +1,24 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+// Unclosed elements
+(0, _helpers.throws)('unclosed string', 'a[href="wow]');
+(0, _helpers.throws)('unclosed comment', '/* oops');
+(0, _helpers.throws)('unclosed pseudo element', 'button::');
+(0, _helpers.throws)('unclosed pseudo class', 'a:');
+(0, _helpers.throws)('unclosed attribute selector', '[name="james"][href');
+(0, _helpers.throws)('no opening parenthesis', ')');
+(0, _helpers.throws)('no opening parenthesis (2)', ':global.foo)');
+(0, _helpers.throws)('no opening parenthesis (3)', 'h1:not(h2:not(h3)))');
+(0, _helpers.throws)('no opening square bracket', ']');
+(0, _helpers.throws)('no opening square bracket (2)', ':global.foo]');
+(0, _helpers.throws)('no opening square bracket (3)', '[global]]');
+(0, _helpers.throws)('bad pseudo element', 'button::"after"');
+(0, _helpers.throws)('missing closing parenthesis in pseudo', ':not([attr="test"]:not([attr="test"])');
+(0, _helpers.throws)('bad syntax', '-moz-osx-font-smoothing: grayscale');
+(0, _helpers.throws)('bad syntax (2)', '! .body');
+(0, _helpers.throws)('missing backslash for semicolon', '.;');
+(0, _helpers.throws)('missing backslash for semicolon (2)', '.\;');
+(0, _helpers.throws)('unexpected / foo', '-Option\/root', "Unexpected '/'. Escaping special characters with \\ may help.");
+(0, _helpers.throws)('bang in selector', '.foo !optional', "Unexpected '!'. Escaping special characters with \\ may help.");
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/guards.js b/node_modules/postcss-selector-parser/dist/__tests__/guards.js
new file mode 100644
index 0000000..b2045ca
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/guards.js
@@ -0,0 +1,118 @@
+"use strict";
+
+var _ = _interopRequireDefault(require("../"));
+
+var _helpers = require("./util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var node = function node(tree, n) {
+ if (n === void 0) {
+ n = 0;
+ }
+
+ return tree.nodes[0].nodes[n];
+};
+
+(0, _helpers.test)('attribute guard', '[foo]', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isAttribute(undefined));
+ t.true(_.default.isAttribute(n));
+ t.false(_.default.isContainer(n));
+ t.true(_.default.isNamespace(n));
+});
+(0, _helpers.test)('className guard', '.foo', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isClassName(undefined));
+ t.true(_.default.isClassName(n));
+ t.false(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('combinator guard', '.foo > .bar', function (t, tree) {
+ var n = node(tree, 1);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isCombinator(undefined));
+ t.true(_.default.isCombinator(n));
+ t.false(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('comment guard', '/* foo */.foo > .bar', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isComment(undefined));
+ t.true(_.default.isComment(n));
+ t.false(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('id guard', '#ident', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isIdentifier(undefined));
+ t.true(_.default.isIdentifier(n));
+ t.false(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('nesting guard', '&.foo', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isNesting(undefined));
+ t.true(_.default.isNesting(n));
+ t.false(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('pseudo class guard', ':hover', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isPseudo(undefined));
+ t.true(_.default.isPseudo(n));
+ t.true(_.default.isPseudoClass(n));
+ t.false(_.default.isPseudoElement(n));
+ t.true(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('pseudo element guard', '::first-line', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isPseudo(undefined));
+ t.true(_.default.isPseudo(n));
+ t.false(_.default.isPseudoClass(n));
+ t.true(_.default.isPseudoElement(n));
+ t.true(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('special pseudo element guard', ':before:after', function (t, tree) {
+ [node(tree), node(tree, 1)].forEach(function (n) {
+ t.true(_.default.isPseudo(n));
+ t.false(_.default.isPseudoClass(n));
+ t.true(_.default.isPseudoElement(n));
+ t.true(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+ });
+});
+(0, _helpers.test)('string guard', '"string"', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isString(undefined));
+ t.true(_.default.isString(n));
+ t.false(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
+(0, _helpers.test)('tag guard', 'h1', function (t, tree) {
+ var n = node(tree);
+ t.false(_.default.isNode(undefined));
+ t.true(_.default.isNode(n));
+ t.false(_.default.isTag(undefined));
+ t.true(_.default.isTag(n));
+ t.false(_.default.isContainer(n));
+ t.true(_.default.isNamespace(n));
+});
+(0, _helpers.test)('universal guard', '*', function (t, tree) {
+ var n = node(tree);
+ t.true(_.default.isNode(n));
+ t.false(_.default.isUniversal(undefined));
+ t.true(_.default.isUniversal(n));
+ t.false(_.default.isContainer(n));
+ t.false(_.default.isNamespace(n));
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/id.js b/node_modules/postcss-selector-parser/dist/__tests__/id.js
new file mode 100644
index 0000000..73386f6
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/id.js
@@ -0,0 +1,229 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('id selector', '#one', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'one');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id hack', '#one#two', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'id');
+});
+(0, _helpers.test)('id and class names mixed', '#one.two.three', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'one');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'two');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'three');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'class');
+});
+(0, _helpers.test)('qualified id', 'button#one', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'id');
+});
+(0, _helpers.test)('qualified id & class name', 'h1#one.two', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'class');
+});
+(0, _helpers.test)('extraneous non-combinating whitespace', ' #h1 , #h2 ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.after, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'h2');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.after, ' ');
+});
+(0, _helpers.test)('Sass interpolation within a class', '.#{foo}', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes.length, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[0].value, '#{foo}');
+});
+(0, _helpers.test)('Sass interpolation within an id', '#foo#{bar}', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes.length, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo#{bar}');
+});
+(0, _helpers.test)('Less interpolation within an id', '#foo@{bar}', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes.length, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo@{bar}');
+});
+(0, _helpers.test)('id selector with escaping', '#\\#test', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '#test');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#test');
+});
+(0, _helpers.test)('id selector with escaping (2)', '#-a-b-c-', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '-a-b-c-');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (3)', '#u-m\\00002b', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'u-m+');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'u-m\\00002b');
+});
+(0, _helpers.test)('id selector with escaping (4)', '#♥', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '♥');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (5)', '#©', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '©');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (6)', '#“‘’”', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '“‘’”');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (7)', '#☺☃', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '☺☃');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (8)', '#⌘⌥', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '⌘⌥');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (9)', '#𝄞♪♩♫♬', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '𝄞♪♩♫♬');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (10)', '#💩', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '💩');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+});
+(0, _helpers.test)('id selector with escaping (11)', '#\\?', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '?');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\?');
+});
+(0, _helpers.test)('id selector with escaping (12)', '#\\@', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '@');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\@');
+});
+(0, _helpers.test)('id selector with escaping (13)', '#\\.', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '.');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\.');
+});
+(0, _helpers.test)('id selector with escaping (14)', '#\\3A \\)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':)');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A \\)');
+});
+(0, _helpers.test)('id selector with escaping (15)', '#\\3A \\`\\(', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':`(');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A \\`\\(');
+});
+(0, _helpers.test)('id selector with escaping (16)', '#\\31 23', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '123');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\31 23');
+});
+(0, _helpers.test)('id selector with escaping (17)', '#\\31 a2b3c', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '1a2b3c');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\31 a2b3c');
+});
+(0, _helpers.test)('id selector with escaping (18)', '#\\<p\\>', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '<p>');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\<p\\>');
+});
+(0, _helpers.test)('id selector with escaping (19)', '#\\<\\>\\<\\<\\<\\>\\>\\<\\>', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '<><<<>><>');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\<\\>\\<\\<\\<\\>\\>\\<\\>');
+});
+(0, _helpers.test)('id selector with escaping (20)', '#\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\[\\>\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\>\\+\\<\\<\\<\\<\\-\\]\\>\\+\\+\\.\\>\\+\\.\\+\\+\\+\\+\\+\\+\\+\\.\\.\\+\\+\\+\\.\\>\\+\\+\\.\\<\\<\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\.\\>\\.\\+\\+\\+\\.\\-\\-\\-\\-\\-\\-\\.\\-\\-\\-\\-\\-\\-\\-\\-\\.\\>\\+\\.\\>\\.', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\[\\>\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\>\\+\\+\\+\\>\\+\\<\\<\\<\\<\\-\\]\\>\\+\\+\\.\\>\\+\\.\\+\\+\\+\\+\\+\\+\\+\\.\\.\\+\\+\\+\\.\\>\\+\\+\\.\\<\\<\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\+\\.\\>\\.\\+\\+\\+\\.\\-\\-\\-\\-\\-\\-\\.\\-\\-\\-\\-\\-\\-\\-\\-\\.\\>\\+\\.\\>\\.');
+});
+(0, _helpers.test)('id selector with escaping (21)', '#\\#', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '#');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#');
+});
+(0, _helpers.test)('id selector with escaping (22)', '#\\#\\#', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '##');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#\\#');
+});
+(0, _helpers.test)('id selector with escaping (23)', '#\\#\\.\\#\\.\\#', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '#.#.#');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\#\\.\\#\\.\\#');
+});
+(0, _helpers.test)('id selector with escaping (24)', '#\\_', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '_');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\_');
+});
+(0, _helpers.test)('id selector with escaping (25)', '#\\{\\}', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '{}');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\{\\}');
+});
+(0, _helpers.test)('id selector with escaping (26)', '#\\.fake\\-class', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '.fake-class');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\.fake\\-class');
+});
+(0, _helpers.test)('id selector with escaping (27)', '#foo\\.bar', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'foo.bar');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'foo\\.bar');
+});
+(0, _helpers.test)('id selector with escaping (28)', '#\\3A hover', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':hover');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A hover');
+});
+(0, _helpers.test)('id selector with escaping (29)', '#\\3A hover\\3A focus\\3A active', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':hover:focus:active');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\3A hover\\3A focus\\3A active');
+});
+(0, _helpers.test)('id selector with escaping (30)', '#\\[attr\\=value\\]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '[attr=value]');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, '\\[attr\\=value\\]');
+});
+(0, _helpers.test)('id selector with escaping (31)', '#f\\/o\\/o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f/o/o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\/o\\/o');
+});
+(0, _helpers.test)('id selector with escaping (32)', '#f\\\\o\\\\o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f\\o\\o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\\\o\\\\o');
+});
+(0, _helpers.test)('id selector with escaping (33)', '#f\\*o\\*o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f*o*o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\*o\\*o');
+});
+(0, _helpers.test)('id selector with escaping (34)', '#f\\!o\\!o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f!o!o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\!o\\!o');
+});
+(0, _helpers.test)('id selector with escaping (35)', '#f\\\'o\\\'o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f\'o\'o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\\'o\\\'o');
+});
+(0, _helpers.test)('id selector with escaping (36)', '#f\\~o\\~o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f~o~o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\~o\\~o');
+});
+(0, _helpers.test)('id selector with escaping (37)', '#f\\+o\\+o', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'f+o+o');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'id');
+ t.deepEqual(tree.nodes[0].nodes[0].raws.value, 'f\\+o\\+o');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/lossy.js b/node_modules/postcss-selector-parser/dist/__tests__/lossy.js
new file mode 100644
index 0000000..bfec388
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/lossy.js
@@ -0,0 +1,88 @@
+"use strict";
+
+exports.__esModule = true;
+exports.testLossy = exports.parse = void 0;
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _index = _interopRequireDefault(require("../index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parse = function parse(input, options, transform) {
+ return (0, _index.default)(transform).processSync(input, options);
+};
+
+exports.parse = parse;
+
+var testLossy = function testLossy(t, input, expected) {
+ var result = parse(input, {
+ lossless: false
+ });
+ t.deepEqual(result, expected);
+};
+
+exports.testLossy = testLossy;
+(0, _ava.default)('combinator, descendant - single', testLossy, '.one .two', '.one .two');
+(0, _ava.default)('combinator, descendant - multiple', testLossy, '.one .two', '.one .two');
+(0, _ava.default)('combinator, child - space before', testLossy, '.one >.two', '.one>.two');
+(0, _ava.default)('combinator, child - space after', testLossy, '.one> .two', '.one>.two');
+(0, _ava.default)('combinator, sibling - space before', testLossy, '.one ~.two', '.one~.two');
+(0, _ava.default)('combinator, sibling - space after', testLossy, '.one~ .two', '.one~.two');
+(0, _ava.default)('combinator, adj sibling - space before', testLossy, '.one +.two', '.one+.two');
+(0, _ava.default)('combinator, adj sibling - space after', testLossy, '.one+ .two', '.one+.two');
+(0, _ava.default)('classes, extraneous spaces', testLossy, ' .h1 , .h2 ', '.h1,.h2');
+(0, _ava.default)('ids, extraneous spaces', testLossy, ' #h1 , #h2 ', '#h1,#h2');
+(0, _ava.default)('attribute, spaces in selector', testLossy, 'h1[ href *= "test" ]', 'h1[href*="test"]');
+(0, _ava.default)('attribute, insensitive flag 1', testLossy, '[href="test" i ]', '[href="test"i]');
+(0, _ava.default)('attribute, insensitive flag 2', testLossy, '[href=TEsT i ]', '[href=TEsT i]');
+(0, _ava.default)('attribute, insensitive flag 3', testLossy, '[href=test i ]', '[href=test i]');
+(0, _ava.default)('attribute, extreneous whitespace', testLossy, ' [href] , [class] ', '[href],[class]');
+(0, _ava.default)('namespace, space before', testLossy, ' postcss|button', 'postcss|button');
+(0, _ava.default)('namespace, space after', testLossy, 'postcss|button ', 'postcss|button');
+(0, _ava.default)('namespace - all elements, space before', testLossy, ' postcss|*', 'postcss|*');
+(0, _ava.default)('namespace - all elements, space after', testLossy, 'postcss|* ', 'postcss|*');
+(0, _ava.default)('namespace - all namespaces, space before', testLossy, ' *|button', '*|button');
+(0, _ava.default)('namespace - all namespaces, space after', testLossy, '*|button ', '*|button');
+(0, _ava.default)('namespace - all elements in all namespaces, space before', testLossy, ' *|*', '*|*');
+(0, _ava.default)('namespace - all elements in all namespaces, space after', testLossy, '*|* ', '*|*');
+(0, _ava.default)('namespace - all elements without namespace, space before', testLossy, ' |*', '|*');
+(0, _ava.default)('namespace - all elements without namespace, space after', testLossy, '|* ', '|*');
+(0, _ava.default)('namespace - tag with no namespace, space before', testLossy, ' |button', '|button');
+(0, _ava.default)('namespace - tag with no namespace, space after', testLossy, '|button ', '|button');
+(0, _ava.default)('namespace - inside attribute, space before', testLossy, ' [ postcss|href=test]', '[postcss|href=test]');
+(0, _ava.default)('namespace - inside attribute, space after', testLossy, '[postcss|href= test ] ', '[postcss|href=test]');
+(0, _ava.default)('namespace - inside attribute (2), space before', testLossy, ' [ postcss|href]', '[postcss|href]');
+(0, _ava.default)('namespace - inside attribute (2), space after', testLossy, '[postcss|href ] ', '[postcss|href]');
+(0, _ava.default)('namespace - inside attribute (3), space before', testLossy, ' [ *|href=test]', '[*|href=test]');
+(0, _ava.default)('namespace - inside attribute (3), space after', testLossy, '[*|href= test ] ', '[*|href=test]');
+(0, _ava.default)('namespace - inside attribute (4), space after', testLossy, '[|href= test ] ', '[|href=test]');
+(0, _ava.default)('tag - extraneous whitespace', testLossy, ' h1 , h2 ', 'h1,h2');
+(0, _ava.default)('tag - trailing comma', testLossy, 'h1, ', 'h1,');
+(0, _ava.default)('tag - trailing comma (1)', testLossy, 'h1,', 'h1,');
+(0, _ava.default)('tag - trailing comma (2)', testLossy, 'h1', 'h1');
+(0, _ava.default)('tag - trailing slash (1)', testLossy, 'h1\\ ', 'h1\\ ');
+(0, _ava.default)('tag - trailing slash (2)', testLossy, 'h1\\ h2\\', 'h1\\ h2\\');
+(0, _ava.default)('universal - combinator', testLossy, ' * + * ', '*+*');
+(0, _ava.default)('universal - extraneous whitespace', testLossy, ' * , * ', '*,*');
+(0, _ava.default)('universal - qualified universal selector', testLossy, '*[href] *:not(*.green)', '*[href] *:not(*.green)');
+(0, _ava.default)('nesting - spacing before', testLossy, ' &.class', '&.class');
+(0, _ava.default)('nesting - spacing after', testLossy, '&.class ', '&.class');
+(0, _ava.default)('nesting - spacing between', testLossy, '& .class ', '& .class');
+(0, _ava.default)('pseudo (single) - spacing before', testLossy, ' :after', ':after');
+(0, _ava.default)('pseudo (single) - spacing after', testLossy, ':after ', ':after');
+(0, _ava.default)('pseudo (double) - spacing before', testLossy, ' ::after', '::after');
+(0, _ava.default)('pseudo (double) - spacing after', testLossy, '::after ', '::after');
+(0, _ava.default)('pseudo - multiple', testLossy, ' *:target::before , a:after ', '*:target::before,a:after');
+(0, _ava.default)('pseudo - negated', testLossy, 'h1:not( .heading )', 'h1:not(.heading)');
+(0, _ava.default)('pseudo - negated with combinators (1)', testLossy, 'h1:not(.heading > .title) > h1', 'h1:not(.heading>.title)>h1');
+(0, _ava.default)('pseudo - negated with combinators (2)', testLossy, '.foo:nth-child(2n + 1)', '.foo:nth-child(2n+1)');
+(0, _ava.default)('pseudo - extra whitespace', testLossy, 'a:not( h2 )', 'a:not(h2)');
+(0, _ava.default)('comments - comment inside descendant selector', testLossy, "div /* wtf */.foo", "div /* wtf */.foo");
+(0, _ava.default)('comments - comment inside complex selector', testLossy, "div /* wtf */ > .foo", "div/* wtf */>.foo");
+(0, _ava.default)('comments - comment inside compound selector with space', testLossy, "div /* wtf */ .foo", "div /* wtf */.foo");
+(0, _ava.default)('@words - space before', testLossy, ' @media', '@media');
+(0, _ava.default)('@words - space after', testLossy, '@media ', '@media');
+(0, _ava.default)('@words - maintains space between', testLossy, '@media (min-width: 700px) and (orientation: landscape)', '@media (min-width: 700px) and (orientation: landscape)');
+(0, _ava.default)('@words - extraneous space between', testLossy, '@media (min-width: 700px) and (orientation: landscape)', '@media (min-width: 700px) and (orientation: landscape)');
+(0, _ava.default)('@words - multiple', testLossy, '@media (min-width: 700px), (min-height: 400px)', '@media (min-width: 700px),(min-height: 400px)');
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/namespaces.js b/node_modules/postcss-selector-parser/dist/__tests__/namespaces.js
new file mode 100644
index 0000000..15333e6
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/namespaces.js
@@ -0,0 +1,66 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('match tags in the postcss namespace', 'postcss|button', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, 'postcss');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'button');
+});
+(0, _helpers.test)('match everything in the postcss namespace', 'postcss|*', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, 'postcss');
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+});
+(0, _helpers.test)('match any namespace', '*|button', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, '*');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'button');
+});
+(0, _helpers.test)('match all elements within the postcss namespace', 'postcss|*', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, 'postcss');
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+});
+(0, _helpers.test)('match all elements in all namespaces', '*|*', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, '*');
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+});
+(0, _helpers.test)('match all elements without a namespace', '|*', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, true);
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+});
+(0, _helpers.test)('match tags with no namespace', '|button', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, true);
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'button');
+});
+(0, _helpers.test)('match namespace inside attribute selector', '[postcss|href=test]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, 'postcss');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'test');
+});
+(0, _helpers.test)('match namespace inside attribute selector (2)', '[postcss|href]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, 'postcss');
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+});
+(0, _helpers.test)('match namespace inside attribute selector (3)', '[*|href]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, '*');
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+});
+(0, _helpers.test)('match default namespace inside attribute selector', '[|href]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, true);
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+});
+(0, _helpers.test)('match default namespace inside attribute selector with spaces', '[ |href ]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, true);
+ t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
+});
+(0, _helpers.test)('namespace with qualified id selector', 'ns|h1#foo', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, 'ns');
+});
+(0, _helpers.test)('namespace with qualified class selector', 'ns|h1.foo', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].namespace, 'ns');
+});
+(0, _helpers.test)('ns alias for namespace', 'f\\oo|h1.foo', function (t, tree) {
+ var tag = tree.nodes[0].nodes[0];
+ t.deepEqual(tag.namespace, 'foo');
+ t.deepEqual(tag.ns, 'foo');
+ tag.ns = "bar";
+ t.deepEqual(tag.namespace, 'bar');
+ t.deepEqual(tag.ns, 'bar');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/nesting.js b/node_modules/postcss-selector-parser/dist/__tests__/nesting.js
new file mode 100644
index 0000000..e3c164a
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/nesting.js
@@ -0,0 +1,40 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('nesting selector', '&', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '&');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'nesting');
+});
+(0, _helpers.test)('nesting selector followed by a class', '& .class', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '&');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'nesting');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'combinator');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'class');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'class');
+});
+(0, _helpers.test)('&foo', '&foo', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '&');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'nesting');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'foo');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'tag');
+});
+(0, _helpers.test)('&-foo', '&-foo', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '&');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'nesting');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '-foo');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'tag');
+});
+(0, _helpers.test)('&_foo', '&_foo', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '&');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'nesting');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '_foo');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'tag');
+});
+(0, _helpers.test)('&|foo', '&|foo', function (t, tree) {
+ var element = tree.nodes[0].nodes[0];
+ t.deepEqual(element.value, 'foo');
+ t.deepEqual(element.type, 'tag');
+ t.deepEqual(element.namespace, '&');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/node.js b/node_modules/postcss-selector-parser/dist/__tests__/node.js
new file mode 100644
index 0000000..6590bf4
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/node.js
@@ -0,0 +1,139 @@
+"use strict";
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _ = _interopRequireDefault(require(".."));
+
+var _helpers = require("./util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _ava.default)('node#clone', function (t) {
+ (0, _helpers.parse)('[href="test"]', function (selectors) {
+ var selector = selectors.first.first;
+ var clone = selector.clone();
+ delete selector.parent;
+ t.deepEqual(clone, selectors.first.first);
+ });
+});
+(0, _ava.default)('node#clone of attribute', function (t) {
+ (0, _helpers.parse)('[href=test]', function (selectors) {
+ var selector = selectors.first.first;
+ var clone = selector.clone();
+ delete selector.parent;
+ t.deepEqual(clone, selectors.first.first);
+ });
+});
+(0, _ava.default)('node#replaceWith', function (t) {
+ var out = (0, _helpers.parse)('[href="test"]', function (selectors) {
+ var attr = selectors.first.first;
+
+ var id = _.default.id({
+ value: 'test'
+ });
+
+ var className = _.default.className({
+ value: 'test'
+ });
+
+ attr.replaceWith(id, className);
+ });
+ t.deepEqual(out, '#test.test');
+});
+(0, _ava.default)('Node#appendToPropertyAndEscape', function (t) {
+ var out = (0, _helpers.parse)('.fo\\o', function (selectors) {
+ var className = selectors.first.first;
+ t.deepEqual(className.raws, {
+ value: "fo\\o"
+ });
+ className.appendToPropertyAndEscape("value", "bar", "ba\\r");
+ t.deepEqual(className.raws, {
+ value: "fo\\oba\\r"
+ });
+ });
+ t.deepEqual(out, '.fo\\oba\\r');
+});
+(0, _ava.default)('Node#setPropertyAndEscape with existing raws', function (t) {
+ var out = (0, _helpers.parse)('.fo\\o', function (selectors) {
+ var className = selectors.first.first;
+ t.deepEqual(className.raws, {
+ value: "fo\\o"
+ });
+ className.setPropertyAndEscape("value", "bar", "ba\\r");
+ t.deepEqual(className.raws, {
+ value: "ba\\r"
+ });
+ });
+ t.deepEqual(out, '.ba\\r');
+});
+(0, _ava.default)('Node#setPropertyAndEscape without existing raws', function (t) {
+ var out = (0, _helpers.parse)('.foo', function (selectors) {
+ var className = selectors.first.first;
+ t.deepEqual(className.raws, undefined);
+ className.setPropertyAndEscape("value", "bar", "ba\\r");
+ t.deepEqual(className.raws, {
+ value: "ba\\r"
+ });
+ });
+ t.deepEqual(out, '.ba\\r');
+});
+(0, _ava.default)('Node#setPropertyWithoutEscape with existing raws', function (t) {
+ var out = (0, _helpers.parse)('.fo\\o', function (selectors) {
+ var className = selectors.first.first;
+ t.deepEqual(className.raws, {
+ value: "fo\\o"
+ });
+ className.setPropertyWithoutEscape("value", "w+t+f");
+ t.deepEqual(className.raws, {});
+ });
+ t.deepEqual(out, '.w+t+f');
+});
+(0, _ava.default)('Node#setPropertyWithoutEscape without existing raws', function (t) {
+ var out = (0, _helpers.parse)('.foo', function (selectors) {
+ var className = selectors.first.first;
+ t.deepEqual(className.raws, undefined);
+ className.setPropertyWithoutEscape("value", "w+t+f");
+ t.deepEqual(className.raws, {});
+ t.deepEqual(className.value, "w+t+f");
+ });
+ t.deepEqual(out, '.w+t+f');
+});
+(0, _ava.default)('Node#isAtPosition', function (t) {
+ (0, _helpers.parse)(':not(.foo),\n#foo > :matches(ol, ul)', function (root) {
+ t.deepEqual(root.isAtPosition(1, 1), true);
+ t.deepEqual(root.isAtPosition(1, 10), true);
+ t.deepEqual(root.isAtPosition(2, 23), true);
+ t.deepEqual(root.isAtPosition(2, 24), false);
+ var selector = root.first;
+ t.deepEqual(selector.isAtPosition(1, 1), true);
+ t.deepEqual(selector.isAtPosition(1, 10), true);
+ t.deepEqual(selector.isAtPosition(1, 11), false);
+ var pseudoNot = selector.first;
+ t.deepEqual(pseudoNot.isAtPosition(1, 1), true);
+ t.deepEqual(pseudoNot.isAtPosition(1, 7), true);
+ t.deepEqual(pseudoNot.isAtPosition(1, 10), true);
+ t.deepEqual(pseudoNot.isAtPosition(1, 11), false);
+ var notSelector = pseudoNot.first;
+ t.deepEqual(notSelector.isAtPosition(1, 1), false);
+ t.deepEqual(notSelector.isAtPosition(1, 4), false);
+ t.deepEqual(notSelector.isAtPosition(1, 5), true);
+ t.deepEqual(notSelector.isAtPosition(1, 6), true);
+ t.deepEqual(notSelector.isAtPosition(1, 9), true);
+ t.deepEqual(notSelector.isAtPosition(1, 10), true);
+ t.deepEqual(notSelector.isAtPosition(1, 11), false);
+ var notClass = notSelector.first;
+ t.deepEqual(notClass.isAtPosition(1, 5), false);
+ t.deepEqual(notClass.isAtPosition(1, 6), true);
+ t.deepEqual(notClass.isAtPosition(1, 9), true);
+ t.deepEqual(notClass.isAtPosition(1, 10), false);
+ var secondSel = root.at(1);
+ t.deepEqual(secondSel.isAtPosition(1, 11), false);
+ t.deepEqual(secondSel.isAtPosition(2, 1), true);
+ t.deepEqual(secondSel.isAtPosition(2, 23), true);
+ t.deepEqual(secondSel.isAtPosition(2, 24), false);
+ var combinator = secondSel.at(1);
+ t.deepEqual(combinator.isAtPosition(2, 5), false);
+ t.deepEqual(combinator.isAtPosition(2, 6), true);
+ t.deepEqual(combinator.isAtPosition(2, 7), false);
+ });
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/nonstandard.js b/node_modules/postcss-selector-parser/dist/__tests__/nonstandard.js
new file mode 100644
index 0000000..599e64d
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/nonstandard.js
@@ -0,0 +1,38 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('non-standard selector', '.icon.is-$(network)', function (t, tree) {
+ var class1 = tree.nodes[0].nodes[0];
+ t.deepEqual(class1.value, 'icon');
+ t.deepEqual(class1.type, 'class');
+ var class2 = tree.nodes[0].nodes[1];
+ t.deepEqual(class2.value, 'is-$(network)');
+ t.deepEqual(class2.type, 'class');
+});
+(0, _helpers.test)('at word in selector', 'em@il.com', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'em@il');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'com');
+});
+(0, _helpers.test)('leading combinator', '> *', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '>');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '*');
+});
+(0, _helpers.test)('sass escapes', '.#{$classname}', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes.map(function (n) {
+ return n.type;
+ }), ["class"]);
+ t.deepEqual(tree.nodes[0].nodes[0].value, "#{$classname}");
+});
+(0, _helpers.test)('sass escapes (2)', '[lang=#{$locale}]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes.map(function (n) {
+ return n.type;
+ }), ["attribute"]);
+ t.deepEqual(tree.nodes[0].nodes[0].value, "#{$locale}");
+});
+(0, _helpers.test)('placeholder', '%foo', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes.map(function (n) {
+ return n.type;
+ }), ["tag"]);
+ t.deepEqual(tree.nodes[0].nodes[0].value, "%foo");
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/parser.js b/node_modules/postcss-selector-parser/dist/__tests__/parser.js
new file mode 100644
index 0000000..2154036
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/parser.js
@@ -0,0 +1,259 @@
+"use strict";
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _index = _interopRequireDefault(require("../index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Node creation
+var nodeTypes = [['attribute', '[href]', {
+ attribute: 'href'
+}], ['className', '.classy', {
+ value: 'classy'
+}], ['combinator', ' >> ', {
+ value: '>>',
+ spaces: {
+ before: ' ',
+ after: ' '
+ }
+}], ['comment', '/* comment */', {
+ value: '/* comment */'
+}], ['id', '#test', {
+ value: 'test'
+}], ['nesting', '&'], ['pseudo', '::before', {
+ value: '::before'
+}], ['string', '"wow"', {
+ value: '"wow"'
+}], ['tag', 'button', {
+ value: 'button'
+}], ['universal', '*']];
+nodeTypes.forEach(function (type) {
+ (0, _ava.default)("parser#" + type[0], function (t) {
+ var node = _index.default[type[0]](type[2] || {});
+
+ t.deepEqual(String(node), type[1]);
+ });
+});
+(0, _ava.default)('string constants', function (t) {
+ t.truthy(_index.default.TAG);
+ t.truthy(_index.default.STRING);
+ t.truthy(_index.default.SELECTOR);
+ t.truthy(_index.default.ROOT);
+ t.truthy(_index.default.PSEUDO);
+ t.truthy(_index.default.NESTING);
+ t.truthy(_index.default.ID);
+ t.truthy(_index.default.COMMENT);
+ t.truthy(_index.default.COMBINATOR);
+ t.truthy(_index.default.CLASS);
+ t.truthy(_index.default.ATTRIBUTE);
+ t.truthy(_index.default.UNIVERSAL);
+});
+(0, _ava.default)('construct a whole tree', function (t) {
+ var root = _index.default.root();
+
+ var selector = _index.default.selector();
+
+ selector.append(_index.default.id({
+ value: 'tree'
+ }));
+ root.append(selector);
+ t.deepEqual(String(root), '#tree');
+});
+(0, _ava.default)('no operation', function (t) {
+ t.notThrows(function () {
+ return (0, _index.default)().processSync('h1 h2 h3');
+ });
+});
+(0, _ava.default)('empty selector string', function (t) {
+ t.notThrows(function () {
+ return (0, _index.default)(function (selectors) {
+ selectors.walk(function (selector) {
+ selector.type = 'tag';
+ });
+ }).processSync('');
+ });
+});
+(0, _ava.default)('async parser', function (t) {
+ return (0, _index.default)(function (selectors) {
+ return new Promise(function (res) {
+ setTimeout(function () {
+ selectors.first.nodes[0].value = 'bar';
+ res();
+ }, 1);
+ });
+ }).process('foo').then(function (result) {
+ t.deepEqual(result, 'bar');
+ });
+});
+(0, _ava.default)('parse errors with the async parser', function (t) {
+ return (0, _index.default)(function (selectors) {
+ return new Promise(function (res) {
+ setTimeout(function () {
+ selectors.first.nodes[0].value = 'bar';
+ res();
+ }, 1);
+ });
+ }).process('a b: c').catch(function (err) {
+ return t.truthy(err);
+ });
+});
+(0, _ava.default)('parse errors within the async processor', function (t) {
+ return (0, _index.default)(function (selectors) {
+ return new Promise(function (res, rej) {
+ setTimeout(function () {
+ rej(selectors.error("async error"));
+ }, 1);
+ });
+ }).process('.foo').catch(function (err) {
+ return t.truthy(err);
+ });
+});
+(0, _ava.default)('parse errors within the async processor before the promise returns', function (t) {
+ return (0, _index.default)(function (selectors) {
+ throw selectors.error("async error");
+ }).process('.foo').catch(function (err) {
+ return t.truthy(err);
+ });
+});
+(0, _ava.default)('returning a promise to the sync processor fails', function (t) {
+ t.throws(function () {
+ return (0, _index.default)(function () {
+ return new Promise(function (res) {
+ setTimeout(function () {
+ res();
+ }, 1);
+ });
+ }).processSync('.foo');
+ });
+});
+(0, _ava.default)('Passing a rule works async', function (t) {
+ var rule = {
+ selector: '.foo'
+ };
+ return (0, _index.default)(function (root) {
+ return new Promise(function (res) {
+ setTimeout(function () {
+ root.walkClasses(function (node) {
+ node.value = "bar";
+ });
+ res();
+ }, 1);
+ });
+ }).process(rule).then(function (newSel) {
+ t.deepEqual(newSel, ".bar");
+ t.deepEqual(rule.selector, ".bar");
+ });
+});
+(0, _ava.default)('Passing a rule with mutation disabled works async', function (t) {
+ var rule = {
+ selector: '.foo'
+ };
+ return (0, _index.default)(function (root) {
+ return new Promise(function (res) {
+ setTimeout(function () {
+ root.walkClasses(function (node) {
+ node.value = "bar";
+ });
+ res();
+ }, 1);
+ });
+ }).process(rule, {
+ updateSelector: false
+ }).then(function (newSel) {
+ t.deepEqual(newSel, ".bar");
+ t.deepEqual(rule.selector, ".foo");
+ });
+});
+(0, _ava.default)('Passing a rule with mutation works sync', function (t) {
+ var rule = {
+ selector: '.foo'
+ };
+ var newSel = (0, _index.default)(function (root) {
+ root.walkClasses(function (node) {
+ node.value = "bar";
+ });
+ }).processSync(rule, {
+ updateSelector: true
+ });
+ t.deepEqual(newSel, ".bar");
+ t.deepEqual(rule.selector, ".bar");
+});
+(0, _ava.default)('Transform a selector synchronously', function (t) {
+ var rule = {
+ selector: '.foo'
+ };
+ var count = (0, _index.default)(function (root) {
+ var classCount = 0;
+ root.walkClasses(function (node) {
+ classCount++;
+ node.value = "bar";
+ });
+ return classCount;
+ }).transformSync(rule, {
+ updateSelector: true
+ });
+ t.deepEqual(count, 1);
+ t.deepEqual(rule.selector, ".bar");
+});
+(0, _ava.default)('Transform a selector asynchronously', function (t) {
+ var rule = {
+ selector: '.foo'
+ };
+ return (0, _index.default)(function (root) {
+ return new Promise(function (res) {
+ setTimeout(function () {
+ var classCount = 0;
+ root.walkClasses(function (node) {
+ classCount++;
+ node.value = "bar";
+ });
+ res(classCount);
+ }, 1);
+ });
+ }).transform(rule, {
+ updateSelector: true
+ }).then(function (count) {
+ t.deepEqual(count, 1);
+ t.deepEqual(rule.selector, ".bar");
+ });
+});
+(0, _ava.default)('get AST of a selector synchronously', function (t) {
+ var rule = {
+ selector: '.foo'
+ };
+ var ast = (0, _index.default)(function (root) {
+ var classCount = 0;
+ root.walkClasses(function (node) {
+ classCount++;
+ node.value = "bar";
+ });
+ return classCount;
+ }).astSync(rule, {
+ updateSelector: true
+ });
+ t.deepEqual(ast.nodes[0].nodes[0].value, "bar");
+ t.deepEqual(rule.selector, ".bar");
+});
+(0, _ava.default)('get AST a selector asynchronously', function (t) {
+ var rule = {
+ selector: '.foo'
+ };
+ return (0, _index.default)(function (root) {
+ return new Promise(function (res) {
+ setTimeout(function () {
+ var classCount = 0;
+ root.walkClasses(function (node) {
+ classCount++;
+ node.value = "bar";
+ });
+ res(classCount);
+ }, 1);
+ });
+ }).ast(rule, {
+ updateSelector: true
+ }).then(function (ast) {
+ t.deepEqual(ast.nodes[0].nodes[0].value, "bar");
+ t.deepEqual(rule.selector, ".bar");
+ });
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/postcss.js b/node_modules/postcss-selector-parser/dist/__tests__/postcss.js
new file mode 100644
index 0000000..d7175f7
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/postcss.js
@@ -0,0 +1,46 @@
+"use strict";
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _postcss = _interopRequireDefault(require("postcss"));
+
+var _helpers = require("./util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var cse = 'CssSyntaxError';
+
+function showCode(t, selector) {
+ var rule = _postcss.default.parse(selector).first;
+
+ try {
+ (0, _helpers.parse)(rule);
+ } catch (e) {
+ if (e.name !== cse) {
+ return;
+ } // Removes ANSI codes from snapshot tests as it makes them illegible.
+ // The formatting of this error is otherwise identical to e.toString()
+
+
+ t.snapshot(cse + ": " + e.message + "\n\n" + e.showSourceCode(false) + "\n");
+ }
+}
+
+(0, _ava.default)('missing open square bracket', showCode, 'a b c] {}');
+(0, _ava.default)('missing open parenthesis', showCode, 'a b c) {}');
+(0, _ava.default)('missing pseudo class or pseudo element', showCode, 'a b c: {}');
+(0, _ava.default)('space in between colon and word (incorrect pseudo)', showCode, 'a b: c {}');
+(0, _ava.default)('string after colon (incorrect pseudo)', showCode, 'a b:"wow" {}'); // attribute selectors
+
+(0, _ava.default)('bad string attribute', showCode, '["hello"] {}');
+(0, _ava.default)('bad string attribute with value', showCode, '["foo"=bar] {}');
+(0, _ava.default)('bad parentheses', showCode, '[foo=(bar)] {}');
+(0, _ava.default)('bad lonely asterisk', showCode, '[*] {}');
+(0, _ava.default)('bad lonely pipe', showCode, '[|] {}');
+(0, _ava.default)('bad lonely caret', showCode, '[^] {}');
+(0, _ava.default)('bad lonely dollar', showCode, '[$] {}');
+(0, _ava.default)('bad lonely tilde', showCode, '[~] {}');
+(0, _ava.default)('bad lonely equals', showCode, '[=] {}');
+(0, _ava.default)('bad lonely operator', showCode, '[*=] {}');
+(0, _ava.default)('bad lonely operator (2)', showCode, '[|=] {}');
+(0, _ava.default)('bad doubled operator', showCode, '[href=foo=bar] {}');
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/pseudos.js b/node_modules/postcss-selector-parser/dist/__tests__/pseudos.js
new file mode 100644
index 0000000..d316a0c
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/pseudos.js
@@ -0,0 +1,98 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('pseudo element (single colon)', 'h1:after', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':after');
+});
+(0, _helpers.test)('pseudo element (double colon)', 'h1::after', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '::after');
+});
+(0, _helpers.test)('multiple pseudo elements', '*:target::before, a:after', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':target');
+ t.deepEqual(tree.nodes[0].nodes[2].value, '::before');
+ t.deepEqual(tree.nodes[1].nodes[1].value, ':after');
+});
+(0, _helpers.test)('negation pseudo element', 'h1:not(.heading)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':not');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, 'heading');
+});
+(0, _helpers.test)('negation pseudo element (2)', 'h1:not(.heading, .title, .content)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':not');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, 'heading');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].value, 'title');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[2].nodes[0].value, 'content');
+});
+(0, _helpers.test)('negation pseudo element (3)', 'h1:not(.heading > .title) > h1', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, 'heading');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[1].value, '>');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[2].value, 'title');
+ t.deepEqual(tree.nodes[0].nodes[2].value, '>');
+ t.deepEqual(tree.nodes[0].nodes[3].value, 'h1');
+});
+(0, _helpers.test)('negation pseudo element (4)', 'h1:not(h2:not(h3))', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[1].nodes[0].nodes[0].value, 'h3');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[1].nodes[0].nodes[0].parent.type, 'selector');
+});
+(0, _helpers.test)('pseudo class in the middle of a selector', 'a:link.external', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'a');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':link');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[2].value, 'external');
+});
+(0, _helpers.test)('extra whitespace inside parentheses', 'a:not( h2 )', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, 'h2');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].spaces.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].spaces.before, ' ');
+});
+(0, _helpers.test)('escaped numbers in class name with pseudo', 'a:before.\\31\\ 0', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'class');
+ t.deepEqual(tree.nodes[0].nodes[2].value, '1 0');
+ t.deepEqual(tree.nodes[0].nodes[2].raws.value, '\\31\\ 0');
+});
+(0, _helpers.test)('nested pseudo', '.btn-group>.btn:last-child:not(:first-child)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[4].value, ':not');
+});
+(0, _helpers.test)('extraneous non-combinating whitespace', ' h1:after , h2:after ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':after');
+ t.deepEqual(tree.nodes[0].nodes[1].spaces.after, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[1].nodes[1].value, ':after');
+ t.deepEqual(tree.nodes[1].nodes[1].spaces.after, ' ');
+});
+(0, _helpers.test)('negation pseudo element with quotes', 'h1:not(".heading")', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':not');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, '".heading"');
+});
+(0, _helpers.test)('negation pseudo element with single quotes', "h1:not('.heading')", function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':not');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, "'.heading'");
+});
+(0, _helpers.test)('Issue #116', "svg:not(:root)", function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].value, ':not');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].value, ':root');
+});
+(0, _helpers.test)('alone pseudo class', ':root', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'pseudo');
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':root');
+});
+(0, _helpers.test)('non standard pseudo (@custom-selector)', ":--foobar, a", function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, ':--foobar');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'pseudo');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'a');
+ t.deepEqual(tree.nodes[1].nodes[0].type, 'tag');
+});
+(0, _helpers.test)('non standard pseudo (@custom-selector) (1)', "a, :--foobar", function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'a');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[1].nodes[0].value, ':--foobar');
+ t.deepEqual(tree.nodes[1].nodes[0].type, 'pseudo');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/sourceIndex.js b/node_modules/postcss-selector-parser/dist/__tests__/sourceIndex.js
new file mode 100644
index 0000000..766d59f
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/sourceIndex.js
@@ -0,0 +1,229 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('universal selector', '*', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+});
+(0, _helpers.test)('lobotomized owl selector', ' * + * ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 2);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 2);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 1);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 4);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 4);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 3);
+ t.deepEqual(tree.nodes[0].nodes[2].source.start.column, 6);
+ t.deepEqual(tree.nodes[0].nodes[2].source.end.column, 6);
+ t.deepEqual(tree.nodes[0].nodes[2].sourceIndex, 5);
+});
+(0, _helpers.test)('comment', '/**\n * Hello!\n */', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 3);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+});
+(0, _helpers.test)('comment & universal selectors', '*/*test*/*', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 2);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 9);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 1);
+ t.deepEqual(tree.nodes[0].nodes[2].source.start.column, 10);
+ t.deepEqual(tree.nodes[0].nodes[2].source.end.column, 10);
+ t.deepEqual(tree.nodes[0].nodes[2].sourceIndex, 9);
+});
+(0, _helpers.test)('tag selector', 'h1', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 2);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+});
+(0, _helpers.test)('id selector', '#id', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 3);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+});
+(0, _helpers.test)('tag selector followed by id selector', 'h1, #id', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 2);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.column, 5);
+ t.deepEqual(tree.nodes[1].nodes[0].source.end.column, 7);
+ t.deepEqual(tree.nodes[1].nodes[0].sourceIndex, 4);
+});
+(0, _helpers.test)('multiple id selectors', '#one#two', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 4);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 5);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 8);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 4);
+});
+(0, _helpers.test)('multiple id selectors (2)', '#one#two#three#four', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[2].source.start.column, 9);
+ t.deepEqual(tree.nodes[0].nodes[2].source.end.column, 14);
+ t.deepEqual(tree.nodes[0].nodes[2].sourceIndex, 8);
+ t.deepEqual(tree.nodes[0].nodes[3].source.start.column, 15);
+ t.deepEqual(tree.nodes[0].nodes[3].source.end.column, 19);
+ t.deepEqual(tree.nodes[0].nodes[3].sourceIndex, 14);
+});
+(0, _helpers.test)('multiple id selectors (3)', '#one#two,#three#four', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 5);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 8);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 4);
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.column, 16);
+ t.deepEqual(tree.nodes[1].nodes[1].source.end.column, 20);
+ t.deepEqual(tree.nodes[1].nodes[1].sourceIndex, 15);
+});
+(0, _helpers.test)('multiple class selectors', '.one.two,.three.four', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 5);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 8);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 4);
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.column, 16);
+ t.deepEqual(tree.nodes[1].nodes[1].source.end.column, 20);
+ t.deepEqual(tree.nodes[1].nodes[1].sourceIndex, 15);
+});
+(0, _helpers.test)('attribute selector', '[name="james"]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 14);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+});
+(0, _helpers.test)('multiple attribute selectors', '[name="james"][name="ed"],[name="snakeman"][name="a"]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 14);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 15);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 25);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 14);
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.line, 1);
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.column, 27);
+ t.deepEqual(tree.nodes[1].nodes[0].source.end.line, 1);
+ t.deepEqual(tree.nodes[1].nodes[0].source.end.column, 43);
+ t.deepEqual(tree.nodes[1].nodes[0].sourceIndex, 26);
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.line, 1);
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.column, 44);
+ t.deepEqual(tree.nodes[1].nodes[1].source.end.line, 1);
+ t.deepEqual(tree.nodes[1].nodes[1].source.end.column, 53);
+ t.deepEqual(tree.nodes[1].nodes[1].sourceIndex, 43);
+});
+(0, _helpers.test)('pseudo-class', 'h1:first-child', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 3);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 14);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 2);
+});
+(0, _helpers.test)('pseudo-class with argument', 'h1:not(.strudel, .food)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 3);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 23);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 2);
+});
+(0, _helpers.test)('pseudo-element', 'h1::before', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 3);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 10);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 2);
+});
+(0, _helpers.test)('multiple pseudos', 'h1:not(.food)::before, a:first-child', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 3);
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 13);
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 2);
+ t.deepEqual(tree.nodes[0].nodes[2].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[2].source.start.column, 14);
+ t.deepEqual(tree.nodes[0].nodes[2].source.end.column, 21);
+ t.deepEqual(tree.nodes[0].nodes[2].sourceIndex, 13);
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.line, 1);
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.column, 25);
+ t.deepEqual(tree.nodes[1].nodes[1].source.end.column, 36);
+ t.deepEqual(tree.nodes[1].nodes[1].sourceIndex, 24);
+});
+(0, _helpers.test)('combinators', 'div > h1 span', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1, "> start line");
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 5, "> start column");
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 5, "> end column");
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 4, "> sourceIndex");
+ t.deepEqual(tree.nodes[0].nodes[3].source.start.line, 1, "' ' start line");
+ t.deepEqual(tree.nodes[0].nodes[3].source.start.column, 9, "' ' start column");
+ t.deepEqual(tree.nodes[0].nodes[3].source.end.column, 9, "' ' end column");
+ t.deepEqual(tree.nodes[0].nodes[3].sourceIndex, 8, "' ' sourceIndex");
+});
+(0, _helpers.test)('combinators surrounded by superfluous spaces', 'div > h1 ~ span a', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1, "> start line");
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 7, "> start column");
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 7, "> end column");
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 6, "> sourceIndex");
+ t.deepEqual(tree.nodes[0].nodes[3].source.start.line, 1, "~ start line");
+ t.deepEqual(tree.nodes[0].nodes[3].source.start.column, 13, "~ start column");
+ t.deepEqual(tree.nodes[0].nodes[3].source.end.column, 13, "~ end column");
+ t.deepEqual(tree.nodes[0].nodes[3].sourceIndex, 12, "~ sourceIndex");
+ t.deepEqual(tree.nodes[0].nodes[5].source.start.line, 1, "' ' start line");
+ t.deepEqual(tree.nodes[0].nodes[5].source.start.column, 21, "' ' start column");
+ t.deepEqual(tree.nodes[0].nodes[5].source.end.column, 23, "' ' end column");
+ t.deepEqual(tree.nodes[0].nodes[5].sourceIndex, 20, "' ' sourceIndex");
+});
+(0, _helpers.test)('multiple id selectors on different lines', '#one,\n#two', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.line, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 4);
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0);
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.line, 2);
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.column, 1);
+ t.deepEqual(tree.nodes[1].nodes[0].source.end.column, 4);
+ t.deepEqual(tree.nodes[1].nodes[0].sourceIndex, 6);
+});
+(0, _helpers.test)('multiple id selectors on different CRLF lines', '#one,\r\n#two,\r\n#three', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.line, 1, '#one start line');
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 1, '#one start column');
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 4, '#one end column');
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 0, '#one sourceIndex');
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.line, 2, '#two start line');
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.column, 1, '#two start column');
+ t.deepEqual(tree.nodes[1].nodes[0].source.end.column, 4, '#two end column');
+ t.deepEqual(tree.nodes[1].nodes[0].sourceIndex, 7, '#two sourceIndex');
+ t.deepEqual(tree.nodes[2].nodes[0].source.start.line, 3, '#three start line');
+ t.deepEqual(tree.nodes[2].nodes[0].source.start.column, 1, '#three start column');
+ t.deepEqual(tree.nodes[2].nodes[0].source.end.column, 6, '#three end column');
+ t.deepEqual(tree.nodes[2].nodes[0].sourceIndex, 14, '#three sourceIndex');
+});
+(0, _helpers.test)('id, tag, pseudo, and class selectors on different lines with indentation', '\t#one,\n\th1:after,\n\t\t.two', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.line, 1, '#one start line');
+ t.deepEqual(tree.nodes[0].nodes[0].source.start.column, 2, '#one start column');
+ t.deepEqual(tree.nodes[0].nodes[0].source.end.column, 5, '#one end column');
+ t.deepEqual(tree.nodes[0].nodes[0].sourceIndex, 1, '#one sourceIndex');
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.line, 2, 'h1 start line');
+ t.deepEqual(tree.nodes[1].nodes[0].source.start.column, 2, 'h1 start column');
+ t.deepEqual(tree.nodes[1].nodes[0].source.end.column, 3, 'h1 end column');
+ t.deepEqual(tree.nodes[1].nodes[0].sourceIndex, 8, 'h1 sourceIndex');
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.line, 2, ':after start line');
+ t.deepEqual(tree.nodes[1].nodes[1].source.start.column, 4, ':after start column');
+ t.deepEqual(tree.nodes[1].nodes[1].source.end.column, 9, ':after end column');
+ t.deepEqual(tree.nodes[1].nodes[1].sourceIndex, 10, ':after sourceIndex');
+ t.deepEqual(tree.nodes[2].nodes[0].source.start.line, 3, '.two start line');
+ t.deepEqual(tree.nodes[2].nodes[0].source.start.column, 3, '.two start column');
+ t.deepEqual(tree.nodes[2].nodes[0].source.end.column, 6, '.two end column');
+ t.deepEqual(tree.nodes[2].nodes[0].sourceIndex, 20, '.two sourceIndex');
+});
+(0, _helpers.test)('pseudo with arguments spanning multiple lines', 'h1:not(\n\t.one,\n\t.two\n)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.line, 1, ':not start line');
+ t.deepEqual(tree.nodes[0].nodes[1].source.start.column, 3, ':not start column');
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.line, 4, ':not end line');
+ t.deepEqual(tree.nodes[0].nodes[1].source.end.column, 1, ':not end column');
+ t.deepEqual(tree.nodes[0].nodes[1].sourceIndex, 2, ':not sourceIndex');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].source.start.line, 2, '.one start line');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].source.start.column, 2, '.one start column');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].source.end.line, 2, '.one end line');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].source.end.column, 5, '.one end column');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[0].nodes[0].sourceIndex, 9, '.one sourceIndex');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].source.start.line, 3, '.two start line');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].source.start.column, 2, '.two start column');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].source.end.line, 3, '.two end line');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].source.end.column, 5, '.two end column');
+ t.deepEqual(tree.nodes[0].nodes[1].nodes[1].nodes[0].sourceIndex, 16, '.two sourceIndex');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/stripComments.js b/node_modules/postcss-selector-parser/dist/__tests__/stripComments.js
new file mode 100644
index 0000000..2d6eb9a
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/stripComments.js
@@ -0,0 +1,17 @@
+"use strict";
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _stripComments = _interopRequireDefault(require("../../src/util/stripComments"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _ava.default)("stripComments()", function (t) {
+ t.deepEqual((0, _stripComments.default)("aaa/**/bbb"), "aaabbb");
+ t.deepEqual((0, _stripComments.default)("aaa/*bbb"), "aaa");
+ t.deepEqual((0, _stripComments.default)("aaa/*xxx*/bbb"), "aaabbb");
+ t.deepEqual((0, _stripComments.default)("aaa/*/xxx/*/bbb"), "aaabbb");
+ t.deepEqual((0, _stripComments.default)("aaa/*x*/bbb/**/"), "aaabbb");
+ t.deepEqual((0, _stripComments.default)("/**/aaa/*x*/bbb/**/"), "aaabbb");
+ t.deepEqual((0, _stripComments.default)("/**/"), "");
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/tags.js b/node_modules/postcss-selector-parser/dist/__tests__/tags.js
new file mode 100644
index 0000000..b6f5aa4
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/tags.js
@@ -0,0 +1,35 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('tag selector', 'h1', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+});
+(0, _helpers.test)('multiple tag selectors', 'h1, h2', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'h2');
+});
+(0, _helpers.test)('extraneous non-combinating whitespace', ' h1 , h2 ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.after, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].value, 'h2');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.after, ' ');
+});
+(0, _helpers.test)('tag with trailing comma', 'h1,', function (t, tree) {
+ t.deepEqual(tree.trailingComma, true);
+});
+(0, _helpers.test)('tag with trailing slash', 'h1\\', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'h1\\');
+});
+(0, _helpers.test)('tag with attribute', 'label[for="email"]', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, 'label');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'tag');
+ t.deepEqual(tree.nodes[0].nodes[1].value, 'email');
+ t.deepEqual(tree.nodes[0].nodes[1].attribute, 'for');
+ t.deepEqual(tree.nodes[0].nodes[1].operator, '=');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'attribute');
+ t.deepEqual(tree.nodes[0].nodes[1].quoteMark, '"');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/universal.js b/node_modules/postcss-selector-parser/dist/__tests__/universal.js
new file mode 100644
index 0000000..019c003
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/universal.js
@@ -0,0 +1,32 @@
+"use strict";
+
+var _helpers = require("./util/helpers");
+
+(0, _helpers.test)('universal selector', '*', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'universal');
+});
+(0, _helpers.test)('lobotomized owl', '* + *', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'universal');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'combinator');
+ t.deepEqual(tree.nodes[0].nodes[2].type, 'universal');
+});
+(0, _helpers.test)('extraneous non-combinating whitespace', ' * , * ', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[0].nodes[0].spaces.after, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].value, '*');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.before, ' ');
+ t.deepEqual(tree.nodes[1].nodes[0].spaces.after, ' ');
+});
+(0, _helpers.test)('qualified universal selector', '*[href] *:not(*.green)', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+ t.deepEqual(tree.nodes[0].nodes[3].value, '*');
+ t.deepEqual(tree.nodes[0].nodes[4].nodes[0].nodes[0].value, '*');
+});
+(0, _helpers.test)('universal selector with pseudo', '*::--webkit-media-controls-play-button', function (t, tree) {
+ t.deepEqual(tree.nodes[0].nodes[0].value, '*');
+ t.deepEqual(tree.nodes[0].nodes[0].type, 'universal');
+ t.deepEqual(tree.nodes[0].nodes[1].value, '::--webkit-media-controls-play-button');
+ t.deepEqual(tree.nodes[0].nodes[1].type, 'pseudo');
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/__tests__/util/helpers.js b/node_modules/postcss-selector-parser/dist/__tests__/util/helpers.js
new file mode 100644
index 0000000..3bf9c0d
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/__tests__/util/helpers.js
@@ -0,0 +1,90 @@
+"use strict";
+
+exports.__esModule = true;
+exports.test = test;
+exports.nodeVersionAtLeast = nodeVersionAtLeast;
+exports.nodeVersionBefore = nodeVersionBefore;
+exports.throws = exports.parse = void 0;
+
+var _process = _interopRequireDefault(require("process"));
+
+var _util = _interopRequireDefault(require("util"));
+
+var _ava = _interopRequireDefault(require("ava"));
+
+var _semver = _interopRequireDefault(require("semver"));
+
+var _index = _interopRequireDefault(require("../../index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parse = function parse(input, transform) {
+ return (0, _index.default)(transform).processSync(input);
+};
+
+exports.parse = parse;
+
+function test(spec, input, callback, only, disabled, serial) {
+ var _this = this;
+
+ if (only === void 0) {
+ only = false;
+ }
+
+ if (disabled === void 0) {
+ disabled = false;
+ }
+
+ if (serial === void 0) {
+ serial = false;
+ }
+
+ var tester = only ? _ava.default.only : _ava.default;
+ tester = disabled ? tester.skip : tester;
+ tester = serial ? tester.serial : tester;
+
+ if (callback) {
+ tester(spec + " (tree)", function (t) {
+ var tree = (0, _index.default)().astSync(input);
+
+ var debug = _util.default.inspect(tree, false, null);
+
+ return callback.call(_this, t, tree, debug);
+ });
+ }
+
+ tester(spec + " (toString)", function (t) {
+ var result = (0, _index.default)().processSync(input);
+ t.deepEqual(result, input);
+ });
+}
+
+test.only = function (spec, input, callback) {
+ return test(spec, input, callback, true);
+};
+
+test.skip = function (spec, input, callback) {
+ return test(spec, input, callback, false, true);
+};
+
+test.serial = function (spec, input, callback) {
+ return test(spec, input, callback, false, false, true);
+};
+
+var throws = function throws(spec, input, validator) {
+ (0, _ava.default)(spec + " (throws)", function (t) {
+ t.throws(function () {
+ return (0, _index.default)().processSync(input);
+ }, validator || Error);
+ });
+};
+
+exports.throws = throws;
+
+function nodeVersionAtLeast(version) {
+ return _semver.default.gte(_process.default.versions.node, version);
+}
+
+function nodeVersionBefore(version) {
+ return _semver.default.lt(_process.default.versions.node, version);
+}
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/index.js b/node_modules/postcss-selector-parser/dist/index.js
new file mode 100644
index 0000000..ac33ec0
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/index.js
@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _processor = _interopRequireDefault(require("./processor"));
+
+var selectors = _interopRequireWildcard(require("./selectors"));
+
+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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { 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 _processor.default(processor);
+};
+
+Object.assign(parser, selectors);
+delete parser.__esModule;
+var _default = parser;
+exports.default = _default;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/parser.js b/node_modules/postcss-selector-parser/dist/parser.js
new file mode 100644
index 0000000..927d18a
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/parser.js
@@ -0,0 +1,1223 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _indexesOf = _interopRequireDefault(require("indexes-of"));
+
+var _uniq = _interopRequireDefault(require("uniq"));
+
+var _root = _interopRequireDefault(require("./selectors/root"));
+
+var _selector = _interopRequireDefault(require("./selectors/selector"));
+
+var _className = _interopRequireDefault(require("./selectors/className"));
+
+var _comment = _interopRequireDefault(require("./selectors/comment"));
+
+var _id = _interopRequireDefault(require("./selectors/id"));
+
+var _tag = _interopRequireDefault(require("./selectors/tag"));
+
+var _string = _interopRequireDefault(require("./selectors/string"));
+
+var _pseudo = _interopRequireDefault(require("./selectors/pseudo"));
+
+var _attribute = _interopRequireWildcard(require("./selectors/attribute"));
+
+var _universal = _interopRequireDefault(require("./selectors/universal"));
+
+var _combinator = _interopRequireDefault(require("./selectors/combinator"));
+
+var _nesting = _interopRequireDefault(require("./selectors/nesting"));
+
+var _sortAscending = _interopRequireDefault(require("./sortAscending"));
+
+var _tokenize = _interopRequireWildcard(require("./tokenize"));
+
+var tokens = _interopRequireWildcard(require("./tokenTypes"));
+
+var types = _interopRequireWildcard(require("./selectors/types"));
+
+var _util = require("./util");
+
+var _WHITESPACE_TOKENS, _Object$assign;
+
+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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+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 WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
+var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
+
+function tokenStart(token) {
+ return {
+ line: token[_tokenize.FIELDS.START_LINE],
+ column: token[_tokenize.FIELDS.START_COL]
+ };
+}
+
+function tokenEnd(token) {
+ return {
+ line: token[_tokenize.FIELDS.END_LINE],
+ column: token[_tokenize.FIELDS.END_COL]
+ };
+}
+
+function getSource(startLine, startColumn, endLine, endColumn) {
+ return {
+ start: {
+ line: startLine,
+ column: startColumn
+ },
+ end: {
+ line: endLine,
+ column: endColumn
+ }
+ };
+}
+
+function getTokenSource(token) {
+ return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
+}
+
+function getTokenSourceSpan(startToken, endToken) {
+ if (!startToken) {
+ return undefined;
+ }
+
+ return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
+}
+
+function unescapeProp(node, prop) {
+ var value = node[prop];
+
+ if (typeof value !== "string") {
+ return;
+ }
+
+ if (value.indexOf("\\") !== -1) {
+ (0, _util.ensureObject)(node, 'raws');
+ node[prop] = (0, _util.unesc)(value);
+
+ if (node.raws[prop] === undefined) {
+ node.raws[prop] = value;
+ }
+ }
+
+ return node;
+}
+
+var Parser =
+/*#__PURE__*/
+function () {
+ function Parser(rule, options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ this.rule = rule;
+ this.options = Object.assign({
+ lossy: false,
+ safe: false
+ }, options);
+ this.position = 0;
+ this.css = typeof this.rule === 'string' ? this.rule : this.rule.selector;
+ this.tokens = (0, _tokenize.default)({
+ css: this.css,
+ error: this._errorGenerator(),
+ safe: this.options.safe
+ });
+ var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
+ this.root = new _root.default({
+ source: rootSource
+ });
+ this.root.errorGenerator = this._errorGenerator();
+ var selector = new _selector.default({
+ source: {
+ start: {
+ line: 1,
+ column: 1
+ }
+ }
+ });
+ this.root.append(selector);
+ this.current = selector;
+ this.loop();
+ }
+
+ var _proto = Parser.prototype;
+
+ _proto._errorGenerator = function _errorGenerator() {
+ var _this = this;
+
+ return function (message, errorOptions) {
+ if (typeof _this.rule === 'string') {
+ return new Error(message);
+ }
+
+ return _this.rule.error(message, errorOptions);
+ };
+ };
+
+ _proto.attribute = function attribute() {
+ var attr = [];
+ var startingToken = this.currToken;
+ this.position++;
+
+ while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+ attr.push(this.currToken);
+ this.position++;
+ }
+
+ if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+ return this.expected('closing square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
+ }
+
+ var len = attr.length;
+ var node = {
+ source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
+ sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+ };
+
+ if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
+ return this.expected('attribute', attr[0][_tokenize.FIELDS.START_POS]);
+ }
+
+ var pos = 0;
+ var spaceBefore = '';
+ var commentBefore = '';
+ var lastAdded = null;
+ var spaceAfterMeaningfulToken = false;
+
+ while (pos < len) {
+ var token = attr[pos];
+ var content = this.content(token);
+ var next = attr[pos + 1];
+
+ switch (token[_tokenize.FIELDS.TYPE]) {
+ case tokens.space:
+ // if (
+ // len === 1 ||
+ // pos === 0 && this.content(next) === '|'
+ // ) {
+ // return this.expected('attribute', token[TOKEN.START_POS], content);
+ // }
+ spaceAfterMeaningfulToken = true;
+
+ if (this.options.lossy) {
+ break;
+ }
+
+ if (lastAdded) {
+ (0, _util.ensureObject)(node, 'spaces', lastAdded);
+ var prevContent = node.spaces[lastAdded].after || '';
+ node.spaces[lastAdded].after = prevContent + content;
+ var existingComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || null;
+
+ if (existingComment) {
+ node.raws.spaces[lastAdded].after = existingComment + content;
+ }
+ } else {
+ spaceBefore = spaceBefore + content;
+ commentBefore = commentBefore + content;
+ }
+
+ break;
+
+ case tokens.asterisk:
+ if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+ node.operator = content;
+ lastAdded = 'operator';
+ } else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
+ if (spaceBefore) {
+ (0, _util.ensureObject)(node, 'spaces', 'attribute');
+ node.spaces.attribute.before = spaceBefore;
+ spaceBefore = '';
+ }
+
+ if (commentBefore) {
+ (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
+ node.raws.spaces.attribute.before = spaceBefore;
+ commentBefore = '';
+ }
+
+ node.namespace = (node.namespace || "") + content;
+ var rawValue = (0, _util.getProp)(node, 'raws', 'namespace') || null;
+
+ if (rawValue) {
+ node.raws.namespace += content;
+ }
+
+ lastAdded = 'namespace';
+ }
+
+ spaceAfterMeaningfulToken = false;
+ break;
+
+ case tokens.dollar:
+ if (lastAdded === "value") {
+ var oldRawValue = (0, _util.getProp)(node, 'raws', 'value');
+ node.value += "$";
+
+ if (oldRawValue) {
+ node.raws.value = oldRawValue + "$";
+ }
+
+ break;
+ }
+
+ // Falls through
+
+ case tokens.caret:
+ if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+ node.operator = content;
+ lastAdded = 'operator';
+ }
+
+ spaceAfterMeaningfulToken = false;
+ break;
+
+ case tokens.combinator:
+ if (content === '~' && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+ node.operator = content;
+ lastAdded = 'operator';
+ }
+
+ if (content !== '|') {
+ spaceAfterMeaningfulToken = false;
+ break;
+ }
+
+ if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+ node.operator = content;
+ lastAdded = 'operator';
+ } else if (!node.namespace && !node.attribute) {
+ node.namespace = true;
+ }
+
+ spaceAfterMeaningfulToken = false;
+ break;
+
+ case tokens.word:
+ if (next && this.content(next) === '|' && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && // this look-ahead probably fails with comment nodes involved.
+ !node.operator && !node.namespace) {
+ node.namespace = content;
+ lastAdded = 'namespace';
+ } else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
+ if (spaceBefore) {
+ (0, _util.ensureObject)(node, 'spaces', 'attribute');
+ node.spaces.attribute.before = spaceBefore;
+ spaceBefore = '';
+ }
+
+ if (commentBefore) {
+ (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
+ node.raws.spaces.attribute.before = commentBefore;
+ commentBefore = '';
+ }
+
+ node.attribute = (node.attribute || "") + content;
+
+ var _rawValue = (0, _util.getProp)(node, 'raws', 'attribute') || null;
+
+ if (_rawValue) {
+ node.raws.attribute += content;
+ }
+
+ lastAdded = 'attribute';
+ } else if (!node.value && node.value !== "" || lastAdded === "value" && !spaceAfterMeaningfulToken) {
+ var _unescaped = (0, _util.unesc)(content);
+
+ var _oldRawValue = (0, _util.getProp)(node, 'raws', 'value') || '';
+
+ var oldValue = node.value || '';
+ node.value = oldValue + _unescaped;
+ node.quoteMark = null;
+
+ if (_unescaped !== content || _oldRawValue) {
+ (0, _util.ensureObject)(node, 'raws');
+ node.raws.value = (_oldRawValue || oldValue) + content;
+ }
+
+ lastAdded = 'value';
+ } else {
+ var insensitive = content === 'i' || content === "I";
+
+ if ((node.value || node.value === '') && (node.quoteMark || spaceAfterMeaningfulToken)) {
+ node.insensitive = insensitive;
+
+ if (!insensitive || content === "I") {
+ (0, _util.ensureObject)(node, 'raws');
+ node.raws.insensitiveFlag = content;
+ }
+
+ lastAdded = 'insensitive';
+
+ if (spaceBefore) {
+ (0, _util.ensureObject)(node, 'spaces', 'insensitive');
+ node.spaces.insensitive.before = spaceBefore;
+ spaceBefore = '';
+ }
+
+ if (commentBefore) {
+ (0, _util.ensureObject)(node, 'raws', 'spaces', 'insensitive');
+ node.raws.spaces.insensitive.before = commentBefore;
+ commentBefore = '';
+ }
+ } else if (node.value || node.value === '') {
+ lastAdded = 'value';
+ node.value += content;
+
+ if (node.raws.value) {
+ node.raws.value += content;
+ }
+ }
+ }
+
+ spaceAfterMeaningfulToken = false;
+ break;
+
+ case tokens.str:
+ if (!node.attribute || !node.operator) {
+ return this.error("Expected an attribute followed by an operator preceding the string.", {
+ index: token[_tokenize.FIELDS.START_POS]
+ });
+ }
+
+ var _unescapeValue = (0, _attribute.unescapeValue)(content),
+ unescaped = _unescapeValue.unescaped,
+ quoteMark = _unescapeValue.quoteMark;
+
+ node.value = unescaped;
+ node.quoteMark = quoteMark;
+ lastAdded = 'value';
+ (0, _util.ensureObject)(node, 'raws');
+ node.raws.value = content;
+ spaceAfterMeaningfulToken = false;
+ break;
+
+ case tokens.equals:
+ if (!node.attribute) {
+ return this.expected('attribute', token[_tokenize.FIELDS.START_POS], content);
+ }
+
+ if (node.value) {
+ return this.error('Unexpected "=" found; an operator was already defined.', {
+ index: token[_tokenize.FIELDS.START_POS]
+ });
+ }
+
+ node.operator = node.operator ? node.operator + content : content;
+ lastAdded = 'operator';
+ spaceAfterMeaningfulToken = false;
+ break;
+
+ case tokens.comment:
+ if (lastAdded) {
+ if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === 'insensitive') {
+ var lastComment = (0, _util.getProp)(node, 'spaces', lastAdded, 'after') || '';
+ var rawLastComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || lastComment;
+ (0, _util.ensureObject)(node, 'raws', 'spaces', lastAdded);
+ node.raws.spaces[lastAdded].after = rawLastComment + content;
+ } else {
+ var lastValue = node[lastAdded] || '';
+ var rawLastValue = (0, _util.getProp)(node, 'raws', lastAdded) || lastValue;
+ (0, _util.ensureObject)(node, 'raws');
+ node.raws[lastAdded] = rawLastValue + content;
+ }
+ } else {
+ commentBefore = commentBefore + content;
+ }
+
+ break;
+
+ default:
+ return this.error("Unexpected \"" + content + "\" found.", {
+ index: token[_tokenize.FIELDS.START_POS]
+ });
+ }
+
+ pos++;
+ }
+
+ unescapeProp(node, "attribute");
+ unescapeProp(node, "namespace");
+ this.newNode(new _attribute.default(node));
+ this.position++;
+ }
+ /**
+ * return a node containing meaningless garbage up to (but not including) the specified token position.
+ * if the token position is negative, all remaining tokens are consumed.
+ *
+ * This returns an array containing a single string node if all whitespace,
+ * otherwise an array of comment nodes with space before and after.
+ *
+ * These tokens are not added to the current selector, the caller can add them or use them to amend
+ * a previous node's space metadata.
+ *
+ * In lossy mode, this returns only comments.
+ */
+ ;
+
+ _proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
+ if (stopPosition < 0) {
+ stopPosition = this.tokens.length;
+ }
+
+ var startPosition = this.position;
+ var nodes = [];
+ var space = "";
+ var lastComment = undefined;
+
+ do {
+ if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+ if (!this.options.lossy) {
+ space += this.content();
+ }
+ } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
+ var spaces = {};
+
+ if (space) {
+ spaces.before = space;
+ space = "";
+ }
+
+ lastComment = new _comment.default({
+ value: this.content(),
+ source: getTokenSource(this.currToken),
+ sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+ spaces: spaces
+ });
+ nodes.push(lastComment);
+ }
+ } while (++this.position < stopPosition);
+
+ if (space) {
+ if (lastComment) {
+ lastComment.spaces.after = space;
+ } else if (!this.options.lossy) {
+ var firstToken = this.tokens[startPosition];
+ var lastToken = this.tokens[this.position - 1];
+ nodes.push(new _string.default({
+ value: '',
+ source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
+ sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+ spaces: {
+ before: space,
+ after: ''
+ }
+ }));
+ }
+ }
+
+ return nodes;
+ }
+ /**
+ *
+ * @param {*} nodes
+ */
+ ;
+
+ _proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
+ var _this2 = this;
+
+ if (requiredSpace === void 0) {
+ requiredSpace = false;
+ }
+
+ var space = "";
+ var rawSpace = "";
+ nodes.forEach(function (n) {
+ var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
+
+ var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
+
+ space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
+ rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
+ });
+
+ if (rawSpace === space) {
+ rawSpace = undefined;
+ }
+
+ var result = {
+ space: space,
+ rawSpace: rawSpace
+ };
+ return result;
+ };
+
+ _proto.isNamedCombinator = function isNamedCombinator(position) {
+ if (position === void 0) {
+ position = this.position;
+ }
+
+ return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
+ };
+
+ _proto.namedCombinator = function namedCombinator() {
+ if (this.isNamedCombinator()) {
+ var nameRaw = this.content(this.tokens[this.position + 1]);
+ var name = (0, _util.unesc)(nameRaw).toLowerCase();
+ var raws = {};
+
+ if (name !== nameRaw) {
+ raws.value = "/" + nameRaw + "/";
+ }
+
+ var node = new _combinator.default({
+ value: "/" + name + "/",
+ source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
+ sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+ raws: raws
+ });
+ this.position = this.position + 3;
+ return node;
+ } else {
+ this.unexpected();
+ }
+ };
+
+ _proto.combinator = function combinator() {
+ var _this3 = this;
+
+ if (this.content() === '|') {
+ return this.namespace();
+ } // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
+
+
+ var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
+
+ if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
+ var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+
+ if (nodes.length > 0) {
+ var last = this.current.last;
+
+ if (last) {
+ var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes),
+ space = _this$convertWhitespa.space,
+ rawSpace = _this$convertWhitespa.rawSpace;
+
+ if (rawSpace !== undefined) {
+ last.rawSpaceAfter += rawSpace;
+ }
+
+ last.spaces.after += space;
+ } else {
+ nodes.forEach(function (n) {
+ return _this3.newNode(n);
+ });
+ }
+ }
+
+ return;
+ }
+
+ var firstToken = this.currToken;
+ var spaceOrDescendantSelectorNodes = undefined;
+
+ if (nextSigTokenPos > this.position) {
+ spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+ }
+
+ var node;
+
+ if (this.isNamedCombinator()) {
+ node = this.namedCombinator();
+ } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
+ node = new _combinator.default({
+ value: this.content(),
+ source: getTokenSource(this.currToken),
+ sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
+ });
+ this.position++;
+ } else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {// pass
+ } else if (!spaceOrDescendantSelectorNodes) {
+ this.unexpected();
+ }
+
+ if (node) {
+ if (spaceOrDescendantSelectorNodes) {
+ var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes),
+ _space = _this$convertWhitespa2.space,
+ _rawSpace = _this$convertWhitespa2.rawSpace;
+
+ node.spaces.before = _space;
+ node.rawSpaceBefore = _rawSpace;
+ }
+ } else {
+ // descendant combinator
+ var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true),
+ _space2 = _this$convertWhitespa3.space,
+ _rawSpace2 = _this$convertWhitespa3.rawSpace;
+
+ if (!_rawSpace2) {
+ _rawSpace2 = _space2;
+ }
+
+ var spaces = {};
+ var raws = {
+ spaces: {}
+ };
+
+ if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) {
+ spaces.before = _space2.slice(0, _space2.length - 1);
+ raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
+ } else if (_space2.startsWith(' ') && _rawSpace2.startsWith(' ')) {
+ spaces.after = _space2.slice(1);
+ raws.spaces.after = _rawSpace2.slice(1);
+ } else {
+ raws.value = _rawSpace2;
+ }
+
+ node = new _combinator.default({
+ value: ' ',
+ source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
+ sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+ spaces: spaces,
+ raws: raws
+ });
+ }
+
+ if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
+ node.spaces.after = this.optionalSpace(this.content());
+ this.position++;
+ }
+
+ return this.newNode(node);
+ };
+
+ _proto.comma = function comma() {
+ if (this.position === this.tokens.length - 1) {
+ this.root.trailingComma = true;
+ this.position++;
+ return;
+ }
+
+ this.current._inferEndPosition();
+
+ var selector = new _selector.default({
+ source: {
+ start: tokenStart(this.tokens[this.position + 1])
+ }
+ });
+ this.current.parent.append(selector);
+ this.current = selector;
+ this.position++;
+ };
+
+ _proto.comment = function comment() {
+ var current = this.currToken;
+ this.newNode(new _comment.default({
+ value: this.content(),
+ source: getTokenSource(current),
+ sourceIndex: current[_tokenize.FIELDS.START_POS]
+ }));
+ this.position++;
+ };
+
+ _proto.error = function error(message, opts) {
+ throw this.root.error(message, opts);
+ };
+
+ _proto.missingBackslash = function missingBackslash() {
+ return this.error('Expected a backslash preceding the semicolon.', {
+ index: this.currToken[_tokenize.FIELDS.START_POS]
+ });
+ };
+
+ _proto.missingParenthesis = function missingParenthesis() {
+ return this.expected('opening parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
+ };
+
+ _proto.missingSquareBracket = function missingSquareBracket() {
+ return this.expected('opening square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
+ };
+
+ _proto.unexpected = function unexpected() {
+ return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
+ };
+
+ _proto.namespace = function namespace() {
+ var before = this.prevToken && this.content(this.prevToken) || true;
+
+ if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+ this.position++;
+ return this.word(before);
+ } else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
+ this.position++;
+ return this.universal(before);
+ }
+ };
+
+ _proto.nesting = function nesting() {
+ if (this.nextToken) {
+ var nextContent = this.content(this.nextToken);
+
+ if (nextContent === "|") {
+ this.position++;
+ return;
+ }
+ }
+
+ var current = this.currToken;
+ this.newNode(new _nesting.default({
+ value: this.content(),
+ source: getTokenSource(current),
+ sourceIndex: current[_tokenize.FIELDS.START_POS]
+ }));
+ this.position++;
+ };
+
+ _proto.parentheses = function parentheses() {
+ var last = this.current.last;
+ var unbalanced = 1;
+ this.position++;
+
+ if (last && last.type === types.PSEUDO) {
+ var selector = new _selector.default({
+ source: {
+ start: tokenStart(this.tokens[this.position - 1])
+ }
+ });
+ var cache = this.current;
+ last.append(selector);
+ this.current = selector;
+
+ while (this.position < this.tokens.length && unbalanced) {
+ if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+ unbalanced++;
+ }
+
+ if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+ unbalanced--;
+ }
+
+ if (unbalanced) {
+ this.parse();
+ } else {
+ this.current.source.end = tokenEnd(this.currToken);
+ this.current.parent.source.end = tokenEnd(this.currToken);
+ this.position++;
+ }
+ }
+
+ this.current = cache;
+ } else {
+ // I think this case should be an error. It's used to implement a basic parse of media queries
+ // but I don't think it's a good idea.
+ var parenStart = this.currToken;
+ var parenValue = "(";
+ var parenEnd;
+
+ while (this.position < this.tokens.length && unbalanced) {
+ if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+ unbalanced++;
+ }
+
+ if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+ unbalanced--;
+ }
+
+ parenEnd = this.currToken;
+ parenValue += this.parseParenthesisToken(this.currToken);
+ this.position++;
+ }
+
+ if (last) {
+ last.appendToPropertyAndEscape("value", parenValue, parenValue);
+ } else {
+ this.newNode(new _string.default({
+ value: parenValue,
+ source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
+ sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
+ }));
+ }
+ }
+
+ if (unbalanced) {
+ return this.expected('closing parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
+ }
+ };
+
+ _proto.pseudo = function pseudo() {
+ var _this4 = this;
+
+ var pseudoStr = '';
+ var startingToken = this.currToken;
+
+ while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
+ pseudoStr += this.content();
+ this.position++;
+ }
+
+ if (!this.currToken) {
+ return this.expected(['pseudo-class', 'pseudo-element'], this.position - 1);
+ }
+
+ if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+ this.splitWord(false, function (first, length) {
+ pseudoStr += first;
+
+ _this4.newNode(new _pseudo.default({
+ value: pseudoStr,
+ source: getTokenSourceSpan(startingToken, _this4.currToken),
+ sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+ }));
+
+ if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+ _this4.error('Misplaced parenthesis.', {
+ index: _this4.nextToken[_tokenize.FIELDS.START_POS]
+ });
+ }
+ });
+ } else {
+ return this.expected(['pseudo-class', 'pseudo-element'], this.currToken[_tokenize.FIELDS.START_POS]);
+ }
+ };
+
+ _proto.space = function space() {
+ var content = this.content(); // Handle space before and after the selector
+
+ if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+ this.spaces = this.optionalSpace(content);
+ this.position++;
+ } else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+ this.current.last.spaces.after = this.optionalSpace(content);
+ this.position++;
+ } else {
+ this.combinator();
+ }
+ };
+
+ _proto.string = function string() {
+ var current = this.currToken;
+ this.newNode(new _string.default({
+ value: this.content(),
+ source: getTokenSource(current),
+ sourceIndex: current[_tokenize.FIELDS.START_POS]
+ }));
+ this.position++;
+ };
+
+ _proto.universal = function universal(namespace) {
+ var nextToken = this.nextToken;
+
+ if (nextToken && this.content(nextToken) === '|') {
+ this.position++;
+ return this.namespace();
+ }
+
+ var current = this.currToken;
+ this.newNode(new _universal.default({
+ value: this.content(),
+ source: getTokenSource(current),
+ sourceIndex: current[_tokenize.FIELDS.START_POS]
+ }), namespace);
+ this.position++;
+ };
+
+ _proto.splitWord = function splitWord(namespace, firstCallback) {
+ var _this5 = this;
+
+ var nextToken = this.nextToken;
+ var word = this.content();
+
+ while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
+ this.position++;
+ var current = this.content();
+ word += current;
+
+ if (current.lastIndexOf('\\') === current.length - 1) {
+ var next = this.nextToken;
+
+ if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
+ word += this.requiredSpace(this.content(next));
+ this.position++;
+ }
+ }
+
+ nextToken = this.nextToken;
+ }
+
+ var hasClass = (0, _indexesOf.default)(word, '.').filter(function (i) {
+ return word[i - 1] !== '\\';
+ });
+ var hasId = (0, _indexesOf.default)(word, '#').filter(function (i) {
+ return word[i - 1] !== '\\';
+ }); // Eliminate Sass interpolations from the list of id indexes
+
+ var interpolations = (0, _indexesOf.default)(word, '#{');
+
+ if (interpolations.length) {
+ hasId = hasId.filter(function (hashIndex) {
+ return !~interpolations.indexOf(hashIndex);
+ });
+ }
+
+ var indices = (0, _sortAscending.default)((0, _uniq.default)([0].concat(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(_this5, value, indices.length);
+ }
+
+ var node;
+ var current = _this5.currToken;
+ var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i];
+ var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
+
+ if (~hasClass.indexOf(ind)) {
+ var classNameOpts = {
+ value: value.slice(1),
+ source: source,
+ sourceIndex: sourceIndex
+ };
+ node = new _className.default(unescapeProp(classNameOpts, "value"));
+ } else if (~hasId.indexOf(ind)) {
+ var idOpts = {
+ value: value.slice(1),
+ source: source,
+ sourceIndex: sourceIndex
+ };
+ node = new _id.default(unescapeProp(idOpts, "value"));
+ } else {
+ var tagOpts = {
+ value: value,
+ source: source,
+ sourceIndex: sourceIndex
+ };
+ unescapeProp(tagOpts, "value");
+ node = new _tag.default(tagOpts);
+ }
+
+ _this5.newNode(node, namespace); // Ensure that the namespace is used only once
+
+
+ namespace = null;
+ });
+ this.position++;
+ };
+
+ _proto.word = function word(namespace) {
+ var nextToken = this.nextToken;
+
+ if (nextToken && this.content(nextToken) === '|') {
+ this.position++;
+ return this.namespace();
+ }
+
+ return this.splitWord(namespace);
+ };
+
+ _proto.loop = function loop() {
+ while (this.position < this.tokens.length) {
+ this.parse(true);
+ }
+
+ this.current._inferEndPosition();
+
+ return this.root;
+ };
+
+ _proto.parse = function parse(throwOnParenthesis) {
+ switch (this.currToken[_tokenize.FIELDS.TYPE]) {
+ case tokens.space:
+ this.space();
+ break;
+
+ case tokens.comment:
+ this.comment();
+ break;
+
+ case tokens.openParenthesis:
+ this.parentheses();
+ break;
+
+ case tokens.closeParenthesis:
+ if (throwOnParenthesis) {
+ this.missingParenthesis();
+ }
+
+ break;
+
+ case tokens.openSquare:
+ this.attribute();
+ break;
+
+ case tokens.dollar:
+ case tokens.caret:
+ case tokens.equals:
+ case tokens.word:
+ this.word();
+ break;
+
+ case tokens.colon:
+ this.pseudo();
+ break;
+
+ case tokens.comma:
+ this.comma();
+ break;
+
+ case tokens.asterisk:
+ this.universal();
+ break;
+
+ case tokens.ampersand:
+ this.nesting();
+ break;
+
+ case tokens.slash:
+ case tokens.combinator:
+ this.combinator();
+ break;
+
+ case tokens.str:
+ this.string();
+ break;
+ // These cases throw; no break needed.
+
+ case tokens.closeSquare:
+ this.missingSquareBracket();
+
+ case tokens.semicolon:
+ this.missingBackslash();
+
+ default:
+ this.unexpected();
+ }
+ }
+ /**
+ * Helpers
+ */
+ ;
+
+ _proto.expected = function expected(description, index, found) {
+ if (Array.isArray(description)) {
+ var last = description.pop();
+ description = description.join(', ') + " or " + last;
+ }
+
+ var an = /^[aeiou]/.test(description[0]) ? 'an' : 'a';
+
+ if (!found) {
+ return this.error("Expected " + an + " " + description + ".", {
+ index: index
+ });
+ }
+
+ return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", {
+ index: index
+ });
+ };
+
+ _proto.requiredSpace = function requiredSpace(space) {
+ return this.options.lossy ? ' ' : space;
+ };
+
+ _proto.optionalSpace = function optionalSpace(space) {
+ return this.options.lossy ? '' : space;
+ };
+
+ _proto.lossySpace = function lossySpace(space, required) {
+ if (this.options.lossy) {
+ return required ? ' ' : '';
+ } else {
+ return space;
+ }
+ };
+
+ _proto.parseParenthesisToken = function parseParenthesisToken(token) {
+ var content = this.content(token);
+
+ if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
+ return this.requiredSpace(content);
+ } else {
+ return content;
+ }
+ };
+
+ _proto.newNode = function newNode(node, namespace) {
+ if (namespace) {
+ if (/^ +$/.test(namespace)) {
+ if (!this.options.lossy) {
+ this.spaces = (this.spaces || '') + namespace;
+ }
+
+ namespace = true;
+ }
+
+ node.namespace = namespace;
+ unescapeProp(node, "namespace");
+ }
+
+ if (this.spaces) {
+ node.spaces.before = this.spaces;
+ this.spaces = '';
+ }
+
+ return this.current.append(node);
+ };
+
+ _proto.content = function content(token) {
+ if (token === void 0) {
+ token = this.currToken;
+ }
+
+ return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
+ };
+
+ /**
+ * returns the index of the next non-whitespace, non-comment token.
+ * returns -1 if no meaningful token is found.
+ */
+ _proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) {
+ if (startPosition === void 0) {
+ startPosition = this.position + 1;
+ }
+
+ var searchPosition = startPosition;
+
+ while (searchPosition < this.tokens.length) {
+ if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
+ searchPosition++;
+ continue;
+ } else {
+ return searchPosition;
+ }
+ }
+
+ return -1;
+ };
+
+ _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-selector-parser/dist/processor.js b/node_modules/postcss-selector-parser/dist/processor.js
new file mode 100644
index 0000000..048b1ef
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/processor.js
@@ -0,0 +1,208 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _parser = _interopRequireDefault(require("./parser"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Processor =
+/*#__PURE__*/
+function () {
+ function Processor(func, options) {
+ this.func = func || function noop() {};
+
+ this.funcRes = null;
+ this.options = options;
+ }
+
+ var _proto = Processor.prototype;
+
+ _proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var merged = Object.assign({}, this.options, options);
+
+ if (merged.updateSelector === false) {
+ return false;
+ } else {
+ return typeof rule !== "string";
+ }
+ };
+
+ _proto._isLossy = function _isLossy(options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var merged = Object.assign({}, this.options, options);
+
+ if (merged.lossless === false) {
+ return true;
+ } else {
+ return false;
+ }
+ };
+
+ _proto._root = function _root(rule, options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var parser = new _parser.default(rule, this._parseOptions(options));
+ return parser.root;
+ };
+
+ _proto._parseOptions = function _parseOptions(options) {
+ return {
+ lossy: this._isLossy(options)
+ };
+ };
+
+ _proto._run = function _run(rule, options) {
+ var _this = this;
+
+ if (options === void 0) {
+ options = {};
+ }
+
+ return new Promise(function (resolve, reject) {
+ try {
+ var root = _this._root(rule, options);
+
+ Promise.resolve(_this.func(root)).then(function (transform) {
+ var string = undefined;
+
+ if (_this._shouldUpdateSelector(rule, options)) {
+ string = root.toString();
+ rule.selector = string;
+ }
+
+ return {
+ transform: transform,
+ root: root,
+ string: string
+ };
+ }).then(resolve, reject);
+ } catch (e) {
+ reject(e);
+ return;
+ }
+ });
+ };
+
+ _proto._runSync = function _runSync(rule, options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var root = this._root(rule, options);
+
+ var transform = this.func(root);
+
+ if (transform && typeof transform.then === "function") {
+ throw new Error("Selector processor returned a promise to a synchronous call.");
+ }
+
+ var string = undefined;
+
+ if (options.updateSelector && typeof rule !== "string") {
+ string = root.toString();
+ rule.selector = string;
+ }
+
+ return {
+ transform: transform,
+ root: root,
+ string: string
+ };
+ }
+ /**
+ * Process rule into a selector AST.
+ *
+ * @param rule {postcss.Rule | string} The css selector to be processed
+ * @param options The options for processing
+ * @returns {Promise<parser.Root>} The AST of the selector after processing it.
+ */
+ ;
+
+ _proto.ast = function ast(rule, options) {
+ return this._run(rule, options).then(function (result) {
+ return result.root;
+ });
+ }
+ /**
+ * Process rule into a selector AST synchronously.
+ *
+ * @param rule {postcss.Rule | string} The css selector to be processed
+ * @param options The options for processing
+ * @returns {parser.Root} The AST of the selector after processing it.
+ */
+ ;
+
+ _proto.astSync = function astSync(rule, options) {
+ return this._runSync(rule, options).root;
+ }
+ /**
+ * Process a selector into a transformed value asynchronously
+ *
+ * @param rule {postcss.Rule | string} The css selector to be processed
+ * @param options The options for processing
+ * @returns {Promise<any>} The value returned by the processor.
+ */
+ ;
+
+ _proto.transform = function transform(rule, options) {
+ return this._run(rule, options).then(function (result) {
+ return result.transform;
+ });
+ }
+ /**
+ * Process a selector into a transformed value synchronously.
+ *
+ * @param rule {postcss.Rule | string} The css selector to be processed
+ * @param options The options for processing
+ * @returns {any} The value returned by the processor.
+ */
+ ;
+
+ _proto.transformSync = function transformSync(rule, options) {
+ return this._runSync(rule, options).transform;
+ }
+ /**
+ * Process a selector into a new selector string asynchronously.
+ *
+ * @param rule {postcss.Rule | string} The css selector to be processed
+ * @param options The options for processing
+ * @returns {string} the selector after processing.
+ */
+ ;
+
+ _proto.process = function process(rule, options) {
+ return this._run(rule, options).then(function (result) {
+ return result.string || result.root.toString();
+ });
+ }
+ /**
+ * Process a selector into a new selector string synchronously.
+ *
+ * @param rule {postcss.Rule | string} The css selector to be processed
+ * @param options The options for processing
+ * @returns {string} the selector after processing.
+ */
+ ;
+
+ _proto.processSync = function processSync(rule, options) {
+ var result = this._runSync(rule, options);
+
+ return result.string || result.root.toString();
+ };
+
+ return Processor;
+}();
+
+exports.default = Processor;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/attribute.js b/node_modules/postcss-selector-parser/dist/selectors/attribute.js
new file mode 100644
index 0000000..8d9c280
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/attribute.js
@@ -0,0 +1,516 @@
+"use strict";
+
+exports.__esModule = true;
+exports.unescapeValue = unescapeValue;
+exports.default = void 0;
+
+var _cssesc = _interopRequireDefault(require("cssesc"));
+
+var _unesc = _interopRequireDefault(require("../util/unesc"));
+
+var _namespace = _interopRequireDefault(require("./namespace"));
+
+var _types = require("./types");
+
+var _CSSESC_QUOTE_OPTIONS;
+
+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; }
+
+var _require = require("util"),
+ deprecate = _require.deprecate;
+
+var WRAPPED_IN_QUOTES = /^('|")(.*)\1$/;
+var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");
+var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
+var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+
+function unescapeValue(value) {
+ var deprecatedUsage = false;
+ var quoteMark = null;
+ var unescaped = value;
+ var m = unescaped.match(WRAPPED_IN_QUOTES);
+
+ if (m) {
+ quoteMark = m[1];
+ unescaped = m[2];
+ }
+
+ unescaped = (0, _unesc.default)(unescaped);
+
+ if (unescaped !== value) {
+ deprecatedUsage = true;
+ }
+
+ return {
+ deprecatedUsage: deprecatedUsage,
+ unescaped: unescaped,
+ quoteMark: quoteMark
+ };
+}
+
+function handleDeprecatedContructorOpts(opts) {
+ if (opts.quoteMark !== undefined) {
+ return opts;
+ }
+
+ if (opts.value === undefined) {
+ return opts;
+ }
+
+ warnOfDeprecatedConstructor();
+
+ var _unescapeValue = unescapeValue(opts.value),
+ quoteMark = _unescapeValue.quoteMark,
+ unescaped = _unescapeValue.unescaped;
+
+ if (!opts.raws) {
+ opts.raws = {};
+ }
+
+ if (opts.raws.value === undefined) {
+ opts.raws.value = opts.value;
+ }
+
+ opts.value = unescaped;
+ opts.quoteMark = quoteMark;
+ return opts;
+}
+
+var Attribute =
+/*#__PURE__*/
+function (_Namespace) {
+ _inheritsLoose(Attribute, _Namespace);
+
+ function Attribute(opts) {
+ var _this;
+
+ if (opts === void 0) {
+ opts = {};
+ }
+
+ _this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
+ _this.type = _types.ATTRIBUTE;
+ _this.raws = _this.raws || {};
+ Object.defineProperty(_this.raws, 'unquoted', {
+ get: deprecate(function () {
+ return _this.value;
+ }, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+ set: deprecate(function () {
+ return _this.value;
+ }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
+ });
+ _this._constructed = true;
+ return _this;
+ }
+ /**
+ * Returns the Attribute's value quoted such that it would be legal to use
+ * in the value of a css file. The original value's quotation setting
+ * used for stringification is left unchanged. See `setValue(value, options)`
+ * if you want to control the quote settings of a new value for the attribute.
+ *
+ * You can also change the quotation used for the current value by setting quoteMark.
+ *
+ * Options:
+ * * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
+ * option is not set, the original value for quoteMark will be used. If
+ * indeterminate, a double quote is used. The legal values are:
+ * * `null` - the value will be unquoted and characters will be escaped as necessary.
+ * * `'` - the value will be quoted with a single quote and single quotes are escaped.
+ * * `"` - the value will be quoted with a double quote and double quotes are escaped.
+ * * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
+ * over the quoteMark option value.
+ * * smart {boolean} - if true, will select a quote mark based on the value
+ * and the other options specified here. See the `smartQuoteMark()`
+ * method.
+ **/
+
+
+ var _proto = Attribute.prototype;
+
+ _proto.getQuotedValue = function getQuotedValue(options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var quoteMark = this._determineQuoteMark(options);
+
+ var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
+ var escaped = (0, _cssesc.default)(this._value, cssescopts);
+ return escaped;
+ };
+
+ _proto._determineQuoteMark = function _determineQuoteMark(options) {
+ return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
+ }
+ /**
+ * Set the unescaped value with the specified quotation options. The value
+ * provided must not include any wrapping quote marks -- those quotes will
+ * be interpreted as part of the value and escaped accordingly.
+ */
+ ;
+
+ _proto.setValue = function setValue(value, options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ this._value = value;
+ this._quoteMark = this._determineQuoteMark(options);
+
+ this._syncRawValue();
+ }
+ /**
+ * Intelligently select a quoteMark value based on the value's contents. If
+ * the value is a legal CSS ident, it will not be quoted. Otherwise a quote
+ * mark will be picked that minimizes the number of escapes.
+ *
+ * If there's no clear winner, the quote mark from these options is used,
+ * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
+ * true). If the quoteMark is unspecified, a double quote is used.
+ *
+ * @param options This takes the quoteMark and preferCurrentQuoteMark options
+ * from the quoteValue method.
+ */
+ ;
+
+ _proto.smartQuoteMark = function smartQuoteMark(options) {
+ var v = this.value;
+ var numSingleQuotes = v.replace(/[^']/g, '').length;
+ var numDoubleQuotes = v.replace(/[^"]/g, '').length;
+
+ if (numSingleQuotes + numDoubleQuotes === 0) {
+ var escaped = (0, _cssesc.default)(v, {
+ isIdentifier: true
+ });
+
+ if (escaped === v) {
+ return Attribute.NO_QUOTE;
+ } else {
+ var pref = this.preferredQuoteMark(options);
+
+ if (pref === Attribute.NO_QUOTE) {
+ // pick a quote mark that isn't none and see if it's smaller
+ var quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
+ var opts = CSSESC_QUOTE_OPTIONS[quote];
+ var quoteValue = (0, _cssesc.default)(v, opts);
+
+ if (quoteValue.length < escaped.length) {
+ return quote;
+ }
+ }
+
+ return pref;
+ }
+ } else if (numDoubleQuotes === numSingleQuotes) {
+ return this.preferredQuoteMark(options);
+ } else if (numDoubleQuotes < numSingleQuotes) {
+ return Attribute.DOUBLE_QUOTE;
+ } else {
+ return Attribute.SINGLE_QUOTE;
+ }
+ }
+ /**
+ * Selects the preferred quote mark based on the options and the current quote mark value.
+ * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
+ * instead.
+ */
+ ;
+
+ _proto.preferredQuoteMark = function preferredQuoteMark(options) {
+ var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
+
+ if (quoteMark === undefined) {
+ quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
+ }
+
+ if (quoteMark === undefined) {
+ quoteMark = Attribute.DOUBLE_QUOTE;
+ }
+
+ return quoteMark;
+ };
+
+ _proto._syncRawValue = function _syncRawValue() {
+ var rawValue = (0, _cssesc.default)(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+
+ if (rawValue === this._value) {
+ if (this.raws) {
+ delete this.raws.value;
+ }
+ } else {
+ this.raws.value = rawValue;
+ }
+ };
+
+ _proto._handleEscapes = function _handleEscapes(prop, value) {
+ if (this._constructed) {
+ var escaped = (0, _cssesc.default)(value, {
+ isIdentifier: true
+ });
+
+ if (escaped !== value) {
+ this.raws[prop] = escaped;
+ } else {
+ delete this.raws[prop];
+ }
+ }
+ };
+
+ _proto._spacesFor = function _spacesFor(name) {
+ var attrSpaces = {
+ before: '',
+ after: ''
+ };
+ var spaces = this.spaces[name] || {};
+ var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
+ return Object.assign(attrSpaces, spaces, rawSpaces);
+ };
+
+ _proto._stringFor = function _stringFor(name, spaceName, concat) {
+ if (spaceName === void 0) {
+ spaceName = name;
+ }
+
+ if (concat === void 0) {
+ concat = defaultAttrConcat;
+ }
+
+ var attrSpaces = this._spacesFor(spaceName);
+
+ return concat(this.stringifyProperty(name), attrSpaces);
+ }
+ /**
+ * returns the offset of the attribute part specified relative to the
+ * start of the node of the output string.
+ *
+ * * "ns" - alias for "namespace"
+ * * "namespace" - the namespace if it exists.
+ * * "attribute" - the attribute name
+ * * "attributeNS" - the start of the attribute or its namespace
+ * * "operator" - the match operator of the attribute
+ * * "value" - The value (string or identifier)
+ * * "insensitive" - the case insensitivity flag;
+ * @param part One of the possible values inside an attribute.
+ * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
+ */
+ ;
+
+ _proto.offsetOf = function offsetOf(name) {
+ var count = 1;
+
+ var attributeSpaces = this._spacesFor("attribute");
+
+ count += attributeSpaces.before.length;
+
+ if (name === "namespace" || name === "ns") {
+ return this.namespace ? count : -1;
+ }
+
+ if (name === "attributeNS") {
+ return count;
+ }
+
+ count += this.namespaceString.length;
+
+ if (this.namespace) {
+ count += 1;
+ }
+
+ if (name === "attribute") {
+ return count;
+ }
+
+ count += this.stringifyProperty("attribute").length;
+ count += attributeSpaces.after.length;
+
+ var operatorSpaces = this._spacesFor("operator");
+
+ count += operatorSpaces.before.length;
+ var operator = this.stringifyProperty("operator");
+
+ if (name === "operator") {
+ return operator ? count : -1;
+ }
+
+ count += operator.length;
+ count += operatorSpaces.after.length;
+
+ var valueSpaces = this._spacesFor("value");
+
+ count += valueSpaces.before.length;
+ var value = this.stringifyProperty("value");
+
+ if (name === "value") {
+ return value ? count : -1;
+ }
+
+ count += value.length;
+ count += valueSpaces.after.length;
+
+ var insensitiveSpaces = this._spacesFor("insensitive");
+
+ count += insensitiveSpaces.before.length;
+
+ if (name === "insensitive") {
+ return this.insensitive ? count : -1;
+ }
+
+ return -1;
+ };
+
+ _proto.toString = function toString() {
+ var _this2 = this;
+
+ var selector = [this.rawSpaceBefore, '['];
+ selector.push(this._stringFor('qualifiedAttribute', 'attribute'));
+
+ if (this.operator && (this.value || this.value === '')) {
+ selector.push(this._stringFor('operator'));
+ selector.push(this._stringFor('value'));
+ selector.push(this._stringFor('insensitiveFlag', 'insensitive', function (attrValue, attrSpaces) {
+ if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) {
+ attrSpaces.before = " ";
+ }
+
+ return defaultAttrConcat(attrValue, attrSpaces);
+ }));
+ }
+
+ selector.push(']');
+ selector.push(this.rawSpaceAfter);
+ return selector.join('');
+ };
+
+ _createClass(Attribute, [{
+ key: "quoted",
+ get: function get() {
+ var qm = this.quoteMark;
+ return qm === "'" || qm === '"';
+ },
+ set: function set(value) {
+ warnOfDeprecatedQuotedAssignment();
+ }
+ /**
+ * returns a single (`'`) or double (`"`) quote character if the value is quoted.
+ * returns `null` if the value is not quoted.
+ * returns `undefined` if the quotation state is unknown (this can happen when
+ * the attribute is constructed without specifying a quote mark.)
+ */
+
+ }, {
+ key: "quoteMark",
+ get: function get() {
+ return this._quoteMark;
+ }
+ /**
+ * Set the quote mark to be used by this attribute's value.
+ * If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute
+ * value is updated accordingly.
+ *
+ * @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
+ */
+ ,
+ set: function set(quoteMark) {
+ if (!this._constructed) {
+ this._quoteMark = quoteMark;
+ return;
+ }
+
+ if (this._quoteMark !== quoteMark) {
+ this._quoteMark = quoteMark;
+
+ this._syncRawValue();
+ }
+ }
+ }, {
+ key: "qualifiedAttribute",
+ get: function get() {
+ return this.qualifiedName(this.raws.attribute || this.attribute);
+ }
+ }, {
+ key: "insensitiveFlag",
+ get: function get() {
+ return this.insensitive ? 'i' : '';
+ }
+ }, {
+ key: "value",
+ get: function get() {
+ return this._value;
+ }
+ /**
+ * Before 3.0, the value had to be set to an escaped value including any wrapped
+ * quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
+ * is unescaped during parsing and any quote marks are removed.
+ *
+ * Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
+ * a deprecation warning is raised when the new value contains any characters that would
+ * require escaping (including if it contains wrapped quotes).
+ *
+ * Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
+ * how the new value is quoted.
+ */
+ ,
+ set: function set(v) {
+ if (this._constructed) {
+ var _unescapeValue2 = unescapeValue(v),
+ deprecatedUsage = _unescapeValue2.deprecatedUsage,
+ unescaped = _unescapeValue2.unescaped,
+ quoteMark = _unescapeValue2.quoteMark;
+
+ if (deprecatedUsage) {
+ warnOfDeprecatedValueAssignment();
+ }
+
+ if (unescaped === this._value && quoteMark === this._quoteMark) {
+ return;
+ }
+
+ this._value = unescaped;
+ this._quoteMark = quoteMark;
+
+ this._syncRawValue();
+ } else {
+ this._value = v;
+ }
+ }
+ }, {
+ key: "attribute",
+ get: function get() {
+ return this._attribute;
+ },
+ set: function set(name) {
+ this._handleEscapes("attribute", name);
+
+ this._attribute = name;
+ }
+ }]);
+
+ return Attribute;
+}(_namespace.default);
+
+exports.default = Attribute;
+Attribute.NO_QUOTE = null;
+Attribute.SINGLE_QUOTE = "'";
+Attribute.DOUBLE_QUOTE = '"';
+var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
+ "'": {
+ quotes: 'single',
+ wrap: true
+ },
+ '"': {
+ quotes: 'double',
+ wrap: true
+ }
+}, _CSSESC_QUOTE_OPTIONS[null] = {
+ isIdentifier: true
+}, _CSSESC_QUOTE_OPTIONS);
+
+function defaultAttrConcat(attrValue, attrSpaces) {
+ return "" + attrSpaces.before + attrValue + attrSpaces.after;
+}
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/className.js b/node_modules/postcss-selector-parser/dist/selectors/className.js
new file mode 100644
index 0000000..d79247d
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/className.js
@@ -0,0 +1,69 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _cssesc = _interopRequireDefault(require("cssesc"));
+
+var _util = require("../util");
+
+var _node = _interopRequireDefault(require("./node"));
+
+var _types = require("./types");
+
+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; }
+
+var ClassName =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(ClassName, _Node);
+
+ function ClassName(opts) {
+ var _this;
+
+ _this = _Node.call(this, opts) || this;
+ _this.type = _types.CLASS;
+ _this._constructed = true;
+ return _this;
+ }
+
+ var _proto = ClassName.prototype;
+
+ _proto.toString = function toString() {
+ return [this.rawSpaceBefore, String('.' + this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+ };
+
+ _createClass(ClassName, [{
+ key: "value",
+ set: function set(v) {
+ if (this._constructed) {
+ var escaped = (0, _cssesc.default)(v, {
+ isIdentifier: true
+ });
+
+ if (escaped !== v) {
+ (0, _util.ensureObject)(this, "raws");
+ this.raws.value = escaped;
+ } else if (this.raws) {
+ delete this.raws.value;
+ }
+ }
+
+ this._value = v;
+ },
+ get: function get() {
+ return this._value;
+ }
+ }]);
+
+ return ClassName;
+}(_node.default);
+
+exports.default = ClassName;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/combinator.js b/node_modules/postcss-selector-parser/dist/selectors/combinator.js
new file mode 100644
index 0000000..479cc4b
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/combinator.js
@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+var _types = require("./types");
+
+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; }
+
+var Combinator =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(Combinator, _Node);
+
+ function Combinator(opts) {
+ var _this;
+
+ _this = _Node.call(this, opts) || this;
+ _this.type = _types.COMBINATOR;
+ return _this;
+ }
+
+ return Combinator;
+}(_node.default);
+
+exports.default = Combinator;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/comment.js b/node_modules/postcss-selector-parser/dist/selectors/comment.js
new file mode 100644
index 0000000..a104b69
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/comment.js
@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+var _types = require("./types");
+
+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; }
+
+var Comment =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(Comment, _Node);
+
+ function Comment(opts) {
+ var _this;
+
+ _this = _Node.call(this, opts) || this;
+ _this.type = _types.COMMENT;
+ return _this;
+ }
+
+ return Comment;
+}(_node.default);
+
+exports.default = Comment;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/constructors.js b/node_modules/postcss-selector-parser/dist/selectors/constructors.js
new file mode 100644
index 0000000..6c5a3b6
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/constructors.js
@@ -0,0 +1,102 @@
+"use strict";
+
+exports.__esModule = true;
+exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = void 0;
+
+var _attribute = _interopRequireDefault(require("./attribute"));
+
+var _className = _interopRequireDefault(require("./className"));
+
+var _combinator = _interopRequireDefault(require("./combinator"));
+
+var _comment = _interopRequireDefault(require("./comment"));
+
+var _id = _interopRequireDefault(require("./id"));
+
+var _nesting = _interopRequireDefault(require("./nesting"));
+
+var _pseudo = _interopRequireDefault(require("./pseudo"));
+
+var _root = _interopRequireDefault(require("./root"));
+
+var _selector = _interopRequireDefault(require("./selector"));
+
+var _string = _interopRequireDefault(require("./string"));
+
+var _tag = _interopRequireDefault(require("./tag"));
+
+var _universal = _interopRequireDefault(require("./universal"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var attribute = function attribute(opts) {
+ return new _attribute.default(opts);
+};
+
+exports.attribute = attribute;
+
+var className = function className(opts) {
+ return new _className.default(opts);
+};
+
+exports.className = className;
+
+var combinator = function combinator(opts) {
+ return new _combinator.default(opts);
+};
+
+exports.combinator = combinator;
+
+var comment = function comment(opts) {
+ return new _comment.default(opts);
+};
+
+exports.comment = comment;
+
+var id = function id(opts) {
+ return new _id.default(opts);
+};
+
+exports.id = id;
+
+var nesting = function nesting(opts) {
+ return new _nesting.default(opts);
+};
+
+exports.nesting = nesting;
+
+var pseudo = function pseudo(opts) {
+ return new _pseudo.default(opts);
+};
+
+exports.pseudo = pseudo;
+
+var root = function root(opts) {
+ return new _root.default(opts);
+};
+
+exports.root = root;
+
+var selector = function selector(opts) {
+ return new _selector.default(opts);
+};
+
+exports.selector = selector;
+
+var string = function string(opts) {
+ return new _string.default(opts);
+};
+
+exports.string = string;
+
+var tag = function tag(opts) {
+ return new _tag.default(opts);
+};
+
+exports.tag = tag;
+
+var universal = function universal(opts) {
+ return new _universal.default(opts);
+};
+
+exports.universal = universal;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/container.js b/node_modules/postcss-selector-parser/dist/selectors/container.js
new file mode 100644
index 0000000..53b552d
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/container.js
@@ -0,0 +1,398 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+var types = _interopRequireWildcard(require("./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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+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; }
+
+var Container =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(Container, _Node);
+
+ function Container(opts) {
+ var _this;
+
+ _this = _Node.call(this, opts) || this;
+
+ if (!_this.nodes) {
+ _this.nodes = [];
+ }
+
+ return _this;
+ }
+
+ var _proto = Container.prototype;
+
+ _proto.append = function append(selector) {
+ selector.parent = this;
+ this.nodes.push(selector);
+ return this;
+ };
+
+ _proto.prepend = function prepend(selector) {
+ selector.parent = this;
+ this.nodes.unshift(selector);
+ return this;
+ };
+
+ _proto.at = function at(index) {
+ return this.nodes[index];
+ };
+
+ _proto.index = function index(child) {
+ if (typeof child === 'number') {
+ return child;
+ }
+
+ return this.nodes.indexOf(child);
+ };
+
+ _proto.removeChild = function removeChild(child) {
+ child = this.index(child);
+ this.at(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;
+ };
+
+ _proto.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;
+ };
+
+ _proto.empty = function empty() {
+ return this.removeAll();
+ };
+
+ _proto.insertAfter = function insertAfter(oldNode, newNode) {
+ newNode.parent = this;
+ var oldIndex = this.index(oldNode);
+ this.nodes.splice(oldIndex + 1, 0, newNode);
+ newNode.parent = this;
+ var index;
+
+ for (var id in this.indexes) {
+ index = this.indexes[id];
+
+ if (oldIndex <= index) {
+ this.indexes[id] = index + 1;
+ }
+ }
+
+ return this;
+ };
+
+ _proto.insertBefore = function insertBefore(oldNode, newNode) {
+ newNode.parent = this;
+ var oldIndex = this.index(oldNode);
+ this.nodes.splice(oldIndex, 0, newNode);
+ newNode.parent = this;
+ var index;
+
+ for (var id in this.indexes) {
+ index = this.indexes[id];
+
+ if (index <= oldIndex) {
+ this.indexes[id] = index + 1;
+ }
+ }
+
+ return this;
+ };
+
+ _proto._findChildAtPosition = function _findChildAtPosition(line, col) {
+ var found = undefined;
+ this.each(function (node) {
+ if (node.atPosition) {
+ var foundChild = node.atPosition(line, col);
+
+ if (foundChild) {
+ found = foundChild;
+ return false;
+ }
+ } else if (node.isAtPosition(line, col)) {
+ found = node;
+ return false;
+ }
+ });
+ return found;
+ }
+ /**
+ * Return the most specific node at the line and column number given.
+ * The source location is based on the original parsed location, locations aren't
+ * updated as selector nodes are mutated.
+ *
+ * Note that this location is relative to the location of the first character
+ * of the selector, and not the location of the selector in the overall document
+ * when used in conjunction with postcss.
+ *
+ * If not found, returns undefined.
+ * @param {number} line The line number of the node to find. (1-based index)
+ * @param {number} col The column number of the node to find. (1-based index)
+ */
+ ;
+
+ _proto.atPosition = function atPosition(line, col) {
+ if (this.isAtPosition(line, col)) {
+ return this._findChildAtPosition(line, col) || this;
+ } else {
+ return undefined;
+ }
+ };
+
+ _proto._inferEndPosition = function _inferEndPosition() {
+ if (this.last && this.last.source && this.last.source.end) {
+ this.source = this.source || {};
+ this.source.end = this.source.end || {};
+ Object.assign(this.source.end, this.last.source.end);
+ }
+ };
+
+ _proto.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, result;
+
+ 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;
+ }
+ };
+
+ _proto.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;
+ }
+ });
+ };
+
+ _proto.walkAttributes = function walkAttributes(callback) {
+ var _this2 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.ATTRIBUTE) {
+ return callback.call(_this2, selector);
+ }
+ });
+ };
+
+ _proto.walkClasses = function walkClasses(callback) {
+ var _this3 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.CLASS) {
+ return callback.call(_this3, selector);
+ }
+ });
+ };
+
+ _proto.walkCombinators = function walkCombinators(callback) {
+ var _this4 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.COMBINATOR) {
+ return callback.call(_this4, selector);
+ }
+ });
+ };
+
+ _proto.walkComments = function walkComments(callback) {
+ var _this5 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.COMMENT) {
+ return callback.call(_this5, selector);
+ }
+ });
+ };
+
+ _proto.walkIds = function walkIds(callback) {
+ var _this6 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.ID) {
+ return callback.call(_this6, selector);
+ }
+ });
+ };
+
+ _proto.walkNesting = function walkNesting(callback) {
+ var _this7 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.NESTING) {
+ return callback.call(_this7, selector);
+ }
+ });
+ };
+
+ _proto.walkPseudos = function walkPseudos(callback) {
+ var _this8 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.PSEUDO) {
+ return callback.call(_this8, selector);
+ }
+ });
+ };
+
+ _proto.walkTags = function walkTags(callback) {
+ var _this9 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.TAG) {
+ return callback.call(_this9, selector);
+ }
+ });
+ };
+
+ _proto.walkUniversals = function walkUniversals(callback) {
+ var _this10 = this;
+
+ return this.walk(function (selector) {
+ if (selector.type === types.UNIVERSAL) {
+ return callback.call(_this10, selector);
+ }
+ });
+ };
+
+ _proto.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;
+ }, []);
+ };
+
+ _proto.map = function map(callback) {
+ return this.nodes.map(callback);
+ };
+
+ _proto.reduce = function reduce(callback, memo) {
+ return this.nodes.reduce(callback, memo);
+ };
+
+ _proto.every = function every(callback) {
+ return this.nodes.every(callback);
+ };
+
+ _proto.some = function some(callback) {
+ return this.nodes.some(callback);
+ };
+
+ _proto.filter = function filter(callback) {
+ return this.nodes.filter(callback);
+ };
+
+ _proto.sort = function sort(callback) {
+ return this.nodes.sort(callback);
+ };
+
+ _proto.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;
+}(_node.default);
+
+exports.default = Container;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/guards.js b/node_modules/postcss-selector-parser/dist/selectors/guards.js
new file mode 100644
index 0000000..8cf7bcf
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/guards.js
@@ -0,0 +1,64 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isNode = isNode;
+exports.isPseudoElement = isPseudoElement;
+exports.isPseudoClass = isPseudoClass;
+exports.isContainer = isContainer;
+exports.isNamespace = isNamespace;
+exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = exports.isPseudo = exports.isNesting = exports.isIdentifier = exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = void 0;
+
+var _types = require("./types");
+
+var _IS_TYPE;
+
+var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
+
+function isNode(node) {
+ return typeof node === "object" && IS_TYPE[node.type];
+}
+
+function isNodeType(type, node) {
+ return isNode(node) && node.type === type;
+}
+
+var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
+exports.isAttribute = isAttribute;
+var isClassName = isNodeType.bind(null, _types.CLASS);
+exports.isClassName = isClassName;
+var isCombinator = isNodeType.bind(null, _types.COMBINATOR);
+exports.isCombinator = isCombinator;
+var isComment = isNodeType.bind(null, _types.COMMENT);
+exports.isComment = isComment;
+var isIdentifier = isNodeType.bind(null, _types.ID);
+exports.isIdentifier = isIdentifier;
+var isNesting = isNodeType.bind(null, _types.NESTING);
+exports.isNesting = isNesting;
+var isPseudo = isNodeType.bind(null, _types.PSEUDO);
+exports.isPseudo = isPseudo;
+var isRoot = isNodeType.bind(null, _types.ROOT);
+exports.isRoot = isRoot;
+var isSelector = isNodeType.bind(null, _types.SELECTOR);
+exports.isSelector = isSelector;
+var isString = isNodeType.bind(null, _types.STRING);
+exports.isString = isString;
+var isTag = isNodeType.bind(null, _types.TAG);
+exports.isTag = isTag;
+var isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
+exports.isUniversal = isUniversal;
+
+function isPseudoElement(node) {
+ return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value === ":before" || node.value === ":after");
+}
+
+function isPseudoClass(node) {
+ return isPseudo(node) && !isPseudoElement(node);
+}
+
+function isContainer(node) {
+ return !!(isNode(node) && node.walk);
+}
+
+function isNamespace(node) {
+ return isAttribute(node) || isTag(node);
+}
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/id.js b/node_modules/postcss-selector-parser/dist/selectors/id.js
new file mode 100644
index 0000000..d93afad
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/id.js
@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+var _types = require("./types");
+
+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; }
+
+var ID =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(ID, _Node);
+
+ function ID(opts) {
+ var _this;
+
+ _this = _Node.call(this, opts) || this;
+ _this.type = _types.ID;
+ return _this;
+ }
+
+ var _proto = ID.prototype;
+
+ _proto.toString = function toString() {
+ return [this.rawSpaceBefore, String('#' + this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+ };
+
+ return ID;
+}(_node.default);
+
+exports.default = ID;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/index.js b/node_modules/postcss-selector-parser/dist/selectors/index.js
new file mode 100644
index 0000000..bc5bc37
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/index.js
@@ -0,0 +1,24 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+ if (key === "default" || key === "__esModule") return;
+ exports[key] = _types[key];
+});
+
+var _constructors = require("./constructors");
+
+Object.keys(_constructors).forEach(function (key) {
+ if (key === "default" || key === "__esModule") return;
+ exports[key] = _constructors[key];
+});
+
+var _guards = require("./guards");
+
+Object.keys(_guards).forEach(function (key) {
+ if (key === "default" || key === "__esModule") return;
+ exports[key] = _guards[key];
+});
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/namespace.js b/node_modules/postcss-selector-parser/dist/selectors/namespace.js
new file mode 100644
index 0000000..6cc6a27
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/namespace.js
@@ -0,0 +1,101 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _cssesc = _interopRequireDefault(require("cssesc"));
+
+var _util = require("../util");
+
+var _node = _interopRequireDefault(require("./node"));
+
+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; }
+
+var Namespace =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(Namespace, _Node);
+
+ function Namespace() {
+ return _Node.apply(this, arguments) || this;
+ }
+
+ var _proto = Namespace.prototype;
+
+ _proto.qualifiedName = function qualifiedName(value) {
+ if (this.namespace) {
+ return this.namespaceString + "|" + value;
+ } else {
+ return value;
+ }
+ };
+
+ _proto.toString = function toString() {
+ return [this.rawSpaceBefore, this.qualifiedName(this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+ };
+
+ _createClass(Namespace, [{
+ key: "namespace",
+ get: function get() {
+ return this._namespace;
+ },
+ set: function set(namespace) {
+ if (namespace === true || namespace === "*" || namespace === "&") {
+ this._namespace = namespace;
+
+ if (this.raws) {
+ delete this.raws.namespace;
+ }
+
+ return;
+ }
+
+ var escaped = (0, _cssesc.default)(namespace, {
+ isIdentifier: true
+ });
+ this._namespace = namespace;
+
+ if (escaped !== namespace) {
+ (0, _util.ensureObject)(this, "raws");
+ this.raws.namespace = escaped;
+ } else if (this.raws) {
+ delete this.raws.namespace;
+ }
+ }
+ }, {
+ key: "ns",
+ get: function get() {
+ return this._namespace;
+ },
+ set: function set(namespace) {
+ this.namespace = namespace;
+ }
+ }, {
+ key: "namespaceString",
+ get: function get() {
+ if (this.namespace) {
+ var ns = this.stringifyProperty("namespace");
+
+ if (ns === true) {
+ return '';
+ } else {
+ return ns;
+ }
+ } else {
+ return '';
+ }
+ }
+ }]);
+
+ return Namespace;
+}(_node.default);
+
+exports.default = Namespace;
+;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/nesting.js b/node_modules/postcss-selector-parser/dist/selectors/nesting.js
new file mode 100644
index 0000000..4cdfb10
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/nesting.js
@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+var _types = require("./types");
+
+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; }
+
+var Nesting =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(Nesting, _Node);
+
+ function Nesting(opts) {
+ var _this;
+
+ _this = _Node.call(this, opts) || this;
+ _this.type = _types.NESTING;
+ _this.value = '&';
+ return _this;
+ }
+
+ return Nesting;
+}(_node.default);
+
+exports.default = Nesting;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/node.js b/node_modules/postcss-selector-parser/dist/selectors/node.js
new file mode 100644
index 0000000..9236311
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/node.js
@@ -0,0 +1,237 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _util = require("../util");
+
+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 cloneNode = function cloneNode(obj, parent) {
+ if (typeof obj !== 'object' || obj === null) {
+ 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;
+
+ 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 Node =
+/*#__PURE__*/
+function () {
+ function Node(opts) {
+ if (opts === void 0) {
+ opts = {};
+ }
+
+ Object.assign(this, opts);
+ this.spaces = this.spaces || {};
+ this.spaces.before = this.spaces.before || '';
+ this.spaces.after = this.spaces.after || '';
+ }
+
+ var _proto = Node.prototype;
+
+ _proto.remove = function remove() {
+ if (this.parent) {
+ this.parent.removeChild(this);
+ }
+
+ this.parent = undefined;
+ return this;
+ };
+
+ _proto.replaceWith = function replaceWith() {
+ if (this.parent) {
+ for (var index in arguments) {
+ this.parent.insertBefore(this, arguments[index]);
+ }
+
+ this.remove();
+ }
+
+ return this;
+ };
+
+ _proto.next = function next() {
+ return this.parent.at(this.parent.index(this) + 1);
+ };
+
+ _proto.prev = function prev() {
+ return this.parent.at(this.parent.index(this) - 1);
+ };
+
+ _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;
+ }
+ /**
+ * Some non-standard syntax doesn't follow normal escaping rules for css.
+ * This allows non standard syntax to be appended to an existing property
+ * by specifying the escaped value. By specifying the escaped value,
+ * illegal characters are allowed to be directly inserted into css output.
+ * @param {string} name the property to set
+ * @param {any} value the unescaped value of the property
+ * @param {string} valueEscaped optional. the escaped value of the property.
+ */
+ ;
+
+ _proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
+ if (!this.raws) {
+ this.raws = {};
+ }
+
+ var originalValue = this[name];
+ var originalEscaped = this.raws[name];
+ this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
+
+ if (originalEscaped || valueEscaped !== value) {
+ this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
+ } else {
+ delete this.raws[name]; // delete any escaped value that was created by the setter.
+ }
+ }
+ /**
+ * Some non-standard syntax doesn't follow normal escaping rules for css.
+ * This allows the escaped value to be specified directly, allowing illegal
+ * characters to be directly inserted into css output.
+ * @param {string} name the property to set
+ * @param {any} value the unescaped value of the property
+ * @param {string} valueEscaped the escaped value of the property.
+ */
+ ;
+
+ _proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
+ if (!this.raws) {
+ this.raws = {};
+ }
+
+ this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+
+ this.raws[name] = valueEscaped;
+ }
+ /**
+ * When you want a value to passed through to CSS directly. This method
+ * deletes the corresponding raw value causing the stringifier to fallback
+ * to the unescaped value.
+ * @param {string} name the property to set.
+ * @param {any} value The value that is both escaped and unescaped.
+ */
+ ;
+
+ _proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
+ this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+
+ if (this.raws) {
+ delete this.raws[name];
+ }
+ }
+ /**
+ *
+ * @param {number} line The number (starting with 1)
+ * @param {number} column The column number (starting with 1)
+ */
+ ;
+
+ _proto.isAtPosition = function isAtPosition(line, column) {
+ if (this.source && this.source.start && this.source.end) {
+ if (this.source.start.line > line) {
+ return false;
+ }
+
+ if (this.source.end.line < line) {
+ return false;
+ }
+
+ if (this.source.start.line === line && this.source.start.column > column) {
+ return false;
+ }
+
+ if (this.source.end.line === line && this.source.end.column < column) {
+ return false;
+ }
+
+ return true;
+ }
+
+ return undefined;
+ };
+
+ _proto.stringifyProperty = function stringifyProperty(name) {
+ return this.raws && this.raws[name] || this[name];
+ };
+
+ _proto.toString = function toString() {
+ return [this.rawSpaceBefore, String(this.stringifyProperty("value")), this.rawSpaceAfter].join('');
+ };
+
+ _createClass(Node, [{
+ key: "rawSpaceBefore",
+ get: function get() {
+ var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+
+ if (rawSpace === undefined) {
+ rawSpace = this.spaces && this.spaces.before;
+ }
+
+ return rawSpace || "";
+ },
+ set: function set(raw) {
+ (0, _util.ensureObject)(this, "raws", "spaces");
+ this.raws.spaces.before = raw;
+ }
+ }, {
+ key: "rawSpaceAfter",
+ get: function get() {
+ var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+
+ if (rawSpace === undefined) {
+ rawSpace = this.spaces.after;
+ }
+
+ return rawSpace || "";
+ },
+ set: function set(raw) {
+ (0, _util.ensureObject)(this, "raws", "spaces");
+ this.raws.spaces.after = raw;
+ }
+ }]);
+
+ return Node;
+}();
+
+exports.default = Node;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/pseudo.js b/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
new file mode 100644
index 0000000..820338b
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _container = _interopRequireDefault(require("./container"));
+
+var _types = require("./types");
+
+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; }
+
+var Pseudo =
+/*#__PURE__*/
+function (_Container) {
+ _inheritsLoose(Pseudo, _Container);
+
+ function Pseudo(opts) {
+ var _this;
+
+ _this = _Container.call(this, opts) || this;
+ _this.type = _types.PSEUDO;
+ return _this;
+ }
+
+ var _proto = Pseudo.prototype;
+
+ _proto.toString = function toString() {
+ var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
+ return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join('');
+ };
+
+ return Pseudo;
+}(_container.default);
+
+exports.default = Pseudo;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/root.js b/node_modules/postcss-selector-parser/dist/selectors/root.js
new file mode 100644
index 0000000..bbc619f
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/root.js
@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _container = _interopRequireDefault(require("./container"));
+
+var _types = require("./types");
+
+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; }
+
+var Root =
+/*#__PURE__*/
+function (_Container) {
+ _inheritsLoose(Root, _Container);
+
+ function Root(opts) {
+ var _this;
+
+ _this = _Container.call(this, opts) || this;
+ _this.type = _types.ROOT;
+ return _this;
+ }
+
+ var _proto = Root.prototype;
+
+ _proto.toString = function toString() {
+ var str = this.reduce(function (memo, selector) {
+ memo.push(String(selector));
+ return memo;
+ }, []).join(',');
+ return this.trailingComma ? str + ',' : str;
+ };
+
+ _proto.error = function error(message, options) {
+ if (this._error) {
+ return this._error(message, options);
+ } else {
+ return new Error(message);
+ }
+ };
+
+ _createClass(Root, [{
+ key: "errorGenerator",
+ set: function set(handler) {
+ this._error = handler;
+ }
+ }]);
+
+ return Root;
+}(_container.default);
+
+exports.default = Root;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/selector.js b/node_modules/postcss-selector-parser/dist/selectors/selector.js
new file mode 100644
index 0000000..618238b
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/selector.js
@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _container = _interopRequireDefault(require("./container"));
+
+var _types = require("./types");
+
+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; }
+
+var Selector =
+/*#__PURE__*/
+function (_Container) {
+ _inheritsLoose(Selector, _Container);
+
+ function Selector(opts) {
+ var _this;
+
+ _this = _Container.call(this, opts) || this;
+ _this.type = _types.SELECTOR;
+ return _this;
+ }
+
+ return Selector;
+}(_container.default);
+
+exports.default = Selector;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/string.js b/node_modules/postcss-selector-parser/dist/selectors/string.js
new file mode 100644
index 0000000..b8526fa
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/string.js
@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _node = _interopRequireDefault(require("./node"));
+
+var _types = require("./types");
+
+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; }
+
+var String =
+/*#__PURE__*/
+function (_Node) {
+ _inheritsLoose(String, _Node);
+
+ function String(opts) {
+ var _this;
+
+ _this = _Node.call(this, opts) || this;
+ _this.type = _types.STRING;
+ return _this;
+ }
+
+ return String;
+}(_node.default);
+
+exports.default = String;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/tag.js b/node_modules/postcss-selector-parser/dist/selectors/tag.js
new file mode 100644
index 0000000..2d95176
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/tag.js
@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _namespace = _interopRequireDefault(require("./namespace"));
+
+var _types = require("./types");
+
+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; }
+
+var Tag =
+/*#__PURE__*/
+function (_Namespace) {
+ _inheritsLoose(Tag, _Namespace);
+
+ function Tag(opts) {
+ var _this;
+
+ _this = _Namespace.call(this, opts) || this;
+ _this.type = _types.TAG;
+ return _this;
+ }
+
+ return Tag;
+}(_namespace.default);
+
+exports.default = Tag;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/types.js b/node_modules/postcss-selector-parser/dist/selectors/types.js
new file mode 100644
index 0000000..ab897b8
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/types.js
@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.UNIVERSAL = exports.ATTRIBUTE = exports.CLASS = exports.COMBINATOR = exports.COMMENT = exports.ID = exports.NESTING = exports.PSEUDO = exports.ROOT = exports.SELECTOR = exports.STRING = exports.TAG = void 0;
+var TAG = 'tag';
+exports.TAG = TAG;
+var STRING = 'string';
+exports.STRING = STRING;
+var SELECTOR = 'selector';
+exports.SELECTOR = SELECTOR;
+var ROOT = 'root';
+exports.ROOT = ROOT;
+var PSEUDO = 'pseudo';
+exports.PSEUDO = PSEUDO;
+var NESTING = 'nesting';
+exports.NESTING = NESTING;
+var ID = 'id';
+exports.ID = ID;
+var COMMENT = 'comment';
+exports.COMMENT = COMMENT;
+var COMBINATOR = 'combinator';
+exports.COMBINATOR = COMBINATOR;
+var CLASS = 'class';
+exports.CLASS = CLASS;
+var ATTRIBUTE = 'attribute';
+exports.ATTRIBUTE = ATTRIBUTE;
+var UNIVERSAL = 'universal';
+exports.UNIVERSAL = UNIVERSAL;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/selectors/universal.js b/node_modules/postcss-selector-parser/dist/selectors/universal.js
new file mode 100644
index 0000000..c83905e
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/selectors/universal.js
@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _namespace = _interopRequireDefault(require("./namespace"));
+
+var _types = require("./types");
+
+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; }
+
+var Universal =
+/*#__PURE__*/
+function (_Namespace) {
+ _inheritsLoose(Universal, _Namespace);
+
+ function Universal(opts) {
+ var _this;
+
+ _this = _Namespace.call(this, opts) || this;
+ _this.type = _types.UNIVERSAL;
+ _this.value = '*';
+ return _this;
+ }
+
+ return Universal;
+}(_namespace.default);
+
+exports.default = Universal;
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/sortAscending.js b/node_modules/postcss-selector-parser/dist/sortAscending.js
new file mode 100644
index 0000000..7af2fec
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/sortAscending.js
@@ -0,0 +1,13 @@
+"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-selector-parser/dist/tokenTypes.js b/node_modules/postcss-selector-parser/dist/tokenTypes.js
new file mode 100644
index 0000000..48314b9
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/tokenTypes.js
@@ -0,0 +1,95 @@
+"use strict";
+
+exports.__esModule = true;
+exports.combinator = exports.word = exports.comment = exports.str = exports.tab = exports.newline = exports.feed = exports.cr = exports.backslash = exports.bang = exports.slash = exports.doubleQuote = exports.singleQuote = exports.space = exports.greaterThan = exports.pipe = exports.equals = exports.plus = exports.caret = exports.tilde = exports.dollar = exports.closeSquare = exports.openSquare = exports.closeParenthesis = exports.openParenthesis = exports.semicolon = exports.colon = exports.comma = exports.at = exports.asterisk = exports.ampersand = void 0;
+var ampersand = 38; // `&`.charCodeAt(0);
+
+exports.ampersand = ampersand;
+var asterisk = 42; // `*`.charCodeAt(0);
+
+exports.asterisk = asterisk;
+var at = 64; // `@`.charCodeAt(0);
+
+exports.at = at;
+var comma = 44; // `,`.charCodeAt(0);
+
+exports.comma = comma;
+var colon = 58; // `:`.charCodeAt(0);
+
+exports.colon = colon;
+var semicolon = 59; // `;`.charCodeAt(0);
+
+exports.semicolon = semicolon;
+var openParenthesis = 40; // `(`.charCodeAt(0);
+
+exports.openParenthesis = openParenthesis;
+var closeParenthesis = 41; // `)`.charCodeAt(0);
+
+exports.closeParenthesis = closeParenthesis;
+var openSquare = 91; // `[`.charCodeAt(0);
+
+exports.openSquare = openSquare;
+var closeSquare = 93; // `]`.charCodeAt(0);
+
+exports.closeSquare = closeSquare;
+var dollar = 36; // `$`.charCodeAt(0);
+
+exports.dollar = dollar;
+var tilde = 126; // `~`.charCodeAt(0);
+
+exports.tilde = tilde;
+var caret = 94; // `^`.charCodeAt(0);
+
+exports.caret = caret;
+var plus = 43; // `+`.charCodeAt(0);
+
+exports.plus = plus;
+var equals = 61; // `=`.charCodeAt(0);
+
+exports.equals = equals;
+var pipe = 124; // `|`.charCodeAt(0);
+
+exports.pipe = pipe;
+var greaterThan = 62; // `>`.charCodeAt(0);
+
+exports.greaterThan = greaterThan;
+var space = 32; // ` `.charCodeAt(0);
+
+exports.space = space;
+var singleQuote = 39; // `'`.charCodeAt(0);
+
+exports.singleQuote = singleQuote;
+var doubleQuote = 34; // `"`.charCodeAt(0);
+
+exports.doubleQuote = doubleQuote;
+var slash = 47; // `/`.charCodeAt(0);
+
+exports.slash = slash;
+var bang = 33; // `!`.charCodeAt(0);
+
+exports.bang = bang;
+var backslash = 92; // '\\'.charCodeAt(0);
+
+exports.backslash = backslash;
+var cr = 13; // '\r'.charCodeAt(0);
+
+exports.cr = cr;
+var feed = 12; // '\f'.charCodeAt(0);
+
+exports.feed = feed;
+var newline = 10; // '\n'.charCodeAt(0);
+
+exports.newline = newline;
+var tab = 9; // '\t'.charCodeAt(0);
+// Expose aliases primarily for readability.
+
+exports.tab = tab;
+var str = singleQuote; // No good single character representation!
+
+exports.str = str;
+var comment = -1;
+exports.comment = comment;
+var word = -2;
+exports.word = word;
+var combinator = -3;
+exports.combinator = combinator;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/tokenize.js b/node_modules/postcss-selector-parser/dist/tokenize.js
new file mode 100644
index 0000000..e890e9c
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/tokenize.js
@@ -0,0 +1,268 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = tokenize;
+exports.FIELDS = void 0;
+
+var t = _interopRequireWildcard(require("./tokenTypes"));
+
+var _unescapable, _wordDelimiters;
+
+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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
+var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
+var hex = {};
+var hexChars = "0123456789abcdefABCDEF";
+
+for (var i = 0; i < hexChars.length; i++) {
+ hex[hexChars.charCodeAt(i)] = true;
+}
+/**
+ * Returns the last index of the bar css word
+ * @param {string} css The string in which the word begins
+ * @param {number} start The index into the string where word's first letter occurs
+ */
+
+
+function consumeWord(css, start) {
+ var next = start;
+ var code;
+
+ do {
+ code = css.charCodeAt(next);
+
+ if (wordDelimiters[code]) {
+ return next - 1;
+ } else if (code === t.backslash) {
+ next = consumeEscape(css, next) + 1;
+ } else {
+ // All other characters are part of the word
+ next++;
+ }
+ } while (next < css.length);
+
+ return next - 1;
+}
+/**
+ * Returns the last index of the escape sequence
+ * @param {string} css The string in which the sequence begins
+ * @param {number} start The index into the string where escape character (`\`) occurs.
+ */
+
+
+function consumeEscape(css, start) {
+ var next = start;
+ var code = css.charCodeAt(next + 1);
+
+ if (unescapable[code]) {// just consume the escape char
+ } else if (hex[code]) {
+ var hexDigits = 0; // consume up to 6 hex chars
+
+ do {
+ next++;
+ hexDigits++;
+ code = css.charCodeAt(next + 1);
+ } while (hex[code] && hexDigits < 6); // if fewer than 6 hex chars, a trailing space ends the escape
+
+
+ if (hexDigits < 6 && code === t.space) {
+ next++;
+ }
+ } else {
+ // the next char is part of the current word
+ next++;
+ }
+
+ return next;
+}
+
+var FIELDS = {
+ TYPE: 0,
+ START_LINE: 1,
+ START_COL: 2,
+ END_LINE: 3,
+ END_COL: 4,
+ START_POS: 5,
+ END_POS: 6
+};
+exports.FIELDS = FIELDS;
+
+function tokenize(input) {
+ var tokens = [];
+ var css = input.css.valueOf();
+ var _css = css,
+ length = _css.length;
+ var offset = -1;
+ var line = 1;
+ var start = 0;
+ var end = 0;
+ var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
+
+ function unclosed(what, fix) {
+ if (input.safe) {
+ // fyi: this is never set to true.
+ css += fix;
+ next = css.length - 1;
+ } else {
+ throw input.error('Unclosed ' + what, line, start - offset, start);
+ }
+ }
+
+ while (start < length) {
+ code = css.charCodeAt(start);
+
+ if (code === t.newline) {
+ offset = start;
+ line += 1;
+ }
+
+ switch (code) {
+ case t.space:
+ case t.tab:
+ case t.newline:
+ case t.cr:
+ case t.feed:
+ next = start;
+
+ do {
+ next += 1;
+ code = css.charCodeAt(next);
+
+ if (code === t.newline) {
+ offset = next;
+ line += 1;
+ }
+ } while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
+
+ tokenType = t.space;
+ endLine = line;
+ endColumn = next - offset - 1;
+ end = next;
+ break;
+
+ case t.plus:
+ case t.greaterThan:
+ case t.tilde:
+ case t.pipe:
+ next = start;
+
+ do {
+ next += 1;
+ code = css.charCodeAt(next);
+ } while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
+
+ tokenType = t.combinator;
+ endLine = line;
+ endColumn = start - offset;
+ end = next;
+ break;
+ // Consume these characters as single tokens.
+
+ case t.asterisk:
+ case t.ampersand:
+ case t.bang:
+ case t.comma:
+ case t.equals:
+ case t.dollar:
+ case t.caret:
+ case t.openSquare:
+ case t.closeSquare:
+ case t.colon:
+ case t.semicolon:
+ case t.openParenthesis:
+ case t.closeParenthesis:
+ next = start;
+ tokenType = code;
+ endLine = line;
+ endColumn = start - offset;
+ end = next + 1;
+ break;
+
+ case t.singleQuote:
+ case t.doubleQuote:
+ quote = code === t.singleQuote ? "'" : '"';
+ next = start;
+
+ do {
+ escaped = false;
+ next = css.indexOf(quote, next + 1);
+
+ if (next === -1) {
+ unclosed('quote', quote);
+ }
+
+ escapePos = next;
+
+ while (css.charCodeAt(escapePos - 1) === t.backslash) {
+ escapePos -= 1;
+ escaped = !escaped;
+ }
+ } while (escaped);
+
+ tokenType = t.str;
+ endLine = line;
+ endColumn = start - offset;
+ end = next + 1;
+ break;
+
+ default:
+ if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
+ next = css.indexOf('*/', start + 2) + 1;
+
+ if (next === 0) {
+ unclosed('comment', '*/');
+ }
+
+ content = css.slice(start, 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;
+ }
+
+ tokenType = t.comment;
+ line = nextLine;
+ endLine = nextLine;
+ endColumn = next - nextOffset;
+ } else if (code === t.slash) {
+ next = start;
+ tokenType = code;
+ endLine = line;
+ endColumn = start - offset;
+ end = next + 1;
+ } else {
+ next = consumeWord(css, start);
+ tokenType = t.word;
+ endLine = line;
+ endColumn = next - offset;
+ }
+
+ end = next + 1;
+ break;
+ } // Ensure that the token structure remains consistent
+
+
+ tokens.push([tokenType, // [0] Token type
+ line, // [1] Starting line
+ start - offset, // [2] Starting column
+ endLine, // [3] Ending line
+ endColumn, // [4] Ending column
+ start, // [5] Start position / Source index
+ end]); // Reset offset for the next token
+
+ if (nextOffset) {
+ offset = nextOffset;
+ nextOffset = null;
+ }
+
+ start = end;
+ }
+
+ return tokens;
+}
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/util/ensureObject.js b/node_modules/postcss-selector-parser/dist/util/ensureObject.js
new file mode 100644
index 0000000..548b107
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/util/ensureObject.js
@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = ensureObject;
+
+function ensureObject(obj) {
+ for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ props[_key - 1] = arguments[_key];
+ }
+
+ while (props.length > 0) {
+ var prop = props.shift();
+
+ if (!obj[prop]) {
+ obj[prop] = {};
+ }
+
+ obj = obj[prop];
+ }
+}
+
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/util/getProp.js b/node_modules/postcss-selector-parser/dist/util/getProp.js
new file mode 100644
index 0000000..fd44505
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/util/getProp.js
@@ -0,0 +1,24 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = getProp;
+
+function getProp(obj) {
+ for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ props[_key - 1] = arguments[_key];
+ }
+
+ while (props.length > 0) {
+ var prop = props.shift();
+
+ if (!obj[prop]) {
+ return undefined;
+ }
+
+ obj = obj[prop];
+ }
+
+ return obj;
+}
+
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/util/index.js b/node_modules/postcss-selector-parser/dist/util/index.js
new file mode 100644
index 0000000..d7a37bd
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/util/index.js
@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.stripComments = exports.ensureObject = exports.getProp = exports.unesc = void 0;
+
+var _unesc = _interopRequireDefault(require("./unesc"));
+
+exports.unesc = _unesc.default;
+
+var _getProp = _interopRequireDefault(require("./getProp"));
+
+exports.getProp = _getProp.default;
+
+var _ensureObject = _interopRequireDefault(require("./ensureObject"));
+
+exports.ensureObject = _ensureObject.default;
+
+var _stripComments = _interopRequireDefault(require("./stripComments"));
+
+exports.stripComments = _stripComments.default;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/util/stripComments.js b/node_modules/postcss-selector-parser/dist/util/stripComments.js
new file mode 100644
index 0000000..7f4defe
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/util/stripComments.js
@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = stripComments;
+
+function stripComments(str) {
+ var s = "";
+ var commentStart = str.indexOf("/*");
+ var lastEnd = 0;
+
+ while (commentStart >= 0) {
+ s = s + str.slice(lastEnd, commentStart);
+ var commentEnd = str.indexOf("*/", commentStart + 2);
+
+ if (commentEnd < 0) {
+ return s;
+ }
+
+ lastEnd = commentEnd + 2;
+ commentStart = str.indexOf("/*", lastEnd);
+ }
+
+ s = s + str.slice(lastEnd);
+ return s;
+}
+
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/dist/util/unesc.js b/node_modules/postcss-selector-parser/dist/util/unesc.js
new file mode 100644
index 0000000..ae12869
--- /dev/null
+++ b/node_modules/postcss-selector-parser/dist/util/unesc.js
@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = unesc;
+var whitespace = '[\\x20\\t\\r\\n\\f]';
+var unescapeRegExp = new RegExp('\\\\([\\da-f]{1,6}' + whitespace + '?|(' + whitespace + ')|.)', 'ig');
+
+function unesc(str) {
+ return str.replace(unescapeRegExp, function (_, escaped, escapedWhitespace) {
+ var high = '0x' + escaped - 0x10000; // NaN means non-codepoint
+ // Workaround erroneous numeric interpretation of +"0x"
+ // eslint-disable-next-line no-self-compare
+
+ return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint
+ String.fromCharCode(high + 0x10000) : // Supplemental Plane codepoint (surrogate pair)
+ String.fromCharCode(high >> 10 | 0xd800, high & 0x3ff | 0xdc00);
+ });
+}
+
+module.exports = exports.default;
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/package.json b/node_modules/postcss-selector-parser/package.json
new file mode 100644
index 0000000..8f46271
--- /dev/null
+++ b/node_modules/postcss-selector-parser/package.json
@@ -0,0 +1,76 @@
+{
+ "ava": {
+ "concurrency": 5,
+ "require": [
+ "@babel/register"
+ ]
+ },
+ "contributors": [
+ {
+ "email": "beneb.info@gmail.com",
+ "name": "Ben Briggs",
+ "url": "http://beneb.info"
+ },
+ {
+ "email": "chris@eppsteins.net",
+ "name": "Chris Eppstein",
+ "url": "http://twitter.com/chriseppstein"
+ }
+ ],
+ "dependencies": {
+ "cssesc": "^3.0.0",
+ "indexes-of": "^1.0.1",
+ "uniq": "^1.0.1"
+ },
+ "devDependencies": {
+ "@babel/cli": "^7.2.3",
+ "@babel/core": "^7.3.4",
+ "@babel/plugin-proposal-class-properties": "^7.3.4",
+ "@babel/preset-env": "^7.3.4",
+ "@babel/register": "^7.0.0",
+ "ava": "^1.3.1",
+ "babel-eslint": "^10.0.1",
+ "babel-plugin-add-module-exports": "^1.0.0",
+ "coveralls": "^3.0.3",
+ "del-cli": "^1.1.0",
+ "eslint": "^5.15.1",
+ "eslint-plugin-babel": "^5.3.0",
+ "eslint-plugin-import": "^2.16.0",
+ "glob": "^7.1.3",
+ "minimist": "^1.2.0",
+ "nyc": "^13.3.0",
+ "postcss": "^7.0.14",
+ "semver": "^5.6.0"
+ },
+ "engines": {
+ "node": ">=4"
+ },
+ "files": [
+ "API.md",
+ "CHANGELOG.md",
+ "LICENSE-MIT",
+ "dist",
+ "postcss-selector-parser.d.ts"
+ ],
+ "homepage": "https://github.com/postcss/postcss-selector-parser",
+ "license": "MIT",
+ "main": "dist/index.js",
+ "name": "postcss-selector-parser",
+ "nyc": {
+ "exclude": [
+ "node_modules",
+ "**/__tests__"
+ ]
+ },
+ "repository": "postcss/postcss-selector-parser",
+ "scripts": {
+ "lintfix": "eslint --fix src",
+ "prepare": "del-cli dist && BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/",
+ "pretest": "eslint src",
+ "report": "nyc report --reporter=html",
+ "test": "nyc ava src/__tests__/*.js",
+ "testone": "ava"
+ },
+ "types": "postcss-selector-parser.d.ts",
+ "version": "6.0.2"
+}
\ No newline at end of file
diff --git a/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts b/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
new file mode 100644
index 0000000..52bdb77
--- /dev/null
+++ b/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
@@ -0,0 +1,499 @@
+// Type definitions for postcss-selector-parser 2.2.3
+// Definitions by: Chris Eppstein <chris@eppsteins.net>
+
+/*~ Note that ES6 modules cannot directly export callable functions.
+ *~ This file should be imported using the CommonJS-style:
+ *~ import x = require('someLibrary');
+ *~
+ *~ Refer to the documentation to understand common
+ *~ workarounds for this limitation of ES6 modules.
+ */
+
+/*~ This declaration specifies that the function
+ *~ is the exported object from the file
+ */
+export = parser;
+
+// TODO: Conditional types in TS 1.8 will really clean this up.
+declare function parser(): parser.Processor<never>;
+declare function parser<Transform>(processor: parser.AsyncProcessor<Transform>): parser.Processor<Transform, never>;
+declare function parser(processor: parser.AsyncProcessor<void>): parser.Processor<never, never>;
+declare function parser<Transform>(processor: parser.SyncProcessor<Transform>): parser.Processor<Transform>;
+declare function parser(processor: parser.SyncProcessor<void>): parser.Processor<never>;
+declare function parser<Transform>(processor?: parser.SyncProcessor<Transform> | parser.AsyncProcessor<Transform>): parser.Processor<Transform>;
+
+/*~ If you want to expose types from your module as well, you can
+ *~ place them in this block. Often you will want to describe the
+ *~ shape of the return type of the function; that type should
+ *~ be declared in here, as this example shows.
+ */
+declare namespace parser {
+ /* copied from postcss -- so we don't need to add a dependency */
+ type ErrorOptions = {
+ plugin?: string;
+ word?: string;
+ index?: number
+ };
+ /* the bits we use of postcss.Rule, copied from postcss -- so we don't need to add a dependency */
+ type PostCSSRuleNode = {
+ selector: string
+ /**
+ * @returns postcss.CssSyntaxError but it's a complex object, caller
+ * should cast to it if they have a dependency on postcss.
+ */
+ error(message: string, options?: ErrorOptions): Error;
+ };
+ /** Accepts a string */
+ type Selectors = string | PostCSSRuleNode
+ type ProcessorFn<ReturnType = void> = (root: parser.Root) => ReturnType;
+ type SyncProcessor<Transform = void> = ProcessorFn<Transform>;
+ type AsyncProcessor<Transform = void> = ProcessorFn<PromiseLike<Transform>>;
+
+ const TAG: "tag";
+ const STRING: "string";
+ const SELECTOR: "selector";
+ const ROOT: "root";
+ const PSEUDO: "pseudo";
+ const NESTING: "nesting";
+ const ID: "id";
+ const COMMENT: "comment";
+ const COMBINATOR: "combinator";
+ const CLASS: "class";
+ const ATTRIBUTE: "attribute";
+ const UNIVERSAL: "universal";
+
+ interface NodeTypes {
+ tag: Tag,
+ string: String,
+ selector: Selector,
+ root: Root,
+ pseudo: Pseudo,
+ nesting: Nesting,
+ id: Identifier,
+ comment: Comment,
+ combinator: Combinator,
+ class: ClassName,
+ attribute: Attribute,
+ universal: Universal
+ }
+
+ type Node = NodeTypes[keyof NodeTypes];
+
+ function isNode(node: any): node is Node;
+
+ interface Options {
+ /**
+ * Preserve whitespace when true. Default: false;
+ */
+ lossless: boolean;
+ /**
+ * When true and a postcss.Rule is passed, set the result of
+ * processing back onto the rule when done. Default: false.
+ */
+ updateSelector: boolean;
+ }
+ class Processor<
+ TransformType = never,
+ SyncSelectorsType extends Selectors | never = Selectors
+ > {
+ res: Root;
+ readonly result: String;
+ ast(selectors: Selectors, options?: Partial<Options>): Promise<Root>;
+ astSync(selectors: SyncSelectorsType, options?: Partial<Options>): Root;
+ transform(selectors: Selectors, options?: Partial<Options>): Promise<TransformType>;
+ transformSync(selectors: SyncSelectorsType, options?: Partial<Options>): TransformType;
+ process(selectors: Selectors, options?: Partial<Options>): Promise<string>;
+ processSync(selectors: SyncSelectorsType, options?: Partial<Options>): string;
+ }
+ interface ParserOptions {
+ css: string;
+ error: (message: string, options: ErrorOptions) => Error;
+ options: Options;
+ }
+ class Parser {
+ input: ParserOptions;
+ lossy: boolean;
+ position: number;
+ root: Root;
+ selectors: string;
+ current: Selector;
+ constructor(input: ParserOptions);
+ /**
+ * Raises an error, if the processor is invoked on
+ * a postcss Rule node, a better error message is raised.
+ */
+ error(message: string, options?: ErrorOptions): void;
+ }
+ interface NodeSource {
+ start?: {
+ line: number,
+ column: number
+ },
+ end?: {
+ line: number,
+ column: number
+ }
+ }
+ interface SpaceAround {
+ before: string;
+ after: string;
+ }
+ interface Spaces extends SpaceAround {
+ [spaceType: string]: string | Partial<SpaceAround> | undefined;
+ }
+ interface NodeOptions<Value = string> {
+ value: Value;
+ spaces?: Partial<Spaces>;
+ source?: NodeSource;
+ sourceIndex?: number;
+ }
+ interface Base<
+ Value extends string | undefined = string,
+ ParentType extends Container | undefined = Container | undefined
+ > {
+ type: keyof NodeTypes;
+ parent: ParentType;
+ value: Value;
+ spaces: Spaces;
+ source?: NodeSource;
+ sourceIndex: number;
+ rawSpaceBefore: string;
+ rawSpaceAfter: string;
+ remove(): Node;
+ replaceWith(...nodes: Node[]): Node;
+ next(): Node;
+ prev(): Node;
+ clone(opts: {[override: string]:any}): Node;
+ /**
+ * Return whether this node includes the character at the position of the given line and column.
+ * Returns undefined if the nodes lack sufficient source metadata to determine the position.
+ * @param line 1-index based line number relative to the start of the selector.
+ * @param column 1-index based column number relative to the start of the selector.
+ */
+ isAtPosition(line: number, column: number): boolean | undefined;
+ /**
+ * Some non-standard syntax doesn't follow normal escaping rules for css,
+ * this allows the escaped value to be specified directly, allowing illegal characters to be
+ * directly inserted into css output.
+ * @param name the property to set
+ * @param value the unescaped value of the property
+ * @param valueEscaped optional. the escaped value of the property.
+ */
+ setPropertyAndEscape(name: string, value: any, valueEscaped: string): void;
+ /**
+ * When you want a value to passed through to CSS directly. This method
+ * deletes the corresponding raw value causing the stringifier to fallback
+ * to the unescaped value.
+ * @param name the property to set.
+ * @param value The value that is both escaped and unescaped.
+ */
+ setPropertyWithoutEscape(name: string, value: any): void;
+ /**
+ * Some non-standard syntax doesn't follow normal escaping rules for css.
+ * This allows non standard syntax to be appended to an existing property
+ * by specifying the escaped value. By specifying the escaped value,
+ * illegal characters are allowed to be directly inserted into css output.
+ * @param {string} name the property to set
+ * @param {any} value the unescaped value of the property
+ * @param {string} valueEscaped optional. the escaped value of the property.
+ */
+ appendToPropertyAndEscape(name: string, value: any, valueEscaped: string): void;
+ toString(): string;
+ }
+ interface ContainerOptions extends NodeOptions {
+ nodes?: Array<Node>;
+ }
+ interface Container<Value extends string | undefined = string> extends Base<Value> {
+ nodes: Array<Node>;
+ append(selector: Selector): Container;
+ prepend(selector: Selector): Container;
+ at(index: number): Node;
+ /**
+ * Return the most specific node at the line and column number given.
+ * The source location is based on the original parsed location, locations aren't
+ * updated as selector nodes are mutated.
+ *
+ * Note that this location is relative to the location of the first character
+ * of the selector, and not the location of the selector in the overall document
+ * when used in conjunction with postcss.
+ *
+ * If not found, returns undefined.
+ * @param line The line number of the node to find. (1-based index)
+ * @param col The column number of the node to find. (1-based index)
+ */
+ atPosition(line: number, column: number): Node;
+ index(child: Node): number;
+ readonly first: Node;
+ readonly last: Node;
+ readonly length: number;
+ removeChild(child: Node): Container;
+ removeAll(): Container;
+ empty(): Container;
+ insertAfter(oldNode: Node, newNode: Node): Container;
+ insertBefore(oldNode: Node, newNode: Node): Container;
+ each(callback: (node: Node) => boolean | void): boolean | undefined;
+ walk(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkAttributes(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkClasses(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkCombinators(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkComments(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkIds(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkNesting(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkPseudos(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkTags(callback: (node: Node) => boolean | void): boolean | undefined;
+ split(callback: (node: Node) => boolean): [Node[], Node[]];
+ map(callback: (node: Node) => Node): Node[];
+ reduce<T>(callback: (node: Node) => Node, memo: T): T;
+ every(callback: (node: Node) => boolean): boolean;
+ some(callback: (node: Node) => boolean): boolean;
+ filter(callback: (node: Node) => boolean): Node[];
+ sort(callback: (nodeA: Node, nodeB: Node) => number): Node[];
+ toString(): string;
+ }
+ function isContainer(node: any): node is Root | Selector | Pseudo;
+
+ interface NamespaceOptions<Value extends string | undefined = string> extends NodeOptions<Value> {
+ namespace?: string | true;
+ }
+ interface Namespace<Value extends string | undefined = string> extends Base<Value> {
+ /** alias for namespace */
+ ns: string | true;
+ /**
+ * namespace prefix.
+ */
+ namespace: string | true;
+ /**
+ * If a namespace exists, prefix the value provided with it, separated by |.
+ */
+ qualifiedName(value: string): string;
+ /**
+ * A string representing the namespace suitable for output.
+ */
+ readonly namespaceString: string;
+ }
+ function isNamespace(node: any): node is Attribute | Tag;
+
+ interface Root extends Container<undefined> {
+ type: "root";
+ /**
+ * Raises an error, if the processor is invoked on
+ * a postcss Rule node, a better error message is raised.
+ */
+ error(message: string, options?: ErrorOptions): Error;
+ nodeAt(line: number, column: number): Node
+ }
+ function root(opts: ContainerOptions): Root;
+ function isRoot(node: any): node is Root;
+
+ interface Selector extends Container {
+ type: "selector";
+ }
+ function selector(opts: ContainerOptions): Selector;
+ function isSelector(node: any): node is Selector;
+
+ interface Combinator extends Base {
+ type: "combinator"
+ }
+ function combinator(opts: NodeOptions): Combinator;
+ function isCombinator(node: any): node is Combinator;
+
+ interface ClassName extends Base {
+ type: "class";
+ }
+ function className(opts: NamespaceOptions): ClassName;
+ function isClassName(node: any): node is ClassName;
+
+ type AttributeOperator = "=" | "~=" | "|=" | "^=" | "$=" | "*=";
+ type QuoteMark = '"' | "'" | null;
+ interface PreferredQuoteMarkOptions {
+ quoteMark?: QuoteMark;
+ preferCurrentQuoteMark?: boolean;
+ }
+ interface SmartQuoteMarkOptions extends PreferredQuoteMarkOptions {
+ smart?: boolean;
+ }
+ interface AttributeOptions extends NamespaceOptions<string | undefined> {
+ attribute: string;
+ operator?: AttributeOperator;
+ insensitive?: boolean;
+ quoteMark?: QuoteMark;
+ /** @deprecated Use quoteMark instead. */
+ quoted?: boolean;
+ spaces?: {
+ before?: string;
+ after?: string;
+ attribute?: Partial<SpaceAround>;
+ operator?: Partial<SpaceAround>;
+ value?: Partial<SpaceAround>;
+ insensitive?: Partial<SpaceAround>;
+ }
+ raws: {
+ unquoted?: string;
+ attribute?: string;
+ operator?: string;
+ value?: string;
+ insensitive?: string;
+ spaces?: {
+ attribute?: Partial<Spaces>;
+ operator?: Partial<Spaces>;
+ value?: Partial<Spaces>;
+ insensitive?: Partial<Spaces>;
+ }
+ };
+ }
+ interface Attribute extends Namespace<string | undefined> {
+ type: "attribute";
+ attribute: string;
+ operator?: AttributeOperator;
+ insensitive?: boolean;
+ quoteMark: QuoteMark;
+ quoted?: boolean;
+ spaces: {
+ before: string;
+ after: string;
+ attribute?: Partial<Spaces>;
+ operator?: Partial<Spaces>;
+ value?: Partial<Spaces>;
+ insensitive?: Partial<Spaces>;
+ }
+ raws: {
+ /** @deprecated The attribute value is unquoted, use that instead.. */
+ unquoted?: string;
+ attribute?: string;
+ operator?: string;
+ /** The value of the attribute with quotes and escapes. */
+ value?: string;
+ insensitive?: string;
+ spaces?: {
+ attribute?: Partial<Spaces>;
+ operator?: Partial<Spaces>;
+ value?: Partial<Spaces>;
+ insensitive?: Partial<Spaces>;
+ }
+ };
+ /**
+ * The attribute name after having been qualified with a namespace.
+ */
+ readonly qualifiedAttribute: string;
+
+ /**
+ * The case insensitivity flag or an empty string depending on whether this
+ * attribute is case insensitive.
+ */
+ readonly insensitiveFlag : 'i' | '';
+
+ /**
+ * Returns the attribute's value quoted such that it would be legal to use
+ * in the value of a css file. The original value's quotation setting
+ * used for stringification is left unchanged. See `setValue(value, options)`
+ * if you want to control the quote settings of a new value for the attribute or
+ * `set quoteMark(mark)` if you want to change the quote settings of the current
+ * value.
+ *
+ * You can also change the quotation used for the current value by setting quoteMark.
+ **/
+ getQuotedValue(options?: SmartQuoteMarkOptions): string;
+
+ /**
+ * Set the unescaped value with the specified quotation options. The value
+ * provided must not include any wrapping quote marks -- those quotes will
+ * be interpreted as part of the value and escaped accordingly.
+ * @param value
+ */
+ setValue(value: string, options?: SmartQuoteMarkOptions): void;
+
+ /**
+ * Intelligently select a quoteMark value based on the value's contents. If
+ * the value is a legal CSS ident, it will not be quoted. Otherwise a quote
+ * mark will be picked that minimizes the number of escapes.
+ *
+ * If there's no clear winner, the quote mark from these options is used,
+ * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
+ * true). If the quoteMark is unspecified, a double quote is used.
+ **/
+ smartQuoteMark(options: PreferredQuoteMarkOptions): QuoteMark;
+
+ /**
+ * Selects the preferred quote mark based on the options and the current quote mark value.
+ * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
+ * instead.
+ */
+ preferredQuoteMark(options: PreferredQuoteMarkOptions): QuoteMark
+
+ /**
+ * returns the offset of the attribute part specified relative to the
+ * start of the node of the output string.
+ *
+ * * "ns" - alias for "namespace"
+ * * "namespace" - the namespace if it exists.
+ * * "attribute" - the attribute name
+ * * "attributeNS" - the start of the attribute or its namespace
+ * * "operator" - the match operator of the attribute
+ * * "value" - The value (string or identifier)
+ * * "insensitive" - the case insensitivity flag;
+ * @param part One of the possible values inside an attribute.
+ * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
+ */
+ offsetOf(part: "ns" | "namespace" | "attribute" | "attributeNS" | "operator" | "value" | "insensitive"): number;
+ }
+ function attribute(opts: AttributeOptions): Attribute;
+ function isAttribute(node: any): node is Attribute;
+
+ interface Pseudo extends Container {
+ type: "pseudo";
+ }
+ function pseudo(opts: ContainerOptions): Pseudo;
+ /**
+ * Checks wether the node is the Psuedo subtype of node.
+ */
+ function isPseudo(node: any): node is Pseudo;
+
+ /**
+ * Checks wether the node is, specifically, a pseudo element instead of
+ * pseudo class.
+ */
+ function isPseudoElement(node: any): node is Pseudo;
+
+ /**
+ * Checks wether the node is, specifically, a pseudo class instead of
+ * pseudo element.
+ */
+ function isPseudoClass(node: any): node is Pseudo;
+
+
+ interface Tag extends Namespace {
+ type: "tag";
+ }
+ function tag(opts: NamespaceOptions): Tag;
+ function isTag(node: any): node is Tag;
+
+ interface Comment extends Base {
+ type: "comment";
+ }
+ function comment(opts: NodeOptions): Comment;
+ function isComment(node: any): node is Comment;
+
+ interface Identifier extends Base {
+ type: "id";
+ }
+ function id(opts: any): any;
+ function isIdentifier(node: any): node is Identifier;
+
+ interface Nesting extends Base {
+ type: "nesting";
+ }
+ function nesting(opts: any): any;
+ function isNesting(node: any): node is Nesting;
+
+ interface String extends Base {
+ type: "string";
+ }
+ function string(opts: NodeOptions): String;
+ function isString(node: any): node is String;
+
+ interface Universal extends Base {
+ type: "universal";
+ }
+ function universal(opts?: NamespaceOptions): any;
+ function isUniversal(node: any): node is Universal;
+}