@salla.sa/twilight-components 1.1.4 → 1.1.5

package/dist/collection/plugins/tailwind-theme/node_modules/cosmiconfig/dist/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cosmiconfig = cosmiconfig;
+exports.cosmiconfigSync = cosmiconfigSync;
+exports.defaultLoaders = void 0;
+
+var _os = _interopRequireDefault(require("os"));
+
+var _Explorer = require("./Explorer");
+
+var _ExplorerSync = require("./ExplorerSync");
+
+var _loaders = require("./loaders");
+
+var _types = require("./types");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function cosmiconfig(moduleName, options = {}) {
+  const normalizedOptions = normalizeOptions(moduleName, options);
+  const explorer = new _Explorer.Explorer(normalizedOptions);
+  return {
+    search: explorer.search.bind(explorer),
+    load: explorer.load.bind(explorer),
+    clearLoadCache: explorer.clearLoadCache.bind(explorer),
+    clearSearchCache: explorer.clearSearchCache.bind(explorer),
+    clearCaches: explorer.clearCaches.bind(explorer)
+  };
+} // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+
+
+function cosmiconfigSync(moduleName, options = {}) {
+  const normalizedOptions = normalizeOptions(moduleName, options);
+  const explorerSync = new _ExplorerSync.ExplorerSync(normalizedOptions);
+  return {
+    search: explorerSync.searchSync.bind(explorerSync),
+    load: explorerSync.loadSync.bind(explorerSync),
+    clearLoadCache: explorerSync.clearLoadCache.bind(explorerSync),
+    clearSearchCache: explorerSync.clearSearchCache.bind(explorerSync),
+    clearCaches: explorerSync.clearCaches.bind(explorerSync)
+  };
+} // do not allow mutation of default loaders. Make sure it is set inside options
+
+
+const defaultLoaders = Object.freeze({
+  '.cjs': _loaders.loaders.loadJs,
+  '.js': _loaders.loaders.loadJs,
+  '.json': _loaders.loaders.loadJson,
+  '.yaml': _loaders.loaders.loadYaml,
+  '.yml': _loaders.loaders.loadYaml,
+  noExt: _loaders.loaders.loadYaml
+});
+exports.defaultLoaders = defaultLoaders;
+
+const identity = function identity(x) {
+  return x;
+};
+
+function normalizeOptions(moduleName, options) {
+  const defaults = {
+    packageProp: moduleName,
+    searchPlaces: ['package.json', `.${moduleName}rc`, `.${moduleName}rc.json`, `.${moduleName}rc.yaml`, `.${moduleName}rc.yml`, `.${moduleName}rc.js`, `.${moduleName}rc.cjs`, `${moduleName}.config.js`, `${moduleName}.config.cjs`],
+    ignoreEmptySearchPlaces: true,
+    stopDir: _os.default.homedir(),
+    cache: true,
+    transform: identity,
+    loaders: defaultLoaders
+  };
+  const normalizedOptions = { ...defaults,
+    ...options,
+    loaders: { ...defaults.loaders,
+      ...options.loaders
+    }
+  };
+  return normalizedOptions;
+}
+//# sourceMappingURL=index.js.map

package/dist/collection/plugins/tailwind-theme/node_modules/cosmiconfig/dist/loaders.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loaders = void 0;
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+let importFresh;
+
+const loadJs = function loadJs(filepath) {
+  if (importFresh === undefined) {
+    importFresh = require('import-fresh');
+  }
+
+  const result = importFresh(filepath);
+  return result;
+};
+
+let parseJson;
+
+const loadJson = function loadJson(filepath, content) {
+  if (parseJson === undefined) {
+    parseJson = require('parse-json');
+  }
+
+  try {
+    const result = parseJson(content);
+    return result;
+  } catch (error) {
+    error.message = `JSON Error in ${filepath}:\n${error.message}`;
+    throw error;
+  }
+};
+
+let yaml;
+
+const loadYaml = function loadYaml(filepath, content) {
+  if (yaml === undefined) {
+    yaml = require('yaml');
+  }
+
+  try {
+    const result = yaml.parse(content, {
+      prettyErrors: true
+    });
+    return result;
+  } catch (error) {
+    error.message = `YAML Error in ${filepath}:\n${error.message}`;
+    throw error;
+  }
+};
+
+const loaders = {
+  loadJs,
+  loadJson,
+  loadYaml
+};
+exports.loaders = loaders;
+//# sourceMappingURL=loaders.js.map

package/dist/collection/plugins/tailwind-theme/node_modules/cosmiconfig/dist/readFile.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readFile = readFile;
+exports.readFileSync = readFileSync;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function fsReadFileAsync(pathname, encoding) {
+  return new Promise((resolve, reject) => {
+    _fs.default.readFile(pathname, encoding, (error, contents) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      resolve(contents);
+    });
+  });
+}
+
+async function readFile(filepath, options = {}) {
+  const throwNotFound = options.throwNotFound === true;
+
+  try {
+    const content = await fsReadFileAsync(filepath, 'utf8');
+    return content;
+  } catch (error) {
+    if (throwNotFound === false && (error.code === 'ENOENT' || error.code === 'EISDIR')) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+function readFileSync(filepath, options = {}) {
+  const throwNotFound = options.throwNotFound === true;
+
+  try {
+    const content = _fs.default.readFileSync(filepath, 'utf8');
+
+    return content;
+  } catch (error) {
+    if (throwNotFound === false && (error.code === 'ENOENT' || error.code === 'EISDIR')) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+//# sourceMappingURL=readFile.js.map

package/dist/collection/plugins/tailwind-theme/node_modules/cosmiconfig/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/dist/collection/plugins/tailwind-theme/node_modules/css-unit-converter/index.js

@@ -0,0 +1,127 @@
+var conversions = {
+    // length
+    'px': {
+        'px': 1,
+        'cm': 96.0/2.54,
+        'mm': 96.0/25.4,
+        'in': 96,
+        'pt': 96.0/72.0,
+        'pc': 16
+    },
+    'cm': {
+        'px': 2.54/96.0,
+        'cm': 1,
+        'mm': 0.1,
+        'in': 2.54,
+        'pt': 2.54/72.0,
+        'pc': 2.54/6.0
+    },
+    'mm': {
+        'px': 25.4/96.0,
+        'cm': 10,
+        'mm': 1,
+        'in': 25.4,
+        'pt': 25.4/72.0,
+        'pc': 25.4/6.0
+    },
+    'in': {
+        'px': 1.0/96.0,
+        'cm': 1.0/2.54,
+        'mm': 1.0/25.4,
+        'in': 1,
+        'pt': 1.0/72.0,
+        'pc': 1.0/6.0
+    },
+    'pt': {
+        'px': 0.75,
+        'cm': 72.0/2.54,
+        'mm': 72.0/25.4,
+        'in': 72,
+        'pt': 1,
+        'pc': 12
+    },
+    'pc': {
+        'px': 6.0/96.0,
+        'cm': 6.0/2.54,
+        'mm': 6.0/25.4,
+        'in': 6,
+        'pt': 6.0/72.0,
+        'pc': 1
+    },
+    // angle
+    'deg': {
+        'deg': 1,
+        'grad': 0.9,
+        'rad': 180/Math.PI,
+        'turn': 360
+    },
+    'grad': {
+        'deg': 400/360,
+        'grad': 1,
+        'rad': 200/Math.PI,
+        'turn': 400
+    },
+    'rad': {
+        'deg': Math.PI/180,
+        'grad': Math.PI/200,
+        'rad': 1,
+        'turn': Math.PI*2
+    },
+    'turn': {
+        'deg': 1/360,
+        'grad': 1/400,
+        'rad': 0.5/Math.PI,
+        'turn': 1
+    },
+    // time
+    's': {
+        's': 1,
+        'ms': 1/1000
+    },
+    'ms': {
+        's': 1000,
+        'ms': 1
+    },
+    // frequency
+    'Hz': {
+        'Hz': 1,
+        'kHz': 1000
+    },
+    'kHz': {
+        'Hz': 1/1000,
+        'kHz': 1
+    },
+    // resolution
+    'dpi': {
+        'dpi': 1,
+        'dpcm': 1.0/2.54,
+        'dppx': 1/96
+    },
+    'dpcm': {
+        'dpi': 2.54,
+        'dpcm': 1,
+        'dppx': 2.54/96.0
+    },
+    'dppx': {
+        'dpi': 96,
+        'dpcm': 96.0/2.54,
+        'dppx': 1
+    }
+};
+
+module.exports = function (value, sourceUnit, targetUnit, precision) {
+    if (!conversions.hasOwnProperty(targetUnit))
+        throw new Error("Cannot convert to " + targetUnit);
+
+    if (!conversions[targetUnit].hasOwnProperty(sourceUnit))
+        throw new Error("Cannot convert from " + sourceUnit + " to " + targetUnit);
+    
+    var converted = conversions[targetUnit][sourceUnit] * value;
+    
+    if (precision !== false) {
+        precision = Math.pow(10, parseInt(precision) || 5);
+        return Math.round(converted * precision) / precision;
+    }
+    
+    return converted;
+};

package/dist/collection/plugins/tailwind-theme/node_modules/cssesc/cssesc.js

@@ -0,0 +1,110 @@
+/*! https://mths.be/cssesc v3.0.0 by @mathias */
+'use strict';
+
+var object = {};
+var hasOwnProperty = object.hasOwnProperty;
+var merge = function merge(options, defaults) {
+	if (!options) {
+		return defaults;
+	}
+	var result = {};
+	for (var key in defaults) {
+		// `if (defaults.hasOwnProperty(key) { … }` is not needed here, since
+		// only recognized option names are used.
+		result[key] = hasOwnProperty.call(options, key) ? options[key] : defaults[key];
+	}
+	return result;
+};
+
+var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
+var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
+var regexAlwaysEscape = /['"\\]/;
+var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+
+// https://mathiasbynens.be/notes/css-escapes#css
+var cssesc = function cssesc(string, options) {
+	options = merge(options, cssesc.options);
+	if (options.quotes != 'single' && options.quotes != 'double') {
+		options.quotes = 'single';
+	}
+	var quote = options.quotes == 'double' ? '"' : '\'';
+	var isIdentifier = options.isIdentifier;
+
+	var firstChar = string.charAt(0);
+	var output = '';
+	var counter = 0;
+	var length = string.length;
+	while (counter < length) {
+		var character = string.charAt(counter++);
+		var codePoint = character.charCodeAt();
+		var value = void 0;
+		// If it’s not a printable ASCII character…
+		if (codePoint < 0x20 || codePoint > 0x7E) {
+			if (codePoint >= 0xD800 && codePoint <= 0xDBFF && counter < length) {
+				// It’s a high surrogate, and there is a next character.
+				var extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) {
+					// next character is low surrogate
+					codePoint = ((codePoint & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000;
+				} else {
+					// It’s an unmatched surrogate; only append this code unit, in case
+					// the next code unit is the high surrogate of a surrogate pair.
+					counter--;
+				}
+			}
+			value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+		} else {
+			if (options.escapeEverything) {
+				if (regexAnySingleEscape.test(character)) {
+					value = '\\' + character;
+				} else {
+					value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+				}
+			} else if (/[\t\n\f\r\x0B]/.test(character)) {
+				value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+			} else if (character == '\\' || !isIdentifier && (character == '"' && quote == character || character == '\'' && quote == character) || isIdentifier && regexSingleEscape.test(character)) {
+				value = '\\' + character;
+			} else {
+				value = character;
+			}
+		}
+		output += value;
+	}
+
+	if (isIdentifier) {
+		if (/^-[-\d]/.test(output)) {
+			output = '\\-' + output.slice(1);
+		} else if (/\d/.test(firstChar)) {
+			output = '\\3' + firstChar + ' ' + output.slice(1);
+		}
+	}
+
+	// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
+	// since they’re redundant. Note that this is only possible if the escape
+	// sequence isn’t preceded by an odd number of backslashes.
+	output = output.replace(regexExcessiveSpaces, function ($0, $1, $2) {
+		if ($1 && $1.length % 2) {
+			// It’s not safe to remove the space, so don’t.
+			return $0;
+		}
+		// Strip the space.
+		return ($1 || '') + $2;
+	});
+
+	if (!isIdentifier && options.wrap) {
+		return quote + output + quote;
+	}
+	return output;
+};
+
+// Expose default options (so they can be overridden globally).
+cssesc.options = {
+	'escapeEverything': false,
+	'isIdentifier': false,
+	'quotes': 'single',
+	'wrap': false
+};
+
+cssesc.version = '3.0.0';
+
+module.exports = cssesc;

package/dist/collection/plugins/tailwind-theme/node_modules/defined/example/defined.js

@@ -0,0 +1,4 @@
+var defined = require('../');
+var opts = { y : false, w : 4 };
+var x = defined(opts.x, opts.y, opts.w, 8);
+console.log(x);

package/dist/collection/plugins/tailwind-theme/node_modules/defined/index.js

@@ -0,0 +1,5 @@
+module.exports = function () {
+    for (var i = 0; i < arguments.length; i++) {
+        if (arguments[i] !== undefined) return arguments[i];
+    }
+};

package/dist/collection/plugins/tailwind-theme/node_modules/defined/test/def.js

@@ -0,0 +1,22 @@
+var defined = require('../');
+var test = require('tape');
+
+test('defined-or', function (t) {
+    var u = undefined;
+    
+    t.equal(defined(), u, 'empty arguments');
+    t.equal(defined(u), u, '1 undefined');
+    t.equal(defined(u, u), u, '2 undefined');
+    t.equal(defined(u, u, u, u), u, '4 undefineds');
+    
+    t.equal(defined(undefined, false, true), false, 'false[0]');
+    t.equal(defined(false, true), false, 'false[1]');
+    t.equal(defined(undefined, 0, true), 0, 'zero[0]');
+    t.equal(defined(0, true), 0, 'zero[1]');
+    
+    t.equal(defined(3, undefined, 4), 3, 'first arg');
+    t.equal(defined(undefined, 3, 4), 3, 'second arg');
+    t.equal(defined(undefined, undefined, 3), 3, 'third arg');
+    
+    t.end();
+});

package/dist/collection/plugins/tailwind-theme/node_modules/defined/test/falsy.js

@@ -0,0 +1,9 @@
+var test = require('tape');
+var defined = require('../');
+
+test('falsy', function (t) {
+    t.plan(1);
+    var opts = { y : false, w : 4 };
+    var x = defined(opts.x, opts.y, opts.w, 8);
+    t.equal(x, false);
+});

package/dist/collection/plugins/tailwind-theme/node_modules/detective/bench/detect.js

@@ -0,0 +1,7 @@
+var detective = require('../');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/src/jquery.js', 'utf8');
+var t0 = Date.now();
+var requires = detective(src);
+console.log(Date.now() - t0);

package/dist/collection/plugins/tailwind-theme/node_modules/detective/bin/detective.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+var detective = require('../');
+var argv = require('minimist')(process.argv.slice(2));
+var fs = require('fs');
+
+argv._.forEach(function(file) {
+    var src = fs.readFileSync(file, 'utf8');
+    var requires = detective(src, argv);
+    console.log(requires.join('\n'));
+});

package/dist/collection/plugins/tailwind-theme/node_modules/detective/example/strings.js

@@ -0,0 +1,6 @@
+var detective = require('../');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/strings_src.js');
+var requires = detective(src);
+console.dir(requires);

package/dist/collection/plugins/tailwind-theme/node_modules/detective/example/strings_src.js

@@ -0,0 +1,3 @@
+var a = require('a');
+var b = require('b');
+var c = require('c');

package/dist/collection/plugins/tailwind-theme/node_modules/detective/index.js

@@ -0,0 +1,80 @@
+var acorn = require('acorn-node');
+var walk = require('acorn-node/walk');
+var defined = require('defined');
+
+var requireRe = /\brequire\b/;
+
+function parse (src, opts) {
+    if (!opts) opts = {};
+    var acornOpts = {
+        ranges: defined(opts.ranges, opts.range),
+        locations: defined(opts.locations, opts.loc),
+        allowReserved: defined(opts.allowReserved, true),
+        allowImportExportEverywhere: defined(opts.allowImportExportEverywhere, false)
+    };
+
+    // Use acorn-node's defaults for the rest.
+    if (opts.ecmaVersion != null) acornOpts.ecmaVersion = opts.ecmaVersion;
+    if (opts.sourceType != null) acornOpts.sourceType = opts.sourceType;
+    if (opts.allowHashBang != null) acornOpts.allowHashBang = opts.allowHashBang;
+    if (opts.allowReturnOutsideFunction != null) acornOpts.allowReturnOutsideFunction = opts.allowReturnOutsideFunction;
+
+    return acorn.parse(src, acornOpts);
+}
+
+var exports = module.exports = function (src, opts) {
+    return exports.find(src, opts).strings;
+};
+
+exports.find = function (src, opts) {
+    if (!opts) opts = {};
+    
+    var word = opts.word === undefined ? 'require' : opts.word;
+    if (typeof src !== 'string') src = String(src);
+    
+    var isRequire = opts.isRequire || function (node) {
+        return node.callee.type === 'Identifier'
+            && node.callee.name === word
+        ;
+    };
+    
+    var modules = { strings : [], expressions : [] };
+    if (opts.nodes) modules.nodes = [];
+    
+    var wordRe = word === 'require' ? requireRe : RegExp('\\b' + word + '\\b');
+    if (!wordRe.test(src)) return modules;
+    
+    var ast = parse(src, opts.parse);
+    
+    function visit(node, st, c) {
+        var hasRequire = wordRe.test(src.slice(node.start, node.end));
+        if (!hasRequire) return;
+        walk.base[node.type](node, st, c);
+        if (node.type !== 'CallExpression') return;
+        if (isRequire(node)) {
+            if (node.arguments.length) {
+                var arg = node.arguments[0];
+                if (arg.type === 'Literal') {
+                    modules.strings.push(arg.value);
+                }
+                else if (arg.type === 'TemplateLiteral'
+                        && arg.quasis.length === 1
+                        && arg.expressions.length === 0) {
+
+                    modules.strings.push(arg.quasis[0].value.raw);
+                }
+                else {
+                    modules.expressions.push(src.slice(arg.start, arg.end));
+                }
+            }
+            if (opts.nodes) modules.nodes.push(node);
+        }
+    }
+    
+    walk.recursive(ast, null, {
+        Statement: visit,
+        Expression: visit
+    });
+    
+    return modules;
+};

package/dist/collection/plugins/tailwind-theme/node_modules/detective/test/both.js

@@ -0,0 +1,26 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/both.js');
+
+test('both', function (t) {
+    var modules = detective.find(src);
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.notOk(modules.nodes, 'has no nodes');
+    t.end();
+});
+
+test('both with nodes specified in opts', function (t) {
+    var modules = detective.find(src, { nodes: true });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+    t.end();
+});

package/dist/collection/plugins/tailwind-theme/node_modules/detective/test/chained.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/chained.js');
+
+test('chained', function (t) {
+    t.deepEqual(detective(src), [ 'c', 'b', 'a' ]);
+    t.end();
+});