@salla.sa/twilight-components 1.1.7 → 1.1.8

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

@@ -1,355 +0,0 @@
-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

@@ -1,5 +0,0 @@
-'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

@@ -1,10 +0,0 @@
-'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

@@ -1,8 +0,0 @@
-'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

@@ -1,16 +0,0 @@
-/*!
- * 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

@@ -1,294 +0,0 @@
-/*!
- * 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

@@ -1,9 +0,0 @@
-'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;
-}