From e06ec920f7a5d784e674c4c4b4e6d1da3dc7391d Mon Sep 17 00:00:00 2001
From: Piotr Russ <mail@pruss.it>
Date: Mon, 16 Nov 2020 00:10:28 +0100
Subject: api, login, auth

---
 node_modules/postcss-modules-values/lib/index.js | 143 +++++++++++++++++++++++
 1 file changed, 143 insertions(+)
 create mode 100644 node_modules/postcss-modules-values/lib/index.js

(limited to 'node_modules/postcss-modules-values/lib/index.js')

diff --git a/node_modules/postcss-modules-values/lib/index.js b/node_modules/postcss-modules-values/lib/index.js
new file mode 100644
index 0000000..33e4f14
--- /dev/null
+++ b/node_modules/postcss-modules-values/lib/index.js
@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var _postcss = require('postcss');
+
+var _postcss2 = _interopRequireDefault(_postcss);
+
+var _icssReplaceSymbols = require('icss-replace-symbols');
+
+var _icssReplaceSymbols2 = _interopRequireDefault(_icssReplaceSymbols);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var matchImports = /^(.+?|\([\s\S]+?\))\s+from\s+("[^"]*"|'[^']*'|[\w-]+)$/;
+var matchValueDefinition = /(?:\s+|^)([\w-]+):?\s+(.+?)\s*$/g;
+var matchImport = /^([\w-]+)(?:\s+as\s+([\w-]+))?/;
+var options = {};
+var importIndex = 0;
+var createImportedName = options && options.createImportedName || function (importName /*, path*/) {
+  return 'i__const_' + importName.replace(/\W/g, '_') + '_' + importIndex++;
+};
+
+exports.default = _postcss2.default.plugin('postcss-modules-values', function () {
+  return function (css, result) {
+    var importAliases = [];
+    var definitions = {};
+
+    var addDefinition = function addDefinition(atRule) {
+      var matches = void 0;
+      while (matches = matchValueDefinition.exec(atRule.params)) {
+        var _matches = matches;
+
+        var _matches2 = _slicedToArray(_matches, 3);
+
+        var /*match*/key = _matches2[1];
+        var value = _matches2[2];
+        // Add to the definitions, knowing that values can refer to each other
+
+        definitions[key] = (0, _icssReplaceSymbols.replaceAll)(definitions, value);
+        atRule.remove();
+      }
+    };
+
+    var addImport = function addImport(atRule) {
+      var matches = matchImports.exec(atRule.params);
+      if (matches) {
+        var _matches3 = _slicedToArray(matches, 3);
+
+        var /*match*/aliases = _matches3[1];
+        var path = _matches3[2];
+        // We can use constants for path names
+
+        if (definitions[path]) path = definitions[path];
+        var imports = aliases.replace(/^\(\s*([\s\S]+)\s*\)$/, '$1').split(/\s*,\s*/).map(function (alias) {
+          var tokens = matchImport.exec(alias);
+          if (tokens) {
+            var _tokens = _slicedToArray(tokens, 3);
+
+            var /*match*/theirName = _tokens[1];
+            var _tokens$ = _tokens[2];
+            var myName = _tokens$ === undefined ? theirName : _tokens$;
+
+            var importedName = createImportedName(myName);
+            definitions[myName] = importedName;
+            return { theirName: theirName, importedName: importedName };
+          } else {
+            throw new Error('@import statement "' + alias + '" is invalid!');
+          }
+        });
+        importAliases.push({ path: path, imports: imports });
+        atRule.remove();
+      }
+    };
+
+    /* Look at all the @value statements and treat them as locals or as imports */
+    css.walkAtRules('value', function (atRule) {
+      if (matchImports.exec(atRule.params)) {
+        addImport(atRule);
+      } else {
+        if (atRule.params.indexOf('@value') !== -1) {
+          result.warn('Invalid value definition: ' + atRule.params);
+        }
+
+        addDefinition(atRule);
+      }
+    });
+
+    /* We want to export anything defined by now, but don't add it to the CSS yet or
+     it well get picked up by the replacement stuff */
+    var exportDeclarations = Object.keys(definitions).map(function (key) {
+      return _postcss2.default.decl({
+        value: definitions[key],
+        prop: key,
+        raws: { before: "\n  " }
+      });
+    });
+
+    /* If we have no definitions, don't continue */
+    if (!Object.keys(definitions).length) return;
+
+    /* Perform replacements */
+    (0, _icssReplaceSymbols2.default)(css, definitions);
+
+    /* Add export rules if any */
+    if (exportDeclarations.length > 0) {
+      var exportRule = _postcss2.default.rule({
+        selector: ':export',
+        raws: { after: "\n" }
+      });
+      exportRule.append(exportDeclarations);
+      css.prepend(exportRule);
+    }
+
+    /* Add import rules */
+    importAliases.reverse().forEach(function (_ref) {
+      var path = _ref.path;
+      var imports = _ref.imports;
+
+      var importRule = _postcss2.default.rule({
+        selector: ':import(' + path + ')',
+        raws: { after: "\n" }
+      });
+      imports.forEach(function (_ref2) {
+        var theirName = _ref2.theirName;
+        var importedName = _ref2.importedName;
+
+        importRule.append({
+          value: theirName,
+          prop: importedName,
+          raws: { before: "\n  " }
+        });
+      });
+
+      css.prepend(importRule);
+    });
+  };
+});
+module.exports = exports['default'];
\ No newline at end of file
-- 
cgit v1.2.3