Conexio amb la api

node_modules/postcss-ordered-values/LICENSE-MIT

@@ -0,0 +1,22 @@
+Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

node_modules/postcss-ordered-values/README.md

@@ -0,0 +1,72 @@
+# [postcss][postcss]-ordered-values
+
+> Ensure values are ordered consistently in your CSS.
+
+
+## Install
+
+With [npm](https://npmjs.org/package/postcss-ordered-values) do:
+
+```
+npm install postcss-ordered-values --save
+```
+
+
+## Example
+
+Some CSS properties accept their values in an arbitrary order; for this reason,
+it is entirely possible that different developers will write their values in
+different orders. This module normalizes the order, making it easier for other
+modules to understand which declarations are duplicates.
+
+### Input
+
+```css
+h1 {
+    border: solid 1px red;
+    border: red solid .5em;
+    border: rgba(0, 30, 105, 0.8) solid 1px;
+    border: 1px solid red;
+}
+```
+
+### Output
+
+```css
+h1 {
+    border: 1px solid red;
+    border: .5em solid red;
+    border: 1px solid rgba(0, 30, 105, 0.8);
+    border: 1px solid red;
+}
+```
+
+
+## Support List
+
+For more examples, see the [tests](src/__tests__/index.js).
+
+* `animation`, `-webkit-animation`
+* `border(border-left|right|top|bottom)`
+* `box-shadow`
+* `outline`
+* `flex-flow`
+* `transition`, `-webkit-transition`
+
+
+## Usage
+
+See the [PostCSS documentation](https://github.com/postcss/postcss#usage) for
+examples for your environment.
+
+
+## Contributors
+
+See [CONTRIBUTORS.md](https://github.com/cssnano/cssnano/blob/master/CONTRIBUTORS.md).
+
+
+## License
+
+MIT © [Ben Briggs](http://beneb.info)
+
+[postcss]: https://github.com/postcss/postcss

node_modules/postcss-ordered-values/dist/index.js

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+
+var _animation = _interopRequireDefault(require("./rules/animation"));
+
+var _border = _interopRequireDefault(require("./rules/border"));
+
+var _boxShadow = _interopRequireDefault(require("./rules/boxShadow"));
+
+var _flexFlow = _interopRequireDefault(require("./rules/flexFlow"));
+
+var _transition = _interopRequireDefault(require("./rules/transition"));
+
+var _grid = require("./rules/grid");
+
+var _listStyle = _interopRequireDefault(require("./rules/listStyle"));
+
+var _columns = require("./rules/columns");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// rules
+const borderRules = {
+  border: _border.default,
+  'border-block': _border.default,
+  'border-inline': _border.default,
+  'border-block-end': _border.default,
+  'border-block-start': _border.default,
+  'border-inline-end': _border.default,
+  'border-inline-start': _border.default,
+  'border-top': _border.default,
+  'border-right': _border.default,
+  'border-bottom': _border.default,
+  'border-left': _border.default
+};
+const grid = {
+  'grid-auto-flow': _grid.normalizeGridAutoFlow,
+  'grid-column-gap': _grid.normalizeGridColumnRowGap,
+  // normal | <length-percentage>
+  'grid-row-gap': _grid.normalizeGridColumnRowGap,
+  // normal | <length-percentage>
+  'grid-column': _grid.normalizeGridColumnRow,
+  // <grid-line>+
+  'grid-row': _grid.normalizeGridColumnRow,
+  // <grid-line>+
+  'grid-row-start': _grid.normalizeGridColumnRow,
+  // <grid-line>
+  'grid-row-end': _grid.normalizeGridColumnRow,
+  // <grid-line>
+  'grid-column-start': _grid.normalizeGridColumnRow,
+  // <grid-line>
+  'grid-column-end': _grid.normalizeGridColumnRow // <grid-line>
+
+};
+const columnRules = {
+  'column-rule': _columns.columnsRule,
+  columns: _columns.column
+};
+const rules = {
+  animation: _animation.default,
+  outline: _border.default,
+  'box-shadow': _boxShadow.default,
+  'flex-flow': _flexFlow.default,
+  'list-style': _listStyle.default,
+  transition: _transition.default,
+  ...borderRules,
+  ...grid,
+  ...columnRules
+};
+
+function vendorUnprefixed(prop) {
+  return prop.replace(/^-\w+-/, '');
+}
+
+function isVariableFunctionNode(node) {
+  if (node.type !== 'function') {
+    return false;
+  }
+
+  return ['var', 'env'].includes(node.value.toLowerCase());
+}
+
+function shouldAbort(parsed) {
+  let abort = false;
+  parsed.walk(node => {
+    if (node.type === 'comment' || isVariableFunctionNode(node) || node.type === 'word' && ~node.value.indexOf(`___CSS_LOADER_IMPORT___`)) {
+      abort = true;
+      return false;
+    }
+  });
+  return abort;
+}
+
+function getValue(decl) {
+  let {
+    value,
+    raws
+  } = decl;
+
+  if (raws && raws.value && raws.value.raw) {
+    value = raws.value.raw;
+  }
+
+  return value;
+}
+
+function pluginCreator() {
+  return {
+    postcssPlugin: 'postcss-ordered-values',
+
+    prepare() {
+      const cache = {};
+      return {
+        OnceExit(css) {
+          css.walkDecls(decl => {
+            const lowerCasedProp = decl.prop.toLowerCase();
+            const normalizedProp = vendorUnprefixed(lowerCasedProp);
+            const processor = rules[normalizedProp];
+
+            if (!processor) {
+              return;
+            }
+
+            const value = getValue(decl);
+
+            if (cache[value]) {
+              decl.value = cache[value];
+              return;
+            }
+
+            const parsed = (0, _postcssValueParser.default)(value);
+
+            if (parsed.nodes.length < 2 || shouldAbort(parsed)) {
+              cache[value] = value;
+              return;
+            }
+
+            const result = processor(parsed);
+            decl.value = result.toString();
+            cache[value] = result.toString();
+          });
+        }
+
+      };
+    }
+
+  };
+}
+
+pluginCreator.postcss = true;
+var _default = pluginCreator;
+exports.default = _default;
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/lib/addSpace.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addSpace;
+
+function addSpace() {
+  return {
+    type: 'space',
+    value: ' '
+  };
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/lib/getValue.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getValue;
+
+var _postcssValueParser = require("postcss-value-parser");
+
+function getValue(values) {
+  return (0, _postcssValueParser.stringify)({
+    nodes: values.reduce((nodes, arg, index) => {
+      arg.forEach((val, idx) => {
+        if (idx === arg.length - 1 && index === values.length - 1 && val.type === 'space') {
+          return;
+        }
+
+        nodes.push(val);
+      });
+
+      if (index !== values.length - 1) {
+        nodes[nodes.length - 1].type = 'div';
+        nodes[nodes.length - 1].value = ',';
+      }
+
+      return nodes;
+    }, [])
+  });
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/lib/joinGridValue.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = joinGridVal;
+
+function joinGridVal(grid) {
+  return grid.join(' / ').trim();
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/rules/animation.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeAnimation;
+
+var _postcssValueParser = require("postcss-value-parser");
+
+var _cssnanoUtils = require("cssnano-utils");
+
+var _addSpace = _interopRequireDefault(require("../lib/addSpace"));
+
+var _getValue = _interopRequireDefault(require("../lib/getValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// animation: [ none | <keyframes-name> ] || <time> || <single-timing-function> || <time> || <single-animation-iteration-count> || <single-animation-direction> || <single-animation-fill-mode> || <single-animation-play-state>
+const isTimingFunction = (value, type) => {
+  const functions = ['steps', 'cubic-bezier', 'frames'];
+  const keywords = ['ease', 'ease-in', 'ease-in-out', 'ease-out', 'linear', 'step-end', 'step-start'];
+  return type === 'function' && functions.includes(value) || keywords.includes(value);
+};
+
+const isDirection = value => {
+  return ['normal', 'reverse', 'alternate', 'alternate-reverse'].includes(value);
+};
+
+const isFillMode = value => {
+  return ['none', 'forwards', 'backwards', 'both'].includes(value);
+};
+
+const isPlayState = value => {
+  return ['running', 'paused'].includes(value);
+};
+
+const isTime = value => {
+  const quantity = (0, _postcssValueParser.unit)(value);
+  return quantity && ['ms', 's'].includes(quantity.unit);
+};
+
+const isIterationCount = value => {
+  const quantity = (0, _postcssValueParser.unit)(value);
+  return value === 'infinite' || quantity && !quantity.unit;
+};
+
+function normalizeAnimation(parsed) {
+  const args = (0, _cssnanoUtils.getArguments)(parsed);
+  const values = args.reduce((list, arg) => {
+    const state = {
+      name: [],
+      duration: [],
+      timingFunction: [],
+      delay: [],
+      iterationCount: [],
+      direction: [],
+      fillMode: [],
+      playState: []
+    };
+    const stateConditions = [{
+      property: 'duration',
+      delegate: isTime
+    }, {
+      property: 'timingFunction',
+      delegate: isTimingFunction
+    }, {
+      property: 'delay',
+      delegate: isTime
+    }, {
+      property: 'iterationCount',
+      delegate: isIterationCount
+    }, {
+      property: 'direction',
+      delegate: isDirection
+    }, {
+      property: 'fillMode',
+      delegate: isFillMode
+    }, {
+      property: 'playState',
+      delegate: isPlayState
+    }];
+    arg.forEach(node => {
+      let {
+        type,
+        value
+      } = node;
+
+      if (type === 'space') {
+        return;
+      }
+
+      value = value.toLowerCase();
+      const hasMatch = stateConditions.some(({
+        property,
+        delegate
+      }) => {
+        if (delegate(value, type) && !state[property].length) {
+          state[property] = [node, (0, _addSpace.default)()];
+          return true;
+        }
+      });
+
+      if (!hasMatch) {
+        state.name = [...state.name, node, (0, _addSpace.default)()];
+      }
+    });
+    return [...list, [...state.name, ...state.duration, ...state.timingFunction, ...state.delay, ...state.iterationCount, ...state.direction, ...state.fillMode, ...state.playState]];
+  }, []);
+  return (0, _getValue.default)(values);
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/rules/border.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeBorder;
+
+var _postcssValueParser = require("postcss-value-parser");
+
+// border: <line-width> || <line-style> || <color>
+// outline: <outline-color> || <outline-style> || <outline-width>
+const borderWidths = ['thin', 'medium', 'thick'];
+const borderStyles = ['none', 'auto', // only in outline-style
+'hidden', 'dotted', 'dashed', 'solid', 'double', 'groove', 'ridge', 'inset', 'outset'];
+
+function normalizeBorder(border) {
+  const order = {
+    width: '',
+    style: '',
+    color: ''
+  };
+  border.walk(node => {
+    const {
+      type,
+      value
+    } = node;
+
+    if (type === 'word') {
+      if (~borderStyles.indexOf(value.toLowerCase())) {
+        order.style = value;
+        return false;
+      }
+
+      if (~borderWidths.indexOf(value.toLowerCase()) || (0, _postcssValueParser.unit)(value.toLowerCase())) {
+        if (order.width !== '') {
+          order.width = `${order.width} ${value}`;
+          return false;
+        }
+
+        order.width = value;
+        return false;
+      }
+
+      order.color = value;
+      return false;
+    }
+
+    if (type === 'function') {
+      if (value.toLowerCase() === 'calc') {
+        order.width = (0, _postcssValueParser.stringify)(node);
+      } else {
+        order.color = (0, _postcssValueParser.stringify)(node);
+      }
+
+      return false;
+    }
+  });
+  return `${order.width} ${order.style} ${order.color}`.trim();
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/rules/boxShadow.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeBoxShadow;
+
+var _postcssValueParser = require("postcss-value-parser");
+
+var _cssnanoUtils = require("cssnano-utils");
+
+var _addSpace = _interopRequireDefault(require("../lib/addSpace"));
+
+var _getValue = _interopRequireDefault(require("../lib/getValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// box-shadow: inset? && <length>{2,4} && <color>?
+function normalizeBoxShadow(parsed) {
+  let args = (0, _cssnanoUtils.getArguments)(parsed);
+  let abort = false;
+  let values = args.reduce((list, arg) => {
+    let val = [];
+    let state = {
+      inset: [],
+      color: []
+    };
+    arg.forEach(node => {
+      const {
+        type,
+        value
+      } = node;
+
+      if (type === 'function' && ~value.toLowerCase().indexOf('calc')) {
+        abort = true;
+        return;
+      }
+
+      if (type === 'space') {
+        return;
+      }
+
+      if ((0, _postcssValueParser.unit)(value)) {
+        val = [...val, node, (0, _addSpace.default)()];
+      } else if (value.toLowerCase() === 'inset') {
+        state.inset = [...state.inset, node, (0, _addSpace.default)()];
+      } else {
+        state.color = [...state.color, node, (0, _addSpace.default)()];
+      }
+    });
+    return [...list, [...state.inset, ...val, ...state.color]];
+  }, []);
+
+  if (abort) {
+    return parsed.toString();
+  }
+
+  return (0, _getValue.default)(values);
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/rules/columns.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.columnsRule = exports.column = void 0;
+
+var _postcssValueParser = require("postcss-value-parser");
+
+var _border = _interopRequireDefault(require("./border.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function hasUnit(value) {
+  const parsedVal = (0, _postcssValueParser.unit)(value);
+  return parsedVal && parsedVal.unit !== '';
+}
+
+const column = columns => {
+  const widths = [];
+  const other = [];
+  columns.walk(node => {
+    const {
+      type,
+      value
+    } = node;
+
+    if (type === 'word') {
+      if (hasUnit(value)) {
+        widths.push(value);
+      } else {
+        other.push(value);
+      }
+    }
+  }); // only transform if declaration is not invalid or a single value
+
+  if (other.length === 1 && widths.length === 1) {
+    return `${widths[0].trimStart()} ${other[0].trimStart()}`;
+  }
+
+  return columns;
+};
+
+exports.column = column;
+const columnsRule = _border.default;
+exports.columnsRule = columnsRule;

node_modules/postcss-ordered-values/dist/rules/flexFlow.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeFlexFlow;
+// flex-flow: <flex-direction> || <flex-wrap>
+const flexDirection = ['row', 'row-reverse', 'column', 'column-reverse'];
+const flexWrap = ['nowrap', 'wrap', 'wrap-reverse'];
+
+function normalizeFlexFlow(flexFlow) {
+  let order = {
+    direction: '',
+    wrap: ''
+  };
+  flexFlow.walk(({
+    value
+  }) => {
+    if (~flexDirection.indexOf(value.toLowerCase())) {
+      order.direction = value;
+      return;
+    }
+
+    if (~flexWrap.indexOf(value.toLowerCase())) {
+      order.wrap = value;
+      return;
+    }
+  });
+  return `${order.direction} ${order.wrap}`.trim();
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/rules/grid.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeGridColumnRow = exports.normalizeGridColumnRowGap = exports.normalizeGridAutoFlow = void 0;
+
+var _joinGridValue = _interopRequireDefault(require("../lib/joinGridValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const normalizeGridAutoFlow = gridAutoFlow => {
+  let newValue = {
+    front: '',
+    back: ''
+  };
+  let shouldNormalize = false;
+  gridAutoFlow.walk(node => {
+    if (node.value === 'dense') {
+      shouldNormalize = true;
+      newValue.back = node.value;
+    } else if (['row', 'column'].includes(node.value.trim().toLowerCase())) {
+      shouldNormalize = true;
+      newValue.front = node.value;
+    } else {
+      shouldNormalize = false;
+    }
+  });
+
+  if (shouldNormalize) {
+    return `${newValue.front.trim()} ${newValue.back.trim()}`;
+  }
+
+  return gridAutoFlow;
+};
+
+exports.normalizeGridAutoFlow = normalizeGridAutoFlow;
+
+const normalizeGridColumnRowGap = gridGap => {
+  let newValue = {
+    front: '',
+    back: ''
+  };
+  let shouldNormalize = false;
+  gridGap.walk(node => {
+    // console.log(node);
+    if (node.value === 'normal') {
+      shouldNormalize = true;
+      newValue.front = node.value;
+    } else {
+      newValue.back = `${newValue.back} ${node.value}`;
+    }
+  });
+
+  if (shouldNormalize) {
+    return `${newValue.front.trim()} ${newValue.back.trim()}`;
+  }
+
+  return gridGap;
+};
+
+exports.normalizeGridColumnRowGap = normalizeGridColumnRowGap;
+
+const normalizeGridColumnRow = grid => {
+  // cant do normalization here using node, so copy it as a string
+  let gridValue = grid.toString().split('/'); // node -> string value, split ->  " 2 / 3 span " ->  [' 2','3 span ']
+
+  if (gridValue.length > 1) {
+    return (0, _joinGridValue.default)(gridValue.map(gridLine => {
+      let normalizeValue = {
+        front: '',
+        back: ''
+      };
+      gridLine = gridLine.trim(); // '3 span ' -> '3 span'
+
+      gridLine.split(' ').forEach(node => {
+        // ['3','span']
+        if (node === 'span') {
+          normalizeValue.front = node; // span _
+        } else {
+          normalizeValue.back = `${normalizeValue.back} ${node}`; // _ 3
+        }
+      });
+      return `${normalizeValue.front.trim()} ${normalizeValue.back.trim()}`; // span 3
+    }) // returns "2 / span 3"
+    );
+  } // doing this separating if `/` is not present as while joining('/') , it will add `/` at the end
+
+
+  return gridValue.map(gridLine => {
+    let normalizeValue = {
+      front: '',
+      back: ''
+    };
+    gridLine = gridLine.trim();
+    gridLine.split(' ').forEach(node => {
+      if (node === 'span') {
+        normalizeValue.front = node;
+      } else {
+        normalizeValue.back = `${normalizeValue.back} ${node}`;
+      }
+    });
+    return `${normalizeValue.front.trim()} ${normalizeValue.back.trim()}`;
+  });
+};
+
+exports.normalizeGridColumnRow = normalizeGridColumnRow;

node_modules/postcss-ordered-values/dist/rules/listStyle.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = listStyleNormalizer;
+
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+
+var _listStyleTypes = _interopRequireDefault(require("./listStyleTypes.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const definedTypes = _listStyleTypes.default['list-style-type'];
+const definedPosition = ['inside', 'outside'];
+
+function listStyleNormalizer(listStyle) {
+  const order = {
+    type: '',
+    position: '',
+    image: ''
+  };
+  listStyle.walk(decl => {
+    if (decl.type === 'word') {
+      if (definedTypes.includes(decl.value)) {
+        // its a type field
+        order.type = `${order.type} ${decl.value}`;
+      } else if (definedPosition.includes(decl.value)) {
+        order.position = `${order.position} ${decl.value}`;
+      } else if (decl.value === 'none') {
+        if (order.type.split(' ').filter(e => e !== '' && e !== ' ').includes('none')) {
+          order.image = `${order.image} ${decl.value}`;
+        } else {
+          order.type = `${order.type} ${decl.value}`;
+        }
+      } else {
+        order.type = `${order.type} ${decl.value}`;
+      }
+    }
+
+    if (decl.type === 'function') {
+      order.image = `${order.image} ${_postcssValueParser.default.stringify(decl)}`;
+    }
+  });
+  return `${order.type.trim()} ${order.position.trim()} ${order.image.trim()}`.trim();
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/dist/rules/listStyleTypes.json

@@ -0,0 +1,102 @@
+{
+  "list-style-type": [
+    "afar",
+    "amharic",
+    "amharic-abegede",
+    "arabic-indic",
+    "armenian",
+    "asterisks",
+    "bengali",
+    "binary",
+    "cambodian",
+    "circle",
+    "cjk-decimal",
+    "cjk-earthly-branch",
+    "cjk-heavenly-stem",
+    "cjk-ideographic",
+    "decimal",
+    "decimal-leading-zero",
+    "devanagari",
+    "disc",
+    "disclosure-closed",
+    "disclosure-open",
+    "ethiopic",
+    "ethiopic-abegede",
+    "ethiopic-abegede-am-et",
+    "ethiopic-abegede-gez",
+    "ethiopic-abegede-ti-er",
+    "ethiopic-abegede-ti-et",
+    "ethiopic-halehame",
+    "ethiopic-halehame-aa-er",
+    "ethiopic-halehame-aa-et",
+    "ethiopic-halehame-am",
+    "ethiopic-halehame-am-et",
+    "ethiopic-halehame-gez",
+    "ethiopic-halehame-om-et",
+    "ethiopic-halehame-sid-et",
+    "ethiopic-halehame-so-et",
+    "ethiopic-halehame-ti-er",
+    "ethiopic-halehame-ti-et",
+    "ethiopic-halehame-tig",
+    "ethiopic-numeric",
+    "footnotes",
+    "georgian",
+    "gujarati",
+    "gurmukhi",
+    "hangul",
+    "hangul-consonant",
+    "hebrew",
+    "hiragana",
+    "hiragana-iroha",
+    "japanese-formal",
+    "japanese-informal",
+    "kannada",
+    "katakana",
+    "katakana-iroha",
+    "khmer",
+    "korean-hangul-formal",
+    "korean-hanja-formal",
+    "korean-hanja-informal",
+    "lao",
+    "lower-alpha",
+    "lower-armenian",
+    "lower-greek",
+    "lower-hexadecimal",
+    "lower-latin",
+    "lower-norwegian",
+    "lower-roman",
+    "malayalam",
+    "mongolian",
+    "myanmar",
+    "octal",
+    "oriya",
+    "oromo",
+    "persian",
+    "sidama",
+    "simp-chinese-formal",
+    "simp-chinese-informal",
+    "somali",
+    "square",
+    "string",
+    "symbols",
+    "tamil",
+    "telugu",
+    "thai",
+    "tibetan",
+    "tigre",
+    "tigrinya-er",
+    "tigrinya-er-abegede",
+    "tigrinya-et",
+    "tigrinya-et-abegede",
+    "trad-chinese-formal",
+    "trad-chinese-informal",
+    "upper-alpha",
+    "upper-armenian",
+    "upper-greek",
+    "upper-hexadecimal",
+    "upper-latin",
+    "upper-norwegian",
+    "upper-roman",
+    "urdu"
+  ]
+}

node_modules/postcss-ordered-values/dist/rules/transition.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeTransition;
+
+var _postcssValueParser = require("postcss-value-parser");
+
+var _cssnanoUtils = require("cssnano-utils");
+
+var _addSpace = _interopRequireDefault(require("../lib/addSpace"));
+
+var _getValue = _interopRequireDefault(require("../lib/getValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// transition: [ none | <single-transition-property> ] || <time> || <single-transition-timing-function> || <time>
+const timingFunctions = ['ease', 'linear', 'ease-in', 'ease-out', 'ease-in-out', 'step-start', 'step-end'];
+
+function normalizeTransition(parsed) {
+  let args = (0, _cssnanoUtils.getArguments)(parsed);
+  let values = args.reduce((list, arg) => {
+    let state = {
+      timingFunction: [],
+      property: [],
+      time1: [],
+      time2: []
+    };
+    arg.forEach(node => {
+      const {
+        type,
+        value
+      } = node;
+
+      if (type === 'space') {
+        return;
+      }
+
+      if (type === 'function' && ~['steps', 'cubic-bezier'].indexOf(value.toLowerCase())) {
+        state.timingFunction = [...state.timingFunction, node, (0, _addSpace.default)()];
+      } else if ((0, _postcssValueParser.unit)(value)) {
+        if (!state.time1.length) {
+          state.time1 = [...state.time1, node, (0, _addSpace.default)()];
+        } else {
+          state.time2 = [...state.time2, node, (0, _addSpace.default)()];
+        }
+      } else if (~timingFunctions.indexOf(value.toLowerCase())) {
+        state.timingFunction = [...state.timingFunction, node, (0, _addSpace.default)()];
+      } else {
+        state.property = [...state.property, node, (0, _addSpace.default)()];
+      }
+    });
+    return [...list, [...state.property, ...state.time1, ...state.timingFunction, ...state.time2]];
+  }, []);
+  return (0, _getValue.default)(values);
+}
+
+module.exports = exports.default;

node_modules/postcss-ordered-values/package.json

@@ -0,0 +1,74 @@
+{
+  "_from": "postcss-ordered-values@^5.0.2",
+  "_id": "postcss-ordered-values@5.0.2",
+  "_inBundle": false,
+  "_integrity": "sha512-8AFYDSOYWebJYLyJi3fyjl6CqMEG/UVworjiyK1r573I56kb3e879sCJLGvR3merj+fAdPpVplXKQZv+ey6CgQ==",
+  "_location": "/postcss-ordered-values",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "postcss-ordered-values@^5.0.2",
+    "name": "postcss-ordered-values",
+    "escapedName": "postcss-ordered-values",
+    "rawSpec": "^5.0.2",
+    "saveSpec": null,
+    "fetchSpec": "^5.0.2"
+  },
+  "_requiredBy": [
+    "/cssnano-preset-default"
+  ],
+  "_resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-5.0.2.tgz",
+  "_shasum": "1f351426977be00e0f765b3164ad753dac8ed044",
+  "_spec": "postcss-ordered-values@^5.0.2",
+  "_where": "/home/jack/Documents/JDA/m14/projecte_janmaroto/node_modules/cssnano-preset-default",
+  "author": {
+    "name": "Ben Briggs",
+    "email": "beneb.info@gmail.com",
+    "url": "http://beneb.info"
+  },
+  "bugs": {
+    "url": "https://github.com/cssnano/cssnano/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "cssnano-utils": "^2.0.1",
+    "postcss-value-parser": "^4.1.0"
+  },
+  "deprecated": false,
+  "description": "Ensure values are ordered consistently in your CSS.",
+  "devDependencies": {
+    "node-fetch": "^2.6.0",
+    "postcss": "^8.2.15"
+  },
+  "engines": {
+    "node": "^10 || ^12 || >=14.0"
+  },
+  "files": [
+    "dist",
+    "LICENSE-MIT"
+  ],
+  "gitHead": "39b4cc089e8825d308df1fa8a7313d38d8f1f2f7",
+  "homepage": "https://github.com/cssnano/cssnano",
+  "keywords": [
+    "css",
+    "postcss",
+    "postcss-plugin"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "name": "postcss-ordered-values",
+  "peerDependencies": {
+    "postcss": "^8.2.15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cssnano/cssnano.git"
+  },
+  "scripts": {
+    "build": "cross-env BABEL_ENV=publish babel src --config-file ../../babel.config.json --out-dir dist --ignore \"**/__tests__/\" && node script/buildListStyleType.js",
+    "prebuild": "rimraf dist",
+    "prepare": "yarn build"
+  },
+  "version": "5.0.2"
+}