@quilted/create 0.2.43 → 0.2.45

package/build/esm/node_modules/.pnpm/fastq@1.13.0/node_modules/fastq/queue.mjs

@@ -1,243 +1,249 @@
 import { __module as queue } from '../../../../../_virtual/queue.mjs';
-import { reusify_1 } from '../../../reusify@1.0.4/node_modules/reusify/reusify.mjs';
+import { __require as requireReusify } from '../../../reusify@1.0.4/node_modules/reusify/reusify.mjs';
 
-/* eslint-disable no-var */
+var hasRequiredQueue;
+function requireQueue() {
+  if (hasRequiredQueue) return queue.exports;
+  hasRequiredQueue = 1;
 
-var reusify = reusify_1;
-function fastqueue(context, worker, concurrency) {
-  if (typeof context === 'function') {
-    concurrency = worker;
-    worker = context;
-    context = null;
-  }
-  if (concurrency < 1) {
-    throw new Error('fastqueue concurrency must be greater than 1');
-  }
-  var cache = reusify(Task);
-  var queueHead = null;
-  var queueTail = null;
-  var _running = 0;
-  var errorHandler = null;
-  var self = {
-    push: push,
-    drain: noop,
-    saturated: noop,
-    pause: pause,
-    paused: false,
-    concurrency: concurrency,
-    running: running,
-    resume: resume,
-    idle: idle,
-    length: length,
-    getQueue: getQueue,
-    unshift: unshift,
-    empty: noop,
-    kill: kill,
-    killAndDrain: killAndDrain,
-    error: error
-  };
-  return self;
-  function running() {
-    return _running;
-  }
-  function pause() {
-    self.paused = true;
-  }
-  function length() {
-    var current = queueHead;
-    var counter = 0;
-    while (current) {
-      current = current.next;
-      counter++;
-    }
-    return counter;
-  }
-  function getQueue() {
-    var current = queueHead;
-    var tasks = [];
-    while (current) {
-      tasks.push(current.value);
-      current = current.next;
-    }
-    return tasks;
-  }
-  function resume() {
-    if (!self.paused) return;
-    self.paused = false;
-    for (var i = 0; i < self.concurrency; i++) {
-      _running++;
-      release();
+  /* eslint-disable no-var */
+
+  var reusify = requireReusify();
+  function fastqueue(context, worker, concurrency) {
+    if (typeof context === 'function') {
+      concurrency = worker;
+      worker = context;
+      context = null;
     }
-  }
-  function idle() {
-    return _running === 0 && self.length() === 0;
-  }
-  function push(value, done) {
-    var current = cache.get();
-    current.context = context;
-    current.release = release;
-    current.value = value;
-    current.callback = done || noop;
-    current.errorHandler = errorHandler;
-    if (_running === self.concurrency || self.paused) {
-      if (queueTail) {
-        queueTail.next = current;
-        queueTail = current;
-      } else {
-        queueHead = current;
-        queueTail = current;
-        self.saturated();
+    if (concurrency < 1) {
+      throw new Error('fastqueue concurrency must be greater than 1');
+    }
+    var cache = reusify(Task);
+    var queueHead = null;
+    var queueTail = null;
+    var _running = 0;
+    var errorHandler = null;
+    var self = {
+      push: push,
+      drain: noop,
+      saturated: noop,
+      pause: pause,
+      paused: false,
+      concurrency: concurrency,
+      running: running,
+      resume: resume,
+      idle: idle,
+      length: length,
+      getQueue: getQueue,
+      unshift: unshift,
+      empty: noop,
+      kill: kill,
+      killAndDrain: killAndDrain,
+      error: error
+    };
+    return self;
+    function running() {
+      return _running;
+    }
+    function pause() {
+      self.paused = true;
+    }
+    function length() {
+      var current = queueHead;
+      var counter = 0;
+      while (current) {
+        current = current.next;
+        counter++;
       }
-    } else {
-      _running++;
-      worker.call(context, current.value, current.worked);
+      return counter;
     }
-  }
-  function unshift(value, done) {
-    var current = cache.get();
-    current.context = context;
-    current.release = release;
-    current.value = value;
-    current.callback = done || noop;
-    if (_running === self.concurrency || self.paused) {
-      if (queueHead) {
-        current.next = queueHead;
-        queueHead = current;
-      } else {
-        queueHead = current;
-        queueTail = current;
-        self.saturated();
+    function getQueue() {
+      var current = queueHead;
+      var tasks = [];
+      while (current) {
+        tasks.push(current.value);
+        current = current.next;
       }
-    } else {
-      _running++;
-      worker.call(context, current.value, current.worked);
+      return tasks;
     }
-  }
-  function release(holder) {
-    if (holder) {
-      cache.release(holder);
-    }
-    var next = queueHead;
-    if (next) {
-      if (!self.paused) {
-        if (queueTail === queueHead) {
-          queueTail = null;
+    function resume() {
+      if (!self.paused) return;
+      self.paused = false;
+      for (var i = 0; i < self.concurrency; i++) {
+        _running++;
+        release();
+      }
+    }
+    function idle() {
+      return _running === 0 && self.length() === 0;
+    }
+    function push(value, done) {
+      var current = cache.get();
+      current.context = context;
+      current.release = release;
+      current.value = value;
+      current.callback = done || noop;
+      current.errorHandler = errorHandler;
+      if (_running === self.concurrency || self.paused) {
+        if (queueTail) {
+          queueTail.next = current;
+          queueTail = current;
+        } else {
+          queueHead = current;
+          queueTail = current;
+          self.saturated();
         }
-        queueHead = next.next;
-        next.next = null;
-        worker.call(context, next.value, next.worked);
-        if (queueTail === null) {
-          self.empty();
+      } else {
+        _running++;
+        worker.call(context, current.value, current.worked);
+      }
+    }
+    function unshift(value, done) {
+      var current = cache.get();
+      current.context = context;
+      current.release = release;
+      current.value = value;
+      current.callback = done || noop;
+      if (_running === self.concurrency || self.paused) {
+        if (queueHead) {
+          current.next = queueHead;
+          queueHead = current;
+        } else {
+          queueHead = current;
+          queueTail = current;
+          self.saturated();
         }
       } else {
-        _running--;
+        _running++;
+        worker.call(context, current.value, current.worked);
+      }
+    }
+    function release(holder) {
+      if (holder) {
+        cache.release(holder);
       }
-    } else if (--_running === 0) {
+      var next = queueHead;
+      if (next) {
+        if (!self.paused) {
+          if (queueTail === queueHead) {
+            queueTail = null;
+          }
+          queueHead = next.next;
+          next.next = null;
+          worker.call(context, next.value, next.worked);
+          if (queueTail === null) {
+            self.empty();
+          }
+        } else {
+          _running--;
+        }
+      } else if (--_running === 0) {
+        self.drain();
+      }
+    }
+    function kill() {
+      queueHead = null;
+      queueTail = null;
+      self.drain = noop;
+    }
+    function killAndDrain() {
+      queueHead = null;
+      queueTail = null;
       self.drain();
+      self.drain = noop;
+    }
+    function error(handler) {
+      errorHandler = handler;
     }
   }
-  function kill() {
-    queueHead = null;
-    queueTail = null;
-    self.drain = noop;
-  }
-  function killAndDrain() {
-    queueHead = null;
-    queueTail = null;
-    self.drain();
-    self.drain = noop;
-  }
-  function error(handler) {
-    errorHandler = handler;
-  }
-}
-function noop() {}
-function Task() {
-  this.value = null;
-  this.callback = noop;
-  this.next = null;
-  this.release = noop;
-  this.context = null;
-  this.errorHandler = null;
-  var self = this;
-  this.worked = function worked(err, result) {
-    var callback = self.callback;
-    var errorHandler = self.errorHandler;
-    var val = self.value;
-    self.value = null;
-    self.callback = noop;
-    if (self.errorHandler) {
-      errorHandler(err, val);
-    }
-    callback.call(self.context, err, result);
-    self.release(self);
-  };
-}
-function queueAsPromised(context, worker, concurrency) {
-  if (typeof context === 'function') {
-    concurrency = worker;
-    worker = context;
-    context = null;
-  }
-  function asyncWrapper(arg, cb) {
-    worker.call(this, arg).then(function (res) {
-      cb(null, res);
-    }, cb);
-  }
-  var queue = fastqueue(context, asyncWrapper, concurrency);
-  var pushCb = queue.push;
-  var unshiftCb = queue.unshift;
-  queue.push = push;
-  queue.unshift = unshift;
-  queue.drained = drained;
-  return queue;
-  function push(value) {
-    var p = new Promise(function (resolve, reject) {
-      pushCb(value, function (err, result) {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(result);
+  function noop() {}
+  function Task() {
+    this.value = null;
+    this.callback = noop;
+    this.next = null;
+    this.release = noop;
+    this.context = null;
+    this.errorHandler = null;
+    var self = this;
+    this.worked = function worked(err, result) {
+      var callback = self.callback;
+      var errorHandler = self.errorHandler;
+      var val = self.value;
+      self.value = null;
+      self.callback = noop;
+      if (self.errorHandler) {
+        errorHandler(err, val);
+      }
+      callback.call(self.context, err, result);
+      self.release(self);
+    };
+  }
+  function queueAsPromised(context, worker, concurrency) {
+    if (typeof context === 'function') {
+      concurrency = worker;
+      worker = context;
+      context = null;
+    }
+    function asyncWrapper(arg, cb) {
+      worker.call(this, arg).then(function (res) {
+        cb(null, res);
+      }, cb);
+    }
+    var queue = fastqueue(context, asyncWrapper, concurrency);
+    var pushCb = queue.push;
+    var unshiftCb = queue.unshift;
+    queue.push = push;
+    queue.unshift = unshift;
+    queue.drained = drained;
+    return queue;
+    function push(value) {
+      var p = new Promise(function (resolve, reject) {
+        pushCb(value, function (err, result) {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(result);
+        });
       });
-    });
 
-    // Let's fork the promise chain to
-    // make the error bubble up to the user but
-    // not lead to a unhandledRejection
-    p.catch(noop);
-    return p;
-  }
-  function unshift(value) {
-    var p = new Promise(function (resolve, reject) {
-      unshiftCb(value, function (err, result) {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(result);
+      // Let's fork the promise chain to
+      // make the error bubble up to the user but
+      // not lead to a unhandledRejection
+      p.catch(noop);
+      return p;
+    }
+    function unshift(value) {
+      var p = new Promise(function (resolve, reject) {
+        unshiftCb(value, function (err, result) {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(result);
+        });
       });
-    });
 
-    // Let's fork the promise chain to
-    // make the error bubble up to the user but
-    // not lead to a unhandledRejection
-    p.catch(noop);
-    return p;
-  }
-  function drained() {
-    var previousDrain = queue.drain;
-    var p = new Promise(function (resolve) {
-      queue.drain = function () {
-        previousDrain();
-        resolve();
-      };
-    });
-    return p;
+      // Let's fork the promise chain to
+      // make the error bubble up to the user but
+      // not lead to a unhandledRejection
+      p.catch(noop);
+      return p;
+    }
+    function drained() {
+      var previousDrain = queue.drain;
+      var p = new Promise(function (resolve) {
+        queue.drain = function () {
+          previousDrain();
+          resolve();
+        };
+      });
+      return p;
+    }
   }
+  queue.exports = fastqueue;
+  queue.exports.promise = queueAsPromised;
+  return queue.exports;
 }
-queue.exports = fastqueue;
-queue.exports.promise = queueAsPromised;
-var queueExports = queue.exports;
 
-export { queueExports };
+export { requireQueue as __require };

package/build/esm/node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.mjs

@@ -0,0 +1,223 @@
+import require$$0 from 'node:util';
+import { __require as requireToRegexRange } from '../../../to-regex-range@5.0.1/node_modules/to-regex-range/index.mjs';
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+var fillRange;
+var hasRequiredFillRange;
+function requireFillRange() {
+  if (hasRequiredFillRange) return fillRange;
+  hasRequiredFillRange = 1;
+  const util = require$$0;
+  const toRegexRange = requireToRegexRange();
+  const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+  const transform = toNumber => {
+    return value => toNumber === true ? Number(value) : String(value);
+  };
+  const isValidValue = value => {
+    return typeof value === 'number' || typeof value === 'string' && value !== '';
+  };
+  const isNumber = num => Number.isInteger(+num);
+  const zeros = input => {
+    let value = `${input}`;
+    let index = -1;
+    if (value[0] === '-') value = value.slice(1);
+    if (value === '0') return false;
+    while (value[++index] === '0');
+    return index > 0;
+  };
+  const stringify = (start, end, options) => {
+    if (typeof start === 'string' || typeof end === 'string') {
+      return true;
+    }
+    return options.stringify === true;
+  };
+  const pad = (input, maxLength, toNumber) => {
+    if (maxLength > 0) {
+      let dash = input[0] === '-' ? '-' : '';
+      if (dash) input = input.slice(1);
+      input = dash + input.padStart(dash ? maxLength - 1 : maxLength, '0');
+    }
+    if (toNumber === false) {
+      return String(input);
+    }
+    return input;
+  };
+  const toMaxLen = (input, maxLength) => {
+    let negative = input[0] === '-' ? '-' : '';
+    if (negative) {
+      input = input.slice(1);
+      maxLength--;
+    }
+    while (input.length < maxLength) input = '0' + input;
+    return negative ? '-' + input : input;
+  };
+  const toSequence = (parts, options, maxLen) => {
+    parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    let prefix = options.capture ? '' : '?:';
+    let positives = '';
+    let negatives = '';
+    let result;
+    if (parts.positives.length) {
+      positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|');
+    }
+    if (parts.negatives.length) {
+      negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`;
+    }
+    if (positives && negatives) {
+      result = `${positives}|${negatives}`;
+    } else {
+      result = positives || negatives;
+    }
+    if (options.wrap) {
+      return `(${prefix}${result})`;
+    }
+    return result;
+  };
+  const toRange = (a, b, isNumbers, options) => {
+    if (isNumbers) {
+      return toRegexRange(a, b, {
+        wrap: false,
+        ...options
+      });
+    }
+    let start = String.fromCharCode(a);
+    if (a === b) return start;
+    let stop = String.fromCharCode(b);
+    return `[${start}-${stop}]`;
+  };
+  const toRegex = (start, end, options) => {
+    if (Array.isArray(start)) {
+      let wrap = options.wrap === true;
+      let prefix = options.capture ? '' : '?:';
+      return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+    }
+    return toRegexRange(start, end, options);
+  };
+  const rangeError = (...args) => {
+    return new RangeError('Invalid range arguments: ' + util.inspect(...args));
+  };
+  const invalidRange = (start, end, options) => {
+    if (options.strictRanges === true) throw rangeError([start, end]);
+    return [];
+  };
+  const invalidStep = (step, options) => {
+    if (options.strictRanges === true) {
+      throw new TypeError(`Expected step "${step}" to be a number`);
+    }
+    return [];
+  };
+  const fillNumbers = (start, end, step = 1, options = {}) => {
+    let a = Number(start);
+    let b = Number(end);
+    if (!Number.isInteger(a) || !Number.isInteger(b)) {
+      if (options.strictRanges === true) throw rangeError([start, end]);
+      return [];
+    }
+
+    // fix negative zero
+    if (a === 0) a = 0;
+    if (b === 0) b = 0;
+    let descending = a > b;
+    let startString = String(start);
+    let endString = String(end);
+    let stepString = String(step);
+    step = Math.max(Math.abs(step), 1);
+    let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+    let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+    let toNumber = padded === false && stringify(start, end, options) === false;
+    let format = options.transform || transform(toNumber);
+    if (options.toRegex && step === 1) {
+      return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+    }
+    let parts = {
+      negatives: [],
+      positives: []
+    };
+    let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+    let range = [];
+    let index = 0;
+    while (descending ? a >= b : a <= b) {
+      if (options.toRegex === true && step > 1) {
+        push(a);
+      } else {
+        range.push(pad(format(a, index), maxLen, toNumber));
+      }
+      a = descending ? a - step : a + step;
+      index++;
+    }
+    if (options.toRegex === true) {
+      return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, {
+        wrap: false,
+        ...options
+      });
+    }
+    return range;
+  };
+  const fillLetters = (start, end, step = 1, options = {}) => {
+    if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) {
+      return invalidRange(start, end, options);
+    }
+    let format = options.transform || (val => String.fromCharCode(val));
+    let a = `${start}`.charCodeAt(0);
+    let b = `${end}`.charCodeAt(0);
+    let descending = a > b;
+    let min = Math.min(a, b);
+    let max = Math.max(a, b);
+    if (options.toRegex && step === 1) {
+      return toRange(min, max, false, options);
+    }
+    let range = [];
+    let index = 0;
+    while (descending ? a >= b : a <= b) {
+      range.push(format(a, index));
+      a = descending ? a - step : a + step;
+      index++;
+    }
+    if (options.toRegex === true) {
+      return toRegex(range, null, {
+        wrap: false,
+        options
+      });
+    }
+    return range;
+  };
+  const fill = (start, end, step, options = {}) => {
+    if (end == null && isValidValue(start)) {
+      return [start];
+    }
+    if (!isValidValue(start) || !isValidValue(end)) {
+      return invalidRange(start, end, options);
+    }
+    if (typeof step === 'function') {
+      return fill(start, end, 1, {
+        transform: step
+      });
+    }
+    if (isObject(step)) {
+      return fill(start, end, 0, step);
+    }
+    let opts = {
+      ...options
+    };
+    if (opts.capture === true) opts.wrap = true;
+    step = step || opts.step || 1;
+    if (!isNumber(step)) {
+      if (step != null && !isObject(step)) return invalidStep(step, opts);
+      return fill(start, end, 1, step);
+    }
+    if (isNumber(start) && isNumber(end)) {
+      return fillNumbers(start, end, step, opts);
+    }
+    return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+  };
+  fillRange = fill;
+  return fillRange;
+}
+
+export { requireFillRange as __require };