@salla.sa/twilight-components 1.1.6 → 1.1.7

package/dist/collection/plugins/tailwind-theme/node_modules/graceful-fs/polyfills.js

@@ -0,0 +1,355 @@
+var constants = require('constants')
+
+var origCwd = process.cwd
+var cwd = null
+
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process)
+  return cwd
+}
+try {
+  process.cwd()
+} catch (er) {}
+
+// This check is needed until node.js 12 is required
+if (typeof process.chdir === 'function') {
+  var chdir = process.chdir
+  process.chdir = function (d) {
+    cwd = null
+    chdir.call(process, d)
+  }
+  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
+}
+
+module.exports = patch
+
+function patch (fs) {
+  // (re-)implement some things that are known busted or missing.
+
+  // lchmod, broken prior to 0.6.2
+  // back-port the fix here.
+  if (constants.hasOwnProperty('O_SYMLINK') &&
+      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+    patchLchmod(fs)
+  }
+
+  // lutimes implementation, or no-op
+  if (!fs.lutimes) {
+    patchLutimes(fs)
+  }
+
+  // https://github.com/isaacs/node-graceful-fs/issues/4
+  // Chown should not fail on einval or eperm if non-root.
+  // It should not fail on enosys ever, as this just indicates
+  // that a fs doesn't support the intended operation.
+
+  fs.chown = chownFix(fs.chown)
+  fs.fchown = chownFix(fs.fchown)
+  fs.lchown = chownFix(fs.lchown)
+
+  fs.chmod = chmodFix(fs.chmod)
+  fs.fchmod = chmodFix(fs.fchmod)
+  fs.lchmod = chmodFix(fs.lchmod)
+
+  fs.chownSync = chownFixSync(fs.chownSync)
+  fs.fchownSync = chownFixSync(fs.fchownSync)
+  fs.lchownSync = chownFixSync(fs.lchownSync)
+
+  fs.chmodSync = chmodFixSync(fs.chmodSync)
+  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+
+  fs.stat = statFix(fs.stat)
+  fs.fstat = statFix(fs.fstat)
+  fs.lstat = statFix(fs.lstat)
+
+  fs.statSync = statFixSync(fs.statSync)
+  fs.fstatSync = statFixSync(fs.fstatSync)
+  fs.lstatSync = statFixSync(fs.lstatSync)
+
+  // if lchmod/lchown do not exist, then make them no-ops
+  if (fs.chmod && !fs.lchmod) {
+    fs.lchmod = function (path, mode, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchmodSync = function () {}
+  }
+  if (fs.chown && !fs.lchown) {
+    fs.lchown = function (path, uid, gid, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchownSync = function () {}
+  }
+
+  // on Windows, A/V software can lock the directory, causing this
+  // to fail with an EACCES or EPERM if the directory contains newly
+  // created files.  Try again on failure, for up to 60 seconds.
+
+  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+  // bit9, may lock files for up to a minute, causing npm package install
+  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+  // CPU to a busy looping process, which can cause the program causing the lock
+  // contention to be starved of CPU by node, so the contention doesn't resolve.
+  if (platform === "win32") {
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
+        var start = Date.now()
+        var backoff = 0;
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
+              fs.stat(to, function (stater, st) {
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er)
+              })
+            }, backoff)
+            if (backoff < 100)
+              backoff += 10;
+            return;
+          }
+          if (cb) cb(er)
+        })
+      }
+      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename)
+      return rename
+    })(fs.rename)
+  }
+
+  // if read() returns EAGAIN, then just try it again.
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
+      var callback
+      if (callback_ && typeof callback_ === 'function') {
+        var eagCounter = 0
+        callback = function (er, _, __) {
+          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+            eagCounter ++
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+          }
+          callback_.apply(this, arguments)
+        }
+      }
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+    }
+
+    // This ensures `util.promisify` works as it does for native `fs.read`.
+    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
+    return read
+  })(fs.read)
+
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++
+          continue
+        }
+        throw er
+      }
+    }
+  }})(fs.readSync)
+
+  function patchLchmod (fs) {
+    fs.lchmod = function (path, mode, callback) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
+        if (err) {
+          if (callback) callback(err)
+          return
+        }
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        fs.fchmod(fd, mode, function (err) {
+          fs.close(fd, function(err2) {
+            if (callback) callback(err || err2)
+          })
+        })
+      })
+    }
+
+    fs.lchmodSync = function (path, mode) {
+      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      var threw = true
+      var ret
+      try {
+        ret = fs.fchmodSync(fd, mode)
+        threw = false
+      } finally {
+        if (threw) {
+          try {
+            fs.closeSync(fd)
+          } catch (er) {}
+        } else {
+          fs.closeSync(fd)
+        }
+      }
+      return ret
+    }
+  }
+
+  function patchLutimes (fs) {
+    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+      fs.lutimes = function (path, at, mt, cb) {
+        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+          if (er) {
+            if (cb) cb(er)
+            return
+          }
+          fs.futimes(fd, at, mt, function (er) {
+            fs.close(fd, function (er2) {
+              if (cb) cb(er || er2)
+            })
+          })
+        })
+      }
+
+      fs.lutimesSync = function (path, at, mt) {
+        var fd = fs.openSync(path, constants.O_SYMLINK)
+        var ret
+        var threw = true
+        try {
+          ret = fs.futimesSync(fd, at, mt)
+          threw = false
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd)
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd)
+          }
+        }
+        return ret
+      }
+
+    } else if (fs.futimes) {
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+      fs.lutimesSync = function () {}
+    }
+  }
+
+  function chmodFix (orig) {
+    if (!orig) return orig
+    return function (target, mode, cb) {
+      return orig.call(fs, target, mode, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chmodFixSync (orig) {
+    if (!orig) return orig
+    return function (target, mode) {
+      try {
+        return orig.call(fs, target, mode)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+
+  function chownFix (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid, cb) {
+      return orig.call(fs, target, uid, gid, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chownFixSync (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid) {
+      try {
+        return orig.call(fs, target, uid, gid)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+  function statFix (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options, cb) {
+      if (typeof options === 'function') {
+        cb = options
+        options = null
+      }
+      function callback (er, stats) {
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000
+          if (stats.gid < 0) stats.gid += 0x100000000
+        }
+        if (cb) cb.apply(this, arguments)
+      }
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
+    }
+  }
+
+  function statFixSync (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options) {
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target)
+      if (stats) {
+        if (stats.uid < 0) stats.uid += 0x100000000
+        if (stats.gid < 0) stats.gid += 0x100000000
+      }
+      return stats;
+    }
+  }
+
+  // ENOSYS means that the fs doesn't support the op. Just ignore
+  // that, because it doesn't matter.
+  //
+  // if there's no getuid, or if getuid() is something other
+  // than 0, and the error is EINVAL or EPERM, then just ignore
+  // it.
+  //
+  // This specific case is a silent failure in cp, install, tar,
+  // and most other unix tools that manage permissions.
+  //
+  // When running as root, or if other types of errors are
+  // encountered, then it's strict.
+  function chownErOk (er) {
+    if (!er)
+      return true
+
+    if (er.code === "ENOSYS")
+      return true
+
+    var nonroot = !process.getuid || process.getuid() !== 0
+    if (nonroot) {
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
+    }
+
+    return false
+  }
+}

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

@@ -0,0 +1,5 @@
+'use strict';
+
+var bind = require('function-bind');
+
+module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);

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

@@ -0,0 +1,10 @@
+'use strict';
+
+var test = require('tape');
+var has = require('../');
+
+test('has', function (t) {
+  t.equal(has({}, 'hasOwnProperty'), false, 'object literal does not have own property "hasOwnProperty"');
+  t.equal(has(Object.prototype, 'hasOwnProperty'), true, 'Object.prototype has own property "hasOwnProperty"');
+  t.end();
+});

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

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = (flag, argv = process.argv) => {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+};

package/dist/collection/plugins/tailwind-theme/node_modules/hex-color-regex/index.js

@@ -0,0 +1,16 @@
+/*!
+ * hex-color-regex <https://github.com/regexps/hex-color-regex>
+ *
+ * Copyright (c) 2015 Charlike Mike Reagent <@tunnckoCore> (http://www.tunnckocore.tk)
+ * Released under the MIT license.
+ */
+
+'use strict'
+
+module.exports = function hexColorRegex(opts) {
+  opts = opts && typeof opts === 'object' ? opts : {}
+
+  return opts.strict
+    ? /^#([a-f0-9]{3,4}|[a-f0-9]{4}(?:[a-f0-9]{2}){1,2})\b$/i
+    : /#([a-f0-9]{3}|[a-f0-9]{4}(?:[a-f0-9]{2}){0,2})\b/gi
+}

package/dist/collection/plugins/tailwind-theme/node_modules/hex-color-regex/test.js

@@ -0,0 +1,294 @@
+/*!
+ * hex-color-regex <https://github.com/regexps/hex-color-regex>
+ *
+ * Copyright (c) 2015 Charlike Mike Reagent <@tunnckoCore> (http://www.tunnckocore.tk)
+ * Released under the MIT license.
+ */
+
+/* jshint asi:true */
+
+'use strict'
+
+var test = require('mukla')
+var hexColorRegex = require('./index')
+
+var sixDigits = {
+  pass: [
+    '#afebe3',
+    '#AFEBE3',
+    '#3cb371',
+    '#3CB371',
+    '#556b2f',
+    '#556B2F',
+    '#708090',
+    '#7b68ee',
+    '#7B68EE',
+    '#eeeeee',
+    '#ffffff',
+    '#123fff}',
+    '#111111'
+  ],
+  fail: [
+    'afebe3',
+    'AFEBE3',
+    '3cb371',
+    'ABC371',
+    '556b2f',
+    '5A6B2F',
+    '708090',
+    '7b68ee',
+    '7B68EE',
+    'eeeeee',
+    'ffffff',
+    '111111',
+    'afebef',
+    '3c537f',
+    '556B2f',
+    '708135',
+    'EE3EF1',
+    '7f68ZY',
+    '#7f68ZY',
+    '#7z68ZY',
+    '#GR68',
+    '#Z68',
+    '#666EFR'
+  ]
+}
+
+var threeDigits = {
+  pass: [
+    '#afe',
+    '#AF3',
+    '#3cb',
+    '#3CB',
+    '#b2f',
+    '#5B2',
+    '#708',
+    '#68e',
+    '#7AF',
+    '#777',
+    '#FFF',
+    '#fff',
+    '#f3f}',
+    '#111'
+  ],
+  fail: [
+    'fff',
+    '4zy',
+    '4g1',
+    '111',
+    'Ge3',
+    'zY1',
+    '#ggg',
+    '#4zy',
+    '#4g1',
+    '#Ge3',
+    '#zY1'
+  ]
+}
+
+var fourDigits = {
+  pass: ['#afe0', '#AF31', '#3cba', '#3CBA', '#b2ff', '#5B2F'],
+  fail: ['afe0', 'AF31', '#3cbg', '#3CBy', '#b2fz']
+}
+
+var eightDigits = {
+  pass: ['#afebe300', '#AFEBE3AA', '#3cb371ff', '#3CB371CC', '#556b2f55'],
+  fail: ['afebe300', 'AFEBE3AA', '#3cb371fg', '#3CB371xy', '#556b2fz9']
+}
+
+test('hex-color-regex:', function() {
+  test('in no strict mode', function() {
+    test('six digit hex', function() {
+      test('should be `true`', function() {
+        sixDigits.pass.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), true)
+          })
+        })
+        test('when `foo #ae3f4c bar` value', function() {
+          test.equal(hexColorRegex().test('foo #ae3f4c bar'), true)
+        })
+      })
+      test('should be `false`', function() {
+        sixDigits.fail.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), false)
+          })
+        })
+      })
+    })
+    test('three digit hex', function() {
+      test('should be `true`', function() {
+        threeDigits.pass.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), true)
+          })
+        })
+        test('when `foo #e4f bar` value', function() {
+          test.equal(hexColorRegex().test('foo #e4f bar'), true)
+        })
+      })
+      test('should be `false`', function() {
+        threeDigits.fail.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), false)
+          })
+        })
+      })
+    })
+    test('eight digit alpha channel hex', function() {
+      test('should be `true`', function() {
+        eightDigits.pass.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), true)
+          })
+        })
+        test('when `foo #ae3f4c bar` value', function() {
+          test.equal(hexColorRegex().test('foo #ae3f4c00 bar'), true)
+        })
+      })
+      test('should be `false`', function() {
+        eightDigits.fail.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), false)
+          })
+        })
+      })
+    })
+    test('four digit alpha channel hex', function() {
+      test('should be `true`', function() {
+        fourDigits.pass.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), true)
+          })
+        })
+        test('when `foo #ae3f4c bar` value', function() {
+          test.equal(hexColorRegex().test('foo #ae3f bar'), true)
+        })
+      })
+      test('should be `false`', function() {
+        fourDigits.fail.forEach(function(hex) {
+          test('when `' + hex + '` value', function() {
+            test.equal(hexColorRegex().test(hex), false)
+          })
+        })
+      })
+    })
+    test('using regex().exec(hex)', function() {
+      sixDigits.pass.forEach(function(hex) {
+        var hexed = hex.replace('}', '')
+        test('should match `' + hexed + '` when `' + hex + '` hex', function() {
+          var actual = hexColorRegex().exec(hex)[0]
+          var expected = hexed
+
+          test.equal(actual, expected)
+        })
+      })
+      test('should match `#ae3f4c` when `foo #ae3f4c bar` string', function() {
+        var actual = hexColorRegex().exec('foo #ae3f4c bar')[0]
+        var expected = '#ae3f4c'
+
+        test.equal(actual, expected)
+      })
+      threeDigits.pass.forEach(function(hex) {
+        var hexed = hex.replace('}', '')
+        test('should match `' + hexed + '` when `' + hex + '` hex', function() {
+          var actual = hexColorRegex().exec(hex)[0]
+          var expected = hexed
+
+          test.equal(actual, expected)
+        })
+      })
+      test('should match `#e7f` when `foo #e7f bar` string', function() {
+        var actual = hexColorRegex().exec('foo #e7f bar')[0]
+        var expected = '#e7f'
+
+        test.equal(actual, expected)
+      })
+      eightDigits.pass.forEach(function(hex) {
+        var hexed = hex.replace('}', '')
+        test('should match `' + hexed + '` when `' + hex + '` hex', function() {
+          var actual = hexColorRegex().exec(hex)[0]
+          var expected = hexed
+
+          test.equal(actual, expected)
+        })
+      })
+      test('should match `#ae3f4c00` when `foo #ae3f4c00 bar` string', function() {
+        var actual = hexColorRegex().exec('foo #ae3f4c00 bar')[0]
+        var expected = '#ae3f4c00'
+
+        test.equal(actual, expected)
+      })
+      fourDigits.pass.forEach(function(hex) {
+        var hexed = hex.replace('}', '')
+        test('should match `' + hexed + '` when `' + hex + '` hex', function() {
+          var actual = hexColorRegex().exec(hex)[0]
+          var expected = hexed
+
+          test.equal(actual, expected)
+        })
+      })
+      test('should match `#e7f0` when `foo #e7f0 bar` string', function() {
+        var actual = hexColorRegex().exec('foo #e7f0 bar')[0]
+        var expected = '#e7f0'
+
+        test.equal(actual, expected)
+      })
+    })
+  })
+  test('in strict mode', function() {
+    test('six digit hex `#123fff}` should return false', function() {
+      test.equal(hexColorRegex({ strict: true }).test('#123fff}'), false)
+    })
+    test('string contain six digit hex `foo #ae3f4c bar` return false', function() {
+      test.equal(hexColorRegex({ strict: true }).test('foo #ae3f4c bar'), false)
+    })
+    test('three digit hex `#f3f}` should return false', function() {
+      test.equal(hexColorRegex({ strict: true }).test('#f3f}'), false)
+    })
+    test('string contain three digit hex `foo #e7f bar` return false', function() {
+      test.equal(hexColorRegex({ strict: true }).test('foo #e7f bar'), false)
+    })
+    test('eight digit alpha channel hex `#123fff00}` should return false', function() {
+      test.equal(hexColorRegex({ strict: true }).test('#123fff00}'), false)
+    })
+    test('string contain eight digit alpha channel hex `foo #ae3f4cff bar` return false', function() {
+      test.equal(
+        hexColorRegex({ strict: true }).test('foo #ae3f4cff bar'),
+        false
+      )
+    })
+    test('four digit alpha channel hex `#f3f0}` should return false', function() {
+      test.equal(hexColorRegex({ strict: true }).test('#f3f0}'), false)
+    })
+    test('string contain four digit alpha channel hex `foo #e7ff bar` return false', function() {
+      test.equal(hexColorRegex({ strict: true }).test('foo #e7ff bar'), false)
+    })
+    test('should not match when `foo #ae3f4c bar` string', function() {
+      var actual = hexColorRegex({ strict: true }).exec('foo #ae3f4c bar')
+      var expected = null
+
+      test.equal(actual, expected)
+    })
+    test('should not match when `foo #e7f bar` string', function() {
+      var actual = hexColorRegex({ strict: true }).exec('foo #e7f bar')
+      var expected = null
+
+      test.equal(actual, expected)
+    })
+    test('should not match when `foo #ae3f4cff bar` string', function() {
+      var actual = hexColorRegex({ strict: true }).exec('foo #ae3f4cff bar')
+      var expected = null
+
+      test.equal(actual, expected)
+    })
+    test('should not match when `foo #e7ff bar` string', function() {
+      var actual = hexColorRegex({ strict: true }).exec('foo #e7ff bar')
+      var expected = null
+
+      test.equal(actual, expected)
+    })
+  })
+})

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

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function hslRegex(options) {
+  options = options || {};
+
+  return options.exact ?
+    /^hsl\(\s*(\d+)\s*,\s*(\d*(?:\.\d+)?%)\s*,\s*(\d*(?:\.\d+)?%)\)$/ :
+    /hsl\(\s*(\d+)\s*,\s*(\d*(?:\.\d+)?%)\s*,\s*(\d*(?:\.\d+)?%)\)/ig;
+}