@quilted/create 0.1.89 → 0.2.0

package/build/esnext/node_modules/.pnpm/colorette@2.0.19/node_modules/colorette/index.esnext

@@ -1,87 +1,31 @@
-import { __exports as colorette } from '../../../../../_virtual/index.esnext';
-import require$$0 from 'node:tty';
-
-Object.defineProperty(colorette, '__esModule', { value: true });
-
-var tty = require$$0;
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var tty__namespace = /*#__PURE__*/_interopNamespace(tty);
+import * as tty from 'tty';
 
 const {
   env = {},
   argv = [],
-  platform = "",
+  platform = ""
 } = typeof process === "undefined" ? {} : process;
-
 const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
 const isForced = "FORCE_COLOR" in env || argv.includes("--color");
 const isWindows = platform === "win32";
 const isDumbTerminal = env.TERM === "dumb";
-
-const isCompatibleTerminal =
-  tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && !isDumbTerminal;
-
-const isCI =
-  "CI" in env &&
-  ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
-
-const isColorSupported =
-  !isDisabled &&
-  (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI);
-
-const replaceClose = (
-  index,
+const isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+const isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+const isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+const replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+const clearBleed = (index, string, open, close, replace) => index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+const filterEmpty = (open, close, replace = open, at = open.length + 1) => (string) => string || !(string === "" || string === void 0) ? clearBleed(
+  ("" + string).indexOf(close, at),
   string,
+  open,
   close,
-  replace,
-  head = string.substring(0, index) + replace,
-  tail = string.substring(index + close.length),
-  next = tail.indexOf(close)
-) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
-
-const clearBleed = (index, string, open, close, replace) =>
-  index < 0
-    ? open + string + close
-    : open + replaceClose(index, string, close, replace) + close;
-
-const filterEmpty =
-  (open, close, replace = open, at = open.length + 1) =>
-  (string) =>
-    string || !(string === "" || string === undefined)
-      ? clearBleed(
-          ("" + string).indexOf(close, at),
-          string,
-          open,
-          close,
-          replace
-        )
-      : "";
-
-const init = (open, close, replace) =>
-  filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
-
+  replace
+) : "";
+const init = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
 const colors = {
   reset: init(0, 0),
-  bold: init(1, 22, "\x1b[22m\x1b[1m"),
-  dim: init(2, 22, "\x1b[22m\x1b[2m"),
+  bold: init(1, 22, "\x1B[22m\x1B[1m"),
+  dim: init(2, 22, "\x1B[22m\x1B[2m"),
   italic: init(3, 23),
   underline: init(4, 24),
   inverse: init(7, 27),
@@ -119,17 +63,12 @@ const colors = {
   bgBlueBright: init(104, 49),
   bgMagentaBright: init(105, 49),
   bgCyanBright: init(106, 49),
-  bgWhiteBright: init(107, 49),
+  bgWhiteBright: init(107, 49)
 };
-
-const createColors = ({ useColor = isColorSupported } = {}) =>
-  useColor
-    ? colors
-    : Object.keys(colors).reduce(
-        (colors, key) => ({ ...colors, [key]: String }),
-        {}
-      );
-
+const createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors : Object.keys(colors).reduce(
+  (colors2, key) => ({ ...colors2, [key]: String }),
+  {}
+);
 const {
   reset,
   bold,
@@ -171,51 +110,7 @@ const {
   bgBlueBright,
   bgMagentaBright,
   bgCyanBright,
-  bgWhiteBright,
+  bgWhiteBright
 } = createColors();
 
-colorette.bgBlack = bgBlack;
-colorette.bgBlackBright = bgBlackBright;
-colorette.bgBlue = bgBlue;
-colorette.bgBlueBright = bgBlueBright;
-colorette.bgCyan = bgCyan;
-colorette.bgCyanBright = bgCyanBright;
-colorette.bgGreen = bgGreen;
-colorette.bgGreenBright = bgGreenBright;
-colorette.bgMagenta = bgMagenta;
-colorette.bgMagentaBright = bgMagentaBright;
-colorette.bgRed = bgRed;
-colorette.bgRedBright = bgRedBright;
-colorette.bgWhite = bgWhite;
-colorette.bgWhiteBright = bgWhiteBright;
-colorette.bgYellow = bgYellow;
-colorette.bgYellowBright = bgYellowBright;
-colorette.black = black;
-colorette.blackBright = blackBright;
-colorette.blue = blue;
-colorette.blueBright = blueBright;
-var bold_1 = colorette.bold = bold;
-colorette.createColors = createColors;
-var cyan_1 = colorette.cyan = cyan;
-colorette.cyanBright = cyanBright;
-var dim_1 = colorette.dim = dim;
-colorette.gray = gray;
-var green_1 = colorette.green = green;
-colorette.greenBright = greenBright;
-colorette.hidden = hidden;
-colorette.inverse = inverse;
-colorette.isColorSupported = isColorSupported;
-colorette.italic = italic;
-var magenta_1 = colorette.magenta = magenta;
-colorette.magentaBright = magentaBright;
-colorette.red = red;
-colorette.redBright = redBright;
-colorette.reset = reset;
-colorette.strikethrough = strikethrough;
-var underline_1 = colorette.underline = underline;
-colorette.white = white;
-colorette.whiteBright = whiteBright;
-colorette.yellow = yellow;
-colorette.yellowBright = yellowBright;
-
-export { bold_1 as bold, cyan_1 as cyan, colorette as default, dim_1 as dim, green_1 as green, magenta_1 as magenta, underline_1 as underline };
+export { bgBlack, bgBlackBright, bgBlue, bgBlueBright, bgCyan, bgCyanBright, bgGreen, bgGreenBright, bgMagenta, bgMagentaBright, bgRed, bgRedBright, bgWhite, bgWhiteBright, bgYellow, bgYellowBright, black, blackBright, blue, blueBright, bold, createColors, cyan, cyanBright, dim, gray, green, greenBright, hidden, inverse, isColorSupported, italic, magenta, magentaBright, red, redBright, reset, strikethrough, underline, white, whiteBright, yellow, yellowBright };

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/TemplateTag/TemplateTag.esnext

@@ -1,81 +1,61 @@
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _templateObject = _taggedTemplateLiteral(['', ''], ['', '']);
-
-function _taggedTemplateLiteral(strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @class TemplateTag
- * @classdesc Consumes a pipeline of composable transformer plugins and produces a template tag.
- */
-var TemplateTag = function () {
-  /**
-   * constructs a template tag
-   * @constructs TemplateTag
-   * @param  {...Object} [...transformers] - an array or arguments list of transformers
-   * @return {Function}                    - a template tag
-   */
-  function TemplateTag() {
+var _createClass = function() {
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor)
+        descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  return function(Constructor, protoProps, staticProps) {
+    if (protoProps)
+      defineProperties(Constructor.prototype, protoProps);
+    if (staticProps)
+      defineProperties(Constructor, staticProps);
+    return Constructor;
+  };
+}();
+var _templateObject = _taggedTemplateLiteral(["", ""], ["", ""]);
+function _taggedTemplateLiteral(strings, raw) {
+  return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } }));
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+var TemplateTag = function() {
+  function TemplateTag2() {
     var _this = this;
-
     for (var _len = arguments.length, transformers = Array(_len), _key = 0; _key < _len; _key++) {
       transformers[_key] = arguments[_key];
     }
-
-    _classCallCheck(this, TemplateTag);
-
-    this.tag = function (strings) {
+    _classCallCheck(this, TemplateTag2);
+    this.tag = function(strings) {
       for (var _len2 = arguments.length, expressions = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
         expressions[_key2 - 1] = arguments[_key2];
       }
-
-      if (typeof strings === 'function') {
-        // if the first argument passed is a function, assume it is a template tag and return
-        // an intermediary tag that processes the template using the aforementioned tag, passing the
-        // result to our tag
+      if (typeof strings === "function") {
         return _this.interimTag.bind(_this, strings);
       }
-
-      if (typeof strings === 'string') {
-        // if the first argument passed is a string, just transform it
+      if (typeof strings === "string") {
         return _this.transformEndResult(strings);
       }
-
-      // else, return a transformed end result of processing the template with our tag
       strings = strings.map(_this.transformString.bind(_this));
       return _this.transformEndResult(strings.reduce(_this.processSubstitutions.bind(_this, expressions)));
     };
-
-    // if first argument is an array, extrude it as a list of transformers
     if (transformers.length > 0 && Array.isArray(transformers[0])) {
       transformers = transformers[0];
     }
-
-    // if any transformers are functions, this means they are not initiated - automatically initiate them
-    this.transformers = transformers.map(function (transformer) {
-      return typeof transformer === 'function' ? transformer() : transformer;
+    this.transformers = transformers.map(function(transformer) {
+      return typeof transformer === "function" ? transformer() : transformer;
     });
-
-    // return an ES2015 template tag
     return this.tag;
   }
-
-  /**
-   * Applies all transformers to a template literal tagged with this method.
-   * If a function is passed as the first argument, assumes the function is a template tag
-   * and applies it to the template, returning a template tag.
-   * @param  {(Function|String|Array<String>)} strings        - Either a template tag or an array containing template strings separated by identifier
-   * @param  {...*}                            ...expressions - Optional list of substitution values.
-   * @return {(String|Function)}                              - Either an intermediary tag function or the results of processing the template.
-   */
-
-
-  _createClass(TemplateTag, [{
-    key: 'interimTag',
-
-
+  _createClass(TemplateTag2, [{
+    key: "interimTag",
     /**
      * An intermediary template tag that receives a template tag and passes the result of calling the template with the received
      * template tag to our own template tag.
@@ -88,10 +68,8 @@ var TemplateTag = function () {
       for (var _len3 = arguments.length, substitutions = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
         substitutions[_key3 - 2] = arguments[_key3];
       }
-
-      return this.tag(_templateObject, previousTag.apply(undefined, [template].concat(substitutions)));
+      return this.tag(_templateObject, previousTag.apply(void 0, [template].concat(substitutions)));
     }
-
     /**
      * Performs bulk processing on the tagged template, transforming each substitution and then
      * concatenating the resulting values into a string.
@@ -100,30 +78,26 @@ var TemplateTag = function () {
      * @param  {String}   remainingPart - the template chunk after the current substitution
      * @return {String}                 - the result of joining this iteration's processed substitution with the result
      */
-
   }, {
-    key: 'processSubstitutions',
+    key: "processSubstitutions",
     value: function processSubstitutions(substitutions, resultSoFar, remainingPart) {
       var substitution = this.transformSubstitution(substitutions.shift(), resultSoFar);
-      return ''.concat(resultSoFar, substitution, remainingPart);
+      return "".concat(resultSoFar, substitution, remainingPart);
     }
-
     /**
      * Iterate through each transformer, applying the transformer's `onString` method to the template
      * strings before all substitutions are processed.
      * @param {String}  str - The input string
      * @return {String}     - The final results of processing each transformer
      */
-
   }, {
-    key: 'transformString',
+    key: "transformString",
     value: function transformString(str) {
-      var cb = function cb(res, transform) {
+      var cb = function cb2(res, transform) {
         return transform.onString ? transform.onString(res) : res;
       };
       return this.transformers.reduce(cb, str);
     }
-
     /**
      * When a substitution is encountered, iterates through each transformer and applies the transformer's
      * `onSubstitution` method to the substitution.
@@ -131,34 +105,30 @@ var TemplateTag = function () {
      * @param  {String} resultSoFar  - The result up to and excluding this substitution.
      * @return {*}                   - The final result of applying all substitution transformations.
      */
-
   }, {
-    key: 'transformSubstitution',
+    key: "transformSubstitution",
     value: function transformSubstitution(substitution, resultSoFar) {
-      var cb = function cb(res, transform) {
+      var cb = function cb2(res, transform) {
         return transform.onSubstitution ? transform.onSubstitution(res, resultSoFar) : res;
       };
       return this.transformers.reduce(cb, substitution);
     }
-
     /**
      * Iterates through each transformer, applying the transformer's `onEndResult` method to the
      * template literal after all substitutions have finished processing.
      * @param  {String} endResult - The processed template, just before it is returned from the tag
      * @return {String}           - The final results of processing each transformer
      */
-
   }, {
-    key: 'transformEndResult',
+    key: "transformEndResult",
     value: function transformEndResult(endResult) {
-      var cb = function cb(res, transform) {
+      var cb = function cb2(res, transform) {
         return transform.onEndResult ? transform.onEndResult(res) : res;
       };
       return this.transformers.reduce(cb, endResult);
     }
   }]);
-
-  return TemplateTag;
+  return TemplateTag2;
 }();
 
 export { TemplateTag as default };

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaLists/commaLists.esnext

@@ -3,4 +3,4 @@ import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransfo
 import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 
-new TemplateTag(inlineArrayTransformer({ separator: ',' }), stripIndentTransformer, trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: "," }), stripIndentTransformer, trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsAnd/commaListsAnd.esnext

@@ -3,4 +3,4 @@ import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransfo
 import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 
-new TemplateTag(inlineArrayTransformer({ separator: ',', conjunction: 'and' }), stripIndentTransformer, trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "and" }), stripIndentTransformer, trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsOr/commaListsOr.esnext

@@ -3,4 +3,4 @@ import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransfo
 import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 
-new TemplateTag(inlineArrayTransformer({ separator: ',', conjunction: 'or' }), stripIndentTransformer, trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "or" }), stripIndentTransformer, trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/html/html.esnext

@@ -5,4 +5,4 @@ import trimResultTransformer from '../trimResultTransformer/trimResultTransforme
 import splitStringTransformer from '../splitStringTransformer/splitStringTransformer.esnext';
 import removeNonPrintingValuesTransformer from '../removeNonPrintingValuesTransformer/removeNonPrintingValuesTransformer.esnext';
 
-new TemplateTag(splitStringTransformer('\n'), removeNonPrintingValuesTransformer, inlineArrayTransformer, stripIndentTransformer, trimResultTransformer);
+new TemplateTag(splitStringTransformer("\n"), removeNonPrintingValuesTransformer, inlineArrayTransformer, stripIndentTransformer, trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/inlineArrayTransformer/inlineArrayTransformer.esnext

@@ -1,39 +1,26 @@
 var defaults = {
-  separator: '',
-  conjunction: '',
+  separator: "",
+  conjunction: "",
   serial: false
 };
-
-/**
- * Converts an array substitution to a string containing a list
- * @param  {String} [opts.separator = ''] - the character that separates each item
- * @param  {String} [opts.conjunction = '']  - replace the last separator with this
- * @param  {Boolean} [opts.serial = false] - include the separator before the conjunction? (Oxford comma use-case)
- *
- * @return {Object}                     - a TemplateTag transformer
- */
-var inlineArrayTransformer = function inlineArrayTransformer() {
-  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaults;
+var inlineArrayTransformer = function inlineArrayTransformer2() {
+  var opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaults;
   return {
     onSubstitution: function onSubstitution(substitution, resultSoFar) {
-      // only operate on arrays
       if (Array.isArray(substitution)) {
         var arrayLength = substitution.length;
         var separator = opts.separator;
         var conjunction = opts.conjunction;
         var serial = opts.serial;
-        // join each item in the array into a string where each item is separated by separator
-        // be sure to maintain indentation
         var indent = resultSoFar.match(/(\n?[^\S\n]+)$/);
         if (indent) {
           substitution = substitution.join(separator + indent[1]);
         } else {
-          substitution = substitution.join(separator + ' ');
+          substitution = substitution.join(separator + " ");
         }
-        // if conjunction is set, replace the last separator with conjunction, but only if there is more than one substitution
         if (conjunction && arrayLength > 1) {
           var separatorIndex = substitution.lastIndexOf(separator);
-          substitution = substitution.slice(0, separatorIndex) + (serial ? separator : '') + ' ' + conjunction + substitution.slice(separatorIndex + 1);
+          substitution = substitution.slice(0, separatorIndex) + (serial ? separator : "") + " " + conjunction + substitution.slice(separatorIndex + 1);
         }
       }
       return substitution;

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLine/oneLine.esnext

@@ -2,4 +2,4 @@ import TemplateTag from '../TemplateTag/TemplateTag.esnext';
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
 
-new TemplateTag(replaceResultTransformer(/(?:\n(?:\s*))+/g, ' '), trimResultTransformer);
+new TemplateTag(replaceResultTransformer(/(?:\n(?:\s*))+/g, " "), trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaLists/oneLineCommaLists.esnext

@@ -3,4 +3,4 @@ import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransfo
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
 
-new TemplateTag(inlineArrayTransformer({ separator: ',' }), replaceResultTransformer(/(?:\s+)/g, ' '), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: "," }), replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsAnd/oneLineCommaListsAnd.esnext

@@ -3,4 +3,4 @@ import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransfo
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
 
-new TemplateTag(inlineArrayTransformer({ separator: ',', conjunction: 'and' }), replaceResultTransformer(/(?:\s+)/g, ' '), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "and" }), replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsOr/oneLineCommaListsOr.esnext

@@ -3,4 +3,4 @@ import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransfo
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
 
-new TemplateTag(inlineArrayTransformer({ separator: ',', conjunction: 'or' }), replaceResultTransformer(/(?:\s+)/g, ' '), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "or" }), replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineInlineLists/oneLineInlineLists.esnext

@@ -3,4 +3,4 @@ import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransfo
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
 
-new TemplateTag(inlineArrayTransformer, replaceResultTransformer(/(?:\s+)/g, ' '), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer, replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineTrim/oneLineTrim.esnext

@@ -2,4 +2,4 @@ import TemplateTag from '../TemplateTag/TemplateTag.esnext';
 import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
 import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
 
-new TemplateTag(replaceResultTransformer(/(?:\n\s*)/g, ''), trimResultTransformer);
+new TemplateTag(replaceResultTransformer(/(?:\n\s*)/g, ""), trimResultTransformer);

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/removeNonPrintingValuesTransformer/removeNonPrintingValuesTransformer.esnext

@@ -1,8 +1,7 @@
-var isValidValue = function isValidValue(x) {
-  return x != null && !Number.isNaN(x) && typeof x !== 'boolean';
+var isValidValue = function isValidValue2(x) {
+  return x != null && !Number.isNaN(x) && typeof x !== "boolean";
 };
-
-var removeNonPrintingValuesTransformer = function removeNonPrintingValuesTransformer() {
+var removeNonPrintingValuesTransformer = function removeNonPrintingValuesTransformer2() {
   return {
     onSubstitution: function onSubstitution(substitution) {
       if (Array.isArray(substitution)) {
@@ -11,7 +10,7 @@ var removeNonPrintingValuesTransformer = function removeNonPrintingValuesTransfo
       if (isValidValue(substitution)) {
         return substitution;
       }
-      return '';
+      return "";
     }
   };
 };

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/replaceResultTransformer/replaceResultTransformer.esnext

@@ -1,14 +1,8 @@
-/**
- * Replaces tabs, newlines and spaces with the chosen value when they occur in sequences
- * @param  {(String|RegExp)} replaceWhat - the value or pattern that should be replaced
- * @param  {*}               replaceWith - the replacement value
- * @return {Object}                      - a TemplateTag transformer
- */
-var replaceResultTransformer = function replaceResultTransformer(replaceWhat, replaceWith) {
+var replaceResultTransformer = function replaceResultTransformer2(replaceWhat, replaceWith) {
   return {
     onEndResult: function onEndResult(endResult) {
       if (replaceWhat == null || replaceWith == null) {
-        throw new Error('replaceResultTransformer requires at least 2 arguments.');
+        throw new Error("replaceResultTransformer requires at least 2 arguments.");
       }
       return endResult.replace(replaceWhat, replaceWith);
     }

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/replaceSubstitutionTransformer/replaceSubstitutionTransformer.esnext

@@ -1,11 +1,9 @@
-var replaceSubstitutionTransformer = function replaceSubstitutionTransformer(replaceWhat, replaceWith) {
+var replaceSubstitutionTransformer = function replaceSubstitutionTransformer2(replaceWhat, replaceWith) {
   return {
     onSubstitution: function onSubstitution(substitution, resultSoFar) {
       if (replaceWhat == null || replaceWith == null) {
-        throw new Error('replaceSubstitutionTransformer requires at least 2 arguments.');
+        throw new Error("replaceSubstitutionTransformer requires at least 2 arguments.");
       }
-
-      // Do not touch if null or undefined
       if (substitution == null) {
         return substitution;
       } else {

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.esnext

@@ -5,4 +5,4 @@ import trimResultTransformer from '../trimResultTransformer/trimResultTransforme
 import splitStringTransformer from '../splitStringTransformer/splitStringTransformer.esnext';
 import replaceSubstitutionTransformer from '../replaceSubstitutionTransformer/replaceSubstitutionTransformer.esnext';
 
-new TemplateTag(splitStringTransformer('\n'), inlineArrayTransformer, stripIndentTransformer, trimResultTransformer, replaceSubstitutionTransformer(/&/g, '&amp;'), replaceSubstitutionTransformer(/</g, '&lt;'), replaceSubstitutionTransformer(/>/g, '&gt;'), replaceSubstitutionTransformer(/"/g, '&quot;'), replaceSubstitutionTransformer(/'/g, '&#x27;'), replaceSubstitutionTransformer(/`/g, '&#x60;'));
+new TemplateTag(splitStringTransformer("\n"), inlineArrayTransformer, stripIndentTransformer, trimResultTransformer, replaceSubstitutionTransformer(/&/g, "&amp;"), replaceSubstitutionTransformer(/</g, "&lt;"), replaceSubstitutionTransformer(/>/g, "&gt;"), replaceSubstitutionTransformer(/"/g, "&quot;"), replaceSubstitutionTransformer(/'/g, "&#x27;"), replaceSubstitutionTransformer(/`/g, "&#x60;"));

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/splitStringTransformer/splitStringTransformer.esnext

@@ -1,12 +1,12 @@
-var splitStringTransformer = function splitStringTransformer(splitBy) {
+var splitStringTransformer = function splitStringTransformer2(splitBy) {
   return {
     onSubstitution: function onSubstitution(substitution, resultSoFar) {
-      if (splitBy != null && typeof splitBy === 'string') {
-        if (typeof substitution === 'string' && substitution.includes(splitBy)) {
+      if (splitBy != null && typeof splitBy === "string") {
+        if (typeof substitution === "string" && substitution.includes(splitBy)) {
           substitution = substitution.split(splitBy);
         }
       } else {
-        throw new Error('You need to specify a string character to split by.');
+        throw new Error("You need to specify a string character to split by.");
       }
       return substitution;
     }

package/build/esnext/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndentTransformer/stripIndentTransformer.esnext

@@ -1,31 +1,32 @@
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
-
-/**
- * strips indentation from a template literal
- * @param  {String} type = 'initial' - whether to remove all indentation or just leading indentation. can be 'all' or 'initial'
- * @return {Object}                  - a TemplateTag transformer
- */
-var stripIndentTransformer = function stripIndentTransformer() {
-  var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'initial';
+function _toConsumableArray(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+    return arr2;
+  } else {
+    return Array.from(arr);
+  }
+}
+var stripIndentTransformer = function stripIndentTransformer2() {
+  var type = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "initial";
   return {
     onEndResult: function onEndResult(endResult) {
-      if (type === 'initial') {
-        // remove the shortest leading indentation from each line
+      if (type === "initial") {
         var match = endResult.match(/^[^\S\n]*(?=\S)/gm);
-        var indent = match && Math.min.apply(Math, _toConsumableArray(match.map(function (el) {
+        var indent = match && Math.min.apply(Math, _toConsumableArray(match.map(function(el) {
           return el.length;
         })));
         if (indent) {
-          var regexp = new RegExp('^.{' + indent + '}', 'gm');
-          return endResult.replace(regexp, '');
+          var regexp = new RegExp("^.{" + indent + "}", "gm");
+          return endResult.replace(regexp, "");
         }
         return endResult;
       }
-      if (type === 'all') {
-        // remove all indentation from each line
-        return endResult.replace(/^[^\S\n]+/gm, '');
+      if (type === "all") {
+        return endResult.replace(/^[^\S\n]+/gm, "");
       }
-      throw new Error('Unknown type: ' + type);
+      throw new Error("Unknown type: " + type);
     }
   };
 };