@quilted/create 0.1.55 → 0.1.57

package/build/esm/node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.mjs

@@ -0,0 +1,154 @@
+import isExtglob$1 from '../../../is-extglob@2.1.1/node_modules/is-extglob/index.mjs';
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isExtglob = isExtglob$1;
+var chars = { '{': '}', '(': ')', '[': ']'};
+var strictCheck = function(str) {
+  if (str[0] === '!') {
+    return true;
+  }
+  var index = 0;
+  var pipeIndex = -2;
+  var closeSquareIndex = -2;
+  var closeCurlyIndex = -2;
+  var closeParenIndex = -2;
+  var backSlashIndex = -2;
+  while (index < str.length) {
+    if (str[index] === '*') {
+      return true;
+    }
+
+    if (str[index + 1] === '?' && /[\].+)]/.test(str[index])) {
+      return true;
+    }
+
+    if (closeSquareIndex !== -1 && str[index] === '[' && str[index + 1] !== ']') {
+      if (closeSquareIndex < index) {
+        closeSquareIndex = str.indexOf(']', index);
+      }
+      if (closeSquareIndex > index) {
+        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+          return true;
+        }
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (closeCurlyIndex !== -1 && str[index] === '{' && str[index + 1] !== '}') {
+      closeCurlyIndex = str.indexOf('}', index);
+      if (closeCurlyIndex > index) {
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (closeParenIndex !== -1 && str[index] === '(' && str[index + 1] === '?' && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ')') {
+      closeParenIndex = str.indexOf(')', index);
+      if (closeParenIndex > index) {
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') {
+      if (pipeIndex < index) {
+        pipeIndex = str.indexOf('|', index);
+      }
+      if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') {
+        closeParenIndex = str.indexOf(')', pipeIndex);
+        if (closeParenIndex > pipeIndex) {
+          backSlashIndex = str.indexOf('\\', pipeIndex);
+          if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+            return true;
+          }
+        }
+      }
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var relaxedCheck = function(str) {
+  if (str[0] === '!') {
+    return true;
+  }
+  var index = 0;
+  while (index < str.length) {
+    if (/[*?{}()[\]]/.test(str[index])) {
+      return true;
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var isGlob = function isGlob(str, options) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
+  }
+
+  if (isExtglob(str)) {
+    return true;
+  }
+
+  var check = strictCheck;
+
+  // optionally relax check
+  if (options && options.strict === false) {
+    check = relaxedCheck;
+  }
+
+  return check(str);
+};
+
+export { isGlob as default };

package/build/esm/node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isNumber = function(num) {
+  if (typeof num === 'number') {
+    return num - num === 0;
+  }
+  if (typeof num === 'string' && num.trim() !== '') {
+    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+  }
+  return false;
+};
+
+export { isNumber as default };

package/build/esm/node_modules/.pnpm/kleur@3.0.3/node_modules/kleur/index.mjs

@@ -0,0 +1,113 @@
+var kleur;
+var hasRequiredKleur;
+
+function requireKleur () {
+	if (hasRequiredKleur) return kleur;
+	hasRequiredKleur = 1;
+
+	const { FORCE_COLOR, NODE_DISABLE_COLORS, TERM } = process.env;
+
+	const $ = {
+		enabled: !NODE_DISABLE_COLORS && TERM !== 'dumb' && FORCE_COLOR !== '0',
+
+		// modifiers
+		reset: init(0, 0),
+		bold: init(1, 22),
+		dim: init(2, 22),
+		italic: init(3, 23),
+		underline: init(4, 24),
+		inverse: init(7, 27),
+		hidden: init(8, 28),
+		strikethrough: init(9, 29),
+
+		// colors
+		black: init(30, 39),
+		red: init(31, 39),
+		green: init(32, 39),
+		yellow: init(33, 39),
+		blue: init(34, 39),
+		magenta: init(35, 39),
+		cyan: init(36, 39),
+		white: init(37, 39),
+		gray: init(90, 39),
+		grey: init(90, 39),
+
+		// background colors
+		bgBlack: init(40, 49),
+		bgRed: init(41, 49),
+		bgGreen: init(42, 49),
+		bgYellow: init(43, 49),
+		bgBlue: init(44, 49),
+		bgMagenta: init(45, 49),
+		bgCyan: init(46, 49),
+		bgWhite: init(47, 49)
+	};
+
+	function run(arr, str) {
+		let i=0, tmp, beg='', end='';
+		for (; i < arr.length; i++) {
+			tmp = arr[i];
+			beg += tmp.open;
+			end += tmp.close;
+			if (str.includes(tmp.close)) {
+				str = str.replace(tmp.rgx, tmp.close + tmp.open);
+			}
+		}
+		return beg + str + end;
+	}
+
+	function chain(has, keys) {
+		let ctx = { has, keys };
+
+		ctx.reset = $.reset.bind(ctx);
+		ctx.bold = $.bold.bind(ctx);
+		ctx.dim = $.dim.bind(ctx);
+		ctx.italic = $.italic.bind(ctx);
+		ctx.underline = $.underline.bind(ctx);
+		ctx.inverse = $.inverse.bind(ctx);
+		ctx.hidden = $.hidden.bind(ctx);
+		ctx.strikethrough = $.strikethrough.bind(ctx);
+
+		ctx.black = $.black.bind(ctx);
+		ctx.red = $.red.bind(ctx);
+		ctx.green = $.green.bind(ctx);
+		ctx.yellow = $.yellow.bind(ctx);
+		ctx.blue = $.blue.bind(ctx);
+		ctx.magenta = $.magenta.bind(ctx);
+		ctx.cyan = $.cyan.bind(ctx);
+		ctx.white = $.white.bind(ctx);
+		ctx.gray = $.gray.bind(ctx);
+		ctx.grey = $.grey.bind(ctx);
+
+		ctx.bgBlack = $.bgBlack.bind(ctx);
+		ctx.bgRed = $.bgRed.bind(ctx);
+		ctx.bgGreen = $.bgGreen.bind(ctx);
+		ctx.bgYellow = $.bgYellow.bind(ctx);
+		ctx.bgBlue = $.bgBlue.bind(ctx);
+		ctx.bgMagenta = $.bgMagenta.bind(ctx);
+		ctx.bgCyan = $.bgCyan.bind(ctx);
+		ctx.bgWhite = $.bgWhite.bind(ctx);
+
+		return ctx;
+	}
+
+	function init(open, close) {
+		let blk = {
+			open: `\x1b[${open}m`,
+			close: `\x1b[${close}m`,
+			rgx: new RegExp(`\\x1b\\[${close}m`, 'g')
+		};
+		return function (txt) {
+			if (this !== void 0 && this.has !== void 0) {
+				this.has.includes(open) || (this.has.push(open),this.keys.push(blk));
+				return txt === void 0 ? this : $.enabled ? run(this.keys, txt+'') : txt+'';
+			}
+			return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt+'') : txt+'';
+		};
+	}
+
+	kleur = $;
+	return kleur;
+}
+
+export { requireKleur as __require };

package/build/esm/node_modules/.pnpm/locate-path@7.1.0/node_modules/locate-path/index.mjs

@@ -0,0 +1,73 @@
+import process from 'node:process';
+import path__default from 'node:path';
+import fs__default, { promises } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import pLocate from '../../../p-locate@6.0.0/node_modules/p-locate/index.mjs';
+
+const typeMappings = {
+	directory: 'isDirectory',
+	file: 'isFile',
+};
+
+function checkType(type) {
+	if (type in typeMappings) {
+		return;
+	}
+
+	throw new Error(`Invalid type specified: ${type}`);
+}
+
+const matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();
+
+const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+
+async function locatePath(
+	paths,
+	{
+		cwd = process.cwd(),
+		type = 'file',
+		allowSymlinks = true,
+		concurrency,
+		preserveOrder,
+	} = {},
+) {
+	checkType(type);
+	cwd = toPath(cwd);
+
+	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
+
+	return pLocate(paths, async path_ => {
+		try {
+			const stat = await statFunction(path__default.resolve(cwd, path_));
+			return matchType(type, stat);
+		} catch {
+			return false;
+		}
+	}, {concurrency, preserveOrder});
+}
+
+function locatePathSync(
+	paths,
+	{
+		cwd = process.cwd(),
+		type = 'file',
+		allowSymlinks = true,
+	} = {},
+) {
+	checkType(type);
+	cwd = toPath(cwd);
+
+	const statFunction = allowSymlinks ? fs__default.statSync : fs__default.lstatSync;
+
+	for (const path_ of paths) {
+		try {
+			const stat = statFunction(path__default.resolve(cwd, path_));
+
+			if (matchType(type, stat)) {
+				return path_;
+			}
+		} catch {}
+	}
+}
+
+export { locatePath, locatePathSync };

package/build/esm/node_modules/.pnpm/merge2@1.4.1/node_modules/merge2/index.mjs

@@ -0,0 +1,147 @@
+import require$$0 from 'node:stream';
+
+/*
+ * merge2
+ * https://github.com/teambition/merge2
+ *
+ * Copyright (c) 2014-2020 Teambition
+ * Licensed under the MIT license.
+ */
+const Stream = require$$0;
+const PassThrough = Stream.PassThrough;
+const slice = Array.prototype.slice;
+
+var merge2_1 = merge2;
+
+function merge2 () {
+  const streamsQueue = [];
+  const args = slice.call(arguments);
+  let merging = false;
+  let options = args[args.length - 1];
+
+  if (options && !Array.isArray(options) && options.pipe == null) {
+    args.pop();
+  } else {
+    options = {};
+  }
+
+  const doEnd = options.end !== false;
+  const doPipeError = options.pipeError === true;
+  if (options.objectMode == null) {
+    options.objectMode = true;
+  }
+  if (options.highWaterMark == null) {
+    options.highWaterMark = 64 * 1024;
+  }
+  const mergedStream = PassThrough(options);
+
+  function addStream () {
+    for (let i = 0, len = arguments.length; i < len; i++) {
+      streamsQueue.push(pauseStreams(arguments[i], options));
+    }
+    mergeStream();
+    return this
+  }
+
+  function mergeStream () {
+    if (merging) {
+      return
+    }
+    merging = true;
+
+    let streams = streamsQueue.shift();
+    if (!streams) {
+      process.nextTick(endStream);
+      return
+    }
+    if (!Array.isArray(streams)) {
+      streams = [streams];
+    }
+
+    let pipesCount = streams.length + 1;
+
+    function next () {
+      if (--pipesCount > 0) {
+        return
+      }
+      merging = false;
+      mergeStream();
+    }
+
+    function pipe (stream) {
+      function onend () {
+        stream.removeListener('merge2UnpipeEnd', onend);
+        stream.removeListener('end', onend);
+        if (doPipeError) {
+          stream.removeListener('error', onerror);
+        }
+        next();
+      }
+      function onerror (err) {
+        mergedStream.emit('error', err);
+      }
+      // skip ended stream
+      if (stream._readableState.endEmitted) {
+        return next()
+      }
+
+      stream.on('merge2UnpipeEnd', onend);
+      stream.on('end', onend);
+
+      if (doPipeError) {
+        stream.on('error', onerror);
+      }
+
+      stream.pipe(mergedStream, { end: false });
+      // compatible for old stream
+      stream.resume();
+    }
+
+    for (let i = 0; i < streams.length; i++) {
+      pipe(streams[i]);
+    }
+
+    next();
+  }
+
+  function endStream () {
+    merging = false;
+    // emit 'queueDrain' when all streams merged.
+    mergedStream.emit('queueDrain');
+    if (doEnd) {
+      mergedStream.end();
+    }
+  }
+
+  mergedStream.setMaxListeners(0);
+  mergedStream.add = addStream;
+  mergedStream.on('unpipe', function (stream) {
+    stream.emit('merge2UnpipeEnd');
+  });
+
+  if (args.length) {
+    addStream.apply(null, args);
+  }
+  return mergedStream
+}
+
+// check and pause streams for pipe.
+function pauseStreams (streams, options) {
+  if (!Array.isArray(streams)) {
+    // Backwards-compat with old-style streams
+    if (!streams._readableState && streams.pipe) {
+      streams = streams.pipe(PassThrough(options));
+    }
+    if (!streams._readableState || !streams.pause || !streams.pipe) {
+      throw new Error('Only readable stream can be merged.')
+    }
+    streams.pause();
+  } else {
+    for (let i = 0, len = streams.length; i < len; i++) {
+      streams[i] = pauseStreams(streams[i], options);
+    }
+  }
+  return streams
+}
+
+export { merge2_1 as default };