@quilted/rollup 0.1.0

package/build/esnext/app.esnext

@@ -0,0 +1,130 @@
+import { MAGIC_MODULE_APP_COMPONENT, MAGIC_MODULE_REQUEST_ROUTER, MAGIC_MODULE_BROWSER_ASSETS } from './constants.esnext';
+import { magicModuleEnv } from './env.esnext';
+import { magicModuleRequestRouterEntry } from './request-router.esnext';
+import { multiline } from './shared/strings.esnext';
+import { createMagicModulePlugin, createMagicModuleEntryPlugin } from './shared/magic-module.esnext';
+
+function quiltApp({
+  env,
+  entry
+} = {}) {
+  return {
+    name: '@quilted/app',
+    options(originalOptions) {
+      const newPlugins = [...(Array.isArray(originalOptions.plugins) ? originalOptions.plugins : originalOptions.plugins ? [originalOptions.plugins] : [])];
+      const newOptions = {
+        ...originalOptions,
+        plugins: newPlugins
+      };
+      if (env) {
+        newPlugins.push(typeof env === 'boolean' ? magicModuleEnv() : magicModuleEnv(env));
+      }
+      if (entry) {
+        newPlugins.push(magicModuleAppComponent({
+          entry
+        }));
+      }
+      return newOptions;
+    }
+  };
+}
+function quiltAppBrowser(options = {}) {
+  return {
+    name: '@quilted/app/browser',
+    options(originalOptions) {
+      const newPlugins = [...(Array.isArray(originalOptions.plugins) ? originalOptions.plugins : originalOptions.plugins ? [originalOptions.plugins] : [])];
+      const newOptions = {
+        ...originalOptions,
+        plugins: newPlugins
+      };
+      newPlugins.push(magicModuleAppBrowserEntry(options));
+      return newOptions;
+    }
+  };
+}
+function quiltAppServer(options = {}) {
+  return {
+    name: '@quilted/app/server',
+    options(originalOptions) {
+      const newPlugins = [...(Array.isArray(originalOptions.plugins) ? originalOptions.plugins : originalOptions.plugins ? [originalOptions.plugins] : [])];
+      const newOptions = {
+        ...originalOptions,
+        plugins: newPlugins
+      };
+      newPlugins.push(magicModuleRequestRouterEntry());
+      newPlugins.push(magicModuleAppRequestRouter(options));
+      return newOptions;
+    }
+  };
+}
+function magicModuleAppComponent({
+  entry
+}) {
+  return createMagicModulePlugin({
+    name: '@quilted/magic-module/app',
+    module: MAGIC_MODULE_APP_COMPONENT,
+    alias: entry
+  });
+}
+function magicModuleAppRequestRouter({
+  entry
+} = {}) {
+  return createMagicModulePlugin({
+    name: '@quilted/magic-module/app-request-router',
+    module: MAGIC_MODULE_REQUEST_ROUTER,
+    alias: entry,
+    source: entry ? undefined : async function source() {
+      return multiline`
+            import '@quilted/quilt/globals';
+
+            import {jsx} from 'react/jsx-runtime';
+            import {RequestRouter} from '@quilted/quilt/request-router';
+            import {renderToResponse} from '@quilted/quilt/server';
+
+            import App from ${JSON.stringify(MAGIC_MODULE_APP_COMPONENT)};
+            import {BrowserAssets} from ${JSON.stringify(MAGIC_MODULE_BROWSER_ASSETS)};
+
+            const router = new RequestRouter();
+            const assets = new BrowserAssets();
+
+            // For all GET requests, render our React application.
+            router.get(async (request) => {
+              const response = await renderToResponse(jsx(App), {
+                request,
+                assets,
+              });
+
+              return response;
+            });
+
+            export default router;
+          `;
+    }
+  });
+}
+function magicModuleAppBrowserEntry({
+  hydrate = true,
+  selector = '#app'
+} = {}) {
+  return createMagicModuleEntryPlugin({
+    name: '@quilted/magic-module/app-browser-entry',
+    sideEffects: true,
+    async source() {
+      const reactRootFunction = hydrate ? 'hydrateRoot' : 'createRoot';
+      return multiline`
+        import '@quilted/quilt/globals';
+
+        import {jsx} from 'react/jsx-runtime';
+        import {${reactRootFunction}} from 'react-dom/client';
+
+        import App from ${JSON.stringify(MAGIC_MODULE_APP_COMPONENT)};
+
+        const element = document.querySelector(${JSON.stringify(selector)});
+
+        ${hydrate ? `${reactRootFunction}(element, jsx(App));` : `${reactRootFunction}(element).render(jsx(App));`}
+      `;
+    }
+  });
+}
+
+export { magicModuleAppBrowserEntry, magicModuleAppComponent, magicModuleAppRequestRouter, quiltApp, quiltAppBrowser, quiltAppServer };

package/build/esnext/constants.esnext

@@ -0,0 +1,7 @@
+const MAGIC_MODULE_ENV = 'quilt:module/env';
+const MAGIC_MODULE_ENTRY = 'quilt:module/entry';
+const MAGIC_MODULE_APP_COMPONENT = 'quilt:module/app';
+const MAGIC_MODULE_BROWSER_ASSETS = 'quilt:module/assets';
+const MAGIC_MODULE_REQUEST_ROUTER = 'quilt:module/request-router';
+
+export { MAGIC_MODULE_APP_COMPONENT, MAGIC_MODULE_BROWSER_ASSETS, MAGIC_MODULE_ENTRY, MAGIC_MODULE_ENV, MAGIC_MODULE_REQUEST_ROUTER };

package/build/esnext/env.esnext

@@ -0,0 +1,108 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/TemplateTag/TemplateTag.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaLists/commaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsAnd/commaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsOr/commaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/html/html.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLine/oneLine.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineTrim/oneLineTrim.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaLists/oneLineCommaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsOr/oneLineCommaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsAnd/oneLineCommaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/inlineLists/inlineLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineInlineLists/oneLineInlineLists.esnext';
+import stripIndent from './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.esnext';
+import { MAGIC_MODULE_ENV } from './constants.esnext';
+import { createMagicModulePlugin } from './shared/magic-module.esnext';
+
+function magicModuleEnv({
+  mode,
+  dotenv = {
+    roots: ['.', 'configuration']
+  },
+  inline = [],
+  runtime = '{}'
+} = {}) {
+  return createMagicModulePlugin({
+    name: '@quilted/magic-module/env',
+    module: MAGIC_MODULE_ENV,
+    async source() {
+      const inlineEnv = {};
+      if (mode) {
+        inlineEnv.MODE = mode;
+      }
+      const loadedEnv = await loadEnv.call(this, {
+        mode,
+        dotenv
+      });
+      for (const inlineVariable of inline.sort()) {
+        if (inlineVariable in inlineEnv) continue;
+        const value = process.env[inlineVariable] ?? loadedEnv[inlineVariable];
+        if (value == null) continue;
+        inlineEnv[inlineVariable] = typeof value === 'string' && value[0] === '"' && value[value.length - 1] === '"' ? JSON.parse(value) : value;
+      }
+      return stripIndent`
+        const runtime = (${runtime});
+        const inline = JSON.parse(${JSON.stringify(JSON.stringify(inlineEnv))});
+
+        const Env = new Proxy(
+          {},
+          {
+            get(_, property) {
+              return runtime[property] ?? inline[property];
+            },
+          },
+        );
+
+        export default Env;
+      `;
+    }
+  });
+}
+
+// Inspired by https://github.com/vitejs/vite/blob/e0a4d810598d1834933ed437ac5a2168cbbbf2f8/packages/vite/source/node/config.ts#L1050-L1113
+async function loadEnv({
+  mode,
+  dotenv
+}) {
+  const env = {
+    ...process.env
+  };
+  if (dotenv !== false) {
+    const {
+      parse
+    } = await import('dotenv');
+    let files = dotenv.files;
+    if (files == null) {
+      const testFiles = [
+      // default file
+      `.env`,
+      // local file
+      `.env.local`];
+      if (mode) {
+        testFiles.push(
+        // mode file
+        `.env.${mode}`,
+        // mode local file
+        `.env.${mode}.local`);
+      }
+      files = testFiles.flatMap(file => (dotenv.roots ?? ['.', 'configuration']).map(root => path.resolve(root, file)));
+    }
+    const envFileResults = await Promise.all(files.map(async file => {
+      if (fs.existsSync(file)) {
+        this.addWatchFile(file);
+        return parse(await fs.promises.readFile(file, 'utf-8'));
+      }
+    }));
+    for (const envFileResult of envFileResults) {
+      if (envFileResult == null) continue;
+      Object.assign(env, envFileResult);
+    }
+  }
+  return env;
+}
+
+export { magicModuleEnv };

package/build/esnext/index.esnext

@@ -0,0 +1,3 @@
+export { magicModuleEnv } from './env.esnext';
+export { magicModuleAppBrowserEntry, magicModuleAppComponent, magicModuleAppRequestRouter, quiltApp, quiltAppBrowser, quiltAppServer } from './app.esnext';
+export { magicModuleRequestRouterEntry } from './request-router.esnext';

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

@@ -0,0 +1,164 @@
+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 _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) {
+      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
+        return _this.interimTag.bind(_this, strings);
+      }
+
+      if (typeof strings === 'string') {
+        // if the first argument passed is a string, just transform it
+        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;
+    });
+
+    // 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',
+
+
+    /**
+     * 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.
+     * @param  {Function}        nextTag          - the received template tag
+     * @param  {Array<String>}   template         - the template to process
+     * @param  {...*}            ...substitutions - `substitutions` is an array of all substitutions in the template
+     * @return {*}                                - the final processed value
+     */
+    value: function interimTag(previousTag, template) {
+      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)));
+    }
+
+    /**
+     * Performs bulk processing on the tagged template, transforming each substitution and then
+     * concatenating the resulting values into a string.
+     * @param  {Array<*>} substitutions - an array of all remaining substitutions present in this template
+     * @param  {String}   resultSoFar   - this iteration's result string so far
+     * @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',
+    value: function processSubstitutions(substitutions, resultSoFar, remainingPart) {
+      var substitution = this.transformSubstitution(substitutions.shift(), resultSoFar);
+      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',
+    value: function transformString(str) {
+      var cb = function cb(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.
+     * @param  {*}      substitution - The current substitution
+     * @param  {String} resultSoFar  - The result up to and excluding this substitution.
+     * @return {*}                   - The final result of applying all substitution transformations.
+     */
+
+  }, {
+    key: 'transformSubstitution',
+    value: function transformSubstitution(substitution, resultSoFar) {
+      var cb = function cb(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',
+    value: function transformEndResult(endResult) {
+      var cb = function cb(res, transform) {
+        return transform.onEndResult ? transform.onEndResult(res) : res;
+      };
+      return this.transformers.reduce(cb, endResult);
+    }
+  }]);
+
+  return TemplateTag;
+}();
+
+export { TemplateTag as default };

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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+
+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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+
+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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+
+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

@@ -0,0 +1,8 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+import splitStringTransformer from '../splitStringTransformer/splitStringTransformer.esnext';
+import removeNonPrintingValuesTransformer from '../removeNonPrintingValuesTransformer/removeNonPrintingValuesTransformer.esnext';
+
+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

@@ -0,0 +1,44 @@
+var defaults = {
+  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;
+  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 + ' ');
+        }
+        // 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);
+        }
+      }
+      return substitution;
+    }
+  };
+};
+
+export { inlineArrayTransformer as default };

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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+
+new TemplateTag(inlineArrayTransformer, stripIndentTransformer, trimResultTransformer);

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

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

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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
+
+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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
+
+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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
+
+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

@@ -0,0 +1,6 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+import replaceResultTransformer from '../replaceResultTransformer/replaceResultTransformer.esnext';
+
+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

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

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

@@ -0,0 +1,19 @@
+var isValidValue = function isValidValue(x) {
+  return x != null && !Number.isNaN(x) && typeof x !== 'boolean';
+};
+
+var removeNonPrintingValuesTransformer = function removeNonPrintingValuesTransformer() {
+  return {
+    onSubstitution: function onSubstitution(substitution) {
+      if (Array.isArray(substitution)) {
+        return substitution.filter(isValidValue);
+      }
+      if (isValidValue(substitution)) {
+        return substitution;
+      }
+      return '';
+    }
+  };
+};
+
+export { removeNonPrintingValuesTransformer as default };

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

@@ -0,0 +1,18 @@
+/**
+ * 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) {
+  return {
+    onEndResult: function onEndResult(endResult) {
+      if (replaceWhat == null || replaceWith == null) {
+        throw new Error('replaceResultTransformer requires at least 2 arguments.');
+      }
+      return endResult.replace(replaceWhat, replaceWith);
+    }
+  };
+};
+
+export { replaceResultTransformer as default };

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

@@ -0,0 +1,18 @@
+var replaceSubstitutionTransformer = function replaceSubstitutionTransformer(replaceWhat, replaceWith) {
+  return {
+    onSubstitution: function onSubstitution(substitution, resultSoFar) {
+      if (replaceWhat == null || replaceWith == null) {
+        throw new Error('replaceSubstitutionTransformer requires at least 2 arguments.');
+      }
+
+      // Do not touch if null or undefined
+      if (substitution == null) {
+        return substitution;
+      } else {
+        return substitution.toString().replace(replaceWhat, replaceWith);
+      }
+    }
+  };
+};
+
+export { replaceSubstitutionTransformer as default };

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

@@ -0,0 +1,8 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
+import inlineArrayTransformer from '../inlineArrayTransformer/inlineArrayTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+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;'));

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

@@ -0,0 +1,16 @@
+var splitStringTransformer = function splitStringTransformer(splitBy) {
+  return {
+    onSubstitution: function onSubstitution(substitution, resultSoFar) {
+      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.');
+      }
+      return substitution;
+    }
+  };
+};
+
+export { splitStringTransformer as default };

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

@@ -0,0 +1,7 @@
+import TemplateTag from '../TemplateTag/TemplateTag.esnext';
+import stripIndentTransformer from '../stripIndentTransformer/stripIndentTransformer.esnext';
+import trimResultTransformer from '../trimResultTransformer/trimResultTransformer.esnext';
+
+var stripIndent = new TemplateTag(stripIndentTransformer, trimResultTransformer);
+
+export { stripIndent as default };