BVB Source Codes

prettier Show parser-postcss.js Source code

Return Download prettier: download parser-postcss.js Source code - Download prettier Source code - Type:.js
  1. var postcss = (function () {
  2. function unwrapExports (x) {
  3.         return x && x.__esModule ? x['default'] : x;
  4. }
  5.  
  6. function createCommonjsModule(fn, module) {
  7.         return module = { exports: {} }, fn(module, module.exports), module.exports;
  8. }
  9.  
  10. var parserPostcss = createCommonjsModule(function (module) {
  11. module.exports =
  12. /******/ (function(modules) { // webpackBootstrap
  13. /******/        // The module cache
  14. /******/        var installedModules = {};
  15. /******/
  16. /******/        // The require function
  17. /******/        function __webpack_require__(moduleId) {
  18. /******/
  19. /******/                // Check if module is in cache
  20. /******/                if(installedModules[moduleId]) {
  21. /******/                        return installedModules[moduleId].exports;
  22. /******/                }
  23. /******/                // Create a new module (and put it into the cache)
  24. /******/                var module = installedModules[moduleId] = {
  25. /******/                        i: moduleId,
  26. /******/                        l: false,
  27. /******/                        exports: {}
  28. /******/                };
  29. /******/
  30. /******/                // Execute the module function
  31. /******/                modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  32. /******/
  33. /******/                // Flag the module as loaded
  34. /******/                module.l = true;
  35. /******/
  36. /******/                // Return the exports of the module
  37. /******/                return module.exports;
  38. /******/        }
  39. /******/
  40. /******/
  41. /******/        // expose the modules object (__webpack_modules__)
  42. /******/        __webpack_require__.m = modules;
  43. /******/
  44. /******/        // expose the module cache
  45. /******/        __webpack_require__.c = installedModules;
  46. /******/
  47. /******/        // identity function for calling harmony imports with the correct context
  48. /******/        __webpack_require__.i = function(value) { return value; };
  49. /******/
  50. /******/        // define getter function for harmony exports
  51. /******/        __webpack_require__.d = function(exports, name, getter) {
  52. /******/                if(!__webpack_require__.o(exports, name)) {
  53. /******/                        Object.defineProperty(exports, name, {
  54. /******/                                configurable: false,
  55. /******/                                enumerable: true,
  56. /******/                                get: getter
  57. /******/                        });
  58. /******/                }
  59. /******/        };
  60. /******/
  61. /******/        // getDefaultExport function for compatibility with non-harmony modules
  62. /******/        __webpack_require__.n = function(module) {
  63. /******/                var getter = module && module.__esModule ?
  64. /******/                        function getDefault() { return module['default']; } :
  65. /******/                        function getModuleExports() { return module; };
  66. /******/                __webpack_require__.d(getter, 'a', getter);
  67. /******/                return getter;
  68. /******/        };
  69. /******/
  70. /******/        // Object.prototype.hasOwnProperty.call
  71. /******/        __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  72. /******/
  73. /******/        // __webpack_public_path__
  74. /******/        __webpack_require__.p = "";
  75. /******/
  76. /******/        // Load entry module and return exports
  77. /******/        return __webpack_require__(__webpack_require__.s = 157);
  78. /******/ })
  79. /************************************************************************/
  80. /******/ ([
  81. /* 0 */
  82. /***/ (function(module, exports, __webpack_require__) {
  83.  
  84. "use strict";
  85.  
  86.  
  87. exports.__esModule = true;
  88. var TAG = exports.TAG = 'tag';
  89. var STRING = exports.STRING = 'string';
  90. var SELECTOR = exports.SELECTOR = 'selector';
  91. var ROOT = exports.ROOT = 'root';
  92. var PSEUDO = exports.PSEUDO = 'pseudo';
  93. var NESTING = exports.NESTING = 'nesting';
  94. var ID = exports.ID = 'id';
  95. var COMMENT = exports.COMMENT = 'comment';
  96. var COMBINATOR = exports.COMBINATOR = 'combinator';
  97. var CLASS = exports.CLASS = 'class';
  98. var ATTRIBUTE = exports.ATTRIBUTE = 'attribute';
  99. var UNIVERSAL = exports.UNIVERSAL = 'universal';
  100.  
  101. /***/ }),
  102. /* 1 */
  103. /***/ (function(module, exports, __webpack_require__) {
  104.  
  105. "use strict";
  106.  
  107.  
  108. const Node = __webpack_require__(4);
  109.  
  110. class Container extends Node {
  111.  
  112.   constructor (opts) {
  113.     super(opts);
  114.  
  115.     if (!this.nodes) {
  116.       this.nodes = [];
  117.     }
  118.   }
  119.  
  120.   push (child) {
  121.     child.parent = this;
  122.     this.nodes.push(child);
  123.     return this;
  124.   }
  125.  
  126.   each (callback) {
  127.     if (!this.lastEach) this.lastEach = 0;
  128.     if (!this.indexes) this.indexes = { };
  129.  
  130.     this.lastEach += 1;
  131.  
  132.     let id = this.lastEach,
  133.       index,
  134.       result;
  135.  
  136.     this.indexes[id] = 0;
  137.  
  138.     if (!this.nodes) return undefined;
  139.  
  140.     while (this.indexes[id] < this.nodes.length) {
  141.       index  = this.indexes[id];
  142.       result = callback(this.nodes[index], index);
  143.       if (result === false) break;
  144.  
  145.       this.indexes[id] += 1;
  146.     }
  147.  
  148.     delete this.indexes[id];
  149.  
  150.     return result;
  151.   }
  152.  
  153.   walk (callback) {
  154.     return this.each((child, i) => {
  155.       let result = callback(child, i);
  156.       if (result !== false && child.walk) {
  157.         result = child.walk(callback);
  158.       }
  159.       return result;
  160.     });
  161.   }
  162.  
  163.   walkType (type, callback) {
  164.     if (!type || !callback) {
  165.       throw new Error('Parameters {type} and {callback} are required.');
  166.     }
  167.  
  168.     // allow users to pass a constructor, or node type string; eg. Word.
  169.     type = type.name && type.prototype ? type.name : type;
  170.  
  171.     return this.walk((node, index) => {
  172.       if (node.type === type) {
  173.         return callback.call(this, node, index);
  174.       }
  175.     });
  176.   }
  177.  
  178.   append (node) {
  179.     node.parent = this;
  180.     this.nodes.push(node);
  181.     return this;
  182.   }
  183.  
  184.   prepend (node) {
  185.     node.parent = this;
  186.     this.nodes.unshift(node);
  187.     return this;
  188.   }
  189.  
  190.   cleanRaws (keepBetween) {
  191.     super.cleanRaws(keepBetween);
  192.     if (this.nodes) {
  193.       for (let node of this.nodes) node.cleanRaws(keepBetween);
  194.     }
  195.   }
  196.  
  197.   insertAfter (oldNode, newNode) {
  198.     let oldIndex = this.index(oldNode),
  199.       index;
  200.  
  201.     this.nodes.splice(oldIndex + 1, 0, newNode);
  202.  
  203.     for (let id in this.indexes) {
  204.       index = this.indexes[id];
  205.       if (oldIndex <= index) {
  206.         this.indexes[id] = index + this.nodes.length;
  207.       }
  208.     }
  209.  
  210.     return this;
  211.   }
  212.  
  213.   insertBefore (oldNode, newNode) {
  214.     let oldIndex = this.index(oldNode),
  215.       index;
  216.  
  217.     this.nodes.splice(oldIndex, 0, newNode);
  218.  
  219.     for (let id in this.indexes) {
  220.       index = this.indexes[id];
  221.       if (oldIndex <= index) {
  222.         this.indexes[id] = index + this.nodes.length;
  223.       }
  224.     }
  225.  
  226.     return this;
  227.   }
  228.  
  229.   removeChild (child) {
  230.     child = this.index(child);
  231.     this.nodes[child].parent = undefined;
  232.     this.nodes.splice(child, 1);
  233.  
  234.     let index;
  235.     for (let id in this.indexes) {
  236.       index = this.indexes[id];
  237.       if (index >= child) {
  238.         this.indexes[id] = index - 1;
  239.       }
  240.     }
  241.  
  242.     return this;
  243.   }
  244.  
  245.   removeAll () {
  246.     for (let node of this.nodes) node.parent = undefined;
  247.     this.nodes = [];
  248.     return this;
  249.   }
  250.  
  251.   every (condition) {
  252.     return this.nodes.every(condition);
  253.   }
  254.  
  255.   some (condition) {
  256.     return this.nodes.some(condition);
  257.   }
  258.  
  259.   index (child) {
  260.     if (typeof child === 'number') {
  261.       return child;
  262.     }
  263.     else {
  264.       return this.nodes.indexOf(child);
  265.     }
  266.   }
  267.  
  268.   get first () {
  269.     if (!this.nodes) return undefined;
  270.     return this.nodes[0];
  271.   }
  272.  
  273.   get last () {
  274.     if (!this.nodes) return undefined;
  275.     return this.nodes[this.nodes.length - 1];
  276.   }
  277.  
  278.   toString () {
  279.     let result = this.nodes.map(String).join('');
  280.  
  281.     if (this.value) {
  282.       result = this.value + result;
  283.     }
  284.  
  285.     if (this.raws.before) {
  286.       result = this.raws.before + result;
  287.     }
  288.  
  289.     if (this.raws.after) {
  290.       result += this.raws.after;
  291.     }
  292.  
  293.     return result;
  294.   }
  295. }
  296.  
  297. Container.registerWalker = (constructor) => {
  298.   let walkerName = 'walk' + constructor.name;
  299.  
  300.   // plural sugar
  301.   if (walkerName.lastIndexOf('s') !== walkerName.length - 1) {
  302.     walkerName += 's';
  303.   }
  304.  
  305.   if (Container.prototype[walkerName]) {
  306.     return;
  307.   }
  308.  
  309.   // we need access to `this` so we can't use an arrow function
  310.   Container.prototype[walkerName] = function (callback) {
  311.     return this.walkType(constructor, callback);
  312.   };
  313. };
  314.  
  315. module.exports = Container;
  316.  
  317.  
  318. /***/ }),
  319. /* 2 */
  320. /***/ (function(module, exports, __webpack_require__) {
  321.  
  322. "use strict";
  323.  
  324.  
  325. Object.defineProperty(exports, "__esModule", {
  326.   value: true
  327. });
  328. var singleQuote = exports.singleQuote = '\''.charCodeAt(0);
  329. var doubleQuote = exports.doubleQuote = '"'.charCodeAt(0);
  330. var backslash = exports.backslash = '\\'.charCodeAt(0);
  331. var backTick = exports.backTick = '`'.charCodeAt(0);
  332. var slash = exports.slash = '/'.charCodeAt(0);
  333. var newline = exports.newline = '\n'.charCodeAt(0);
  334. var space = exports.space = ' '.charCodeAt(0);
  335. var feed = exports.feed = '\f'.charCodeAt(0);
  336. var tab = exports.tab = '\t'.charCodeAt(0);
  337. var carriageReturn = exports.carriageReturn = '\r'.charCodeAt(0);
  338. var openedParenthesis = exports.openedParenthesis = '('.charCodeAt(0);
  339. var closedParenthesis = exports.closedParenthesis = ')'.charCodeAt(0);
  340. var openedCurlyBracket = exports.openedCurlyBracket = '{'.charCodeAt(0);
  341. var closedCurlyBracket = exports.closedCurlyBracket = '}'.charCodeAt(0);
  342. var openSquareBracket = exports.openSquareBracket = '['.charCodeAt(0);
  343. var closeSquareBracket = exports.closeSquareBracket = ']'.charCodeAt(0);
  344. var semicolon = exports.semicolon = ';'.charCodeAt(0);
  345. var asterisk = exports.asterisk = '*'.charCodeAt(0);
  346. var colon = exports.colon = ':'.charCodeAt(0);
  347. var comma = exports.comma = ','.charCodeAt(0);
  348. var dot = exports.dot = '.'.charCodeAt(0);
  349. var atRule = exports.atRule = '@'.charCodeAt(0);
  350. var tilde = exports.tilde = '~'.charCodeAt(0);
  351. var hash = exports.hash = '#'.charCodeAt(0);
  352.  
  353. var atEndPattern = exports.atEndPattern = /[ \n\t\r\f\{\(\)'"\\;/\[\]#]/g;
  354. var wordEndPattern = exports.wordEndPattern = /[ \n\t\r\f\(\)\{\}:,;@!'"\\\]\[#]|\/(?=\*)/g;
  355. var badBracketPattern = exports.badBracketPattern = /.[\\\/\("'\n]/;
  356.  
  357. var variablePattern = exports.variablePattern = /^@[^:\(\{]+:/;
  358. var hashColorPattern = exports.hashColorPattern = /^#[0-9a-fA-F]{6}$|^#[0-9a-fA-F]{3}$/;
  359.  
  360. /***/ }),
  361. /* 3 */
  362. /***/ (function(module, exports, __webpack_require__) {
  363.  
  364. "use strict";
  365.  
  366.  
  367. exports.__esModule = true;
  368. exports.default = warnOnce;
  369. var printed = {};
  370.  
  371. function warnOnce(message) {
  372.    if (printed[message]) return;
  373.    printed[message] = true;
  374.  
  375.    if (typeof console !== 'undefined' && console.warn) console.warn(message);
  376. }
  377. module.exports = exports['default'];
  378.  
  379.  
  380.  
  381. /***/ }),
  382. /* 4 */
  383. /***/ (function(module, exports, __webpack_require__) {
  384.  
  385. "use strict";
  386.  
  387.  
  388. let cloneNode = function (obj, parent) {
  389.  let cloned = new obj.constructor();
  390.  
  391.  for (let i in obj) {
  392.    if (!obj.hasOwnProperty(i)) continue;
  393.  
  394.    let value = obj[i],
  395.      type  = typeof value;
  396.  
  397.    if (i === 'parent' && type === 'object') {
  398.      if (parent) cloned[i] = parent;
  399.    }
  400.    else if (i === 'source') {
  401.      cloned[i] = value;
  402.    }
  403.    else if (value instanceof Array) {
  404.      cloned[i] = value.map(j => cloneNode(j, cloned));
  405.    }
  406.    else if (i !== 'before'  && i !== 'after' && i !== 'between' && i !== 'semicolon') {
  407.      if (type === 'object' && value !== null) value = cloneNode(value);
  408.      cloned[i] = value;
  409.    }
  410.  }
  411.  
  412.  return cloned;
  413. };
  414.  
  415. module.exports = class Node {
  416.  
  417.  constructor (defaults) {
  418.    defaults = defaults || {};
  419.    this.raws = { before: '', after: '' };
  420.  
  421.    for (let name in defaults) {
  422.      this[name] = defaults[name];
  423.    }
  424.  }
  425.  
  426.  remove () {
  427.    if (this.parent) {
  428.      this.parent.removeChild(this);
  429.    }
  430.  
  431.    this.parent = undefined;
  432.  
  433.    return this;
  434.  }
  435.  
  436.  toString () {
  437.    return [
  438.      this.raws.before,
  439.      String(this.value),
  440.      this.raws.after
  441.    ].join('');
  442.  }
  443.  
  444.  clone (overrides) {
  445.    overrides = overrides || {};
  446.  
  447.    let cloned = cloneNode(this);
  448.  
  449.    for (let name in overrides) {
  450.      cloned[name] = overrides[name];
  451.    }
  452.  
  453.    return cloned;
  454.  }
  455.  
  456.  cloneBefore (overrides) {
  457.    overrides = overrides || {};
  458.  
  459.    let cloned = this.clone(overrides);
  460.  
  461.    this.parent.insertBefore(this, cloned);
  462.    return cloned;
  463.  }
  464.  
  465.  cloneAfter (overrides) {
  466.    overrides = overrides || {};
  467.  
  468.    let cloned = this.clone(overrides);
  469.  
  470.    this.parent.insertAfter(this, cloned);
  471.    return cloned;
  472.  }
  473.  
  474.  replaceWith () {
  475.    let nodes = Array.prototype.slice.call(arguments);
  476.  
  477.    if (this.parent) {
  478.      for (let node of nodes) {
  479.        this.parent.insertBefore(this, node);
  480.      }
  481.  
  482.      this.remove();
  483.    }
  484.  
  485.    return this;
  486.  }
  487.  
  488.  moveTo (container) {
  489.    this.cleanRaws(this.root() === container.root());
  490.    this.remove();
  491.  
  492.    container.append(this);
  493.  
  494.    return this;
  495.  }
  496.  
  497.  moveBefore (node) {
  498.    this.cleanRaws(this.root() === node.root());
  499.    this.remove();
  500.  
  501.    node.parent.insertBefore(node, this);
  502.  
  503.    return this;
  504.  }
  505.  
  506.  moveAfter (node) {
  507.    this.cleanRaws(this.root() === node.root());
  508.    this.remove();
  509.    node.parent.insertAfter(node, this);
  510.    return this;
  511.  }
  512.  
  513.  next () {
  514.    let index = this.parent.index(this);
  515.  
  516.    return this.parent.nodes[index + 1];
  517.  }
  518.  
  519.  prev () {
  520.    let index = this.parent.index(this);
  521.  
  522.    return this.parent.nodes[index - 1];
  523.  }
  524.  
  525.  toJSON () {
  526.    let fixed = { };
  527.  
  528.    for (let name in this) {
  529.      if (!this.hasOwnProperty(name)) continue;
  530.      if (name === 'parent') continue;
  531.      let value = this[name];
  532.  
  533.      if (value instanceof Array) {
  534.        fixed[name] = value.map(i => {
  535.          if (typeof i === 'object' && i.toJSON) {
  536.            return i.toJSON();
  537.          }
  538.          else {
  539.            return i;
  540.          }
  541.        });
  542.      }
  543.      else if (typeof value === 'object' && value.toJSON) {
  544.        fixed[name] = value.toJSON();
  545.      }
  546.      else {
  547.        fixed[name] = value;
  548.      }
  549.    }
  550.  
  551.    return fixed;
  552.  }
  553.  
  554.  root () {
  555.    let result = this;
  556.  
  557.    while (result.parent) result = result.parent;
  558.  
  559.    return result;
  560.  }
  561.  
  562.  cleanRaws (keepBetween) {
  563.    delete this.raws.before;
  564.    delete this.raws.after;
  565.    if (!keepBetween) delete this.raws.between;
  566.  }
  567.  
  568.  positionInside (index) {
  569.    let string = this.toString(),
  570.      column = this.source.start.column,
  571.      line   = this.source.start.line;
  572.  
  573.    for (let i = 0; i < index; i++) {
  574.      if (string[i] === '\n') {
  575.        column = 1;
  576.        line  += 1;
  577.      }
  578.      else {
  579.        column += 1;
  580.      }
  581.    }
  582.  
  583.    return { line, column };
  584.  }
  585.  
  586.  positionBy (opts) {
  587.    let pos = this.source.start;
  588.  
  589.    if (opts.index) {
  590.      pos = this.positionInside(opts.index);
  591.    }
  592.    else if (opts.word) {
  593.      let index = this.toString().indexOf(opts.word);
  594.      if (index !== -1) pos = this.positionInside(index);
  595.    }
  596.  
  597.    return pos;
  598.  }
  599. };
  600.  
  601.  
  602. /***/ }),
  603. /* 5 */
  604. /***/ (function(module, exports, __webpack_require__) {
  605.  
  606. /* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
  607. //
  608. // Permission is hereby granted, free of charge, to any person obtaining a
  609. // copy of this software and associated documentation files (the
  610. // "Software"), to deal in the Software without restriction, including
  611. // without limitation the rights to use, copy, modify, merge, publish,
  612. // distribute, sublicense, and/or sell copies of the Software, and to permit
  613. // persons to whom the Software is furnished to do so, subject to the
  614. // following conditions:
  615. //
  616. // The above copyright notice and this permission notice shall be included
  617. // in all copies or substantial portions of the Software.
  618. //
  619. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  620. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  621. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  622. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  623. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  624. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  625. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  626.  
  627. // resolves . and .. elements in a path array with directory names there
  628. // must be no slashes, empty elements, or device names (c:\) in the array
  629. // (so also no leading and trailing slashes - it does not distinguish
  630. // relative and absolute paths)
  631. function normalizeArray(parts, allowAboveRoot) {
  632.  // if the path tries to go above the root, `up` ends up > 0
  633.  var up = 0;
  634.  for (var i = parts.length - 1; i >= 0; i--) {
  635.    var last = parts[i];
  636.    if (last === '.') {
  637.      parts.splice(i, 1);
  638.    } else if (last === '..') {
  639.      parts.splice(i, 1);
  640.      up++;
  641.    } else if (up) {
  642.      parts.splice(i, 1);
  643.      up--;
  644.    }
  645.  }
  646.  
  647.  // if the path is allowed to go above the root, restore leading ..s
  648.  if (allowAboveRoot) {
  649.    for (; up--; up) {
  650.      parts.unshift('..');
  651.    }
  652.  }
  653.  
  654.  return parts;
  655. }
  656.  
  657. // Split a filename into [root, dir, basename, ext], unix version
  658. // 'root' is just a slash, or nothing.
  659. var splitPathRe =
  660.    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
  661. var splitPath = function(filename) {
  662.  return splitPathRe.exec(filename).slice(1);
  663. };
  664.  
  665. // path.resolve([from ...], to)
  666. // posix version
  667. exports.resolve = function() {
  668.  var resolvedPath = '',
  669.      resolvedAbsolute = false;
  670.  
  671.  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
  672.    var path = (i >= 0) ? arguments[i] : process.cwd();
  673.  
  674.    // Skip empty and invalid entries
  675.    if (typeof path !== 'string') {
  676.      throw new TypeError('Arguments to path.resolve must be strings');
  677.    } else if (!path) {
  678.      continue;
  679.    }
  680.  
  681.    resolvedPath = path + '/' + resolvedPath;
  682.    resolvedAbsolute = path.charAt(0) === '/';
  683.  }
  684.  
  685.  // At this point the path should be resolved to a full absolute path, but
  686.  // handle relative paths to be safe (might happen when process.cwd() fails)
  687.  
  688.  // Normalize the path
  689.  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
  690.    return !!p;
  691.  }), !resolvedAbsolute).join('/');
  692.  
  693.  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
  694. };
  695.  
  696. // path.normalize(path)
  697. // posix version
  698. exports.normalize = function(path) {
  699.  var isAbsolute = exports.isAbsolute(path),
  700.      trailingSlash = substr(path, -1) === '/';
  701.  
  702.  // Normalize the path
  703.  path = normalizeArray(filter(path.split('/'), function(p) {
  704.    return !!p;
  705.  }), !isAbsolute).join('/');
  706.  
  707.  if (!path && !isAbsolute) {
  708.    path = '.';
  709.  }
  710.  if (path && trailingSlash) {
  711.    path += '/';
  712.  }
  713.  
  714.  return (isAbsolute ? '/' : '') + path;
  715. };
  716.  
  717. // posix version
  718. exports.isAbsolute = function(path) {
  719.  return path.charAt(0) === '/';
  720. };
  721.  
  722. // posix version
  723. exports.join = function() {
  724.  var paths = Array.prototype.slice.call(arguments, 0);
  725.  return exports.normalize(filter(paths, function(p, index) {
  726.    if (typeof p !== 'string') {
  727.      throw new TypeError('Arguments to path.join must be strings');
  728.    }
  729.    return p;
  730.  }).join('/'));
  731. };
  732.  
  733.  
  734. // path.relative(from, to)
  735. // posix version
  736. exports.relative = function(from, to) {
  737.  from = exports.resolve(from).substr(1);
  738.  to = exports.resolve(to).substr(1);
  739.  
  740.  function trim(arr) {
  741.    var start = 0;
  742.    for (; start < arr.length; start++) {
  743.      if (arr[start] !== '') break;
  744.    }
  745.  
  746.    var end = arr.length - 1;
  747.    for (; end >= 0; end--) {
  748.      if (arr[end] !== '') break;
  749.    }
  750.  
  751.    if (start > end) return [];
  752.    return arr.slice(start, end - start + 1);
  753.  }
  754.  
  755.  var fromParts = trim(from.split('/'));
  756.  var toParts = trim(to.split('/'));
  757.  
  758.  var length = Math.min(fromParts.length, toParts.length);
  759.  var samePartsLength = length;
  760.  for (var i = 0; i < length; i++) {
  761.    if (fromParts[i] !== toParts[i]) {
  762.      samePartsLength = i;
  763.      break;
  764.    }
  765.  }
  766.  
  767.  var outputParts = [];
  768.  for (var i = samePartsLength; i < fromParts.length; i++) {
  769.    outputParts.push('..');
  770.  }
  771.  
  772.  outputParts = outputParts.concat(toParts.slice(samePartsLength));
  773.  
  774.  return outputParts.join('/');
  775. };
  776.  
  777. exports.sep = '/';
  778. exports.delimiter = ':';
  779.  
  780. exports.dirname = function(path) {
  781.  var result = splitPath(path),
  782.      root = result[0],
  783.      dir = result[1];
  784.  
  785.  if (!root && !dir) {
  786.    // No dirname whatsoever
  787.    return '.';
  788.  }
  789.  
  790.  if (dir) {
  791.    // It has a dirname, strip trailing slash
  792.    dir = dir.substr(0, dir.length - 1);
  793.  }
  794.  
  795.  return root + dir;
  796. };
  797.  
  798.  
  799. exports.basename = function(path, ext) {
  800.  var f = splitPath(path)[2];
  801.  // TODO: make this comparison case-insensitive on windows?
  802.  if (ext && f.substr(-1 * ext.length) === ext) {
  803.    f = f.substr(0, f.length - ext.length);
  804.  }
  805.  return f;
  806. };
  807.  
  808.  
  809. exports.extname = function(path) {
  810.  return splitPath(path)[3];
  811. };
  812.  
  813. function filter (xs, f) {
  814.    if (xs.filter) return xs.filter(f);
  815.    var res = [];
  816.    for (var i = 0; i < xs.length; i++) {
  817.        if (f(xs[i], i, xs)) res.push(xs[i]);
  818.    }
  819.    return res;
  820. }
  821.  
  822. // String.prototype.substr - negative index don't work in IE8
  823. var substr = 'ab'.substr(-1) === 'b'
  824.     ? function (str, start, len) { return str.substr(start, len) }
  825.     : function (str, start, len) {
  826.         if (start < 0) start = str.length + start;
  827.         return str.substr(start, len);
  828.     };
  829.  
  830. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(13)));
  831.  
  832. /***/ }),
  833. /* 6 */
  834. /***/ (function(module, exports, __webpack_require__) {
  835.  
  836. "use strict";
  837.  
  838.  
  839. exports.__esModule = true;
  840.  
  841. 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; };
  842.  
  843. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  844.  
  845. var cloneNode = function cloneNode(obj, parent) {
  846.     if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object') {
  847.         return obj;
  848.     }
  849.  
  850.     var cloned = new obj.constructor();
  851.  
  852.     for (var i in obj) {
  853.         if (!obj.hasOwnProperty(i)) {
  854.             continue;
  855.         }
  856.         var value = obj[i];
  857.         var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
  858.  
  859.         if (i === 'parent' && type === 'object') {
  860.             if (parent) {
  861.                 cloned[i] = parent;
  862.             }
  863.         } else if (value instanceof Array) {
  864.             cloned[i] = value.map(function (j) {
  865.                 return cloneNode(j, cloned);
  866.             });
  867.         } else {
  868.             cloned[i] = cloneNode(value, cloned);
  869.         }
  870.     }
  871.  
  872.     return cloned;
  873. };
  874.  
  875. var _class = function () {
  876.     function _class() {
  877.         var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  878.  
  879.         _classCallCheck(this, _class);
  880.  
  881.         for (var key in opts) {
  882.             this[key] = opts[key];
  883.         }
  884.         var _opts$spaces = opts.spaces;
  885.         _opts$spaces = _opts$spaces === undefined ? {} : _opts$spaces;
  886.         var _opts$spaces$before = _opts$spaces.before,
  887.             before = _opts$spaces$before === undefined ? '' : _opts$spaces$before,
  888.             _opts$spaces$after = _opts$spaces.after,
  889.             after = _opts$spaces$after === undefined ? '' : _opts$spaces$after;
  890.  
  891.         this.spaces = { before: before, after: after };
  892.     }
  893.  
  894.     _class.prototype.remove = function remove() {
  895.         if (this.parent) {
  896.             this.parent.removeChild(this);
  897.         }
  898.         this.parent = undefined;
  899.         return this;
  900.     };
  901.  
  902.     _class.prototype.replaceWith = function replaceWith() {
  903.         if (this.parent) {
  904.             for (var index in arguments) {
  905.                 this.parent.insertBefore(this, arguments[index]);
  906.             }
  907.             this.remove();
  908.         }
  909.         return this;
  910.     };
  911.  
  912.     _class.prototype.next = function next() {
  913.         return this.parent.at(this.parent.index(this) + 1);
  914.     };
  915.  
  916.     _class.prototype.prev = function prev() {
  917.         return this.parent.at(this.parent.index(this) - 1);
  918.     };
  919.  
  920.     _class.prototype.clone = function clone() {
  921.         var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  922.  
  923.         var cloned = cloneNode(this);
  924.         for (var name in overrides) {
  925.             cloned[name] = overrides[name];
  926.         }
  927.         return cloned;
  928.     };
  929.  
  930.     _class.prototype.toString = function toString() {
  931.         return [this.spaces.before, String(this.value), this.spaces.after].join('');
  932.     };
  933.  
  934.     return _class;
  935. }();
  936.  
  937. exports.default = _class;
  938. module.exports = exports['default'];
  939.  
  940. /***/ }),
  941. /* 7 */
  942. /***/ (function(module, exports, __webpack_require__) {
  943.  
  944. "use strict";
  945.  
  946.  
  947. Object.defineProperty(exports, "__esModule", {
  948.   value: true
  949. });
  950. exports.default = unclosed;
  951. function unclosed(state, what) {
  952.   throw state.input.error("Unclosed " + what, state.line, state.pos - state.offset);
  953. }
  954. module.exports = exports["default"];
  955.  
  956. /***/ }),
  957. /* 8 */
  958. /***/ (function(module, exports, __webpack_require__) {
  959.  
  960. "use strict";
  961.  
  962.  
  963. exports.__esModule = true;
  964.  
  965. 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; }; }();
  966.  
  967. var _container = __webpack_require__(19);
  968.  
  969. var _container2 = _interopRequireDefault(_container);
  970.  
  971. var _warnOnce = __webpack_require__(3);
  972.  
  973. var _warnOnce2 = _interopRequireDefault(_warnOnce);
  974.  
  975. var _list = __webpack_require__(115);
  976.  
  977. var _list2 = _interopRequireDefault(_list);
  978.  
  979. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  980.  
  981. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  982.  
  983. 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; }
  984.  
  985. 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; }
  986.  
  987. /**
  988.  * Represents a CSS rule: a selector followed by a declaration block.
  989.  *
  990.  * @extends Container
  991.  *
  992.  * @example
  993.  * const root = postcss.parse('a{}');
  994.  * const rule = root.first;
  995.  * rule.type       //=> 'rule'
  996.  * rule.toString() //=> 'a{}'
  997.  */
  998. var Rule = function (_Container) {
  999.     _inherits(Rule, _Container);
  1000.  
  1001.     function Rule(defaults) {
  1002.         _classCallCheck(this, Rule);
  1003.  
  1004.         var _this = _possibleConstructorReturn(this, _Container.call(this, defaults));
  1005.  
  1006.         _this.type = 'rule';
  1007.         if (!_this.nodes) _this.nodes = [];
  1008.         return _this;
  1009.     }
  1010.  
  1011.     /**
  1012.      * An array containing the rule鈥檚 individual selectors.
  1013.      * Groups of selectors are split at commas.
  1014.      *
  1015.      * @type {string[]}
  1016.      *
  1017.      * @example
  1018.      * const root = postcss.parse('a, b { }');
  1019.      * const rule = root.first;
  1020.      *
  1021.      * rule.selector  //=> 'a, b'
  1022.      * rule.selectors //=> ['a', 'b']
  1023.      *
  1024.      * rule.selectors = ['a', 'strong'];
  1025.      * rule.selector //=> 'a, strong'
  1026.      */
  1027.  
  1028.  
  1029.     _createClass(Rule, [{
  1030.         key: 'selectors',
  1031.         get: function get() {
  1032.             return _list2.default.comma(this.selector);
  1033.         },
  1034.         set: function set(values) {
  1035.             var match = this.selector ? this.selector.match(/,\s*/) : null;
  1036.             var sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');
  1037.             this.selector = values.join(sep);
  1038.         }
  1039.     }, {
  1040.         key: '_selector',
  1041.         get: function get() {
  1042.             (0, _warnOnce2.default)('Rule#_selector is deprecated. Use Rule#raws.selector');
  1043.             return this.raws.selector;
  1044.         },
  1045.         set: function set(val) {
  1046.             (0, _warnOnce2.default)('Rule#_selector is deprecated. Use Rule#raws.selector');
  1047.             this.raws.selector = val;
  1048.         }
  1049.  
  1050.         /**
  1051.          * @memberof Rule#
  1052.          * @member {string} selector - the rule鈥檚 full selector represented
  1053.          *                             as a string
  1054.          *
  1055.          * @example
  1056.          * const root = postcss.parse('a, b { }');
  1057.          * const rule = root.first;
  1058.          * rule.selector //=> 'a, b'
  1059.          */
  1060.  
  1061.         /**
  1062.          * @memberof Rule#
  1063.          * @member {object} raws - Information to generate byte-to-byte equal
  1064.          *                         node string as it was in the origin input.
  1065.          *
  1066.          * Every parser saves its own properties,
  1067.          * but the default CSS parser uses:
  1068.          *
  1069.          * * `before`: the space symbols before the node. It also stores `*`
  1070.          *   and `_` symbols before the declaration (IE hack).
  1071.          * * `after`: the space symbols after the last child of the node
  1072.          *   to the end of the node.
  1073.          * * `between`: the symbols between the property and value
  1074.          *   for declarations, selector and `{` for rules, or last parameter
  1075.          *   and `{` for at-rules.
  1076.          * * `semicolon`: contains true if the last child has
  1077.          *   an (optional) semicolon.
  1078.          *
  1079.          * PostCSS cleans selectors from comments and extra spaces,
  1080.          * but it stores origin content in raws properties.
  1081.          * As such, if you don鈥檛 change a declaration鈥檚 value,
  1082.          * PostCSS will use the raw value with comments.
  1083.          *
  1084.          * @example
  1085.          * const root = postcss.parse('a {\n  color:black\n}')
  1086.          * root.first.first.raws //=> { before: '', between: ' ', after: '\n' }
  1087.          */
  1088.  
  1089.     }]);
  1090.  
  1091.     return Rule;
  1092. }(_container2.default);
  1093.  
  1094. exports.default = Rule;
  1095. module.exports = exports['default'];
  1096.  
  1097.  
  1098.  
  1099. /***/ }),
  1100. /* 9 */
  1101. /***/ (function(module, exports, __webpack_require__) {
  1102.  
  1103. "use strict";
  1104.  
  1105.  
  1106. exports.__esModule = true;
  1107.  
  1108. 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; }; }();
  1109.  
  1110. var _node = __webpack_require__(6);
  1111.  
  1112. var _node2 = _interopRequireDefault(_node);
  1113.  
  1114. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  1115.  
  1116. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  1117.  
  1118. 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; }
  1119.  
  1120. 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; }
  1121.  
  1122. var Namespace = function (_Node) {
  1123.     _inherits(Namespace, _Node);
  1124.  
  1125.     function Namespace() {
  1126.         _classCallCheck(this, Namespace);
  1127.  
  1128.         return _possibleConstructorReturn(this, _Node.apply(this, arguments));
  1129.     }
  1130.  
  1131.     Namespace.prototype.toString = function toString() {
  1132.         return [this.spaces.before, this.ns, String(this.value), this.spaces.after].join('');
  1133.     };
  1134.  
  1135.     _createClass(Namespace, [{
  1136.         key: 'ns',
  1137.         get: function get() {
  1138.             var n = this.namespace;
  1139.             return n ? (typeof n === 'string' ? n : '') + '|' : '';
  1140.         }
  1141.     }]);
  1142.  
  1143.     return Namespace;
  1144. }(_node2.default);
  1145.  
  1146. exports.default = Namespace;
  1147.  
  1148. module.exports = exports['default'];
  1149.  
  1150. /***/ }),
  1151. /* 10 */
  1152. /***/ (function(module, exports) {
  1153.  
  1154. /* -*- Mode: js; js-indent-level: 2; -*- */
  1155. /*
  1156.  * Copyright 2011 Mozilla Foundation and contributors
  1157.  * Licensed under the New BSD license. See LICENSE or:
  1158.  * http://opensource.org/licenses/BSD-3-Clause
  1159.  */
  1160.  
  1161. /**
  1162.  * This is a helper function for getting values from parameter/options
  1163.  * objects.
  1164.  *
  1165.  * @param args The object we are extracting values from
  1166.  * @param name The name of the property we are getting.
  1167.  * @param defaultValue An optional value to return if the property is missing
  1168.  * from the object. If this is not specified and the property is missing, an
  1169.  * error will be thrown.
  1170.  */
  1171. function getArg(aArgs, aName, aDefaultValue) {
  1172.   if (aName in aArgs) {
  1173.     return aArgs[aName];
  1174.   } else if (arguments.length === 3) {
  1175.     return aDefaultValue;
  1176.   } else {
  1177.     throw new Error('"' + aName + '" is a required argument.');
  1178.   }
  1179. }
  1180. exports.getArg = getArg;
  1181.  
  1182. var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
  1183. var dataUrlRegexp = /^data:.+\,.+$/;
  1184.  
  1185. function urlParse(aUrl) {
  1186.   var match = aUrl.match(urlRegexp);
  1187.   if (!match) {
  1188.     return null;
  1189.   }
  1190.   return {
  1191.     scheme: match[1],
  1192.     auth: match[2],
  1193.     host: match[3],
  1194.     port: match[4],
  1195.     path: match[5]
  1196.   };
  1197. }
  1198. exports.urlParse = urlParse;
  1199.  
  1200. function urlGenerate(aParsedUrl) {
  1201.   var url = '';
  1202.   if (aParsedUrl.scheme) {
  1203.     url += aParsedUrl.scheme + ':';
  1204.   }
  1205.   url += '//';
  1206.   if (aParsedUrl.auth) {
  1207.     url += aParsedUrl.auth + '@';
  1208.   }
  1209.   if (aParsedUrl.host) {
  1210.     url += aParsedUrl.host;
  1211.   }
  1212.   if (aParsedUrl.port) {
  1213.     url += ":" + aParsedUrl.port;
  1214.   }
  1215.   if (aParsedUrl.path) {
  1216.     url += aParsedUrl.path;
  1217.   }
  1218.   return url;
  1219. }
  1220. exports.urlGenerate = urlGenerate;
  1221.  
  1222. /**
  1223.  * Normalizes a path, or the path portion of a URL:
  1224.  *
  1225.  * - Replaces consecutive slashes with one slash.
  1226.  * - Removes unnecessary '.' parts.
  1227.  * - Removes unnecessary '<dir>/..' parts.
  1228.  *
  1229.  * Based on code in the Node.js 'path' core module.
  1230.  *
  1231.  * @param aPath The path or url to normalize.
  1232.  */
  1233. function normalize(aPath) {
  1234.   var path = aPath;
  1235.   var url = urlParse(aPath);
  1236.   if (url) {
  1237.     if (!url.path) {
  1238.       return aPath;
  1239.     }
  1240.     path = url.path;
  1241.   }
  1242.   var isAbsolute = exports.isAbsolute(path);
  1243.  
  1244.   var parts = path.split(/\/+/);
  1245.   for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
  1246.     part = parts[i];
  1247.     if (part === '.') {
  1248.       parts.splice(i, 1);
  1249.     } else if (part === '..') {
  1250.       up++;
  1251.     } else if (up > 0) {
  1252.       if (part === '') {
  1253.         // The first part is blank if the path is absolute. Trying to go
  1254.         // above the root is a no-op. Therefore we can remove all '..' parts
  1255.         // directly after the root.
  1256.         parts.splice(i + 1, up);
  1257.         up = 0;
  1258.       } else {
  1259.         parts.splice(i, 2);
  1260.         up--;
  1261.       }
  1262.     }
  1263.   }
  1264.   path = parts.join('/');
  1265.  
  1266.   if (path === '') {
  1267.     path = isAbsolute ? '/' : '.';
  1268.   }
  1269.  
  1270.   if (url) {
  1271.     url.path = path;
  1272.     return urlGenerate(url);
  1273.   }
  1274.   return path;
  1275. }
  1276. exports.normalize = normalize;
  1277.  
  1278. /**
  1279.  * Joins two paths/URLs.
  1280.  *
  1281.  * @param aRoot The root path or URL.
  1282.  * @param aPath The path or URL to be joined with the root.
  1283.  *
  1284.  * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
  1285.  *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
  1286.  *   first.
  1287.  * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
  1288.  *   is updated with the result and aRoot is returned. Otherwise the result
  1289.  *   is returned.
  1290.  *   - If aPath is absolute, the result is aPath.
  1291.  *   - Otherwise the two paths are joined with a slash.
  1292.  * - Joining for example 'http://' and 'www.example.com' is also supported.
  1293.  */
  1294. function join(aRoot, aPath) {
  1295.   if (aRoot === "") {
  1296.     aRoot = ".";
  1297.   }
  1298.   if (aPath === "") {
  1299.     aPath = ".";
  1300.   }
  1301.   var aPathUrl = urlParse(aPath);
  1302.   var aRootUrl = urlParse(aRoot);
  1303.   if (aRootUrl) {
  1304.     aRoot = aRootUrl.path || '/';
  1305.   }
  1306.  
  1307.   // `join(foo, '//www.example.org')`
  1308.   if (aPathUrl && !aPathUrl.scheme) {
  1309.     if (aRootUrl) {
  1310.       aPathUrl.scheme = aRootUrl.scheme;
  1311.     }
  1312.     return urlGenerate(aPathUrl);
  1313.   }
  1314.  
  1315.   if (aPathUrl || aPath.match(dataUrlRegexp)) {
  1316.     return aPath;
  1317.   }
  1318.  
  1319.   // `join('http://', 'www.example.com')`
  1320.   if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
  1321.     aRootUrl.host = aPath;
  1322.     return urlGenerate(aRootUrl);
  1323.   }
  1324.  
  1325.   var joined = aPath.charAt(0) === '/'
  1326.     ? aPath
  1327.     : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
  1328.  
  1329.   if (aRootUrl) {
  1330.     aRootUrl.path = joined;
  1331.     return urlGenerate(aRootUrl);
  1332.   }
  1333.   return joined;
  1334. }
  1335. exports.join = join;
  1336.  
  1337. exports.isAbsolute = function (aPath) {
  1338.   return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);
  1339. };
  1340.  
  1341. /**
  1342.  * Make a path relative to a URL or another path.
  1343.  *
  1344.  * @param aRoot The root path or URL.
  1345.  * @param aPath The path or URL to be made relative to aRoot.
  1346.  */
  1347. function relative(aRoot, aPath) {
  1348.   if (aRoot === "") {
  1349.     aRoot = ".";
  1350.   }
  1351.  
  1352.   aRoot = aRoot.replace(/\/$/, '');
  1353.  
  1354.   // It is possible for the path to be above the root. In this case, simply
  1355.   // checking whether the root is a prefix of the path won't work. Instead, we
  1356.   // need to remove components from the root one by one, until either we find
  1357.   // a prefix that fits, or we run out of components to remove.
  1358.   var level = 0;
  1359.   while (aPath.indexOf(aRoot + '/') !== 0) {
  1360.     var index = aRoot.lastIndexOf("/");
  1361.     if (index < 0) {
  1362.       return aPath;
  1363.     }
  1364.  
  1365.     // If the only part of the root that is left is the scheme (i.e. http://,
  1366.     // file:///, etc.), one or more slashes (/), or simply nothing at all, we
  1367.     // have exhausted all components, so the path is not relative to the root.
  1368.     aRoot = aRoot.slice(0, index);
  1369.     if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
  1370.       return aPath;
  1371.     }
  1372.  
  1373.     ++level;
  1374.   }
  1375.  
  1376.   // Make sure we add a "../" for each component we removed from the root.
  1377.   return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
  1378. }
  1379. exports.relative = relative;
  1380.  
  1381. var supportsNullProto = (function () {
  1382.   var obj = Object.create(null);
  1383.   return !('__proto__' in obj);
  1384. }());
  1385.  
  1386. function identity (s) {
  1387.   return s;
  1388. }
  1389.  
  1390. /**
  1391.  * Because behavior goes wacky when you set `__proto__` on objects, we
  1392.  * have to prefix all the strings in our set with an arbitrary character.
  1393.  *
  1394.  * See https://github.com/mozilla/source-map/pull/31 and
  1395.  * https://github.com/mozilla/source-map/issues/30
  1396.  *
  1397.  * @param String aStr
  1398.  */
  1399. function toSetString(aStr) {
  1400.   if (isProtoString(aStr)) {
  1401.     return '$' + aStr;
  1402.   }
  1403.  
  1404.   return aStr;
  1405. }
  1406. exports.toSetString = supportsNullProto ? identity : toSetString;
  1407.  
  1408. function fromSetString(aStr) {
  1409.   if (isProtoString(aStr)) {
  1410.     return aStr.slice(1);
  1411.   }
  1412.  
  1413.   return aStr;
  1414. }
  1415. exports.fromSetString = supportsNullProto ? identity : fromSetString;
  1416.  
  1417. function isProtoString(s) {
  1418.   if (!s) {
  1419.     return false;
  1420.   }
  1421.  
  1422.   var length = s.length;
  1423.  
  1424.   if (length < 9 /* "__proto__".length */) {
  1425.     return false;
  1426.   }
  1427.  
  1428.   if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
  1429.       s.charCodeAt(length - 2) !== 95  /* '_' */ ||
  1430.       s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
  1431.       s.charCodeAt(length - 4) !== 116 /* 't' */ ||
  1432.       s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
  1433.       s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
  1434.       s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
  1435.       s.charCodeAt(length - 8) !== 95  /* '_' */ ||
  1436.       s.charCodeAt(length - 9) !== 95  /* '_' */) {
  1437.     return false;
  1438.   }
  1439.  
  1440.   for (var i = length - 10; i >= 0; i--) {
  1441.     if (s.charCodeAt(i) !== 36 /* '$' */) {
  1442.       return false;
  1443.     }
  1444.   }
  1445.  
  1446.   return true;
  1447. }
  1448.  
  1449. /**
  1450.  * Comparator between two mappings where the original positions are compared.
  1451.  *
  1452.  * Optionally pass in `true` as `onlyCompareGenerated` to consider two
  1453.  * mappings with the same original source/line/column, but different generated
  1454.  * line and column the same. Useful when searching for a mapping with a
  1455.  * stubbed out mapping.
  1456.  */
  1457. function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
  1458.   var cmp = mappingA.source - mappingB.source;
  1459.   if (cmp !== 0) {
  1460.     return cmp;
  1461.   }
  1462.  
  1463.   cmp = mappingA.originalLine - mappingB.originalLine;
  1464.   if (cmp !== 0) {
  1465.     return cmp;
  1466.   }
  1467.  
  1468.   cmp = mappingA.originalColumn - mappingB.originalColumn;
  1469.   if (cmp !== 0 || onlyCompareOriginal) {
  1470.     return cmp;
  1471.   }
  1472.  
  1473.   cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  1474.   if (cmp !== 0) {
  1475.     return cmp;
  1476.   }
  1477.  
  1478.   cmp = mappingA.generatedLine - mappingB.generatedLine;
  1479.   if (cmp !== 0) {
  1480.     return cmp;
  1481.   }
  1482.  
  1483.   return mappingA.name - mappingB.name;
  1484. }
  1485. exports.compareByOriginalPositions = compareByOriginalPositions;
  1486.  
  1487. /**
  1488.  * Comparator between two mappings with deflated source and name indices where
  1489.  * the generated positions are compared.
  1490.  *
  1491.  * Optionally pass in `true` as `onlyCompareGenerated` to consider two
  1492.  * mappings with the same generated line and column, but different
  1493.  * source/name/original line and column the same. Useful when searching for a
  1494.  * mapping with a stubbed out mapping.
  1495.  */
  1496. function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
  1497.   var cmp = mappingA.generatedLine - mappingB.generatedLine;
  1498.   if (cmp !== 0) {
  1499.     return cmp;
  1500.   }
  1501.  
  1502.   cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  1503.   if (cmp !== 0 || onlyCompareGenerated) {
  1504.     return cmp;
  1505.   }
  1506.  
  1507.   cmp = mappingA.source - mappingB.source;
  1508.   if (cmp !== 0) {
  1509.     return cmp;
  1510.   }
  1511.  
  1512.   cmp = mappingA.originalLine - mappingB.originalLine;
  1513.   if (cmp !== 0) {
  1514.     return cmp;
  1515.   }
  1516.  
  1517.   cmp = mappingA.originalColumn - mappingB.originalColumn;
  1518.   if (cmp !== 0) {
  1519.     return cmp;
  1520.   }
  1521.  
  1522.   return mappingA.name - mappingB.name;
  1523. }
  1524. exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
  1525.  
  1526. function strcmp(aStr1, aStr2) {
  1527.   if (aStr1 === aStr2) {
  1528.     return 0;
  1529.   }
  1530.  
  1531.   if (aStr1 > aStr2) {
  1532.     return 1;
  1533.   }
  1534.  
  1535.   return -1;
  1536. }
  1537.  
  1538. /**
  1539.  * Comparator between two mappings with inflated source and name strings where
  1540.  * the generated positions are compared.
  1541.  */
  1542. function compareByGeneratedPositionsInflated(mappingA, mappingB) {
  1543.   var cmp = mappingA.generatedLine - mappingB.generatedLine;
  1544.   if (cmp !== 0) {
  1545.     return cmp;
  1546.   }
  1547.  
  1548.   cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  1549.   if (cmp !== 0) {
  1550.     return cmp;
  1551.   }
  1552.  
  1553.   cmp = strcmp(mappingA.source, mappingB.source);
  1554.   if (cmp !== 0) {
  1555.     return cmp;
  1556.   }
  1557.  
  1558.   cmp = mappingA.originalLine - mappingB.originalLine;
  1559.   if (cmp !== 0) {
  1560.     return cmp;
  1561.   }
  1562.  
  1563.   cmp = mappingA.originalColumn - mappingB.originalColumn;
  1564.   if (cmp !== 0) {
  1565.     return cmp;
  1566.   }
  1567.  
  1568.   return strcmp(mappingA.name, mappingB.name);
  1569. }
  1570. exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
  1571.  
  1572.  
  1573. /***/ }),
  1574. /* 11 */
  1575. /***/ (function(module, exports, __webpack_require__) {
  1576.  
  1577. "use strict";
  1578. /* WEBPACK VAR INJECTION */(function(process) {
  1579. var escapeStringRegexp = __webpack_require__(90);
  1580. var ansiStyles = __webpack_require__(87);
  1581. var stripAnsi = __webpack_require__(152);
  1582. var hasAnsi = __webpack_require__(91);
  1583. var supportsColor = __webpack_require__(89);
  1584. var defineProps = Object.defineProperties;
  1585. var isSimpleWindowsTerm = process.platform === 'win32' && !/^xterm/i.test(process.env.TERM);
  1586.  
  1587. function Chalk(options) {
  1588.         // detect mode if not set manually
  1589.         this.enabled = !options || options.enabled === undefined ? supportsColor : options.enabled;
  1590. }
  1591.  
  1592. // use bright blue on Windows as the normal blue color is illegible
  1593. if (isSimpleWindowsTerm) {
  1594.         ansiStyles.blue.open = '\u001b[94m';
  1595. }
  1596.  
  1597. var styles = (function () {
  1598.         var ret = {};
  1599.  
  1600.         Object.keys(ansiStyles).forEach(function (key) {
  1601.                 ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
  1602.  
  1603.                 ret[key] = {
  1604.                         get: function () {
  1605.                                 return build.call(this, this._styles.concat(key));
  1606.                         }
  1607.                 };
  1608.         });
  1609.  
  1610.         return ret;
  1611. })();
  1612.  
  1613. var proto = defineProps(function chalk() {}, styles);
  1614.  
  1615. function build(_styles) {
  1616.         var builder = function () {
  1617.                 return applyStyle.apply(builder, arguments);
  1618.         };
  1619.  
  1620.         builder._styles = _styles;
  1621.         builder.enabled = this.enabled;
  1622.         // __proto__ is used because we must return a function, but there is
  1623.         // no way to create a function with a different prototype.
  1624.         /* eslint-disable no-proto */
  1625.         builder.__proto__ = proto;
  1626.  
  1627.         return builder;
  1628. }
  1629.  
  1630. function applyStyle() {
  1631.         // support varags, but simply cast to string in case there's only one arg
  1632.         var args = arguments;
  1633.         var argsLen = args.length;
  1634.         var str = argsLen !== 0 && String(arguments[0]);
  1635.  
  1636.         if (argsLen > 1) {
  1637.                 // don't slice `arguments`, it prevents v8 optimizations
  1638.                 for (var a = 1; a < argsLen; a++) {
  1639.                         str += ' ' + args[a];
  1640.                 }
  1641.         }
  1642.  
  1643.         if (!this.enabled || !str) {
  1644.                 return str;
  1645.         }
  1646.  
  1647.         var nestedStyles = this._styles;
  1648.         var i = nestedStyles.length;
  1649.  
  1650.         // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
  1651.         // see https://github.com/chalk/chalk/issues/58
  1652.         // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
  1653.         var originalDim = ansiStyles.dim.open;
  1654.         if (isSimpleWindowsTerm && (nestedStyles.indexOf('gray') !== -1 || nestedStyles.indexOf('grey') !== -1)) {
  1655.                 ansiStyles.dim.open = '';
  1656.         }
  1657.  
  1658.         while (i--) {
  1659.                 var code = ansiStyles[nestedStyles[i]];
  1660.  
  1661.                 // Replace any instances already present with a re-opening code
  1662.                 // otherwise only the part of the string until said closing code
  1663.                 // will be colored, and the rest will simply be 'plain'.
  1664.                 str = code.open + str.replace(code.closeRe, code.open) + code.close;
  1665.         }
  1666.  
  1667.         // Reset the original 'dim' if we changed it to work around the Windows dimmed gray issue.
  1668.         ansiStyles.dim.open = originalDim;
  1669.  
  1670.         return str;
  1671. }
  1672.  
  1673. function init() {
  1674.         var ret = {};
  1675.  
  1676.         Object.keys(styles).forEach(function (name) {
  1677.                 ret[name] = {
  1678.                         get: function () {
  1679.                                 return build.call(this, [name]);
  1680.                         }
  1681.                 };
  1682.         });
  1683.  
  1684.         return ret;
  1685. }
  1686.  
  1687. defineProps(Chalk.prototype, init());
  1688.  
  1689. module.exports = new Chalk();
  1690. module.exports.styles = ansiStyles;
  1691. module.exports.hasColor = hasAnsi;
  1692. module.exports.stripColor = stripAnsi;
  1693. module.exports.supportsColor = supportsColor;
  1694.  
  1695. /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(13)));
  1696.  
  1697. /***/ }),
  1698. /* 12 */
  1699. /***/ (function(module, exports, __webpack_require__) {
  1700.  
  1701. "use strict";
  1702.  
  1703.  
  1704. exports.__esModule = true;
  1705.  
  1706. 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; }; }();
  1707.  
  1708. var _declaration = __webpack_require__(68);
  1709.  
  1710. var _declaration2 = _interopRequireDefault(_declaration);
  1711.  
  1712. var _comment = __webpack_require__(25);
  1713.  
  1714. var _comment2 = _interopRequireDefault(_comment);
  1715.  
  1716. var _node = __webpack_require__(27);
  1717.  
  1718. var _node2 = _interopRequireDefault(_node);
  1719.  
  1720. function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  1721.  
  1722. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  1723.  
  1724. 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; }
  1725.  
  1726. 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; }
  1727.  
  1728. function cleanSource(nodes) {
  1729.     return nodes.map(function (i) {
  1730.         if (i.nodes) i.nodes = cleanSource(i.nodes);
  1731.         delete i.source;
  1732.         return i;
  1733.     });
  1734. }
  1735.  
  1736. /**
  1737.  * The {@link Root}, {@link AtRule}, and {@link Rule} container nodes
  1738.  * inherit some common methods to help work with their children.
  1739.  *
  1740.  * Note that all containers can store any content. If you write a rule inside
  1741.  * a rule, PostCSS will parse it.
  1742.  *
  1743.  * @extends Node
  1744.  * @abstract
  1745.  */
  1746.  
  1747. var Container = function (_Node) {
  1748.     _inherits(Container, _Node);
  1749.  
  1750.     function Container() {
  1751.         _classCallCheck(this, Container);
  1752.  
  1753.         return _possibleConstructorReturn(this, _Node.apply(this, arguments));
  1754.     }
  1755.  
  1756.     Container.prototype.push = function push(child) {
  1757.         child.parent = this;
  1758.         this.nodes.push(child);
  1759.         return this;
  1760.     };
  1761.  
  1762.     /**
  1763.      * Iterates through the container鈥檚 immediate children,
  1764.      * calling `callback` for each child.
  1765.      *
  1766.      * Returning `false` in the callback will break iteration.
  1767.      *
  1768.      * This method only iterates through the container鈥檚 immediate children.
  1769.      * If you need to recursively iterate through all the container鈥檚 descendant
  1770.      * nodes, use {@link Container#walk}.
  1771.      *
  1772.      * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
  1773.      * if you are mutating the array of child nodes during iteration.
  1774.      * PostCSS will adjust the current index to match the mutations.
  1775.      *
  1776.      * @param {childIterator} callback - iterator receives each node and index
  1777.      *
  1778.      * @return {false|undefined} returns `false` if iteration was broke
  1779.      *
  1780.      * @example
  1781.      * const root = postcss.parse('a { color: black; z-index: 1 }');
  1782.      * const rule = root.first;
  1783.      *
  1784.      * for ( let decl of rule.nodes ) {
  1785.      *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
  1786.      *     // Cycle will be infinite, because cloneBefore moves the current node
  1787.      *     // to the next index
  1788.      * }
  1789.      *
  1790.      * rule.each(decl => {
  1791.      *     decl.cloneBefore({ prop: '-webkit-' + decl.prop });
  1792.      *     // Will be executed only for color and z-index
  1793.      * });
  1794.      */
  1795.  
  1796.  
  1797.     Container.prototype.each = function each(callback) {
  1798.         if (!this.lastEach) this.lastEach = 0;
  1799.         if (!this.indexes) this.indexes = {};
  1800.  
  1801.         this.lastEach += 1;
  1802.         var id = this.lastEach;
  1803.         this.indexes[id] = 0;
  1804.  
  1805.         if (!this.nodes) return undefined;
  1806.  
  1807.         var index = void 0,
  1808.             result = void 0;
  1809.         while (this.indexes[id] < this.nodes.length) {
  1810.             index = this.indexes[id];
  1811.             result = callback(this.nodes[index], index);
  1812.             if (result === false) break;
  1813.  
  1814.             this.indexes[id] += 1;
  1815.         }
  1816.  
  1817.         delete this.indexes[id];
  1818.  
  1819.         return result;
  1820.     };
  1821.  
  1822.     /**
  1823.      * Traverses the container鈥檚 descendant nodes, calling callback
  1824.      * for each node.
  1825.      *
  1826.      * Like container.each(), this method is safe to use
  1827.      * if you are mutating arrays during iteration.
  1828.      *
  1829.      * If you only need to iterate through the container鈥檚 immediate children,
  1830.      * use {@link Container#each}.
  1831.      *
  1832.      * @param {childIterator} callback - iterator receives each node and index
  1833.      *
  1834.      * @return {false|undefined} returns `false` if iteration was broke
  1835.      *
  1836.      * @example
  1837.      * root.walk(node => {
  1838.      *   // Traverses all descendant nodes.
  1839.      * });
  1840.      */
  1841.  
  1842.  
  1843.     Container.prototype.walk = function walk(callback) {
  1844.         return this.each(function (child, i) {
  1845.             var result = callback(child, i);
  1846.             if (result !== false && child.walk) {
  1847.                 result = child.walk(callback);
  1848.             }
  1849.             return result;
  1850.         });
  1851.     };
  1852.  
  1853.     /**
  1854.      * Traverses the container鈥檚 descendant nodes, calling callback
  1855.      * for each declaration node.
  1856.      *
  1857.      * If you pass a filter, iteration will only happen over declarations
  1858.      * with matching properties.
  1859.      *
  1860.      * Like {@link Container#each}, this method is safe
  1861.      * to use if you are mutating arrays during iteration.
  1862.      *
  1863.      * @param {string|RegExp} [prop]   - string or regular expression
  1864.      *                                   to filter declarations by property name
  1865.      * @param {childIterator} callback - iterator receives each node and index
  1866.      *
  1867.      * @return {false|undefined} returns `false` if iteration was broke
  1868.      *
  1869.      * @example
  1870.      * root.walkDecls(decl => {
  1871.      *   checkPropertySupport(decl.prop);
  1872.      * });
  1873.      *
  1874.      * root.walkDecls('border-radius', decl => {
  1875.      *   decl.remove();
  1876.      * });
  1877.      *
  1878.      * root.walkDecls(/^background/, decl => {
  1879.      *   decl.value = takeFirstColorFromGradient(decl.value);
  1880.      * });
  1881.      */
  1882.  
  1883.  
  1884.     Container.prototype.walkDecls = function walkDecls(prop, callback) {
  1885.         if (!callback) {
  1886.             callback = prop;
  1887.             return this.walk(function (child, i) {
  1888.                 if (child.type === 'decl') {
  1889.                     return callback(child, i);
  1890.                 }
  1891.             });
  1892.         } else if (prop instanceof RegExp) {
  1893.             return this.walk(function (child, i) {
  1894.                 if (child.type === 'decl' && prop.test(child.prop)) {
  1895.                     return callback(child, i);
  1896.                 }
  1897.             });
  1898.         } else {
  1899.             return this.walk(function (child, i) {
  1900.                 if (child.type === 'decl' && child.prop === prop) {
  1901.                     return callback(child, i);
  1902.                 }
  1903.             });
  1904.         }
  1905.     };
  1906.  
  1907.     /**
  1908.      * Traverses the container鈥檚 descendant nodes, calling callback
  1909.      * for each rule node.
  1910.      *
  1911.      * If you pass a filter, iteration will only happen over rules
  1912.      * with matching selectors.
  1913.      *
  1914.      * Like {@link Container#each}, this method is safe
  1915.      * to use if you are mutating arrays during iteration.
  1916.      *
  1917.      * @param {string|RegExp} [selector] - string or regular expression
  1918.      *                                     to filter rules by selector
  1919.      * @param {childIterator} callback   - iterator receives each node and index
  1920.      *
  1921.      * @return {false|undefined} returns `false` if iteration was broke
  1922.      *
  1923.      * @example
  1924.      * const selectors = [];
  1925.      * root.walkRules(rule => {
  1926.      *   selectors.push(rule.selector);
  1927.      * });
  1928.      * console.log(`Your CSS uses ${selectors.length} selectors`);
  1929.      */
  1930.  
  1931.  
  1932.     Container.prototype.walkRules = function walkRules(selector, callback) {
  1933.         if (!callback) {
  1934.             callback = selector;
  1935.  
  1936.             return this.walk(function (child, i) {
  1937.                 if (child.type === 'rule') {
  1938.                     return callback(child, i);
  1939.                 }
  1940.             });
  1941.         } else if (selector instanceof RegExp) {
  1942.             return this.walk(function (child, i) {
  1943.                 if (child.type === 'rule' && selector.test(child.selector)) {
  1944.                     return callback(child, i);
  1945.                 }
  1946.             });
  1947.         } else {
  1948.             return this.walk(function (child, i) {
  1949.                 if (child.type === 'rule' && child.selector === selector) {
  1950.                     return callback(child, i);
  1951.                 }
  1952.             });
  1953.         }
  1954.     };
  1955.  
  1956.     /**
  1957.      * Traverses the container鈥檚 descendant nodes, calling callback
  1958.      * for each at-rule node.
  1959.      *
  1960.      * If you pass a filter, iteration will only happen over at-rules
  1961.      * that have matching names.
  1962.      *
  1963.      * Like {@link Container#each}, this method is safe
  1964.      * to use if you are mutating arrays during iteration.
  1965.      *
  1966.      * @param {string|RegExp} [name]   - string or regular expression
  1967.      *                                   to filter at-rules by name
  1968.      * @param {childIterator} callback - iterator receives each node and index
  1969.      *
  1970.      * @return {false|undefined} returns `false` if iteration was broke
  1971.      *
  1972.      * @example
  1973.      * root.walkAtRules(rule => {
  1974.      *   if ( isOld(rule.name) ) rule.remove();
  1975.      * });
  1976.      *
  1977.      * let first = false;
  1978.      * root.walkAtRules('charset', rule => {
  1979.      *   if ( !first ) {
  1980.      *     first = true;
  1981.      *   } else {
  1982.      *     rule.remove();
  1983.      *   }
  1984.      * });
  1985.      */
  1986.  
  1987.  
  1988.     Container.prototype.walkAtRules = function walkAtRules(name, callback) {
  1989.         if (!callback) {
  1990.             callback = name;
  1991.             return this.walk(function (child, i) {
  1992.                 if (child.type === 'atrule') {
  1993.                     return callback(child, i);
  1994.                 }
  1995.             });
  1996.         } else if (name instanceof RegExp) {
  1997.             return this.walk(function (child, i) {
  1998.                 if (child.type === 'atrule' && name.test(child.name)) {
  1999.                     return callback(child, i);
  2000.                 }
  2001.             });
  2002.         } else {
  2003.             return this.walk(function (child, i) {
  2004.                 if (child.type === 'atrule' && child.name === name) {
  2005.                     return callback(child, i);
  2006.                 }
  2007.             });
  2008.         }
  2009.     };
  2010.  
  2011.     /**
  2012.      * Traverses the container鈥檚 descendant nodes, calling callback
  2013.      * for each comment node.
  2014.      *
  2015.      * Like {@link Container#each}, this method is safe
  2016.      * to use if you are mutating arrays during iteration.
  2017.      *
  2018.      * @param {childIterator} callback - iterator receives each node and index
  2019.      *
  2020.      * @return {false|undefined} returns `false` if iteration was broke
  2021.      *
  2022.      * @example
  2023.      * root.walkComments(comment => {
  2024.      *   comment.remove();
  2025.      * });
  2026.      */
  2027.  
  2028.  
  2029.     Container.prototype.walkComments = function walkComments(callback) {
  2030.         return this.walk(function (child, i) {
  2031.             if (child.type === 'comment') {
  2032.                 return callback(child, i);
  2033.             }
  2034.         });
  2035.     };
  2036.  
  2037.     /**
  2038.      * Inserts new nodes to the end of the container.
  2039.      *
  2040.      * @param {...(Node|object|string|Node[])} children - new nodes
  2041.      *
  2042.      * @return {Node} this node for methods chain
  2043.      *
  2044.      * @example
  2045.      * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
  2046.      * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
  2047.      * rule.append(decl1, decl2);
  2048.      *
  2049.      * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
  2050.      * root.append({ selector: 'a' });                       // rule
  2051.      * rule.append({ prop: 'color', value: 'black' });       // declaration
  2052.      * rule.append({ text: 'Comment' })                      // comment
  2053.      *
  2054.      * root.append('a {}');
  2055.      * root.first.append('color: black; z-index: 1');
  2056.      */
  2057.  
  2058.  
  2059.     Container.prototype.append = function append() {
  2060.         for (var _len = arguments.length, children = Array(_len), _key = 0; _key < _len; _key++) {
  2061.             children[_key] = arguments[_key];
  2062.         }
  2063.  
  2064.         for (var _iterator = children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
  2065.             var _ref;
  2066.  
  2067.             if (_isArray) {
  2068.                 if (_i >= _iterator.length) break;
  2069.                 _ref = _iterator[_i++];
  2070.             } else {
  2071.                 _i = _iterator.next();
  2072.                 if (_i.done) break;
  2073.                 _ref = _i.value;
  2074.             }
  2075.  
  2076.             var child = _ref;
  2077.  
  2078.             var nodes = this.normalize(child, this.last);
  2079.             for (var _iterator2 = nodes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
  2080.                 var _ref2;
  2081.  
  2082.                 if (_isArray2) {
  2083.                     if (_i2 >= _iterator2.length) break;
  2084.                     _ref2 = _iterator2[_i2++];
  2085.                 } else {
  2086.                     _i2 = _iterator2.next();
  2087.                     if (_i2.done) break;
  2088.                     _ref2 = _i2.value;
  2089.                 }
  2090.  
  2091.                 var node = _ref2;
  2092.                 this.nodes.push(node);
  2093.             }
  2094.         }
  2095.         return this;
  2096.     };
  2097.  
  2098.     /**
  2099.      * Inserts new nodes to the start of the container.
  2100.      *
  2101.      * @param {...(Node|object|string|Node[])} children - new nodes
  2102.      *
  2103.      * @return {Node} this node for methods chain
  2104.      *
  2105.      * @example
  2106.      * const decl1 = postcss.decl({ prop: 'color', value: 'black' });
  2107.      * const decl2 = postcss.decl({ prop: 'background-color', value: 'white' });
  2108.      * rule.prepend(decl1, decl2);
  2109.      *
  2110.      * root.append({ name: 'charset', params: '"UTF-8"' });  // at-rule
  2111.      * root.append({ selector: 'a' });                       // rule
  2112.      * rule.append({ prop: 'color', value: 'black' });       // declaration
  2113.      * rule.append({ text: 'Comment' })                      // comment
  2114.      *
  2115.      * root.append('a {}');
  2116.      * root.first.append('color: black; z-index: 1');
  2117.      */
  2118.  
  2119.  
  2120.     Container.prototype.prepend = function prepend() {
  2121.         for (var _len2 = arguments.length, children = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
  2122.             children[_key2] = arguments[_key2];
  2123.         }
  2124.  
  2125.         children = children.reverse();
  2126.         for (var _iterator3 = children, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
  2127.             var _ref3;
  2128.  
  2129.             if (_isArray3) {
  2130.                 if (_i3 >= _iterator3.length) break;
  2131.                 _ref3 = _iterator3[_i3++];
  2132.             } else {
  2133.                 _i3 = _iterator3.next();
  2134.                 if (_i3.done) break;
  2135.                 _ref3 = _i3.value;
  2136.             }
  2137.  
  2138.             var child = _ref3;
  2139.  
  2140.             var nodes = this.normalize(child, this.first, 'prepend').reverse();
  2141.             for (var _iterator4 = nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
  2142.                 var _ref4;
  2143.  
  2144.                 if (_isArray4) {
  2145.                     if (_i4 >= _iterator4.length) break;
  2146.                     _ref4 = _iterator4[_i4++];
  2147.                 } else {
  2148.                     _i4 = _iterator4.next();
  2149.                     if (_i4.done) break;
  2150.                     _ref4 = _i4.value;
  2151.                 }
  2152.  
  2153.                 var node = _ref4;
  2154.                 this.nodes.unshift(node);
  2155.             }for (var id in this.indexes) {
  2156.                 this.indexes[id] = this.indexes[id] + nodes.length;
  2157.             }
  2158.         }
  2159.         return this;
  2160.     };
  2161.  
  2162.     Container.prototype.cleanRaws = function cleanRaws(keepBetween) {
  2163.         _Node.prototype.cleanRaws.call(this, keepBetween);
  2164.         if (this.nodes) {
  2165.             for (var _iterator5 = this.nodes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
  2166.                 var _ref5;
  2167.  
  2168.                 if (_isArray5) {
  2169.                     if (_i5 >= _iterator5.length) break;
  2170.                     _ref5 = _iterator5[_i5++];
  2171.                 } else {
  2172.                     _i5 = _iterator5.next();
  2173.                     if (_i5.done) break;
  2174.                     _ref5 = _i5.value;
  2175.                 }
  2176.  
  2177.                 var node = _ref5;
  2178.                 node.cleanRaws(keepBetween);
  2179.             }
  2180.         }
  2181.     };
  2182.  
  2183.     /**
  2184.      * Insert new node before old node within the container.
  2185.      *
  2186.      * @param {Node|number} exist             - child or child鈥檚 index.
  2187.      * @param {Node|object|string|Node[]} add - new node
  2188.      *
  2189.      * @return {Node} this node for methods chain
  2190.      *
  2191.      * @example
  2192.      * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }));
  2193.      */
  2194.  
  2195.  
  2196.     Container.prototype.insertBefore = function insertBefore(exist, add) {
  2197.         exist = this.index(exist);
  2198.  
  2199.         var type = exist === 0 ? 'prepend' : false;
  2200.         var nodes = this.normalize(add, this.nodes[exist], type).reverse();
  2201.         for (var _iterator6 = nodes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
  2202.             var _ref6;
  2203.  
  2204.             if (_isArray6) {
  2205.                 if (_i6 >= _iterator6.length) break;
  2206.                 _ref6 = _iterator6[_i6++];
  2207.             } else {
  2208.                 _i6 = _iterator6.next();
  2209.                 if (_i6.done) break;
  2210.                 _ref6 = _i6.value;
  2211.             }
  2212.  
  2213.             var node = _ref6;
  2214.             this.nodes.splice(exist, 0, node);
  2215.         }var index = void 0;
  2216.         for (var id in this.indexes) {
  2217.             index = this.indexes[id];
  2218.             if (exist <= index) {
  2219.                 this.indexes[id] = index + nodes.length;
  2220.             }
  2221.         }
  2222.  
  2223.         return this;
  2224.     };
  2225.  
  2226.     /**
  2227.      * Insert new node after old node within the container.
  2228.      *
  2229.      * @param {Node|number} exist             - child or child鈥檚 index
  2230.      * @param {Node|object|string|Node[]} add - new node
  2231.      *
  2232.      * @return {Node} this node for methods chain
  2233.      */
  2234.  
  2235.  
  2236.     Container.prototype.insertAfter = function insertAfter(exist, add) {
  2237.         exist = this.index(exist);
  2238.  
  2239.         var nodes = this.normalize(add, this.nodes[exist]).reverse();
  2240.         for (var _iterator7 = nodes, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
  2241.             var _ref7;
  2242.  
  2243.             if (_isArray7) {
  2244.                 if (_i7 >= _iterator7.length) break;
  2245.                 _ref7 = _iterator7[_i7++];
  2246.             } else {
  2247.                 _i7 = _iterator7.next();
  2248.                 if (_i7.done) break;
  2249.                 _ref7 = _i7.value;
  2250.             }
  2251.  
  2252.             var node = _ref7;
  2253.             this.nodes.splice(exist + 1, 0, node);
  2254.         }var index = void 0;
  2255.         for (var id in this.indexes) {
  2256.             index = this.indexes[id];
  2257.             if (exist < index) {
  2258.                 this.indexes[id] = index + nodes.length;
  2259.             }
  2260.         }
  2261.  
  2262.         return this;
  2263.     };
  2264.  
  2265.     /**
  2266.      * Removes node from the container and cleans the parent properties
  2267.      * from the node and its children.
  2268.      *
  2269.      * @param {Node|number} child - child or child鈥檚 index
  2270.      *
  2271.      * @return {Node} this node for methods chain
  2272.      *
  2273.      * @example
  2274.      * rule.nodes.length  //=> 5
  2275.      * rule.removeChild(decl);
  2276.      * rule.nodes.length  //=> 4
  2277.      * decl.parent        //=> undefined
  2278.      */
  2279.  
  2280.  
  2281.     Container.prototype.removeChild = function removeChild(child) {
  2282.         child = this.index(child);
  2283.         this.nodes[child].parent = undefined;
  2284.         this.nodes.splice(child, 1);
  2285.  
  2286.         var index = void 0;
  2287.         for (var id in this.indexes) {
  2288.             index = this.indexes[id];
  2289.             if (index >= child) {
  2290.                 this.indexes[id] = index - 1;
  2291.             }
  2292.         }
  2293.  
  2294.         return this;
  2295.     };
  2296.  
  2297.     /**
  2298.      * Removes all children from the container
  2299.      * and cleans their parent properties.
  2300.      *
  2301.      * @return {Node} this node for methods chain
  2302.      *
  2303.      * @example
  2304.      * rule.removeAll();
  2305.      * rule.nodes.length //=> 0
  2306.      */
  2307.  
  2308.  
  2309.     Container.prototype.removeAll = function removeAll() {
  2310.         for (var _iterator8 = this.nodes, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
  2311.             var _ref8;
  2312.  
  2313.             if (_isArray8) {
  2314.                 if (_i8 >= _iterator8.length) break;
  2315.                 _ref8 = _iterator8[_i8++];
  2316.             } else {
  2317.                 _i8 = _iterator8.next();
  2318.                 if (_i8.done) break;
  2319.                 _ref8 = _i8.value;
  2320.             }
  2321.  
  2322.             var node = _ref8;
  2323.             node.parent = undefined;
  2324.         }this.nodes = [];
  2325.         return this;
  2326.     };
  2327.  
  2328.     /**
  2329.      * Passes all declaration values within the container that match pattern
  2330.      * through callback, replacing those values with the returned result
  2331.      * of callback.
  2332.      *
  2333.      * This method is useful if you are using a custom unit or function
  2334.      * and need to iterate through all values.
  2335.      *
  2336.      * @param {string|RegExp} pattern      - replace pattern
  2337.      * @param {object} opts                - options to speed up the search
  2338.      * @param {string|string[]} opts.props - an array of property names
  2339.      * @param {string} opts.fast           - string that鈥檚 used
  2340.      *                                       to narrow down values and speed up
  2341.                                              the regexp search
  2342.      * @param {function|string} callback   - string to replace pattern
  2343.      *                                       or callback that returns a new
  2344.      *                                       value.
  2345.      *                                       The callback will receive
  2346.      *                                       the same arguments as those
  2347.      *                                       passed to a function parameter
  2348.      *                                       of `String#replace`.
  2349.      *
  2350.      * @return {Node} this node for methods chain
  2351.      *
  2352.      * @example
  2353.      * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
  2354.      *   return 15 * parseInt(string) + 'px';
  2355.      * });
  2356.      */
  2357.  
  2358.  
  2359.     Container.prototype.replaceValues = function replaceValues(pattern, opts, callback) {
  2360.         if (!callback) {
  2361.             callback = opts;
  2362.             opts = {};
  2363.         }
  2364.  
  2365.         this.walkDecls(function (decl) {
  2366.             if (opts.props && opts.props.indexOf(decl.prop) === -1) return;
  2367.             if (opts.fast && decl.value.indexOf(opts.fast) === -1) return;
  2368.  
  2369.             decl.value = decl.value.replace(pattern, callback);
  2370.         });
  2371.  
  2372.         return this;
  2373.     };
  2374.  
  2375.     /**
  2376.      * Returns `true` if callback returns `true`
  2377.      * for all of the container鈥檚 children.
  2378.      *
  2379.      * @param {childCondition} condition - iterator returns true or false.
  2380.      *
  2381.      * @return {boolean} is every child pass condition
  2382.      *
  2383.      * @example
  2384.      * const noPrefixes = rule.every(i => i.prop[0] !== '-');
  2385.      */
  2386.  
  2387.  
  2388.     Container.prototype.every = function every(condition) {
  2389.         return this.nodes.every(condition);
  2390.     };
  2391.  
  2392.     /**
  2393.      * Returns `true` if callback returns `true` for (at least) one
  2394.      * of the container鈥檚 children.
  2395.      *
  2396.      * @param {childCondition} condition - iterator returns true or false.
  2397.      *
  2398.      * @return {boolean} is some child pass condition
  2399.      *
  2400.      * @example
  2401.      * const hasPrefix = rule.some(i => i.prop[0] === '-');
  2402.      */
  2403.  
  2404.  
  2405.     Container.prototype.some = function some(condition) {
  2406.         return this.nodes.some(condition);
  2407.     };
  2408.  
  2409.     /**
  2410.      * Returns a `child`鈥檚 index within the {@link Container#nodes} array.
  2411.      *
  2412.      * @param {Node} child - child of the current container.
  2413.      *
  2414.      * @return {number} child index
  2415.      *
  2416.      * @example
  2417.      * rule.index( rule.nodes[2] ) //=> 2
  2418.      */
  2419.  
  2420.  
  2421.     Container.prototype.index = function index(child) {
  2422.         if (typeof child === 'number') {
  2423.             return child;
  2424.         } else {
  2425.             return this.nodes.indexOf(child);
  2426.         }
  2427.     };
  2428.  
  2429.     /**
  2430.      * The container鈥檚 first child.
  2431.      *
  2432.      * @type {Node}
  2433.      *
  2434.      * @example
  2435.      * rule.first == rules.nodes[0];
  2436.      */
  2437.  
  2438.  
  2439.     Container.prototype.normalize = function normalize(nodes, sample) {
  2440.         var _this2 = this;
  2441.  
  2442.         if (typeof nodes === 'string') {
  2443.             var parse = __webpack_require__(70);
  2444.             nodes = cleanSource(parse(nodes).nodes);
  2445.         } else if (Array.isArray(nodes)) {
  2446.             nodes = nodes.slice(0);
  2447.         } else if (nodes.type === 'root') {
  2448.             nodes = nodes.nodes.slice(0);
  2449.         } else if (nodes.type) {
  2450.             nodes = [nodes];
  2451.         } else if (nodes.prop) {
  2452.             if (typeof nodes.value === 'undefined') {
  2453.                 throw new Error('Value field is missed in node creation');
  2454.             } else if (typeof nodes.value !== 'string') {
  2455.                 nodes.value = String(nodes.value);
  2456.             }
  2457.             nodes = [new _declaration2.default(nodes)];
  2458.         } else if (nodes.selector) {
  2459.             var Rule = __webpack_require__(28);
  2460.             nodes = [new Rule(nodes)];
  2461.         } else if (nodes.name) {
  2462.             var AtRule = __webpack_require__(24);
  2463.             nodes = [new AtRule(nodes)];
  2464.         } else if (nodes.text) {
  2465.             nodes = [new _comment2.default(nodes)];
  2466.         } else {
  2467.             throw new Error('Unknown node type in node creation');
  2468.         }
  2469.  
  2470.         var processed = nodes.map(function (i) {
  2471.             if (typeof i.before !== 'function') i = _this2.rebuild(i);
  2472.  
  2473.             if (i.parent) i.parent.removeChild(i);
  2474.             if (typeof i.raws.before === 'undefined') {
  2475.                 if (sample && typeof sample.raws.before !== 'undefined') {
  2476.                     i.raws.before = sample.raws.before.replace(/[^\s]/g, '');
  2477.                 }
  2478.             }
  2479.             i.parent = _this2;
  2480.             return i;
  2481.         });
  2482.  
  2483.         return processed;
  2484.     };
  2485.  
  2486.     Container.prototype.rebuild = function rebuild(node, parent) {
  2487.         var _this3 = this;
  2488.  
  2489.         var fix = void 0;
  2490.         if (node.type === 'root') {
  2491.             var Root = __webpack_require__(72);
  2492.             fix = new Root();
  2493.         } else if (node.type === 'atrule') {
  2494.             var AtRule = __webpack_require__(24);
  2495.             fix = new AtRule();
  2496.         } else if (node.type === 'rule') {
  2497.             var Rule = __webpack_require__(28);
  2498.             fix = new Rule();
  2499.         } else if (node.type === 'decl') {
  2500.             fix = new _declaration2.default();
  2501.         } else if (node.type === 'comment') {
  2502.             fix = new _comment2.default();
  2503.         }
  2504.  
  2505.         for (var i in node) {
  2506.             if (i === 'nodes') {
  2507.                 fix.nodes = node.nodes.map(function (j) {
  2508.                     return _this3.rebuild(j, fix);
  2509.                 });
  2510.             } else if (i === 'parent' && parent) {
  2511.                 fix.parent = parent;
  2512.             } else if (node.hasOwnProperty(i)) {
  2513.                 fix[i] = node[i];
  2514.             }
  2515.         }
  2516.  
  2517.         return fix;
  2518.     };
  2519.  
  2520.     /**
  2521.      * @memberof Container#
  2522.      * @member {Node[]} nodes - an array containing the container鈥檚 children
  2523.      *
  2524.      * @example
  2525.      * const root = postcss.parse('a { color: black }');
  2526.      * root.nodes.length           //=> 1
  2527.      * root.nodes[0].selector      //=> 'a'
  2528.      * root.nodes[0].nodes[0].prop //=> 'color'
  2529.      */
  2530.  
  2531.     _createClass(Container, [{
  2532.         key: 'first',
  2533.         get: function get() {
  2534.             if (!this.nodes) return undefined;
  2535.             return this.nodes[0];
  2536.         }
  2537.  
  2538.         /**
  2539.          * The container鈥檚 last child.
  2540.          *
  2541.          * @type {Node}
  2542.          *
  2543.          * @example
  2544.          * rule.last == rule.nodes[rule.nodes.length - 1];
  2545.          */
  2546.  
  2547.     }, {
  2548.         key: 'last',
  2549.         get: function get() {
  2550.             if (!this.nodes) return undefined;
  2551.             return this.nodes[this.nodes.length - 1];
  2552.         }
  2553.     }]);
  2554.  
  2555.     return Container;
  2556. }(_node2.default);
  2557.  
  2558. exports.default = Container;
  2559.  
  2560. /**
  2561.  * @callback childCondition
  2562.  * @param {Node} node    - container child
  2563.  * @param {number} index - child index
  2564.  * @param {Node[]} nodes - all container children
  2565.  * @return {boolean}
  2566.  */
  2567.  
  2568. /**
  2569.  * @callback childIterator
  2570.  * @param {Node} node    - container child
  2571.  * @param {number} index - child index
  2572.  * @return {false|undefined} returning `false` will break iteration
  2573.  */
  2574.  
  2575. module.exports = exports['default'];
  2576.  
  2577.  
  2578.  
  2579. /***/ }),
  2580. /* 13 */
  2581. /***/ (function(module, exports) {
  2582.  
  2583. // shim for using process in browser
  2584. var process = module.exports = {};
  2585.  
  2586. // cached from whatever global is present so that test runners that stub it
  2587. // don't break things.  But we need to wrap it in a try catch in case it is
  2588. // wrapped in strict mode code which doesn't define any globals.  It's inside a
  2589. // function because try/catches deoptimize in certain engines.
  2590.  
  2591. var cachedSetTimeout;
  2592. var cachedClearTimeout;
  2593.  
  2594. function defaultSetTimout() {
  2595.     throw new Error('setTimeout has not been defined');
  2596. }
  2597. function defaultClearTimeout () {
  2598.     throw new Error('clearTimeout has not been defined');
  2599. }
  2600. (function () {
  2601.     try {
  2602.         if (typeof setTimeout === 'function') {
  2603.             cachedSetTimeout = setTimeout;
  2604.         } else {
  2605.             cachedSetTimeout = defaultSetTimout;
  2606.         }
  2607.     } catch (e) {
  2608.         cachedSetTimeout = defaultSetTimout;
  2609.     }
  2610.     try {
  2611.         if (typeof clearTimeout === 'function') {
  2612.             cachedClearTimeout = clearTimeout;
  2613.         } else {
  2614.             cachedClearTimeout = defaultClearTimeout;
  2615.         }
  2616.     } catch (e) {
  2617.         cachedClearTimeout = defaultClearTimeout;
  2618.     }
  2619. } ());
  2620. function runTimeout(fun) {
  2621.     if (cachedSetTimeout === setTimeout) {
  2622.         //normal enviroments in sane situations
  2623.         return setTimeout(fun, 0);
  2624.     }
  2625.     // if setTimeout wasn't available but was latter defined
  2626.     if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
  2627.         cachedSetTimeout = setTimeout;
  2628.         return setTimeout(fun, 0);
  2629.     }
  2630.     try {
  2631.         // when when somebody has screwed with setTimeout but no I.E. maddness
  2632.         return cachedSetTimeout(fun, 0);
  2633.     } catch(e){
  2634.         try {
  2635.             // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
  2636.             return cachedSetTimeout.call(null, fun, 0);
  2637.         } catch(e){
  2638.             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
  2639.             return cachedSetTimeout.call(this, fun, 0);
  2640.         }
  2641.     }
  2642.  
  2643.  
  2644. }
  2645. function runClearTimeout(marker) {
  2646.     if (cachedClearTimeout === clearTimeout) {
  2647.         //normal enviroments in sane situations
  2648.         return clearTimeout(marker);
  2649.     }
  2650.     // if clearTimeout wasn't available but was latter defined
  2651.     if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
  2652.         cachedClearTimeout = clearTimeout;
  2653.         return clearTimeout(marker);
  2654.     }
  2655.     try {
  2656.         // when when somebody has screwed with setTimeout but no I.E. maddness
  2657.         return cachedClearTimeout(marker);
  2658.     } catch (e){
  2659.         try {
  2660.             // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
  2661.             return cachedClearTimeout.call(null, marker);
  2662.         } catch (e){
  2663.             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
  2664.             // Some versions of I.E. have different rules for clearTimeout vs setTimeout
  2665.             return cachedClearTimeout.call(this, marker);
  2666.         }
  2667.     }
  2668.  
  2669.  
  2670.  
  2671. }
  2672. var queue = [];
  2673. var draining = false;
  2674. var currentQueue;
  2675. var queueIndex = -1;
  2676.  
  2677. function cleanUpNextTick() {
  2678.     if (!draining || !currentQueue) {
  2679.         return;
  2680.     }
  2681.     draining = false;
  2682.     if (currentQueue.length) {
  2683.         queue = currentQueue.concat(queue);
  2684.     } else {
  2685.         queueIndex = -1;
  2686.     }
  2687.     if (queue.length) {
  2688.         drainQueue();
  2689.     }
  2690. }
  2691.  
  2692. function drainQueue() {
  2693.     if (draining) {
  2694.         return;
  2695.     }
  2696.     var timeout = runTimeout(cleanUpNextTick);
  2697.     draining = true;
  2698.  
  2699.     var len = queue.length;
  2700.     while(len) {
  2701.         currentQueue = queue;
  2702.         queue = [];
  2703.         while (++queueIndex < len) {
  2704.             if (currentQueue) {
  2705.                 currentQueue[queueIndex].run();
  2706.             }
  2707.         }
  2708.         queueIndex = -1;
  2709.         len = queue.length;
  2710.     }
  2711.     currentQueue = null;
  2712.     draining = false;
  2713.     runClearTimeout(timeout);
  2714. }
  2715.  
  2716. process.nextTick = function (fun) {
  2717.     var args = new Array(arguments.length - 1);
  2718.     if (arguments.length > 1) {
  2719.         for (var i = 1; i < arguments.length; i++) {
  2720.             args[i - 1] = arguments[i];
  2721.         }
  2722.     }
  2723.     queue.push(new Item(fun, args));
  2724.     if (queue.length === 1 && !draining) {
  2725.         runTimeout(drainQueue);
  2726.     }
  2727. };
  2728.  
  2729. // v8 likes predictible objects
  2730. function Item(fun, array) {
  2731.     this.fun = fun;
  2732.     this.array = array;
  2733. }
  2734. Item.prototype.run = function () {
  2735.     this.fun.apply(null, this.array);
  2736. };
  2737. process.title = 'browser';
  2738. process.browser = true;
  2739. process.env = {};
  2740. process.argv = [];
  2741. process.version = ''; // empty string to avoid regexp issues
  2742. process.versions = {};
  2743.  
  2744. function noop() {}
  2745.  
  2746. process.on = noop;
  2747. process.addListener = noop;
  2748. process.once = noop;
  2749. process.off = noop;
  2750. process.removeListener = noop;
  2751. process.removeAllListeners = noop;
  2752. process.emit = noop;
  2753. process.prependListener = noop;
  2754. process.prependOnceListener = noop;
  2755.  
  2756. process.listeners = function (name) { return [] };
  2757.  
  2758. process.binding = function (name) {
  2759.     throw new Error('process.binding is not supported');
  2760. };
  2761.  
  2762. process.cwd = function () { return '/' };
  2763. process.chdir = function (dir) {
  2764.     throw new Error('process.chdir is not supported');
  2765. };
  2766. process.umask = function() { return 0; };
  2767.  
  2768.  
  2769. /***/ }),
  2770. /* 14 */
  2771. /***/ (function(module, exports, __webpack_require__) {
  2772.  
  2773. /*
  2774.  * Copyright 2009-2011 Mozilla Foundation and contributors
  2775.  * Licensed under the New BSD license. See LICENSE.txt or:
  2776.  * http://opensource.org/licenses/BSD-3-Clause
  2777.  */
  2778. exports.SourceMapGenerator = __webpack_require__(77).SourceMapGenerator;
  2779. exports.SourceMapConsumer = __webpack_require__(150).SourceMapConsumer;
  2780. exports.SourceNode = __webpack_require__(151).SourceNode;
  2781.  
  2782.  
  2783. /***/ }),
  2784. /* 15 */
  2785. /***/ (function(module, exports, __webpack_require__) {
  2786.  
  2787. "use strict";
  2788. /* WEBPACK VAR INJECTION */(function(global) {/*!
  2789.  * The buffer module from node.js, for the browser.
  2790.  *
  2791.  * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
  2792.  * @license  MIT
  2793.  */
  2794. /* eslint-disable no-proto */
  2795.  
  2796.  
  2797.  
  2798. var base64 = __webpack_require__(88);
  2799. var ieee754 = __webpack_require__(92);
  2800. var isArray = __webpack_require__(93);
  2801.  
  2802. exports.Buffer = Buffer;
  2803. exports.SlowBuffer = SlowBuffer;
  2804. exports.INSPECT_MAX_BYTES = 50;
  2805.  
  2806. /**
  2807.  * If `Buffer.TYPED_ARRAY_SUPPORT`:
  2808.  *   === true    Use Uint8Array implementation (fastest)
  2809.  *   === false   Use Object implementation (most compatible, even IE6)
  2810.  *
  2811.  * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
  2812.  * Opera 11.6+, iOS 4.2+.
  2813.  *
  2814.  * Due to various browser bugs, sometimes the Object implementation will be used even
  2815.  * when the browser supports typed arrays.
  2816.  *
  2817.  * Note:
  2818.  *
  2819.  *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
  2820.  *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
  2821.  *
  2822.  *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
  2823.  *
  2824.  *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
  2825.  *     incorrect length in some situations.
  2826.  
  2827.  * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
  2828.  * get the Object implementation, which is slower but behaves correctly.
  2829.  */
  2830. Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
  2831.   ? global.TYPED_ARRAY_SUPPORT
  2832.   : typedArraySupport();
  2833.  
  2834. /*
  2835.  * Export kMaxLength after typed array support is determined.
  2836.  */
  2837. exports.kMaxLength = kMaxLength();
  2838.  
  2839. function typedArraySupport () {
  2840.   try {
  2841.     var arr = new Uint8Array(1);
  2842.     arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }};
  2843.     return arr.foo() === 42 && // typed array instances can be augmented
  2844.         typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
  2845.         arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
  2846.   } catch (e) {
  2847.     return false
  2848.   }
  2849. }
  2850.  
  2851. function kMaxLength () {
  2852.   return Buffer.TYPED_ARRAY_SUPPORT
  2853.     ? 0x7fffffff
  2854.     : 0x3fffffff
  2855. }
  2856.  
  2857. function createBuffer (that, length) {
  2858.   if (kMaxLength() < length) {
  2859.     throw new RangeError('Invalid typed array length')
  2860.   }
  2861.   if (Buffer.TYPED_ARRAY_SUPPORT) {
  2862.     // Return an augmented `Uint8Array` instance, for best performance
  2863.     that = new Uint8Array(length);
  2864.     that.__proto__ = Buffer.prototype;
  2865.   } else {
  2866.     // Fallback: Return an object instance of the Buffer class
  2867.     if (that === null) {
  2868.       that = new Buffer(length);
  2869.     }
  2870.     that.length = length;
  2871.   }
  2872.  
  2873.   return that
  2874. }
  2875.  
  2876. /**
  2877.  * The Buffer constructor returns instances of `Uint8Array` that have their
  2878.  * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
  2879.  * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
  2880.  * and the `Uint8Array` methods. Square bracket notation works as expected -- it
  2881.  * returns a single octet.
  2882.  *
  2883.  * The `Uint8Array` prototype remains unmodified.
  2884.  */
  2885.  
  2886. function Buffer (arg, encodingOrOffset, length) {
  2887.   if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
  2888.     return new Buffer(arg, encodingOrOffset, length)
  2889.   }
  2890.  
  2891.   // Common case.
  2892.   if (typeof arg === 'number') {
  2893.     if (typeof encodingOrOffset === 'string') {
  2894.       throw new Error(
  2895.         'If encoding is specified then the first argument must be a string'
  2896.       )
  2897.     }
  2898.     return allocUnsafe(this, arg)
  2899.   }
  2900.   return from(this, arg, encodingOrOffset, length)
  2901. }
  2902.  
  2903. Buffer.poolSize = 8192; // not used by this implementation
  2904.  
  2905. // TODO: Legacy, not needed anymore. Remove in next major version.
  2906. Buffer._augment = function (arr) {
  2907.   arr.__proto__ = Buffer.prototype;
  2908.   return arr
  2909. };
  2910.  
  2911. function from (that, value, encodingOrOffset, length) {
  2912.   if (typeof value === 'number') {
  2913.     throw new TypeError('"value" argument must not be a number')
  2914.   }
  2915.  
  2916.   if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
  2917.     return fromArrayBuffer(that, value, encodingOrOffset, length)
  2918.   }
  2919.  
  2920.   if (typeof value === 'string') {
  2921.     return fromString(that, value, encodingOrOffset)
  2922.   }
  2923.  
  2924.   return fromObject(that, value)
  2925. }
  2926.  
  2927. /**
  2928.  * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
  2929.  * if value is a number.
  2930.  * Buffer.from(str[, encoding])
  2931.  * Buffer.from(array)
  2932.  * Buffer.from(buffer)
  2933.  * Buffer.from(arrayBuffer[, byteOffset[, length]])
  2934.  **/
  2935. Buffer.from = function (value, encodingOrOffset, length) {
  2936.   return from(null, value, encodingOrOffset, length)
  2937. };
  2938.  
  2939. if (Buffer.TYPED_ARRAY_SUPPORT) {
  2940.   Buffer.prototype.__proto__ = Uint8Array.prototype;
  2941.   Buffer.__proto__ = Uint8Array;
  2942.   if (typeof Symbol !== 'undefined' && Symbol.species &&
  2943.       Buffer[Symbol.species] === Buffer) {
  2944.     // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
  2945.     Object.defineProperty(Buffer, Symbol.species, {
  2946.       value: null,
  2947.       configurable: true
  2948.     });
  2949.   }
  2950. }
  2951.  
  2952. function assertSize (size) {
  2953.   if (typeof size !== 'number') {
  2954.     throw new TypeError('"size" argument must be a number')
  2955.   } else if (size < 0) {
  2956.     throw new RangeError('"size" argument must not be negative')
  2957.   }
  2958. }
  2959.  
  2960. function alloc (that, size, fill, encoding) {
  2961.   assertSize(size);
  2962.   if (size <= 0) {
  2963.     return createBuffer(that, size)
  2964.   }
  2965.   if (fill !== undefined) {
  2966.     // Only pay attention to encoding if it's a string. This
  2967.     // prevents accidentally sending in a number that would
  2968.     // be interpretted as a start offset.
  2969.     return typeof encoding === 'string'
  2970.       ? createBuffer(that, size).fill(fill, encoding)
  2971.       : createBuffer(that, size).fill(fill)
  2972.   }
  2973.   return createBuffer(that, size)
  2974. }
  2975.  
  2976. /**
  2977.  * Creates a new filled Buffer instance.
  2978.  * alloc(size[, fill[, encoding]])
  2979.  **/
  2980. Buffer.alloc = function (size, fill, encoding) {
  2981.   return alloc(null, size, fill, encoding)
  2982. };
  2983.  
  2984. function allocUnsafe (that, size) {
  2985.   assertSize(size);
  2986.   that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
  2987.   if (!Buffer.TYPED_ARRAY_SUPPORT) {
  2988.     for (var i = 0; i < size; ++i) {
  2989.       that[i] = 0;
  2990.     }
  2991.   }
  2992.   return that
  2993. }
  2994.  
  2995. /**
  2996.  * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
  2997.  * */
  2998. Buffer.allocUnsafe = function (size) {
  2999.   return allocUnsafe(null, size)
  3000. };
  3001. /**
  3002.  * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
  3003.  */