From 26105034da4fcce7ac883c899d781f016559310d Mon Sep 17 00:00:00 2001 From: ruki Date: Thu, 8 Nov 2018 00:38:48 +0800 Subject: switch to vuepress --- node_modules/postcss-selector-parser/API.md | 624 ++++++++++++++++++++ node_modules/postcss-selector-parser/CHANGELOG.md | 157 +++++ node_modules/postcss-selector-parser/LICENSE-MIT | 22 + node_modules/postcss-selector-parser/README.md | 46 ++ node_modules/postcss-selector-parser/dist/index.js | 114 ++++ .../postcss-selector-parser/dist/parser.js | 643 +++++++++++++++++++++ .../postcss-selector-parser/dist/processor.js | 49 ++ .../dist/selectors/attribute.js | 54 ++ .../dist/selectors/className.js | 39 ++ .../dist/selectors/combinator.js | 35 ++ .../dist/selectors/comment.js | 35 ++ .../dist/selectors/container.js | 338 +++++++++++ .../postcss-selector-parser/dist/selectors/id.js | 39 ++ .../dist/selectors/namespace.js | 45 ++ .../dist/selectors/nesting.js | 36 ++ .../postcss-selector-parser/dist/selectors/node.js | 102 ++++ .../dist/selectors/pseudo.js | 40 ++ .../postcss-selector-parser/dist/selectors/root.js | 43 ++ .../dist/selectors/selector.js | 35 ++ .../dist/selectors/string.js | 35 ++ .../postcss-selector-parser/dist/selectors/tag.js | 35 ++ .../dist/selectors/types.js | 15 + .../dist/selectors/universal.js | 36 ++ .../postcss-selector-parser/dist/sortAscending.js | 10 + .../postcss-selector-parser/dist/tokenize.js | 231 ++++++++ node_modules/postcss-selector-parser/package.json | 64 ++ 26 files changed, 2922 insertions(+) create mode 100644 node_modules/postcss-selector-parser/API.md create mode 100644 node_modules/postcss-selector-parser/CHANGELOG.md create mode 100644 node_modules/postcss-selector-parser/LICENSE-MIT create mode 100644 node_modules/postcss-selector-parser/README.md create mode 100644 node_modules/postcss-selector-parser/dist/index.js create mode 100644 node_modules/postcss-selector-parser/dist/parser.js create mode 100644 node_modules/postcss-selector-parser/dist/processor.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/attribute.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/className.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/combinator.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/comment.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/container.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/id.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/namespace.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/nesting.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/node.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/pseudo.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/root.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/selector.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/string.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/tag.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/types.js create mode 100644 node_modules/postcss-selector-parser/dist/selectors/universal.js create mode 100644 node_modules/postcss-selector-parser/dist/sortAscending.js create mode 100644 node_modules/postcss-selector-parser/dist/tokenize.js create mode 100644 node_modules/postcss-selector-parser/package.json (limited to 'node_modules/postcss-selector-parser') diff --git a/node_modules/postcss-selector-parser/API.md b/node_modules/postcss-selector-parser/API.md new file mode 100644 index 00000000..3386d547 --- /dev/null +++ b/node_modules/postcss-selector-parser/API.md @@ -0,0 +1,624 @@ +# API Documentation + +*Please use only this documented API when working with the parser. Methods +not documented here are subject to change at any point.* + +## `parser` function + +This is the module's main entry point. + +```js +var parser = require('postcss-selector-parser'); +``` + +### `parser([transform])` + +Creates a new `processor` instance + +```js +var processor = parser(); + +// or, with optional transform function +var transform = function (selectors) { + selectors.eachUniversal(function (selector) { + selector.remove(); + }); +}; + +var processor = parser(transform) + +// Example +var result = processor.process('*.class').result; +// => .class +``` + +[See processor documentation](#processor) + +Arguments: + +* `transform (function)`: Provide a function to work with the parsed AST. + +### `parser.attribute([props])` + +Creates a new attribute selector. + +```js +parser.attribute({attribute: 'href'}); +// => [href] +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.className([props])` + +Creates a new class selector. + +```js +parser.className({value: 'button'}); +// => .button +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.combinator([props])` + +Creates a new selector combinator. + +```js +parser.combinator({value: '+'}); +// => + +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.comment([props])` + +Creates a new comment. + +```js +parser.comment({value: '/* Affirmative, Dave. I read you. */'}); +// => /* Affirmative, Dave. I read you. */ +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.id([props])` + +Creates a new id selector. + +```js +parser.id({value: 'search'}); +// => #search +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.nesting([props])` + +Creates a new nesting selector. + +```js +parser.nesting(); +// => & +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.pseudo([props])` + +Creates a new pseudo selector. + +```js +parser.pseudo({value: '::before'}); +// => ::before +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.root([props])` + +Creates a new root node. + +```js +parser.root(); +// => (empty) +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.selector([props])` + +Creates a new selector node. + +```js +parser.selector(); +// => (empty) +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.string([props])` + +Creates a new string node. + +```js +parser.string(); +// => (empty) +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.tag([props])` + +Creates a new tag selector. + +```js +parser.tag({value: 'button'}); +// => button +``` + +Arguments: + +* `props (object)`: The new node's properties. + +### `parser.universal([props])` + +Creates a new universal selector. + +```js +parser.universal(); +// => * +``` + +Arguments: + +* `props (object)`: The new node's properties. + +## Node types + +### `node.type` + +A string representation of the selector type. It can be one of the following; +`attribute`, `class`, `combinator`, `comment`, `id`, `nesting`, `pseudo`, +`root`, `selector`, `string`, `tag`, or `universal`. Note that for convenience, +these constants are exposed on the main `parser` as uppercased keys. So for +example you can get `id` by querying `parser.ID`. + +```js +parser.attribute({attribute: 'href'}).type; +// => 'attribute' +``` + +### `node.parent` + +Returns the parent node. + +```js +root.nodes[0].parent === root; +``` + +### `node.toString()`, `String(node)`, or `'' + node` + +Returns a string representation of the node. + +```js +var id = parser.id({value: 'search'}); +console.log(String(id)); +// => #search +``` + +### `node.next()` & `node.prev()` + +Returns the next/previous child of the parent node. + +```js +var next = id.next(); +if (next && next.type !== 'combinator') { + throw new Error('Qualified IDs are not allowed!'); +} +``` + +### `node.replaceWith(node)` + +Replace a node with another. + +```js +var attr = selectors.first.first; +var className = parser.className({value: 'test'}); +attr.replaceWith(className); +``` + +Arguments: + +* `node`: The node to substitute the original with. + +### `node.remove()` + +Removes the node from its parent node. + +```js +if (node.type === 'id') { + node.remove(); +} +``` + +### `node.clone()` + +Returns a copy of a node, detached from any parent containers that the +original might have had. + +```js +var cloned = parser.id({value: 'search'}); +String(cloned); + +// => #search +``` + +### `node.spaces` + +Extra whitespaces around the node will be moved into `node.spaces.before` and +`node.spaces.after`. So for example, these spaces will be moved as they have +no semantic meaning: + +```css + h1 , h2 {} +``` + +However, *combinating* spaces will form a `combinator` node: + +```css +h1 h2 {} +``` + +A `combinator` node may only have the `spaces` property set if the combinator +value is a non-whitespace character, such as `+`, `~` or `>`. Otherwise, the +combinator value will contain all of the spaces between selectors. + +### `node.source` + +An object describing the node's start/end, line/column source position. + +Within the following CSS, the `.bar` class node ... + +```css +.foo, + .bar {} +``` + +... will contain the following `source` object. + +```js +source: { + start: { + line: 2, + column: 3 + }, + end: { + line: 2, + column: 6 + } +} +``` + +### `node.sourceIndex` + +The zero-based index of the node within the original source string. + +Within the following CSS, the `.baz` class node will have a `sourceIndex` of `12`. + +```css +.foo, .bar, .baz {} +``` + +## Container types + +The `root`, `selector`, and `pseudo` nodes have some helper methods for working +with their children. + +### `container.nodes` + +An array of the container's children. + +```js +// Input: h1 h2 +selectors.at(0).nodes.length // => 3 +selectors.at(0).nodes[0].value // => 'h1' +selectors.at(0).nodes[1].value // => ' ' +``` + +### `container.first` & `container.last` + +The first/last child of the container. + +```js +selector.first === selector.nodes[0]; +selector.last === selector.nodes[selector.nodes.length - 1]; +``` + +### `container.at(index)` + +Returns the node at position `index`. + +```js +selector.at(0) === selector.first; +selector.at(0) === selector.nodes[0]; +``` + +Arguments: + +* `index`: The index of the node to return. + +### `container.index(node)` + +Return the index of the node within its container. + +```js +selector.index(selector.nodes[2]) // => 2 +``` + +Arguments: + +* `node`: A node within the current container. + +### `container.length` + +Proxy to the length of the container's nodes. + +```js +container.length === container.nodes.length +``` + +### `container` Array iterators + +The container class provides proxies to certain Array methods; these are: + +* `container.map === container.nodes.map` +* `container.reduce === container.nodes.reduce` +* `container.every === container.nodes.every` +* `container.some === container.nodes.some` +* `container.filter === container.nodes.filter` +* `container.sort === container.nodes.sort` + +Note that these methods only work on a container's immediate children; recursive +iteration is provided by `container.walk`. + +### `container.each(callback)` + +Iterate the container's immediate children, calling `callback` for each child. +You may return `false` within the callback to break the iteration. + +```js +var className; +selectors.each(function (selector, index) { + if (selector.type === 'class') { + className = selector.value; + return false; + } +}); +``` + +Note that unlike `Array#forEach()`, this iterator is safe to use whilst adding +or removing nodes from the container. + +Arguments: + +* `callback (function)`: A function to call for each node, which receives `node` + and `index` arguments. + +### `container.walk(callback)` + +Like `container#each`, but will also iterate child nodes as long as they are +`container` types. + +```js +selectors.walk(function (selector, index) { + // all nodes +}); +``` + +Arguments: + +* `callback (function)`: A function to call for each node, which receives `node` + and `index` arguments. + +This iterator is safe to use whilst mutating `container.nodes`, +like `container#each`. + +### `container.walk` proxies + +The container class provides proxy methods for iterating over types of nodes, +so that it is easier to write modules that target specific selectors. Those +methods are: + +* `container.walkAttributes` +* `container.walkClasses` +* `container.walkCombinators` +* `container.walkComments` +* `container.walkIds` +* `container.walkNesting` +* `container.walkPseudos` +* `container.walkTags` +* `container.walkUniversals` + +### `container.split(callback)` + +This method allows you to split a group of nodes by returning `true` from +a callback. It returns an array of arrays, where each inner array corresponds +to the groups that you created via the callback. + +```js +// (input) => h1 h2>>h3 +var list = selectors.first.split((selector) => { + return selector.type === 'combinator'; +}); + +// (node values) => [['h1', ' '], ['h2', '>>'], ['h3']] +``` + +Arguments: + +* `callback (function)`: A function to call for each node, which receives `node` + as an argument. + +### `container.prepend(node)` & `container.append(node)` + +Add a node to the start/end of the container. Note that doing so will set +the parent property of the node to this container. + +```js +var id = parser.id({value: 'search'}); +selector.append(id); +``` + +Arguments: + +* `node`: The node to add. + +### `container.insertBefore(old, new)` & `container.insertAfter(old, new)` + +Add a node before or after an existing node in a container: + +```js +selectors.walk(function (selector) { + if (selector.type !== 'class') { + var className = parser.className({value: 'theme-name'}); + selector.parent.insertAfter(selector, className); + } +}); +``` + +Arguments: + +* `old`: The existing node in the container. +* `new`: The new node to add before/after the existing node. + +### `container.removeChild(node)` + +Remove the node from the container. Note that you can also use +`node.remove()` if you would like to remove just a single node. + +```js +selector.length // => 2 +selector.remove(id) +selector.length // => 1; +id.parent // undefined +``` + +Arguments: + +* `node`: The node to remove. + +### `container.removeAll()` or `container.empty()` + +Remove all children from the container. + +```js +selector.removeAll(); +selector.length // => 0 +``` + +## Root nodes + +A root node represents a comma separated list of selectors. Indeed, all +a root's `toString()` method does is join its selector children with a ','. +Other than this, it has no special functionality and acts like a container. + +### `root.trailingComma` + +This will be set to `true` if the input has a trailing comma, in order to +support parsing of legacy CSS hacks. + +## Selector nodes + +A selector node represents a single compound selector. For example, this +selector string `h1 h2 h3, [href] > p`, is represented as two selector nodes. +It has no special functionality of its own. + +## Pseudo nodes + +A pseudo selector extends a container node; if it has any parameters of its +own (such as `h1:not(h2, h3)`), they will be its children. Note that the pseudo +`value` will always contain the colons preceding the pseudo identifier. This +is so that both `:before` and `::before` are properly represented in the AST. + +## Attribute nodes + +### `attribute.quoted` + +Returns `true` if the attribute's value is wrapped in quotation marks, false if it is not. +Remains `undefined` if there is no attribute value. + +```css +[href=foo] /* false */ +[href='foo'] /* true */ +[href="foo"] /* true */ +[href] /* undefined */ +``` + +### `attribute.raws.unquoted` + +Returns the unquoted content of the attribute's value. +Remains `undefined` if there is no attribute value. + +```css +[href=foo] /* foo */ +[href='foo'] /* foo */ +[href="foo"] /* foo */ +[href] /* undefined */ +``` + +### `attribute.raws.insensitive` + +If there is an `i` specifying case insensitivity, returns that `i` along with the whitespace +around it. + +```css +[id=Bar i ] /* " i " */ +[id=Bar i ] /* " i " */ +``` + +## `processor` + +### `process(cssText, [options])` + +Processes the `cssText`, returning the parsed output + +```js +var processor = parser(); + +var result = processor.process(' .class').result; +// => .class + +// To have the parser normalize whitespace values, utilize the options +var result = processor.process(' .class ', {lossless: false}).result; +// => .class +``` + +Arguments: + +* `cssText (string)`: The css to be parsed. +* `[options] (object)`: Process options + +Options: + +* `lossless (boolean)`: false to normalize the selector whitespace, defaults to true diff --git a/node_modules/postcss-selector-parser/CHANGELOG.md b/node_modules/postcss-selector-parser/CHANGELOG.md new file mode 100644 index 00000000..34995769 --- /dev/null +++ b/node_modules/postcss-selector-parser/CHANGELOG.md @@ -0,0 +1,157 @@ +# 2.2.3 + +* Resolves an issue where the parser would not reduce multiple spaces between an + ampersand and another simple selector in lossy mode (thanks to @adam-26). + +# 2.2.2 + +* No longer hangs on an unescaped semicolon; instead the parser will throw + an exception for these cases. + +# 2.2.1 + +* Allows a consumer to specify whitespace tokens when creating a new Node + (thanks to @Semigradsky). + +# 2.2.0 + +* Added a new option to normalize whitespace when parsing the selector string + (thanks to @adam-26). + +# 2.1.1 + +* Better unquoted value handling within attribute selectors + (thanks to @evilebottnawi). + +# 2.1.0 + +* Added: Use string constants for all node types & expose them on the main + parser instance (thanks to @Aweary). + +# 2.0.0 + +This release contains the following breaking changes: + +* Renamed all `eachInside` iterators to `walk`. For example, `eachTag` is now + `walkTags`, and `eachInside` is now `walk`. +* Renamed `Node#removeSelf()` to `Node#remove()`. +* Renamed `Container#remove()` to `Container#removeChild()`. +* Renamed `Node#raw` to `Node#raws` (thanks to @davidtheclark). +* Now parses `&` as the *nesting* selector, rather than a *tag* selector. +* Fixes misinterpretation of Sass interpolation (e.g. `#{foo}`) as an + id selector (thanks to @davidtheclark). + +and; + +* Fixes parsing of attribute selectors with equals signs in them + (e.g. `[data-attr="foo=bar"]`) (thanks to @montmanu). +* Adds `quoted` and `raw.unquoted` properties to attribute nodes + (thanks to @davidtheclark). + +# 1.3.3 + +* Fixes an infinite loop on `)` and `]` tokens when they had no opening pairs. + Now postcss-selector-parser will throw when it encounters these lone tokens. + +# 1.3.2 + +* Now uses plain integers rather than `str.charCodeAt(0)` for compiled builds. + +# 1.3.1 + +* Update flatten to v1.x (thanks to @shinnn). + +# 1.3.0 + +* Adds a new node type, `String`, to fix a crash on selectors such as + `foo:bar("test")`. + +# 1.2.1 + +* Fixes a crash when the parser encountered a trailing combinator. + +# 1.2.0 + +* A more descriptive error is thrown when the parser expects to find a + pseudo-class/pseudo-element (thanks to @ashelley). +* Adds support for line/column locations for selector nodes, as well as a + `Node#sourceIndex` method (thanks to @davidtheclark). + +# 1.1.4 + +* Fixes a crash when a selector started with a `>` combinator. The module will + now no longer throw if a selector has a leading/trailing combinator node. + +# 1.1.3 + +* Fixes a crash on `@` tokens. + +# 1.1.2 + +* Fixes an infinite loop caused by using parentheses in a non-pseudo element + context. + +# 1.1.1 + +* Fixes a crash when a backslash ended a selector string. + +# 1.1.0 + +* Adds support for replacing multiple nodes at once with `replaceWith` + (thanks to @jonathantneal). +* Parser no longer throws on sequential IDs and trailing commas, to support + parsing of selector hacks. + +# 1.0.1 + +* Fixes using `insertAfter` and `insertBefore` during iteration. + +# 1.0.0 + +* Adds `clone` and `replaceWith` methods to nodes. +* Adds `insertBefore` and `insertAfter` to containers. +* Stabilises API. + +# 0.0.5 + +* Fixes crash on extra whitespace inside a pseudo selector's parentheses. +* Adds sort function to the container class. +* Enables the parser to pass its input through without transforming. +* Iteration-safe `each` and `eachInside`. + +# 0.0.4 + +* Tidy up redundant duplication. +* Fixes a bug where the parser would loop infinitely on universal selectors + inside pseudo selectors. +* Adds `length` getter and `eachInside`, `map`, `reduce` to the container class. +* When a selector has been removed from the tree, the root node will no longer + cast it to a string. +* Adds node type iterators to the container class (e.g. `eachComment`). +* Adds filter function to the container class. +* Adds split function to the container class. +* Create new node types by doing `parser.id(opts)` etc. +* Adds support for pseudo classes anywhere in the selector. + +# 0.0.3 + +* Adds `next` and `prev` to the node class. +* Adds `first` and `last` getters to the container class. +* Adds `every` and `some` iterators to the container class. +* Add `empty` alias for `removeAll`. +* Combinators are now types of node. +* Fixes the at method so that it is not an alias for `index`. +* Tidy up creation of new nodes in the parser. +* Refactors how namespaces are handled for consistency & less redundant code. +* Refactors AST to use `nodes` exclusively, and eliminates excessive nesting. +* Fixes nested pseudo parsing. +* Fixes whitespace parsing. + +# 0.0.2 + +* Adds support for namespace selectors. +* Adds support for selectors joined by escaped spaces - such as `.\31\ 0`. + +# 0.0.1 + +* Initial release. diff --git a/node_modules/postcss-selector-parser/LICENSE-MIT b/node_modules/postcss-selector-parser/LICENSE-MIT new file mode 100644 index 00000000..fd0e863a --- /dev/null +++ b/node_modules/postcss-selector-parser/LICENSE-MIT @@ -0,0 +1,22 @@ +Copyright (c) Ben Briggs (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 00000000..aa52db36 --- /dev/null +++ b/node_modules/postcss-selector-parser/README.md @@ -0,0 +1,46 @@ +# postcss-selector-parser [![Build Status](https://travis-ci.org/postcss/postcss-selector-parser.svg?branch=master)](https://travis-ci.org/postcss/postcss-selector-parser) + +> Selector parser with built in methods for working with selector strings. + +## Install + +With [npm](https://npmjs.com/package/postcss-selector-parser) do: + +``` +npm install postcss-selector-parser +``` + +## Quick Start + +```js +var parser = require('postcss-selector-parser'); +var transform = function (selectors) { + selectors.eachInside(function (selector) { + // do something with the selector + console.log(String(selector)) + }); +}; + +var transformed = parser(transform).process('h1, h2, h3').result; +``` + +To normalize selector whitespace: + +```js +var parser = require('postcss-selector-parser'); +var normalized = parser().process('h1, h2, h3', {lossless:false}).result; +// -> h1,h2,h3 +``` + +## API + +Please see [API.md](API.md). + +## Credits + +* Huge thanks to Andrey Sitnik (@ai) for work on PostCSS which helped + accelerate this module's development. + +## License + +MIT diff --git a/node_modules/postcss-selector-parser/dist/index.js b/node_modules/postcss-selector-parser/dist/index.js new file mode 100644 index 00000000..62400258 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/index.js @@ -0,0 +1,114 @@ +'use strict'; + +exports.__esModule = true; + +var _processor = require('./processor'); + +var _processor2 = _interopRequireDefault(_processor); + +var _attribute = require('./selectors/attribute'); + +var _attribute2 = _interopRequireDefault(_attribute); + +var _className = require('./selectors/className'); + +var _className2 = _interopRequireDefault(_className); + +var _combinator = require('./selectors/combinator'); + +var _combinator2 = _interopRequireDefault(_combinator); + +var _comment = require('./selectors/comment'); + +var _comment2 = _interopRequireDefault(_comment); + +var _id = require('./selectors/id'); + +var _id2 = _interopRequireDefault(_id); + +var _nesting = require('./selectors/nesting'); + +var _nesting2 = _interopRequireDefault(_nesting); + +var _pseudo = require('./selectors/pseudo'); + +var _pseudo2 = _interopRequireDefault(_pseudo); + +var _root = require('./selectors/root'); + +var _root2 = _interopRequireDefault(_root); + +var _selector = require('./selectors/selector'); + +var _selector2 = _interopRequireDefault(_selector); + +var _string = require('./selectors/string'); + +var _string2 = _interopRequireDefault(_string); + +var _tag = require('./selectors/tag'); + +var _tag2 = _interopRequireDefault(_tag); + +var _universal = require('./selectors/universal'); + +var _universal2 = _interopRequireDefault(_universal); + +var _types = require('./selectors/types'); + +var types = _interopRequireWildcard(_types); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var parser = function parser(processor) { + return new _processor2.default(processor); +}; + +parser.attribute = function (opts) { + return new _attribute2.default(opts); +}; +parser.className = function (opts) { + return new _className2.default(opts); +}; +parser.combinator = function (opts) { + return new _combinator2.default(opts); +}; +parser.comment = function (opts) { + return new _comment2.default(opts); +}; +parser.id = function (opts) { + return new _id2.default(opts); +}; +parser.nesting = function (opts) { + return new _nesting2.default(opts); +}; +parser.pseudo = function (opts) { + return new _pseudo2.default(opts); +}; +parser.root = function (opts) { + return new _root2.default(opts); +}; +parser.selector = function (opts) { + return new _selector2.default(opts); +}; +parser.string = function (opts) { + return new _string2.default(opts); +}; +parser.tag = function (opts) { + return new _tag2.default(opts); +}; +parser.universal = function (opts) { + return new _universal2.default(opts); +}; + +Object.keys(types).forEach(function (type) { + if (type === '__esModule') { + return; + } + parser[type] = types[type]; // eslint-disable-line +}); + +exports.default = parser; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/parser.js b/node_modules/postcss-selector-parser/dist/parser.js new file mode 100644 index 00000000..18beadbb --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/parser.js @@ -0,0 +1,643 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _flatten = require('flatten'); + +var _flatten2 = _interopRequireDefault(_flatten); + +var _indexesOf = require('indexes-of'); + +var _indexesOf2 = _interopRequireDefault(_indexesOf); + +var _uniq = require('uniq'); + +var _uniq2 = _interopRequireDefault(_uniq); + +var _root = require('./selectors/root'); + +var _root2 = _interopRequireDefault(_root); + +var _selector = require('./selectors/selector'); + +var _selector2 = _interopRequireDefault(_selector); + +var _className = require('./selectors/className'); + +var _className2 = _interopRequireDefault(_className); + +var _comment = require('./selectors/comment'); + +var _comment2 = _interopRequireDefault(_comment); + +var _id = require('./selectors/id'); + +var _id2 = _interopRequireDefault(_id); + +var _tag = require('./selectors/tag'); + +var _tag2 = _interopRequireDefault(_tag); + +var _string = require('./selectors/string'); + +var _string2 = _interopRequireDefault(_string); + +var _pseudo = require('./selectors/pseudo'); + +var _pseudo2 = _interopRequireDefault(_pseudo); + +var _attribute = require('./selectors/attribute'); + +var _attribute2 = _interopRequireDefault(_attribute); + +var _universal = require('./selectors/universal'); + +var _universal2 = _interopRequireDefault(_universal); + +var _combinator = require('./selectors/combinator'); + +var _combinator2 = _interopRequireDefault(_combinator); + +var _nesting = require('./selectors/nesting'); + +var _nesting2 = _interopRequireDefault(_nesting); + +var _sortAscending = require('./sortAscending'); + +var _sortAscending2 = _interopRequireDefault(_sortAscending); + +var _tokenize = require('./tokenize'); + +var _tokenize2 = _interopRequireDefault(_tokenize); + +var _types = require('./selectors/types'); + +var types = _interopRequireWildcard(_types); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Parser = function () { + function Parser(input) { + _classCallCheck(this, Parser); + + this.input = input; + this.lossy = input.options.lossless === false; + this.position = 0; + this.root = new _root2.default(); + + var selectors = new _selector2.default(); + this.root.append(selectors); + + this.current = selectors; + if (this.lossy) { + this.tokens = (0, _tokenize2.default)({ safe: input.safe, css: input.css.trim() }); + } else { + this.tokens = (0, _tokenize2.default)(input); + } + + return this.loop(); + } + + Parser.prototype.attribute = function attribute() { + var str = ''; + var attr = void 0; + var startingToken = this.currToken; + this.position++; + while (this.position < this.tokens.length && this.currToken[0] !== ']') { + str += this.tokens[this.position][1]; + this.position++; + } + if (this.position === this.tokens.length && !~str.indexOf(']')) { + this.error('Expected a closing square bracket.'); + } + var parts = str.split(/((?:[*~^$|]?=))([^]*)/); + var namespace = parts[0].split(/(\|)/g); + var attributeProps = { + operator: parts[1], + value: parts[2], + source: { + start: { + line: startingToken[2], + column: startingToken[3] + }, + end: { + line: this.currToken[2], + column: this.currToken[3] + } + }, + sourceIndex: startingToken[4] + }; + if (namespace.length > 1) { + if (namespace[0] === '') { + namespace[0] = true; + } + attributeProps.attribute = this.parseValue(namespace[2]); + attributeProps.namespace = this.parseNamespace(namespace[0]); + } else { + attributeProps.attribute = this.parseValue(parts[0]); + } + attr = new _attribute2.default(attributeProps); + + if (parts[2]) { + var insensitive = parts[2].split(/(\s+i\s*?)$/); + var trimmedValue = insensitive[0].trim(); + attr.value = this.lossy ? trimmedValue : insensitive[0]; + if (insensitive[1]) { + attr.insensitive = true; + if (!this.lossy) { + attr.raws.insensitive = insensitive[1]; + } + } + attr.quoted = trimmedValue[0] === '\'' || trimmedValue[0] === '"'; + attr.raws.unquoted = attr.quoted ? trimmedValue.slice(1, -1) : trimmedValue; + } + this.newNode(attr); + this.position++; + }; + + Parser.prototype.combinator = function combinator() { + if (this.currToken[1] === '|') { + return this.namespace(); + } + var node = new _combinator2.default({ + value: '', + source: { + start: { + line: this.currToken[2], + column: this.currToken[3] + }, + end: { + line: this.currToken[2], + column: this.currToken[3] + } + }, + sourceIndex: this.currToken[4] + }); + while (this.position < this.tokens.length && this.currToken && (this.currToken[0] === 'space' || this.currToken[0] === 'combinator')) { + if (this.nextToken && this.nextToken[0] === 'combinator') { + node.spaces.before = this.parseSpace(this.currToken[1]); + node.source.start.line = this.nextToken[2]; + node.source.start.column = this.nextToken[3]; + node.source.end.column = this.nextToken[3]; + node.source.end.line = this.nextToken[2]; + node.sourceIndex = this.nextToken[4]; + } else if (this.prevToken && this.prevToken[0] === 'combinator') { + node.spaces.after = this.parseSpace(this.currToken[1]); + } else if (this.currToken[0] === 'combinator') { + node.value = this.currToken[1]; + } else if (this.currToken[0] === 'space') { + node.value = this.parseSpace(this.currToken[1], ' '); + } + this.position++; + } + return this.newNode(node); + }; + + Parser.prototype.comma = function comma() { + if (this.position === this.tokens.length - 1) { + this.root.trailingComma = true; + this.position++; + return; + } + var selectors = new _selector2.default(); + this.current.parent.append(selectors); + this.current = selectors; + this.position++; + }; + + Parser.prototype.comment = function comment() { + var node = new _comment2.default({ + value: this.currToken[1], + source: { + start: { + line: this.currToken[2], + column: this.currToken[3] + }, + end: { + line: this.currToken[4], + column: this.currToken[5] + } + }, + sourceIndex: this.currToken[6] + }); + this.newNode(node); + this.position++; + }; + + Parser.prototype.error = function error(message) { + throw new this.input.error(message); // eslint-disable-line new-cap + }; + + Parser.prototype.missingBackslash = function missingBackslash() { + return this.error('Expected a backslash preceding the semicolon.'); + }; + + Parser.prototype.missingParenthesis = function missingParenthesis() { + return this.error('Expected opening parenthesis.'); + }; + + Parser.prototype.missingSquareBracket = function missingSquareBracket() { + return this.error('Expected opening square bracket.'); + }; + + Parser.prototype.namespace = function namespace() { + var before = this.prevToken && this.prevToken[1] || true; + if (this.nextToken[0] === 'word') { + this.position++; + return this.word(before); + } else if (this.nextToken[0] === '*') { + this.position++; + return this.universal(before); + } + }; + + Parser.prototype.nesting = function nesting() { + this.newNode(new _nesting2.default({ + value: this.currToken[1], + source: { + start: { + line: this.currToken[2], + column: this.currToken[3] + }, + end: { + line: this.currToken[2], + column: this.currToken[3] + } + }, + sourceIndex: this.currToken[4] + })); + this.position++; + }; + + Parser.prototype.parentheses = function parentheses() { + var last = this.current.last; + if (last && last.type === types.PSEUDO) { + var selector = new _selector2.default(); + var cache = this.current; + last.append(selector); + this.current = selector; + var balanced = 1; + this.position++; + while (this.position < this.tokens.length && balanced) { + if (this.currToken[0] === '(') { + balanced++; + } + if (this.currToken[0] === ')') { + balanced--; + } + if (balanced) { + this.parse(); + } else { + selector.parent.source.end.line = this.currToken[2]; + selector.parent.source.end.column = this.currToken[3]; + this.position++; + } + } + if (balanced) { + this.error('Expected closing parenthesis.'); + } + this.current = cache; + } else { + var _balanced = 1; + this.position++; + last.value += '('; + while (this.position < this.tokens.length && _balanced) { + if (this.currToken[0] === '(') { + _balanced++; + } + if (this.currToken[0] === ')') { + _balanced--; + } + last.value += this.parseParenthesisToken(this.currToken); + this.position++; + } + if (_balanced) { + this.error('Expected closing parenthesis.'); + } + } + }; + + Parser.prototype.pseudo = function pseudo() { + var _this = this; + + var pseudoStr = ''; + var startingToken = this.currToken; + while (this.currToken && this.currToken[0] === ':') { + pseudoStr += this.currToken[1]; + this.position++; + } + if (!this.currToken) { + return this.error('Expected pseudo-class or pseudo-element'); + } + if (this.currToken[0] === 'word') { + var pseudo = void 0; + this.splitWord(false, function (first, length) { + pseudoStr += first; + pseudo = new _pseudo2.default({ + value: pseudoStr, + source: { + start: { + line: startingToken[2], + column: startingToken[3] + }, + end: { + line: _this.currToken[4], + column: _this.currToken[5] + } + }, + sourceIndex: startingToken[4] + }); + _this.newNode(pseudo); + if (length > 1 && _this.nextToken && _this.nextToken[0] === '(') { + _this.error('Misplaced parenthesis.'); + } + }); + } else { + this.error('Unexpected "' + this.currToken[0] + '" found.'); + } + }; + + Parser.prototype.space = function space() { + var token = this.currToken; + // Handle space before and after the selector + if (this.position === 0 || this.prevToken[0] === ',' || this.prevToken[0] === '(') { + this.spaces = this.parseSpace(token[1]); + this.position++; + } else if (this.position === this.tokens.length - 1 || this.nextToken[0] === ',' || this.nextToken[0] === ')') { + this.current.last.spaces.after = this.parseSpace(token[1]); + this.position++; + } else { + this.combinator(); + } + }; + + Parser.prototype.string = function string() { + var token = this.currToken; + this.newNode(new _string2.default({ + value: this.currToken[1], + source: { + start: { + line: token[2], + column: token[3] + }, + end: { + line: token[4], + column: token[5] + } + }, + sourceIndex: token[6] + })); + this.position++; + }; + + Parser.prototype.universal = function universal(namespace) { + var nextToken = this.nextToken; + if (nextToken && nextToken[1] === '|') { + this.position++; + return this.namespace(); + } + this.newNode(new _universal2.default({ + value: this.currToken[1], + source: { + start: { + line: this.currToken[2], + column: this.currToken[3] + }, + end: { + line: this.currToken[2], + column: this.currToken[3] + } + }, + sourceIndex: this.currToken[4] + }), namespace); + this.position++; + }; + + Parser.prototype.splitWord = function splitWord(namespace, firstCallback) { + var _this2 = this; + + var nextToken = this.nextToken; + var word = this.currToken[1]; + while (nextToken && nextToken[0] === 'word') { + this.position++; + var current = this.currToken[1]; + word += current; + if (current.lastIndexOf('\\') === current.length - 1) { + var next = this.nextToken; + if (next && next[0] === 'space') { + word += this.parseSpace(next[1], ' '); + this.position++; + } + } + nextToken = this.nextToken; + } + var hasClass = (0, _indexesOf2.default)(word, '.'); + var hasId = (0, _indexesOf2.default)(word, '#'); + // Eliminate Sass interpolations from the list of id indexes + var interpolations = (0, _indexesOf2.default)(word, '#{'); + if (interpolations.length) { + hasId = hasId.filter(function (hashIndex) { + return !~interpolations.indexOf(hashIndex); + }); + } + var indices = (0, _sortAscending2.default)((0, _uniq2.default)((0, _flatten2.default)([[0], hasClass, hasId]))); + indices.forEach(function (ind, i) { + var index = indices[i + 1] || word.length; + var value = word.slice(ind, index); + if (i === 0 && firstCallback) { + return firstCallback.call(_this2, value, indices.length); + } + var node = void 0; + if (~hasClass.indexOf(ind)) { + node = new _className2.default({ + value: value.slice(1), + source: { + start: { + line: _this2.currToken[2], + column: _this2.currToken[3] + ind + }, + end: { + line: _this2.currToken[4], + column: _this2.currToken[3] + (index - 1) + } + }, + sourceIndex: _this2.currToken[6] + indices[i] + }); + } else if (~hasId.indexOf(ind)) { + node = new _id2.default({ + value: value.slice(1), + source: { + start: { + line: _this2.currToken[2], + column: _this2.currToken[3] + ind + }, + end: { + line: _this2.currToken[4], + column: _this2.currToken[3] + (index - 1) + } + }, + sourceIndex: _this2.currToken[6] + indices[i] + }); + } else { + node = new _tag2.default({ + value: value, + source: { + start: { + line: _this2.currToken[2], + column: _this2.currToken[3] + ind + }, + end: { + line: _this2.currToken[4], + column: _this2.currToken[3] + (index - 1) + } + }, + sourceIndex: _this2.currToken[6] + indices[i] + }); + } + _this2.newNode(node, namespace); + }); + this.position++; + }; + + Parser.prototype.word = function word(namespace) { + var nextToken = this.nextToken; + if (nextToken && nextToken[1] === '|') { + this.position++; + return this.namespace(); + } + return this.splitWord(namespace); + }; + + Parser.prototype.loop = function loop() { + while (this.position < this.tokens.length) { + this.parse(true); + } + return this.root; + }; + + Parser.prototype.parse = function parse(throwOnParenthesis) { + switch (this.currToken[0]) { + case 'space': + this.space(); + break; + case 'comment': + this.comment(); + break; + case '(': + this.parentheses(); + break; + case ')': + if (throwOnParenthesis) { + this.missingParenthesis(); + } + break; + case '[': + this.attribute(); + break; + case ']': + this.missingSquareBracket(); + break; + case 'at-word': + case 'word': + this.word(); + break; + case ':': + this.pseudo(); + break; + case ';': + this.missingBackslash(); + break; + case ',': + this.comma(); + break; + case '*': + this.universal(); + break; + case '&': + this.nesting(); + break; + case 'combinator': + this.combinator(); + break; + case 'string': + this.string(); + break; + } + }; + + /** + * Helpers + */ + + Parser.prototype.parseNamespace = function parseNamespace(namespace) { + if (this.lossy && typeof namespace === 'string') { + var trimmed = namespace.trim(); + if (!trimmed.length) { + return true; + } + + return trimmed; + } + + return namespace; + }; + + Parser.prototype.parseSpace = function parseSpace(space, replacement) { + return this.lossy ? replacement || '' : space; + }; + + Parser.prototype.parseValue = function parseValue(value) { + return this.lossy && value && typeof value === 'string' ? value.trim() : value; + }; + + Parser.prototype.parseParenthesisToken = function parseParenthesisToken(token) { + if (!this.lossy) { + return token[1]; + } + + if (token[0] === 'space') { + return this.parseSpace(token[1], ' '); + } + + return this.parseValue(token[1]); + }; + + Parser.prototype.newNode = function newNode(node, namespace) { + if (namespace) { + node.namespace = this.parseNamespace(namespace); + } + if (this.spaces) { + node.spaces.before = this.spaces; + this.spaces = ''; + } + return this.current.append(node); + }; + + _createClass(Parser, [{ + key: 'currToken', + get: function get() { + return this.tokens[this.position]; + } + }, { + key: 'nextToken', + get: function get() { + return this.tokens[this.position + 1]; + } + }, { + key: 'prevToken', + get: function get() { + return this.tokens[this.position - 1]; + } + }]); + + return Parser; +}(); + +exports.default = Parser; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/processor.js b/node_modules/postcss-selector-parser/dist/processor.js new file mode 100644 index 00000000..087618ce --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/processor.js @@ -0,0 +1,49 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _parser = require('./parser'); + +var _parser2 = _interopRequireDefault(_parser); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Processor = function () { + function Processor(func) { + _classCallCheck(this, Processor); + + this.func = func || function noop() {}; + return this; + } + + Processor.prototype.process = function process(selectors) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var input = new _parser2.default({ + css: selectors, + error: function error(e) { + throw new Error(e); + }, + options: options + }); + this.res = input; + this.func(input); + return this; + }; + + _createClass(Processor, [{ + key: 'result', + get: function get() { + return String(this.res); + } + }]); + + return Processor; +}(); + +exports.default = Processor; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/attribute.js b/node_modules/postcss-selector-parser/dist/selectors/attribute.js new file mode 100644 index 00000000..4ea74c12 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/attribute.js @@ -0,0 +1,54 @@ +'use strict'; + +exports.__esModule = true; + +var _namespace = require('./namespace'); + +var _namespace2 = _interopRequireDefault(_namespace); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Attribute = function (_Namespace) { + _inherits(Attribute, _Namespace); + + function Attribute(opts) { + _classCallCheck(this, Attribute); + + var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts)); + + _this.type = _types.ATTRIBUTE; + _this.raws = {}; + return _this; + } + + Attribute.prototype.toString = function toString() { + var selector = [this.spaces.before, '[', this.ns, this.attribute]; + + if (this.operator) { + selector.push(this.operator); + } + if (this.value) { + selector.push(this.value); + } + if (this.raws.insensitive) { + selector.push(this.raws.insensitive); + } else if (this.insensitive) { + selector.push(' i'); + } + selector.push(']'); + return selector.concat(this.spaces.after).join(''); + }; + + return Attribute; +}(_namespace2.default); + +exports.default = Attribute; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/className.js b/node_modules/postcss-selector-parser/dist/selectors/className.js new file mode 100644 index 00000000..d7bff16b --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/className.js @@ -0,0 +1,39 @@ +'use strict'; + +exports.__esModule = true; + +var _namespace = require('./namespace'); + +var _namespace2 = _interopRequireDefault(_namespace); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var ClassName = function (_Namespace) { + _inherits(ClassName, _Namespace); + + function ClassName(opts) { + _classCallCheck(this, ClassName); + + var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts)); + + _this.type = _types.CLASS; + return _this; + } + + ClassName.prototype.toString = function toString() { + return [this.spaces.before, this.ns, String('.' + this.value), this.spaces.after].join(''); + }; + + return ClassName; +}(_namespace2.default); + +exports.default = ClassName; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/combinator.js b/node_modules/postcss-selector-parser/dist/selectors/combinator.js new file mode 100644 index 00000000..673dc750 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/combinator.js @@ -0,0 +1,35 @@ +'use strict'; + +exports.__esModule = true; + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Combinator = function (_Node) { + _inherits(Combinator, _Node); + + function Combinator(opts) { + _classCallCheck(this, Combinator); + + var _this = _possibleConstructorReturn(this, _Node.call(this, opts)); + + _this.type = _types.COMBINATOR; + return _this; + } + + return Combinator; +}(_node2.default); + +exports.default = Combinator; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/comment.js b/node_modules/postcss-selector-parser/dist/selectors/comment.js new file mode 100644 index 00000000..6d96556e --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/comment.js @@ -0,0 +1,35 @@ +'use strict'; + +exports.__esModule = true; + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Comment = function (_Node) { + _inherits(Comment, _Node); + + function Comment(opts) { + _classCallCheck(this, Comment); + + var _this = _possibleConstructorReturn(this, _Node.call(this, opts)); + + _this.type = _types.COMMENT; + return _this; + } + + return Comment; +}(_node2.default); + +exports.default = Comment; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/container.js b/node_modules/postcss-selector-parser/dist/selectors/container.js new file mode 100644 index 00000000..bc9ec00c --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/container.js @@ -0,0 +1,338 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +var _types = require('./types'); + +var types = _interopRequireWildcard(_types); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Container = function (_Node) { + _inherits(Container, _Node); + + function Container(opts) { + _classCallCheck(this, Container); + + var _this = _possibleConstructorReturn(this, _Node.call(this, opts)); + + if (!_this.nodes) { + _this.nodes = []; + } + return _this; + } + + Container.prototype.append = function append(selector) { + selector.parent = this; + this.nodes.push(selector); + return this; + }; + + Container.prototype.prepend = function prepend(selector) { + selector.parent = this; + this.nodes.unshift(selector); + return this; + }; + + Container.prototype.at = function at(index) { + return this.nodes[index]; + }; + + Container.prototype.index = function index(child) { + if (typeof child === 'number') { + return child; + } + return this.nodes.indexOf(child); + }; + + Container.prototype.removeChild = function removeChild(child) { + child = this.index(child); + this.at(child).parent = undefined; + this.nodes.splice(child, 1); + + var index = void 0; + for (var id in this.indexes) { + index = this.indexes[id]; + if (index >= child) { + this.indexes[id] = index - 1; + } + } + + return this; + }; + + Container.prototype.removeAll = function removeAll() { + for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var node = _ref; + + node.parent = undefined; + } + this.nodes = []; + return this; + }; + + Container.prototype.empty = function empty() { + return this.removeAll(); + }; + + Container.prototype.insertAfter = function insertAfter(oldNode, newNode) { + var oldIndex = this.index(oldNode); + this.nodes.splice(oldIndex + 1, 0, newNode); + + var index = void 0; + for (var id in this.indexes) { + index = this.indexes[id]; + if (oldIndex <= index) { + this.indexes[id] = index + this.nodes.length; + } + } + + return this; + }; + + Container.prototype.insertBefore = function insertBefore(oldNode, newNode) { + var oldIndex = this.index(oldNode); + this.nodes.splice(oldIndex, 0, newNode); + + var index = void 0; + for (var id in this.indexes) { + index = this.indexes[id]; + if (oldIndex <= index) { + this.indexes[id] = index + this.nodes.length; + } + } + + return this; + }; + + Container.prototype.each = function each(callback) { + if (!this.lastEach) { + this.lastEach = 0; + } + if (!this.indexes) { + this.indexes = {}; + } + + this.lastEach++; + var id = this.lastEach; + this.indexes[id] = 0; + + if (!this.length) { + return undefined; + } + + var index = void 0, + result = void 0; + while (this.indexes[id] < this.length) { + index = this.indexes[id]; + result = callback(this.at(index), index); + if (result === false) { + break; + } + + this.indexes[id] += 1; + } + + delete this.indexes[id]; + + if (result === false) { + return false; + } + }; + + Container.prototype.walk = function walk(callback) { + return this.each(function (node, i) { + var result = callback(node, i); + + if (result !== false && node.length) { + result = node.walk(callback); + } + + if (result === false) { + return false; + } + }); + }; + + Container.prototype.walkAttributes = function walkAttributes(callback) { + var _this2 = this; + + return this.walk(function (selector) { + if (selector.type === types.ATTRIBUTE) { + return callback.call(_this2, selector); + } + }); + }; + + Container.prototype.walkClasses = function walkClasses(callback) { + var _this3 = this; + + return this.walk(function (selector) { + if (selector.type === types.CLASS) { + return callback.call(_this3, selector); + } + }); + }; + + Container.prototype.walkCombinators = function walkCombinators(callback) { + var _this4 = this; + + return this.walk(function (selector) { + if (selector.type === types.COMBINATOR) { + return callback.call(_this4, selector); + } + }); + }; + + Container.prototype.walkComments = function walkComments(callback) { + var _this5 = this; + + return this.walk(function (selector) { + if (selector.type === types.COMMENT) { + return callback.call(_this5, selector); + } + }); + }; + + Container.prototype.walkIds = function walkIds(callback) { + var _this6 = this; + + return this.walk(function (selector) { + if (selector.type === types.ID) { + return callback.call(_this6, selector); + } + }); + }; + + Container.prototype.walkNesting = function walkNesting(callback) { + var _this7 = this; + + return this.walk(function (selector) { + if (selector.type === types.NESTING) { + return callback.call(_this7, selector); + } + }); + }; + + Container.prototype.walkPseudos = function walkPseudos(callback) { + var _this8 = this; + + return this.walk(function (selector) { + if (selector.type === types.PSEUDO) { + return callback.call(_this8, selector); + } + }); + }; + + Container.prototype.walkTags = function walkTags(callback) { + var _this9 = this; + + return this.walk(function (selector) { + if (selector.type === types.TAG) { + return callback.call(_this9, selector); + } + }); + }; + + Container.prototype.walkUniversals = function walkUniversals(callback) { + var _this10 = this; + + return this.walk(function (selector) { + if (selector.type === types.UNIVERSAL) { + return callback.call(_this10, selector); + } + }); + }; + + Container.prototype.split = function split(callback) { + var _this11 = this; + + var current = []; + return this.reduce(function (memo, node, index) { + var split = callback.call(_this11, node); + current.push(node); + if (split) { + memo.push(current); + current = []; + } else if (index === _this11.length - 1) { + memo.push(current); + } + return memo; + }, []); + }; + + Container.prototype.map = function map(callback) { + return this.nodes.map(callback); + }; + + Container.prototype.reduce = function reduce(callback, memo) { + return this.nodes.reduce(callback, memo); + }; + + Container.prototype.every = function every(callback) { + return this.nodes.every(callback); + }; + + Container.prototype.some = function some(callback) { + return this.nodes.some(callback); + }; + + Container.prototype.filter = function filter(callback) { + return this.nodes.filter(callback); + }; + + Container.prototype.sort = function sort(callback) { + return this.nodes.sort(callback); + }; + + Container.prototype.toString = function toString() { + return this.map(String).join(''); + }; + + _createClass(Container, [{ + key: 'first', + get: function get() { + return this.at(0); + } + }, { + key: 'last', + get: function get() { + return this.at(this.length - 1); + } + }, { + key: 'length', + get: function get() { + return this.nodes.length; + } + }]); + + return Container; +}(_node2.default); + +exports.default = Container; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/id.js b/node_modules/postcss-selector-parser/dist/selectors/id.js new file mode 100644 index 00000000..4538dcf8 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/id.js @@ -0,0 +1,39 @@ +'use strict'; + +exports.__esModule = true; + +var _namespace = require('./namespace'); + +var _namespace2 = _interopRequireDefault(_namespace); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var ID = function (_Namespace) { + _inherits(ID, _Namespace); + + function ID(opts) { + _classCallCheck(this, ID); + + var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts)); + + _this.type = _types.ID; + return _this; + } + + ID.prototype.toString = function toString() { + return [this.spaces.before, this.ns, String('#' + this.value), this.spaces.after].join(''); + }; + + return ID; +}(_namespace2.default); + +exports.default = ID; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/namespace.js b/node_modules/postcss-selector-parser/dist/selectors/namespace.js new file mode 100644 index 00000000..5121b2d4 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/namespace.js @@ -0,0 +1,45 @@ +'use strict'; + +exports.__esModule = true; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Namespace = function (_Node) { + _inherits(Namespace, _Node); + + function Namespace() { + _classCallCheck(this, Namespace); + + return _possibleConstructorReturn(this, _Node.apply(this, arguments)); + } + + Namespace.prototype.toString = function toString() { + return [this.spaces.before, this.ns, String(this.value), this.spaces.after].join(''); + }; + + _createClass(Namespace, [{ + key: 'ns', + get: function get() { + var n = this.namespace; + return n ? (typeof n === 'string' ? n : '') + '|' : ''; + } + }]); + + return Namespace; +}(_node2.default); + +exports.default = Namespace; +; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/nesting.js b/node_modules/postcss-selector-parser/dist/selectors/nesting.js new file mode 100644 index 00000000..c3264b07 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/nesting.js @@ -0,0 +1,36 @@ +'use strict'; + +exports.__esModule = true; + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Nesting = function (_Node) { + _inherits(Nesting, _Node); + + function Nesting(opts) { + _classCallCheck(this, Nesting); + + var _this = _possibleConstructorReturn(this, _Node.call(this, opts)); + + _this.type = _types.NESTING; + _this.value = '&'; + return _this; + } + + return Nesting; +}(_node2.default); + +exports.default = Nesting; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/node.js b/node_modules/postcss-selector-parser/dist/selectors/node.js new file mode 100644 index 00000000..30f45fd4 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/node.js @@ -0,0 +1,102 @@ +'use strict'; + +exports.__esModule = true; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var cloneNode = function cloneNode(obj, parent) { + if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object') { + return obj; + } + + var cloned = new obj.constructor(); + + for (var i in obj) { + if (!obj.hasOwnProperty(i)) { + continue; + } + var value = obj[i]; + var type = typeof value === 'undefined' ? 'undefined' : _typeof(value); + + if (i === 'parent' && type === 'object') { + if (parent) { + cloned[i] = parent; + } + } else if (value instanceof Array) { + cloned[i] = value.map(function (j) { + return cloneNode(j, cloned); + }); + } else { + cloned[i] = cloneNode(value, cloned); + } + } + + return cloned; +}; + +var _class = function () { + function _class() { + var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + _classCallCheck(this, _class); + + for (var key in opts) { + this[key] = opts[key]; + } + var _opts$spaces = opts.spaces; + _opts$spaces = _opts$spaces === undefined ? {} : _opts$spaces; + var _opts$spaces$before = _opts$spaces.before, + before = _opts$spaces$before === undefined ? '' : _opts$spaces$before, + _opts$spaces$after = _opts$spaces.after, + after = _opts$spaces$after === undefined ? '' : _opts$spaces$after; + + this.spaces = { before: before, after: after }; + } + + _class.prototype.remove = function remove() { + if (this.parent) { + this.parent.removeChild(this); + } + this.parent = undefined; + return this; + }; + + _class.prototype.replaceWith = function replaceWith() { + if (this.parent) { + for (var index in arguments) { + this.parent.insertBefore(this, arguments[index]); + } + this.remove(); + } + return this; + }; + + _class.prototype.next = function next() { + return this.parent.at(this.parent.index(this) + 1); + }; + + _class.prototype.prev = function prev() { + return this.parent.at(this.parent.index(this) - 1); + }; + + _class.prototype.clone = function clone() { + var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var cloned = cloneNode(this); + for (var name in overrides) { + cloned[name] = overrides[name]; + } + return cloned; + }; + + _class.prototype.toString = function toString() { + return [this.spaces.before, String(this.value), this.spaces.after].join(''); + }; + + return _class; +}(); + +exports.default = _class; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/pseudo.js b/node_modules/postcss-selector-parser/dist/selectors/pseudo.js new file mode 100644 index 00000000..709cc224 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/pseudo.js @@ -0,0 +1,40 @@ +'use strict'; + +exports.__esModule = true; + +var _container = require('./container'); + +var _container2 = _interopRequireDefault(_container); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Pseudo = function (_Container) { + _inherits(Pseudo, _Container); + + function Pseudo(opts) { + _classCallCheck(this, Pseudo); + + var _this = _possibleConstructorReturn(this, _Container.call(this, opts)); + + _this.type = _types.PSEUDO; + return _this; + } + + Pseudo.prototype.toString = function toString() { + var params = this.length ? '(' + this.map(String).join(',') + ')' : ''; + return [this.spaces.before, String(this.value), params, this.spaces.after].join(''); + }; + + return Pseudo; +}(_container2.default); + +exports.default = Pseudo; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/root.js b/node_modules/postcss-selector-parser/dist/selectors/root.js new file mode 100644 index 00000000..d8865b5b --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/root.js @@ -0,0 +1,43 @@ +'use strict'; + +exports.__esModule = true; + +var _container = require('./container'); + +var _container2 = _interopRequireDefault(_container); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Root = function (_Container) { + _inherits(Root, _Container); + + function Root(opts) { + _classCallCheck(this, Root); + + var _this = _possibleConstructorReturn(this, _Container.call(this, opts)); + + _this.type = _types.ROOT; + return _this; + } + + Root.prototype.toString = function toString() { + var str = this.reduce(function (memo, selector) { + var sel = String(selector); + return sel ? memo + sel + ',' : ''; + }, '').slice(0, -1); + return this.trailingComma ? str + ',' : str; + }; + + return Root; +}(_container2.default); + +exports.default = Root; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/selector.js b/node_modules/postcss-selector-parser/dist/selectors/selector.js new file mode 100644 index 00000000..e2187662 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/selector.js @@ -0,0 +1,35 @@ +'use strict'; + +exports.__esModule = true; + +var _container = require('./container'); + +var _container2 = _interopRequireDefault(_container); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Selector = function (_Container) { + _inherits(Selector, _Container); + + function Selector(opts) { + _classCallCheck(this, Selector); + + var _this = _possibleConstructorReturn(this, _Container.call(this, opts)); + + _this.type = _types.SELECTOR; + return _this; + } + + return Selector; +}(_container2.default); + +exports.default = Selector; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/string.js b/node_modules/postcss-selector-parser/dist/selectors/string.js new file mode 100644 index 00000000..d644e7d1 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/string.js @@ -0,0 +1,35 @@ +'use strict'; + +exports.__esModule = true; + +var _node = require('./node'); + +var _node2 = _interopRequireDefault(_node); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var String = function (_Node) { + _inherits(String, _Node); + + function String(opts) { + _classCallCheck(this, String); + + var _this = _possibleConstructorReturn(this, _Node.call(this, opts)); + + _this.type = _types.STRING; + return _this; + } + + return String; +}(_node2.default); + +exports.default = String; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/tag.js b/node_modules/postcss-selector-parser/dist/selectors/tag.js new file mode 100644 index 00000000..a1f2848a --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/tag.js @@ -0,0 +1,35 @@ +'use strict'; + +exports.__esModule = true; + +var _namespace = require('./namespace'); + +var _namespace2 = _interopRequireDefault(_namespace); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Tag = function (_Namespace) { + _inherits(Tag, _Namespace); + + function Tag(opts) { + _classCallCheck(this, Tag); + + var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts)); + + _this.type = _types.TAG; + return _this; + } + + return Tag; +}(_namespace2.default); + +exports.default = Tag; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/types.js b/node_modules/postcss-selector-parser/dist/selectors/types.js new file mode 100644 index 00000000..aa73ac9a --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/types.js @@ -0,0 +1,15 @@ +'use strict'; + +exports.__esModule = true; +var TAG = exports.TAG = 'tag'; +var STRING = exports.STRING = 'string'; +var SELECTOR = exports.SELECTOR = 'selector'; +var ROOT = exports.ROOT = 'root'; +var PSEUDO = exports.PSEUDO = 'pseudo'; +var NESTING = exports.NESTING = 'nesting'; +var ID = exports.ID = 'id'; +var COMMENT = exports.COMMENT = 'comment'; +var COMBINATOR = exports.COMBINATOR = 'combinator'; +var CLASS = exports.CLASS = 'class'; +var ATTRIBUTE = exports.ATTRIBUTE = 'attribute'; +var UNIVERSAL = exports.UNIVERSAL = 'universal'; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/selectors/universal.js b/node_modules/postcss-selector-parser/dist/selectors/universal.js new file mode 100644 index 00000000..f4a35ff5 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/selectors/universal.js @@ -0,0 +1,36 @@ +'use strict'; + +exports.__esModule = true; + +var _namespace = require('./namespace'); + +var _namespace2 = _interopRequireDefault(_namespace); + +var _types = require('./types'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Universal = function (_Namespace) { + _inherits(Universal, _Namespace); + + function Universal(opts) { + _classCallCheck(this, Universal); + + var _this = _possibleConstructorReturn(this, _Namespace.call(this, opts)); + + _this.type = _types.UNIVERSAL; + _this.value = '*'; + return _this; + } + + return Universal; +}(_namespace2.default); + +exports.default = Universal; +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/sortAscending.js b/node_modules/postcss-selector-parser/dist/sortAscending.js new file mode 100644 index 00000000..17a2eb4e --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/sortAscending.js @@ -0,0 +1,10 @@ +"use strict"; + +exports.__esModule = true; +exports.default = sortAscending; +function sortAscending(list) { + return list.sort(function (a, b) { + return a - b; + }); +}; +module.exports = exports["default"]; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/dist/tokenize.js b/node_modules/postcss-selector-parser/dist/tokenize.js new file mode 100644 index 00000000..acc73b05 --- /dev/null +++ b/node_modules/postcss-selector-parser/dist/tokenize.js @@ -0,0 +1,231 @@ +'use strict'; + +exports.__esModule = true; +exports.default = tokenize; +var singleQuote = 39, + doubleQuote = 34, + backslash = 92, + slash = 47, + newline = 10, + space = 32, + feed = 12, + tab = 9, + cr = 13, + plus = 43, + gt = 62, + tilde = 126, + pipe = 124, + comma = 44, + openBracket = 40, + closeBracket = 41, + openSq = 91, + closeSq = 93, + semicolon = 59, + asterisk = 42, + colon = 58, + ampersand = 38, + at = 64, + atEnd = /[ \n\t\r\{\(\)'"\\;/]/g, + wordEnd = /[ \n\t\r\(\)\*:;@!&'"\+\|~>,\[\]\\]|\/(?=\*)/g; + +function tokenize(input) { + var tokens = []; + var css = input.css.valueOf(); + + var code = void 0, + next = void 0, + quote = void 0, + lines = void 0, + last = void 0, + content = void 0, + escape = void 0, + nextLine = void 0, + nextOffset = void 0, + escaped = void 0, + escapePos = void 0; + + var length = css.length; + var offset = -1; + var line = 1; + var pos = 0; + + var unclosed = function unclosed(what, end) { + if (input.safe) { + css += end; + next = css.length - 1; + } else { + throw input.error('Unclosed ' + what, line, pos - offset, pos); + } + }; + + while (pos < length) { + code = css.charCodeAt(pos); + + if (code === newline) { + offset = pos; + line += 1; + } + + switch (code) { + case newline: + case space: + case tab: + case cr: + case feed: + next = pos; + do { + next += 1; + code = css.charCodeAt(next); + if (code === newline) { + offset = next; + line += 1; + } + } while (code === space || code === newline || code === tab || code === cr || code === feed); + + tokens.push(['space', css.slice(pos, next), line, pos - offset, pos]); + pos = next - 1; + break; + + case plus: + case gt: + case tilde: + case pipe: + next = pos; + do { + next += 1; + code = css.charCodeAt(next); + } while (code === plus || code === gt || code === tilde || code === pipe); + tokens.push(['combinator', css.slice(pos, next), line, pos - offset, pos]); + pos = next - 1; + break; + + case asterisk: + tokens.push(['*', '*', line, pos - offset, pos]); + break; + + case ampersand: + tokens.push(['&', '&', line, pos - offset, pos]); + break; + + case comma: + tokens.push([',', ',', line, pos - offset, pos]); + break; + + case openSq: + tokens.push(['[', '[', line, pos - offset, pos]); + break; + + case closeSq: + tokens.push([']', ']', line, pos - offset, pos]); + break; + + case colon: + tokens.push([':', ':', line, pos - offset, pos]); + break; + + case semicolon: + tokens.push([';', ';', line, pos - offset, pos]); + break; + + case openBracket: + tokens.push(['(', '(', line, pos - offset, pos]); + break; + + case closeBracket: + tokens.push([')', ')', line, pos - offset, pos]); + break; + + case singleQuote: + case doubleQuote: + quote = code === singleQuote ? "'" : '"'; + next = pos; + do { + escaped = false; + next = css.indexOf(quote, next + 1); + if (next === -1) { + unclosed('quote', quote); + } + escapePos = next; + while (css.charCodeAt(escapePos - 1) === backslash) { + escapePos -= 1; + escaped = !escaped; + } + } while (escaped); + + tokens.push(['string', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]); + pos = next; + break; + + case at: + atEnd.lastIndex = pos + 1; + atEnd.test(css); + if (atEnd.lastIndex === 0) { + next = css.length - 1; + } else { + next = atEnd.lastIndex - 2; + } + tokens.push(['at-word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]); + pos = next; + break; + + case backslash: + next = pos; + escape = true; + while (css.charCodeAt(next + 1) === backslash) { + next += 1; + escape = !escape; + } + code = css.charCodeAt(next + 1); + if (escape && code !== slash && code !== space && code !== newline && code !== tab && code !== cr && code !== feed) { + next += 1; + } + tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]); + pos = next; + break; + + default: + if (code === slash && css.charCodeAt(pos + 1) === asterisk) { + next = css.indexOf('*/', pos + 2) + 1; + if (next === 0) { + unclosed('comment', '*/'); + } + + content = css.slice(pos, next + 1); + lines = content.split('\n'); + last = lines.length - 1; + + if (last > 0) { + nextLine = line + last; + nextOffset = next - lines[last].length; + } else { + nextLine = line; + nextOffset = offset; + } + + tokens.push(['comment', content, line, pos - offset, nextLine, next - nextOffset, pos]); + + offset = nextOffset; + line = nextLine; + pos = next; + } else { + wordEnd.lastIndex = pos + 1; + wordEnd.test(css); + if (wordEnd.lastIndex === 0) { + next = css.length - 1; + } else { + next = wordEnd.lastIndex - 2; + } + + tokens.push(['word', css.slice(pos, next + 1), line, pos - offset, line, next - offset, pos]); + pos = next; + } + + break; + } + + pos++; + } + + return tokens; +} +module.exports = exports['default']; \ No newline at end of file diff --git a/node_modules/postcss-selector-parser/package.json b/node_modules/postcss-selector-parser/package.json new file mode 100644 index 00000000..f4a59597 --- /dev/null +++ b/node_modules/postcss-selector-parser/package.json @@ -0,0 +1,64 @@ +{ + "name": "postcss-selector-parser", + "version": "2.2.3", + "devDependencies": { + "ava": "^0.17.0", + "babel-cli": "^6.4.0", + "babel-core": "^6.4.0", + "babel-plugin-add-module-exports": "^0.2.0", + "babel-plugin-precompile-charcodes": "^1.0.0", + "babel-preset-es2015": "^6.3.13", + "babel-preset-es2015-loose": "^7.0.0", + "babel-preset-stage-0": "^6.3.13", + "babel-register": "^6.9.0", + "coveralls": "^2.11.6", + "del-cli": "^0.2.0", + "eslint": "^3.0.0", + "eslint-config-cssnano": "^3.0.0", + "eslint-plugin-babel": "^3.3.0", + "eslint-plugin-import": "^1.10.2", + "glob": "^7.0.3", + "minimist": "^1.2.0", + "nyc": "^10.0.0" + }, + "main": "dist/index.js", + "files": [ + "API.md", + "CHANGELOG.md", + "LICENSE-MIT", + "dist" + ], + "scripts": { + "pretest": "eslint src", + "prepublish": "del-cli dist && BABEL_ENV=publish babel src --out-dir dist --ignore /__tests__/", + "report": "nyc report --reporter=html", + "test": "nyc ava src/__tests__/*.js", + "test-012": "nyc ava src/__tests__/*.js" + }, + "dependencies": { + "flatten": "^1.0.2", + "indexes-of": "^1.0.1", + "uniq": "^1.0.1" + }, + "license": "MIT", + "homepage": "https://github.com/postcss/postcss-selector-parser", + "author": { + "name": "Ben Briggs", + "email": "beneb.info@gmail.com", + "url": "http://beneb.info" + }, + "repository": "postcss/postcss-selector-parser", + "ava": { + "require": "babel-register", + "concurrency": 5 + }, + "nyc": { + "exclude": [ + "node_modules", + "**/__tests__" + ] + }, + "eslintConfig": { + "extends": "cssnano" + } +} -- cgit v1.2.3