@quilted/create 0.1.55 → 0.1.57

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/prompts.cjs

@@ -0,0 +1,221 @@
+'use strict';
+
+var prompts = require('../../../../../../_virtual/prompts2.cjs');
+var index = require('./elements/index.cjs');
+
+var hasRequiredPrompts;
+
+function requirePrompts () {
+	if (hasRequiredPrompts) return prompts.__exports;
+	hasRequiredPrompts = 1;
+	(function (exports) {
+		const $ = exports;
+		const el = index.__require();
+		const noop = v => v;
+
+		function toPrompt(type, args, opts={}) {
+		  return new Promise((res, rej) => {
+		    const p = new el[type](args);
+		    const onAbort = opts.onAbort || noop;
+		    const onSubmit = opts.onSubmit || noop;
+		    const onExit = opts.onExit || noop;
+		    p.on('state', args.onState || noop);
+		    p.on('submit', x => res(onSubmit(x)));
+		    p.on('exit', x => res(onExit(x)));
+		    p.on('abort', x => rej(onAbort(x)));
+		  });
+		}
+
+		/**
+		 * Text prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {string} [args.initial] Default string value
+		 * @param {string} [args.style="default"] Render style ('default', 'password', 'invisible')
+		 * @param {function} [args.onState] On state change callback
+		 * @param {function} [args.validate] Function to validate user input
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.text = args => toPrompt('TextPrompt', args);
+
+		/**
+		 * Password prompt with masked input
+		 * @param {string} args.message Prompt message to display
+		 * @param {string} [args.initial] Default string value
+		 * @param {function} [args.onState] On state change callback
+		 * @param {function} [args.validate] Function to validate user input
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.password = args => {
+		  args.style = 'password';
+		  return $.text(args);
+		};
+
+		/**
+		 * Prompt where input is invisible, like sudo
+		 * @param {string} args.message Prompt message to display
+		 * @param {string} [args.initial] Default string value
+		 * @param {function} [args.onState] On state change callback
+		 * @param {function} [args.validate] Function to validate user input
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.invisible = args => {
+		  args.style = 'invisible';
+		  return $.text(args);
+		};
+
+		/**
+		 * Number prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {number} args.initial Default number value
+		 * @param {function} [args.onState] On state change callback
+		 * @param {number} [args.max] Max value
+		 * @param {number} [args.min] Min value
+		 * @param {string} [args.style="default"] Render style ('default', 'password', 'invisible')
+		 * @param {Boolean} [opts.float=false] Parse input as floats
+		 * @param {Number} [opts.round=2] Round floats to x decimals
+		 * @param {Number} [opts.increment=1] Number to increment by when using arrow-keys
+		 * @param {function} [args.validate] Function to validate user input
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.number = args => toPrompt('NumberPrompt', args);
+
+		/**
+		 * Date prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {number} args.initial Default number value
+		 * @param {function} [args.onState] On state change callback
+		 * @param {number} [args.max] Max value
+		 * @param {number} [args.min] Min value
+		 * @param {string} [args.style="default"] Render style ('default', 'password', 'invisible')
+		 * @param {Boolean} [opts.float=false] Parse input as floats
+		 * @param {Number} [opts.round=2] Round floats to x decimals
+		 * @param {Number} [opts.increment=1] Number to increment by when using arrow-keys
+		 * @param {function} [args.validate] Function to validate user input
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.date = args => toPrompt('DatePrompt', args);
+
+		/**
+		 * Classic yes/no prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {boolean} [args.initial=false] Default value
+		 * @param {function} [args.onState] On state change callback
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.confirm = args => toPrompt('ConfirmPrompt', args);
+
+		/**
+		 * List prompt, split intput string by `seperator`
+		 * @param {string} args.message Prompt message to display
+		 * @param {string} [args.initial] Default string value
+		 * @param {string} [args.style="default"] Render style ('default', 'password', 'invisible')
+		 * @param {string} [args.separator] String separator
+		 * @param {function} [args.onState] On state change callback
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input, in form of an `Array`
+		 */
+		$.list = args => {
+		  const sep = args.separator || ',';
+		  return toPrompt('TextPrompt', args, {
+		    onSubmit: str => str.split(sep).map(s => s.trim())
+		  });
+		};
+
+		/**
+		 * Toggle/switch prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {boolean} [args.initial=false] Default value
+		 * @param {string} [args.active="on"] Text for `active` state
+		 * @param {string} [args.inactive="off"] Text for `inactive` state
+		 * @param {function} [args.onState] On state change callback
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.toggle = args => toPrompt('TogglePrompt', args);
+
+		/**
+		 * Interactive select prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {Array} args.choices Array of choices objects `[{ title, value }, ...]`
+		 * @param {number} [args.initial] Index of default value
+		 * @param {String} [args.hint] Hint to display
+		 * @param {function} [args.onState] On state change callback
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.select = args => toPrompt('SelectPrompt', args);
+
+		/**
+		 * Interactive multi-select / autocompleteMultiselect prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {Array} args.choices Array of choices objects `[{ title, value, [selected] }, ...]`
+		 * @param {number} [args.max] Max select
+		 * @param {string} [args.hint] Hint to display user
+		 * @param {Number} [args.cursor=0] Cursor start position
+		 * @param {function} [args.onState] On state change callback
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.multiselect = args => {
+		  args.choices = [].concat(args.choices || []);
+		  const toSelected = items => items.filter(item => item.selected).map(item => item.value);
+		  return toPrompt('MultiselectPrompt', args, {
+		    onAbort: toSelected,
+		    onSubmit: toSelected
+		  });
+		};
+
+		$.autocompleteMultiselect = args => {
+		  args.choices = [].concat(args.choices || []);
+		  const toSelected = items => items.filter(item => item.selected).map(item => item.value);
+		  return toPrompt('AutocompleteMultiselectPrompt', args, {
+		    onAbort: toSelected,
+		    onSubmit: toSelected
+		  });
+		};
+
+		const byTitle = (input, choices) => Promise.resolve(
+		  choices.filter(item => item.title.slice(0, input.length).toLowerCase() === input.toLowerCase())
+		);
+
+		/**
+		 * Interactive auto-complete prompt
+		 * @param {string} args.message Prompt message to display
+		 * @param {Array} args.choices Array of auto-complete choices objects `[{ title, value }, ...]`
+		 * @param {Function} [args.suggest] Function to filter results based on user input. Defaults to sort by `title`
+		 * @param {number} [args.limit=10] Max number of results to show
+		 * @param {string} [args.style="default"] Render style ('default', 'password', 'invisible')
+		 * @param {String} [args.initial] Index of the default value
+		 * @param {boolean} [opts.clearFirst] The first ESCAPE keypress will clear the input
+		 * @param {String} [args.fallback] Fallback message - defaults to initial value
+		 * @param {function} [args.onState] On state change callback
+		 * @param {Stream} [args.stdin] The Readable stream to listen to
+		 * @param {Stream} [args.stdout] The Writable stream to write readline data to
+		 * @returns {Promise} Promise with user input
+		 */
+		$.autocomplete = args => {
+		  args.suggest = args.suggest || byTitle;
+		  args.choices = [].concat(args.choices || []);
+		  return toPrompt('AutocompletePrompt', args);
+		};
+} (prompts.__exports));
+	return prompts.__exports;
+}
+
+exports.__require = requirePrompts;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/action.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var action;
+var hasRequiredAction;
+
+function requireAction () {
+	if (hasRequiredAction) return action;
+	hasRequiredAction = 1;
+
+	action = (key, isSelect) => {
+	  if (key.meta && key.name !== 'escape') return;
+	  
+	  if (key.ctrl) {
+	    if (key.name === 'a') return 'first';
+	    if (key.name === 'c') return 'abort';
+	    if (key.name === 'd') return 'abort';
+	    if (key.name === 'e') return 'last';
+	    if (key.name === 'g') return 'reset';
+	  }
+	  
+	  if (isSelect) {
+	    if (key.name === 'j') return 'down';
+	    if (key.name === 'k') return 'up';
+	  }
+
+	  if (key.name === 'return') return 'submit';
+	  if (key.name === 'enter') return 'submit'; // ctrl + J
+	  if (key.name === 'backspace') return 'delete';
+	  if (key.name === 'delete') return 'deleteForward';
+	  if (key.name === 'abort') return 'abort';
+	  if (key.name === 'escape') return 'exit';
+	  if (key.name === 'tab') return 'next';
+	  if (key.name === 'pagedown') return 'nextPage';
+	  if (key.name === 'pageup') return 'prevPage';
+	  // TODO create home() in prompt types (e.g. TextPrompt)
+	  if (key.name === 'home') return 'home';
+	  // TODO create end() in prompt types (e.g. TextPrompt)
+	  if (key.name === 'end') return 'end';
+
+	  if (key.name === 'up') return 'up';
+	  if (key.name === 'down') return 'down';
+	  if (key.name === 'right') return 'right';
+	  if (key.name === 'left') return 'left';
+
+	  return false;
+	};
+	return action;
+}
+
+exports.__require = requireAction;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/clear.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var strip = require('./strip.cjs');
+var index = require('../../../../../sisteransi@1.0.5/node_modules/sisteransi/src/index.cjs');
+
+var clear;
+var hasRequiredClear;
+
+function requireClear () {
+	if (hasRequiredClear) return clear;
+	hasRequiredClear = 1;
+
+	const strip$1 = strip.__require();
+	const { erase, cursor } = index.__require();
+
+	const width = str => [...strip$1(str)].length;
+
+	/**
+	 * @param {string} prompt
+	 * @param {number} perLine
+	 */
+	clear = function(prompt, perLine) {
+	  if (!perLine) return erase.line + cursor.to(0);
+
+	  let rows = 0;
+	  const lines = prompt.split(/\r?\n/);
+	  for (let line of lines) {
+	    rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / perLine);
+	  }
+
+	  return erase.lines(rows);
+	};
+	return clear;
+}
+
+exports.__require = requireClear;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/entriesToDisplay.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var entriesToDisplay;
+var hasRequiredEntriesToDisplay;
+
+function requireEntriesToDisplay () {
+	if (hasRequiredEntriesToDisplay) return entriesToDisplay;
+	hasRequiredEntriesToDisplay = 1;
+
+	/**
+	 * Determine what entries should be displayed on the screen, based on the
+	 * currently selected index and the maximum visible. Used in list-based
+	 * prompts like `select` and `multiselect`.
+	 *
+	 * @param {number} cursor the currently selected entry
+	 * @param {number} total the total entries available to display
+	 * @param {number} [maxVisible] the number of entries that can be displayed
+	 */
+	entriesToDisplay = (cursor, total, maxVisible)  => {
+	  maxVisible = maxVisible || total;
+
+	  let startIndex = Math.min(total- maxVisible, cursor - Math.floor(maxVisible / 2));
+	  if (startIndex < 0) startIndex = 0;
+
+	  let endIndex = Math.min(startIndex + maxVisible, total);
+
+	  return { startIndex, endIndex };
+	};
+	return entriesToDisplay;
+}
+
+exports.__require = requireEntriesToDisplay;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/figures.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var figures_1;
+var hasRequiredFigures;
+
+function requireFigures () {
+	if (hasRequiredFigures) return figures_1;
+	hasRequiredFigures = 1;
+
+	 const main = {
+	  arrowUp: '↑',
+	  arrowDown: '↓',
+	  arrowLeft: '←',
+	  arrowRight: '→',
+	  radioOn: '◉',
+	  radioOff: '◯',
+	  tick: '✔',	
+	  cross: '✖',	
+	  ellipsis: '…',	
+	  pointerSmall: '›',	
+	  line: '─',	
+	  pointer: '❯'	
+	};	
+	const win = {
+	  arrowUp: main.arrowUp,
+	  arrowDown: main.arrowDown,
+	  arrowLeft: main.arrowLeft,
+	  arrowRight: main.arrowRight,
+	  radioOn: '(*)',
+	  radioOff: '( )',	
+	  tick: '√',	
+	  cross: '×',	
+	  ellipsis: '...',	
+	  pointerSmall: '»',	
+	  line: '─',	
+	  pointer: '>'	
+	};	
+	const figures = process.platform === 'win32' ? win : main;	
+
+	 figures_1 = figures;
+	return figures_1;
+}
+
+exports.__require = requireFigures;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/index.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var action = require('./action.cjs');
+var clear = require('./clear.cjs');
+var style = require('./style.cjs');
+var strip = require('./strip.cjs');
+var figures = require('./figures.cjs');
+var lines = require('./lines.cjs');
+var wrap = require('./wrap.cjs');
+var entriesToDisplay = require('./entriesToDisplay.cjs');
+
+var util;
+var hasRequiredUtil;
+
+function requireUtil () {
+	if (hasRequiredUtil) return util;
+	hasRequiredUtil = 1;
+
+	util = {
+	  action: action.__require(),
+	  clear: clear.__require(),
+	  style: style.__require(),
+	  strip: strip.__require(),
+	  figures: figures.__require(),
+	  lines: lines.__require(),
+	  wrap: wrap.__require(),
+	  entriesToDisplay: entriesToDisplay.__require()
+	};
+	return util;
+}
+
+exports.__require = requireUtil;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/lines.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var strip = require('./strip.cjs');
+
+var lines;
+var hasRequiredLines;
+
+function requireLines () {
+	if (hasRequiredLines) return lines;
+	hasRequiredLines = 1;
+
+	const strip$1 = strip.__require();
+
+	/**
+	 * @param {string} msg
+	 * @param {number} perLine
+	 */
+	lines = function (msg, perLine) {
+	  let lines = String(strip$1(msg) || '').split(/\r?\n/);
+
+	  if (!perLine) return lines.length;
+	  return lines.map(l => Math.ceil(l.length / perLine))
+	      .reduce((a, b) => a + b);
+	};
+	return lines;
+}
+
+exports.__require = requireLines;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/strip.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var strip;
+var hasRequiredStrip;
+
+function requireStrip () {
+	if (hasRequiredStrip) return strip;
+	hasRequiredStrip = 1;
+
+	strip = str => {
+	  const pattern = [
+	    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+	    '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))'
+	  ].join('|');
+
+	  const RGX = new RegExp(pattern, 'g');
+	  return typeof str === 'string' ? str.replace(RGX, '') : str;
+	};
+	return strip;
+}
+
+exports.__require = requireStrip;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/style.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var index = require('../../../../../kleur@3.0.3/node_modules/kleur/index.cjs');
+var figures = require('./figures.cjs');
+
+var style;
+var hasRequiredStyle;
+
+function requireStyle () {
+	if (hasRequiredStyle) return style;
+	hasRequiredStyle = 1;
+
+	const c = index.__require();
+	const figures$1 = figures.__require();
+
+	// rendering user input.
+	const styles = Object.freeze({
+	  password: { scale: 1, render: input => '*'.repeat(input.length) },
+	  emoji: { scale: 2, render: input => '😃'.repeat(input.length) },
+	  invisible: { scale: 0, render: input => '' },
+	  default: { scale: 1, render: input => `${input}` }
+	});
+	const render = type => styles[type] || styles.default;
+
+	// icon to signalize a prompt.
+	const symbols = Object.freeze({
+	  aborted: c.red(figures$1.cross),
+	  done: c.green(figures$1.tick),
+	  exited: c.yellow(figures$1.cross),
+	  default: c.cyan('?')
+	});
+
+	const symbol = (done, aborted, exited) =>
+	  aborted ? symbols.aborted : exited ? symbols.exited : done ? symbols.done : symbols.default;
+
+	// between the question and the user's input.
+	const delimiter = completing =>
+	  c.gray(completing ? figures$1.ellipsis : figures$1.pointerSmall);
+
+	const item = (expandable, expanded) =>
+	  c.gray(expandable ? (expanded ? figures$1.pointerSmall : '+') : figures$1.line);
+
+	style = {
+	  styles,
+	  render,
+	  symbols,
+	  symbol,
+	  delimiter,
+	  item
+	};
+	return style;
+}
+
+exports.__require = requireStyle;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/wrap.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var wrap;
+var hasRequiredWrap;
+
+function requireWrap () {
+	if (hasRequiredWrap) return wrap;
+	hasRequiredWrap = 1;
+
+	/**
+	 * @param {string} msg The message to wrap
+	 * @param {object} opts
+	 * @param {number|string} [opts.margin] Left margin
+	 * @param {number} opts.width Maximum characters per line including the margin
+	 */
+	wrap = (msg, opts = {}) => {
+	  const tab = Number.isSafeInteger(parseInt(opts.margin))
+	    ? new Array(parseInt(opts.margin)).fill(' ').join('')
+	    : (opts.margin || '');
+
+	  const width = opts.width;
+
+	  return (msg || '').split(/\r?\n/g)
+	    .map(line => line
+	      .split(/\s+/g)
+	      .reduce((arr, w) => {
+	        if (w.length + tab.length >= width || arr[arr.length - 1].length + w.length + 1 < width)
+	          arr[arr.length - 1] += ` ${w}`;
+	        else arr.push(`${tab}${w}`);
+	        return arr;
+	      }, [ tab ])
+	      .join('\n'))
+	    .join('\n');
+	};
+	return wrap;
+}
+
+exports.__require = requireWrap;

package/build/cjs/node_modules/.pnpm/queue-microtask@1.2.3/node_modules/queue-microtask/index.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _commonjsHelpers = require('../../../../../_virtual/_commonjsHelpers.cjs');
+
+/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+let promise;
+
+var queueMicrotask_1 = typeof queueMicrotask === 'function'
+  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : _commonjsHelpers.commonjsGlobal)
+  // reuse resolved promise, and allocate it lazily
+  : cb => (promise || (promise = Promise.resolve()))
+    .then(cb)
+    .catch(err => setTimeout(() => { throw err }, 0));
+
+exports["default"] = queueMicrotask_1;

package/build/cjs/node_modules/.pnpm/reusify@1.0.4/node_modules/reusify/reusify.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function reusify (Constructor) {
+  var head = new Constructor();
+  var tail = head;
+
+  function get () {
+    var current = head;
+
+    if (current.next) {
+      head = current.next;
+    } else {
+      head = new Constructor();
+      tail = head;
+    }
+
+    current.next = null;
+
+    return current
+  }
+
+  function release (obj) {
+    tail.next = obj;
+    tail = obj;
+  }
+
+  return {
+    get: get,
+    release: release
+  }
+}
+
+var reusify_1 = reusify;
+
+exports["default"] = reusify_1;

package/build/cjs/node_modules/.pnpm/run-parallel@1.2.0/node_modules/run-parallel/index.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../queue-microtask@1.2.3/node_modules/queue-microtask/index.cjs');
+
+/*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+var runParallel_1 = runParallel;
+
+const queueMicrotask = index["default"];
+
+function runParallel (tasks, cb) {
+  let results, pending, keys;
+  let isSync = true;
+
+  if (Array.isArray(tasks)) {
+    results = [];
+    pending = tasks.length;
+  } else {
+    keys = Object.keys(tasks);
+    results = {};
+    pending = keys.length;
+  }
+
+  function done (err) {
+    function end () {
+      if (cb) cb(err, results);
+      cb = null;
+    }
+    if (isSync) queueMicrotask(end);
+    else end();
+  }
+
+  function each (i, err, result) {
+    results[i] = result;
+    if (--pending === 0 || err) {
+      done(err);
+    }
+  }
+
+  if (!pending) {
+    // empty
+    done(null);
+  } else if (keys) {
+    // object
+    keys.forEach(function (key) {
+      tasks[key](function (err, result) { each(key, err, result); });
+    });
+  } else {
+    // array
+    tasks.forEach(function (task, i) {
+      task(function (err, result) { each(i, err, result); });
+    });
+  }
+
+  isSync = false;
+}
+
+exports["default"] = runParallel_1;