@wirechunk/cli 0.0.1 → 0.0.3

package/build/main.js

@@ -3907,6 +3907,24 @@ const cleanTinyId = () => {
 };
 const domainRegex = /^([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}$/i;
 const validDomain = (domain) => domainRegex.test(domain);
+const removeColons = (domain) => domain.replaceAll(":", "");
+const normalizeDomain = (domain, { allowPort = false } = {}) => {
+  let normalizedDomain = domain.trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/\.+/g, ".").replace(/[^a-z0-9.:-]/g, "");
+  if (allowPort) {
+    const lastColonIndex = normalizedDomain.lastIndexOf(":");
+    if (lastColonIndex !== normalizedDomain.indexOf(":")) {
+      normalizedDomain = removeColons(normalizedDomain);
+    } else {
+      const port = normalizedDomain.slice(lastColonIndex + 1);
+      if (!/^\d{1,4}$/.test(port)) {
+        normalizedDomain = removeColons(normalizedDomain);
+      }
+    }
+  } else {
+    normalizedDomain = removeColons(normalizedDomain);
+  }
+  return normalizedDomain || null;
+};
 const extractParts = (email) => {
   const [name, domain] = email.split("@");
   return { name, domain };
@@ -3937,102 +3955,17 @@ const normalizeEmailAddress = (email) => {
   }
   return { ok: true, value: emailTrimmed };
 };
+const siteDomainKey = "siteDomain";
+const submittedAtKey = "submittedAt";
 const defaultFormattedDataTemplate = `{{#each .}}{{@key}}: {{{.}}}
 {{/each}}`;
-const siteDomainKey = "siteDomain";
-const formattedDataKey = "formattedData";
 const defaultNotificationEmailBodyTemplate = `Form entry from your site {{${siteDomainKey}}}:
 
-{{{${formattedDataKey}}}}
+{{#each .}}{{@key}}: {{{.}}}
+{{/each}}
+
+Submitted {{${submittedAtKey}}}
 `;
-var DeploymentEnvironment = /* @__PURE__ */ ((DeploymentEnvironment2) => {
-  DeploymentEnvironment2["Development"] = "development";
-  DeploymentEnvironment2["Production"] = "production";
-  DeploymentEnvironment2["Staging"] = "staging";
-  DeploymentEnvironment2["Test"] = "test";
-  return DeploymentEnvironment2;
-})(DeploymentEnvironment || {});
-const deploymentEnvironments = Object.values(DeploymentEnvironment);
-const isDeploymentEnvironment = (value) => deploymentEnvironments.includes(value);
-const nodeEnv = process.env.NODE_ENV;
-const deploymentEnv = process.env.DEPLOYMENT_ENVIRONMENT;
-const deploymentEnvironmentDefaultProduction = (rawDeploymentEnv) => {
-  if (isDeploymentEnvironment(rawDeploymentEnv)) {
-    return rawDeploymentEnv;
-  }
-  if (!rawDeploymentEnv) {
-    return DeploymentEnvironment.Production;
-  }
-  throw new Error(`Invalid deployment environment: ${rawDeploymentEnv}`);
-};
-const environment = nodeEnv === "test" ? DeploymentEnvironment.Test : nodeEnv === "development" ? DeploymentEnvironment.Development : deploymentEnvironmentDefaultProduction(deploymentEnv);
-const forceCloudDeployment = process.env.FORCE_CLOUD_DEPLOYMENT === "true";
-const cloudDeployment = environment === DeploymentEnvironment.Production || environment === DeploymentEnvironment.Staging || forceCloudDeployment;
-process.env.APP_VERSION || "";
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = freeGlobal || freeSelf || Function("return this")();
-var Symbol$1 = root.Symbol;
-var objectProto$1 = Object.prototype;
-var hasOwnProperty$2 = objectProto$1.hasOwnProperty;
-var nativeObjectToString$1 = objectProto$1.toString;
-var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty$2.call(value, symToStringTag$1), tag = value[symToStringTag$1];
-  try {
-    value[symToStringTag$1] = void 0;
-    var unmasked = true;
-  } catch (e) {
-  }
-  var result2 = nativeObjectToString$1.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag$1] = tag;
-    } else {
-      delete value[symToStringTag$1];
-    }
-  }
-  return result2;
-}
-var objectProto = Object.prototype;
-var nativeObjectToString = objectProto.toString;
-function objectToString(value) {
-  return nativeObjectToString.call(value);
-}
-var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
-var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
-function baseGetTag(value) {
-  if (value == null) {
-    return value === void 0 ? undefinedTag : nullTag;
-  }
-  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
-}
-function isObjectLike(value) {
-  return value != null && typeof value == "object";
-}
-var isArray = Array.isArray;
-var stringTag = "[object String]";
-function isString(value) {
-  return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
-}
-const removeColons = (domain) => domain.replaceAll(":", "");
-const normalizeDomain = (domain, { allowPort = !cloudDeployment } = {}) => {
-  let normalizedDomain = domain.trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/\.+/g, ".").replace(/[^a-z0-9.:-]/g, "");
-  if (allowPort) {
-    const lastColonIndex = normalizedDomain.lastIndexOf(":");
-    if (lastColonIndex !== normalizedDomain.indexOf(":")) {
-      normalizedDomain = removeColons(normalizedDomain);
-    } else {
-      const port = normalizedDomain.slice(lastColonIndex + 1);
-      if (!/^\d{1,4}$/.test(port)) {
-        normalizedDomain = removeColons(normalizedDomain);
-      }
-    }
-  } else {
-    normalizedDomain = removeColons(normalizedDomain);
-  }
-  return normalizedDomain || null;
-};
 var dist$b = {};
 var dist$a = {};
 var createSqlTag = {};
@@ -4067,18 +4000,18 @@ function requireConstants$3() {
   };
   return constants$3;
 }
-var hasOwnProperty$1 = {};
+var hasOwnProperty$2 = {};
 var hasRequiredHasOwnProperty$1;
 function requireHasOwnProperty$1() {
-  if (hasRequiredHasOwnProperty$1) return hasOwnProperty$1;
+  if (hasRequiredHasOwnProperty$1) return hasOwnProperty$2;
   hasRequiredHasOwnProperty$1 = 1;
-  Object.defineProperty(hasOwnProperty$1, "__esModule", { value: true });
-  hasOwnProperty$1.hasOwnProperty = void 0;
+  Object.defineProperty(hasOwnProperty$2, "__esModule", { value: true });
+  hasOwnProperty$2.hasOwnProperty = void 0;
   const hasOwnProperty2 = (object, property) => {
     return Object.prototype.hasOwnProperty.call(object, property);
   };
-  hasOwnProperty$1.hasOwnProperty = hasOwnProperty2;
-  return hasOwnProperty$1;
+  hasOwnProperty$2.hasOwnProperty = hasOwnProperty2;
+  return hasOwnProperty$2;
 }
 var isBrowser = {};
 var hasRequiredIsBrowser;
@@ -4529,7 +4462,7 @@ function requireSafeStableStringify() {
               return circularValue;
             }
             let res = "";
-            let join = ",";
+            let join2 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -4543,7 +4476,7 @@ function requireSafeStableStringify() {
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join = `,
+                join2 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -4551,13 +4484,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join;
+                res += join2;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -4578,7 +4511,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join = `,
+              join2 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -4592,13 +4525,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join;
+                separator = join2;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join;
+              separator = join2;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -4639,7 +4572,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join = ",";
+            let join2 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -4652,7 +4585,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join = `,
+                join2 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -4660,13 +4593,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join;
+                res += join2;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -4679,7 +4612,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join = `,
+              join2 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -4688,7 +4621,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join;
+                separator = join2;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -4746,20 +4679,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join2 = `,
+              const join3 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join2;
+                res2 += join3;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join3}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -4775,16 +4708,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join = `,
+            const join2 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join, maximumBreadth);
+              res += stringifyTypedArray(value, join2, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join;
+              separator = join2;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -4795,13 +4728,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join;
+                separator = join2;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join;
+              separator = join2;
             }
             if (separator !== "") {
               res = `
@@ -5482,18 +5415,18 @@ function requireIsPrimitiveValueExpression() {
   return isPrimitiveValueExpression;
 }
 var isSqlToken = {};
-var hasOwnProperty = {};
+var hasOwnProperty$1 = {};
 var hasRequiredHasOwnProperty;
 function requireHasOwnProperty() {
-  if (hasRequiredHasOwnProperty) return hasOwnProperty;
+  if (hasRequiredHasOwnProperty) return hasOwnProperty$1;
   hasRequiredHasOwnProperty = 1;
-  Object.defineProperty(hasOwnProperty, "__esModule", { value: true });
-  hasOwnProperty.hasOwnProperty = void 0;
-  const hasOwnProperty$12 = (object, property) => {
+  Object.defineProperty(hasOwnProperty$1, "__esModule", { value: true });
+  hasOwnProperty$1.hasOwnProperty = void 0;
+  const hasOwnProperty2 = (object, property) => {
     return Object.prototype.hasOwnProperty.call(object, property);
   };
-  hasOwnProperty.hasOwnProperty = hasOwnProperty$12;
-  return hasOwnProperty;
+  hasOwnProperty$1.hasOwnProperty = hasOwnProperty2;
+  return hasOwnProperty$1;
 }
 var dist$9 = {};
 var errors$3 = {};
@@ -10238,22 +10171,22 @@ function requireCreateIntervalSqlFragment() {
   return createIntervalSqlFragment;
 }
 var createJsonSqlFragment = {};
-var isPlainObject = {};
+var isPlainObject$1 = {};
 var hasRequiredIsPlainObject$1;
 function requireIsPlainObject$1() {
-  if (hasRequiredIsPlainObject$1) return isPlainObject;
+  if (hasRequiredIsPlainObject$1) return isPlainObject$1;
   hasRequiredIsPlainObject$1 = 1;
-  Object.defineProperty(isPlainObject, "__esModule", { value: true });
-  isPlainObject.isPlainObject = void 0;
-  const isPlainObject$1 = (subject) => {
+  Object.defineProperty(isPlainObject$1, "__esModule", { value: true });
+  isPlainObject$1.isPlainObject = void 0;
+  const isPlainObject2 = (subject) => {
     if (typeof subject !== "object" || subject === null) {
       return false;
     }
     const prototype = Object.getPrototypeOf(subject);
     return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in subject) && !(Symbol.iterator in subject);
   };
-  isPlainObject.isPlainObject = isPlainObject$1;
-  return isPlainObject;
+  isPlainObject$1.isPlainObject = isPlainObject2;
+  return isPlainObject$1;
 }
 var serializeError_1;
 var hasRequiredSerializeError;
@@ -11264,7 +11197,7 @@ function requireDist$9() {
 var dist$7 = {};
 var getStackTrace = {};
 var UNKNOWN_FUNCTION = "<unknown>";
-function parse$1(stackString) {
+function parse$2(stackString) {
   var lines = stackString.split("\n");
   return lines.reduce(function(stack, line) {
     var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseNode(line) || parseJSC(line);
@@ -11363,7 +11296,7 @@ function parseNode(line) {
 }
 const stackTraceParser_esm = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  parse: parse$1
+  parse: parse$2
 }, Symbol.toStringTag, { value: "Module" }));
 const require$$0$4 = /* @__PURE__ */ getAugmentedNamespace(stackTraceParser_esm);
 var hasRequiredGetStackTrace;
@@ -12646,7 +12579,7 @@ const defaultDuration = Object.freeze({
   seconds: 0
 });
 const pattern$2 = new RegExp(iso8601);
-const parse = (durationString) => {
+const parse$1 = (durationString) => {
   return durationString.match(pattern$2).slice(1).reduce((prev, next2, idx) => {
     prev[objMap[idx]] = parseFloat(next2) || 0;
     return prev;
@@ -12677,13 +12610,13 @@ const index$1 = {
   end,
   toSeconds,
   pattern: pattern$2,
-  parse
+  parse: parse$1
 };
 const src = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   default: index$1,
   end,
-  parse,
+  parse: parse$1,
   pattern: pattern$2,
   toSeconds
 }, Symbol.toStringTag, { value: "Module" }));
@@ -15994,7 +15927,7 @@ function requireParser() {
   const LEN_LENGTH = 4;
   const HEADER_LENGTH = CODE_LENGTH + LEN_LENGTH;
   const emptyBuffer = Buffer.allocUnsafe(0);
-  class Parser {
+  class Parser2 {
     constructor(opts) {
       this.buffer = emptyBuffer;
       this.bufferLength = 0;
@@ -16269,7 +16202,7 @@ function requireParser() {
       return message;
     }
   }
-  parser.Parser = Parser;
+  parser.Parser = Parser2;
   return parser;
 }
 var hasRequiredDist$6;
@@ -25038,7 +24971,7 @@ const bootstrap = async (opts, env2) => {
   });
   console.log(`Created platform ${name} with handle ${handle} (ID ${platformId})`);
 };
-const validateExtensionConfig$1 = validate25;
+const validateExtensionConfig = validate25;
 function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
   let vErrors = null;
   let errors2 = 0;
@@ -30563,7 +30496,7 @@ function requireContains() {
         const count = gen.let("count", 0);
         validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
       }
-      function validateItems(_valid, block) {
+      function validateItems(_valid, block2) {
         gen.forRange("i", 0, len, (i) => {
           cxt.subschema({
             keyword: "contains",
@@ -30571,7 +30504,7 @@ function requireContains() {
             dataPropType: util_1.Type.Num,
             compositeRule: true
           }, _valid);
-          block();
+          block2();
         });
       }
       function checkLimits(count) {
@@ -32101,7 +32034,7 @@ const preCompiledSafeValidator = (validate2) => (value) => {
     error: errorsText(validate2)
   };
 };
-const validateExtensionConfig = preCompiledSafeValidator(validateExtensionConfig$1);
+const validateExtensionManifest = preCompiledSafeValidator(validateExtensionConfig);
 const requireValidExtensionDir = async (dir2) => {
   const extConfigPath = resolve$1(dir2, "extension.json");
   if (!existsSync(extConfigPath)) {
@@ -32109,7 +32042,7 @@ const requireValidExtensionDir = async (dir2) => {
     process.exit(1);
   }
   const extConfig = JSON.parse(await readFile(extConfigPath, "utf8"));
-  const validateResult = validateExtensionConfig(extConfig);
+  const validateResult = validateExtensionManifest(extConfig);
   if (validateResult.ok) {
     const config2 = validateResult.value;
     if (config2.components) {
@@ -32125,11 +32058,57 @@ const requireValidExtensionDir = async (dir2) => {
         }
       }
     }
-    return { ...config2, dir: dir2 };
+    return { manifest: config2, dir: dir2 };
   }
   console.error(`Invalid extension config file:`, validateResult.error);
   process.exit(1);
 };
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol$1 = root.Symbol;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$1.toString;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result2 = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result2;
+}
+var objectProto = Object.prototype;
+var nativeObjectToString = objectProto.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObjectLike$1(value) {
+  return value != null && typeof value == "object";
+}
+var isArray = Array.isArray;
+var stringTag = "[object String]";
+function isString(value) {
+  return typeof value == "string" || !isArray(value) && isObjectLike$1(value) && baseGetTag(value) == stringTag;
+}
 const isNonEmptyString = (value) => isString(value) && value.length > 0;
 const genericErrorMessage = "An unknown error occurred";
 const parseErrorMessage = (err) => {
@@ -33168,7 +33147,7 @@ var hasNextTick = typeof process === "object" && typeof process.nextTick === "fu
 function fallback(fn) {
   setTimeout(fn, 0);
 }
-function wrap(defer2) {
+function wrap$1(defer2) {
   return (fn, ...args) => defer2(() => fn(...args));
 }
 var _defer$1;
@@ -33181,7 +33160,7 @@ if (hasQueueMicrotask) {
 } else {
   _defer$1 = fallback;
 }
-var setImmediate$1 = wrap(_defer$1);
+var setImmediate$1 = wrap$1(_defer$1);
 function asyncify(func) {
   if (isAsync(func)) {
     return function(...args) {
@@ -34359,7 +34338,7 @@ if (hasNextTick) {
 } else {
   _defer = fallback;
 }
-var nextTick = wrap(_defer);
+var nextTick = wrap$1(_defer);
 var _parallel = awaitify((eachfn, tasks, callback) => {
   var results = isArrayLike(tasks) ? [] : {};
   eachfn(tasks, (task, key, taskCb) => {
@@ -36088,7 +36067,7 @@ function requireBufferList() {
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList2.prototype.join = function join(s) {
+      BufferList2.prototype.join = function join2(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -39539,7 +39518,7 @@ var hasRequiredErrors;
 function requireErrors() {
   if (hasRequiredErrors) return errors;
   hasRequiredErrors = 1;
-  const { format: format2, inspect, AggregateError: CustomAggregateError } = requireUtil$2();
+  const { format: format2, inspect: inspect2, AggregateError: CustomAggregateError } = requireUtil$2();
   const AggregateError = globalThis.AggregateError || CustomAggregateError;
   const kIsNodeError = Symbol("kIsNodeError");
   const kTypes = [
@@ -39747,13 +39726,13 @@ function requireErrors() {
         if ((_actual$constructor = actual.constructor) !== null && _actual$constructor !== void 0 && _actual$constructor.name) {
           msg += `. Received an instance of ${actual.constructor.name}`;
         } else {
-          const inspected = inspect(actual, {
+          const inspected = inspect2(actual, {
             depth: -1
           });
           msg += `. Received ${inspected}`;
         }
       } else {
-        let inspected = inspect(actual, {
+        let inspected = inspect2(actual, {
           colors: false
         });
         if (inspected.length > 25) {
@@ -39768,7 +39747,7 @@ function requireErrors() {
   E(
     "ERR_INVALID_ARG_VALUE",
     (name, value, reason = "is invalid") => {
-      let inspected = inspect(value);
+      let inspected = inspect2(value);
       if (inspected.length > 128) {
         inspected = inspected.slice(0, 128) + "...";
       }
@@ -39825,7 +39804,7 @@ function requireErrors() {
         }
         received += "n";
       } else {
-        received = inspect(input);
+        received = inspect2(input);
       }
       return `The value of "${str}" is out of range. It must be ${range2}. Received ${received}`;
     },
@@ -40986,7 +40965,7 @@ function requireBuffer_list() {
   hasRequiredBuffer_list = 1;
   const { StringPrototypeSlice, SymbolIterator, TypedArrayPrototypeSet, Uint8Array: Uint8Array2 } = requirePrimordials();
   const { Buffer: Buffer2 } = require$$0$h;
-  const { inspect } = requireUtil$2();
+  const { inspect: inspect2 } = requireUtil$2();
   buffer_list = class BufferList {
     constructor() {
       this.head = null;
@@ -41123,7 +41102,7 @@ function requireBuffer_list() {
     }
     // Make sure the linked list only shows the minimal necessary information.
     [Symbol.for("nodejs.util.inspect.custom")](_2, options) {
-      return inspect(this, {
+      return inspect2(this, {
         ...options,
         // Only inspect one level.
         depth: 0,
@@ -54294,10 +54273,10 @@ function requireZipStream() {
  * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
  * @copyright (c) 2012-2014 Chris Talkington, contributors.
  */
-var zip;
+var zip$1;
 var hasRequiredZip;
 function requireZip() {
-  if (hasRequiredZip) return zip;
+  if (hasRequiredZip) return zip$1;
   hasRequiredZip = 1;
   var engine = requireZipStream();
   var util2 = requireArchiverUtils();
@@ -54332,8 +54311,8 @@ function requireZip() {
   Zip.prototype.unpipe = function() {
     return this.engine.unpipe.apply(this.engine, arguments);
   };
-  zip = Zip;
-  return zip;
+  zip$1 = Zip;
+  return zip$1;
 }
 var tarStream = {};
 var queueMicrotask_1;
@@ -55917,16 +55896,16 @@ function requireHeaders() {
     }
     return 0;
   }
-  function indexOf(block, num, offset, end2) {
+  function indexOf(block2, num, offset, end2) {
     for (; offset < end2; offset++) {
-      if (block[offset] === num) return offset;
+      if (block2[offset] === num) return offset;
     }
     return end2;
   }
-  function cksum(block) {
+  function cksum(block2) {
     let sum = 8 * 32;
-    for (let i = 0; i < 148; i++) sum += block[i];
-    for (let j = 156; j < 512; j++) sum += block[j];
+    for (let i = 0; i < 148; i++) sum += block2[i];
+    for (let j = 156; j < 512; j++) sum += block2[j];
     return sum;
   }
   function encodeOct(val, n) {
@@ -56043,7 +56022,7 @@ function requireExtract() {
       return buf.subarray(this._offset, this._offset += size);
     }
   }
-  class Source extends Readable {
+  class Source2 extends Readable {
     constructor(self2, header, offset) {
       super();
       this.header = header;
@@ -56192,7 +56171,7 @@ function requireExtract() {
       return drained;
     }
     _createStream() {
-      return new Source(this, this._header, this._offset);
+      return new Source2(this, this._header, this._offset);
     }
     _update() {
       while (this._buffer.buffered > 0 && !this.destroying) {
@@ -57099,6 +57078,3616 @@ function requireArchiver() {
 }
 var archiverExports = requireArchiver();
 const archiver = /* @__PURE__ */ getDefaultExportFromCjs(archiverExports);
+class ClientError extends Error {
+  response;
+  request;
+  constructor(response, request) {
+    const message = `${ClientError.extractMessage(response)}: ${JSON.stringify({
+      response,
+      request
+    })}`;
+    super(message);
+    Object.setPrototypeOf(this, ClientError.prototype);
+    this.response = response;
+    this.request = request;
+    if (typeof Error.captureStackTrace === `function`) {
+      Error.captureStackTrace(this, ClientError);
+    }
+  }
+  static extractMessage(response) {
+    return response.errors?.[0]?.message ?? `GraphQL Error (Code: ${String(response.status)})`;
+  }
+}
+const uppercase = (str) => str.toUpperCase();
+const callOrIdentity = (value) => {
+  return typeof value === `function` ? value() : value;
+};
+const zip = (a, b) => a.map((k, i) => [k, b[i]]);
+const HeadersInitToPlainObject = (headers2) => {
+  let oHeaders = {};
+  if (headers2 instanceof Headers) {
+    oHeaders = HeadersInstanceToPlainObject(headers2);
+  } else if (Array.isArray(headers2)) {
+    headers2.forEach(([name, value]) => {
+      if (name && value !== void 0) {
+        oHeaders[name] = value;
+      }
+    });
+  } else if (headers2) {
+    oHeaders = headers2;
+  }
+  return oHeaders;
+};
+const HeadersInstanceToPlainObject = (headers2) => {
+  const o = {};
+  headers2.forEach((v, k) => {
+    o[k] = v;
+  });
+  return o;
+};
+const tryCatch = (fn) => {
+  try {
+    const result2 = fn();
+    if (isPromiseLikeValue(result2)) {
+      return result2.catch((error2) => {
+        return errorFromMaybeError(error2);
+      });
+    }
+    return result2;
+  } catch (error2) {
+    return errorFromMaybeError(error2);
+  }
+};
+const errorFromMaybeError = (maybeError) => {
+  if (maybeError instanceof Error)
+    return maybeError;
+  return new Error(String(maybeError));
+};
+const isPromiseLikeValue = (value) => {
+  return typeof value === `object` && value !== null && `then` in value && typeof value.then === `function` && `catch` in value && typeof value.catch === `function` && `finally` in value && typeof value.finally === `function`;
+};
+const casesExhausted = (value) => {
+  throw new Error(`Unhandled case: ${String(value)}`);
+};
+const isPlainObject = (value) => {
+  return typeof value === `object` && value !== null && !Array.isArray(value);
+};
+const parseBatchRequestArgs = (documentsOrOptions, requestHeaders) => {
+  return documentsOrOptions.documents ? documentsOrOptions : {
+    documents: documentsOrOptions,
+    requestHeaders,
+    signal: void 0
+  };
+};
+const parseRawRequestArgs = (queryOrOptions, variables, requestHeaders) => {
+  return queryOrOptions.query ? queryOrOptions : {
+    query: queryOrOptions,
+    variables,
+    requestHeaders,
+    signal: void 0
+  };
+};
+function devAssert(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message);
+  }
+}
+function isObjectLike(value) {
+  return typeof value == "object" && value !== null;
+}
+function invariant(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(
+      "Unexpected invariant triggered."
+    );
+  }
+}
+const LineRegExp = /\r\n|[\n\r]/g;
+function getLocation(source, position) {
+  let lastLineStart = 0;
+  let line = 1;
+  for (const match of source.body.matchAll(LineRegExp)) {
+    typeof match.index === "number" || invariant(false);
+    if (match.index >= position) {
+      break;
+    }
+    lastLineStart = match.index + match[0].length;
+    line += 1;
+  }
+  return {
+    line,
+    column: position + 1 - lastLineStart
+  };
+}
+function printLocation(location) {
+  return printSourceLocation(
+    location.source,
+    getLocation(location.source, location.start)
+  );
+}
+function printSourceLocation(source, sourceLocation) {
+  const firstLineColumnOffset = source.locationOffset.column - 1;
+  const body = "".padStart(firstLineColumnOffset) + source.body;
+  const lineIndex = sourceLocation.line - 1;
+  const lineOffset = source.locationOffset.line - 1;
+  const lineNum = sourceLocation.line + lineOffset;
+  const columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;
+  const columnNum = sourceLocation.column + columnOffset;
+  const locationStr = `${source.name}:${lineNum}:${columnNum}
+`;
+  const lines = body.split(/\r\n|[\n\r]/g);
+  const locationLine = lines[lineIndex];
+  if (locationLine.length > 120) {
+    const subLineIndex = Math.floor(columnNum / 80);
+    const subLineColumnNum = columnNum % 80;
+    const subLines = [];
+    for (let i = 0; i < locationLine.length; i += 80) {
+      subLines.push(locationLine.slice(i, i + 80));
+    }
+    return locationStr + printPrefixedLines([
+      [`${lineNum} |`, subLines[0]],
+      ...subLines.slice(1, subLineIndex + 1).map((subLine) => ["|", subLine]),
+      ["|", "^".padStart(subLineColumnNum)],
+      ["|", subLines[subLineIndex + 1]]
+    ]);
+  }
+  return locationStr + printPrefixedLines([
+    // Lines specified like this: ["prefix", "string"],
+    [`${lineNum - 1} |`, lines[lineIndex - 1]],
+    [`${lineNum} |`, locationLine],
+    ["|", "^".padStart(columnNum)],
+    [`${lineNum + 1} |`, lines[lineIndex + 1]]
+  ]);
+}
+function printPrefixedLines(lines) {
+  const existingLines = lines.filter(([_2, line]) => line !== void 0);
+  const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
+  return existingLines.map(([prefix, line]) => prefix.padStart(padLen) + (line ? " " + line : "")).join("\n");
+}
+function toNormalizedOptions(args) {
+  const firstArg = args[0];
+  if (firstArg == null || "kind" in firstArg || "length" in firstArg) {
+    return {
+      nodes: firstArg,
+      source: args[1],
+      positions: args[2],
+      path: args[3],
+      originalError: args[4],
+      extensions: args[5]
+    };
+  }
+  return firstArg;
+}
+class GraphQLError extends Error {
+  /**
+   * An array of `{ line, column }` locations within the source GraphQL document
+   * which correspond to this error.
+   *
+   * Errors during validation often contain multiple locations, for example to
+   * point out two things with the same name. Errors during execution include a
+   * single location, the field which produced the error.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array describing the JSON-path into the execution response which
+   * corresponds to this error. Only included for errors during execution.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array of GraphQL AST Nodes corresponding to this error.
+   */
+  /**
+   * The source GraphQL document for the first location of this error.
+   *
+   * Note that if this Error represents more than one node, the source may not
+   * represent nodes after the first node.
+   */
+  /**
+   * An array of character offsets within the source GraphQL document
+   * which correspond to this error.
+   */
+  /**
+   * The original error thrown from a field resolver during execution.
+   */
+  /**
+   * Extension fields to add to the formatted error.
+   */
+  /**
+   * @deprecated Please use the `GraphQLErrorOptions` constructor overload instead.
+   */
+  constructor(message, ...rawArgs) {
+    var _this$nodes, _nodeLocations$, _ref;
+    const { nodes, source, positions, path: path2, originalError, extensions } = toNormalizedOptions(rawArgs);
+    super(message);
+    this.name = "GraphQLError";
+    this.path = path2 !== null && path2 !== void 0 ? path2 : void 0;
+    this.originalError = originalError !== null && originalError !== void 0 ? originalError : void 0;
+    this.nodes = undefinedIfEmpty(
+      Array.isArray(nodes) ? nodes : nodes ? [nodes] : void 0
+    );
+    const nodeLocations = undefinedIfEmpty(
+      (_this$nodes = this.nodes) === null || _this$nodes === void 0 ? void 0 : _this$nodes.map((node2) => node2.loc).filter((loc) => loc != null)
+    );
+    this.source = source !== null && source !== void 0 ? source : nodeLocations === null || nodeLocations === void 0 ? void 0 : (_nodeLocations$ = nodeLocations[0]) === null || _nodeLocations$ === void 0 ? void 0 : _nodeLocations$.source;
+    this.positions = positions !== null && positions !== void 0 ? positions : nodeLocations === null || nodeLocations === void 0 ? void 0 : nodeLocations.map((loc) => loc.start);
+    this.locations = positions && source ? positions.map((pos) => getLocation(source, pos)) : nodeLocations === null || nodeLocations === void 0 ? void 0 : nodeLocations.map((loc) => getLocation(loc.source, loc.start));
+    const originalExtensions = isObjectLike(
+      originalError === null || originalError === void 0 ? void 0 : originalError.extensions
+    ) ? originalError === null || originalError === void 0 ? void 0 : originalError.extensions : void 0;
+    this.extensions = (_ref = extensions !== null && extensions !== void 0 ? extensions : originalExtensions) !== null && _ref !== void 0 ? _ref : /* @__PURE__ */ Object.create(null);
+    Object.defineProperties(this, {
+      message: {
+        writable: true,
+        enumerable: true
+      },
+      name: {
+        enumerable: false
+      },
+      nodes: {
+        enumerable: false
+      },
+      source: {
+        enumerable: false
+      },
+      positions: {
+        enumerable: false
+      },
+      originalError: {
+        enumerable: false
+      }
+    });
+    if (originalError !== null && originalError !== void 0 && originalError.stack) {
+      Object.defineProperty(this, "stack", {
+        value: originalError.stack,
+        writable: true,
+        configurable: true
+      });
+    } else if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, GraphQLError);
+    } else {
+      Object.defineProperty(this, "stack", {
+        value: Error().stack,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+  toString() {
+    let output = this.message;
+    if (this.nodes) {
+      for (const node2 of this.nodes) {
+        if (node2.loc) {
+          output += "\n\n" + printLocation(node2.loc);
+        }
+      }
+    } else if (this.source && this.locations) {
+      for (const location of this.locations) {
+        output += "\n\n" + printSourceLocation(this.source, location);
+      }
+    }
+    return output;
+  }
+  toJSON() {
+    const formattedError = {
+      message: this.message
+    };
+    if (this.locations != null) {
+      formattedError.locations = this.locations;
+    }
+    if (this.path != null) {
+      formattedError.path = this.path;
+    }
+    if (this.extensions != null && Object.keys(this.extensions).length > 0) {
+      formattedError.extensions = this.extensions;
+    }
+    return formattedError;
+  }
+}
+function undefinedIfEmpty(array) {
+  return array === void 0 || array.length === 0 ? void 0 : array;
+}
+function syntaxError(source, position, description2) {
+  return new GraphQLError(`Syntax Error: ${description2}`, {
+    source,
+    positions: [position]
+  });
+}
+class Location {
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The Token at which this Node begins.
+   */
+  /**
+   * The Token at which this Node ends.
+   */
+  /**
+   * The Source document the AST represents.
+   */
+  constructor(startToken, endToken, source) {
+    this.start = startToken.start;
+    this.end = endToken.end;
+    this.startToken = startToken;
+    this.endToken = endToken;
+    this.source = source;
+  }
+  get [Symbol.toStringTag]() {
+    return "Location";
+  }
+  toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  }
+}
+class Token {
+  /**
+   * The kind of Token.
+   */
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The 1-indexed line number on which this Token appears.
+   */
+  /**
+   * The 1-indexed column number at which this Token begins.
+   */
+  /**
+   * For non-punctuation tokens, represents the interpreted value of the token.
+   *
+   * Note: is undefined for punctuation tokens, but typed as string for
+   * convenience in the parser.
+   */
+  /**
+   * Tokens exist as nodes in a double-linked-list amongst all tokens
+   * including ignored tokens. <SOF> is always the first node and <EOF>
+   * the last.
+   */
+  constructor(kind, start, end2, line, column, value) {
+    this.kind = kind;
+    this.start = start;
+    this.end = end2;
+    this.line = line;
+    this.column = column;
+    this.value = value;
+    this.prev = null;
+    this.next = null;
+  }
+  get [Symbol.toStringTag]() {
+    return "Token";
+  }
+  toJSON() {
+    return {
+      kind: this.kind,
+      value: this.value,
+      line: this.line,
+      column: this.column
+    };
+  }
+}
+const QueryDocumentKeys = {
+  Name: [],
+  Document: ["definitions"],
+  OperationDefinition: [
+    "name",
+    "variableDefinitions",
+    "directives",
+    "selectionSet"
+  ],
+  VariableDefinition: ["variable", "type", "defaultValue", "directives"],
+  Variable: ["name"],
+  SelectionSet: ["selections"],
+  Field: ["alias", "name", "arguments", "directives", "selectionSet"],
+  Argument: ["name", "value"],
+  FragmentSpread: ["name", "directives"],
+  InlineFragment: ["typeCondition", "directives", "selectionSet"],
+  FragmentDefinition: [
+    "name",
+    // Note: fragment variable definitions are deprecated and will removed in v17.0.0
+    "variableDefinitions",
+    "typeCondition",
+    "directives",
+    "selectionSet"
+  ],
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ["values"],
+  ObjectValue: ["fields"],
+  ObjectField: ["name", "value"],
+  Directive: ["name", "arguments"],
+  NamedType: ["name"],
+  ListType: ["type"],
+  NonNullType: ["type"],
+  SchemaDefinition: ["description", "directives", "operationTypes"],
+  OperationTypeDefinition: ["type"],
+  ScalarTypeDefinition: ["description", "name", "directives"],
+  ObjectTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  FieldDefinition: ["description", "name", "arguments", "type", "directives"],
+  InputValueDefinition: [
+    "description",
+    "name",
+    "type",
+    "defaultValue",
+    "directives"
+  ],
+  InterfaceTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  UnionTypeDefinition: ["description", "name", "directives", "types"],
+  EnumTypeDefinition: ["description", "name", "directives", "values"],
+  EnumValueDefinition: ["description", "name", "directives"],
+  InputObjectTypeDefinition: ["description", "name", "directives", "fields"],
+  DirectiveDefinition: ["description", "name", "arguments", "locations"],
+  SchemaExtension: ["directives", "operationTypes"],
+  ScalarTypeExtension: ["name", "directives"],
+  ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
+  InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
+  UnionTypeExtension: ["name", "directives", "types"],
+  EnumTypeExtension: ["name", "directives", "values"],
+  InputObjectTypeExtension: ["name", "directives", "fields"]
+};
+const kindValues = new Set(Object.keys(QueryDocumentKeys));
+function isNode(maybeNode) {
+  const maybeKind = maybeNode === null || maybeNode === void 0 ? void 0 : maybeNode.kind;
+  return typeof maybeKind === "string" && kindValues.has(maybeKind);
+}
+var OperationTypeNode;
+(function(OperationTypeNode2) {
+  OperationTypeNode2["QUERY"] = "query";
+  OperationTypeNode2["MUTATION"] = "mutation";
+  OperationTypeNode2["SUBSCRIPTION"] = "subscription";
+})(OperationTypeNode || (OperationTypeNode = {}));
+var DirectiveLocation;
+(function(DirectiveLocation2) {
+  DirectiveLocation2["QUERY"] = "QUERY";
+  DirectiveLocation2["MUTATION"] = "MUTATION";
+  DirectiveLocation2["SUBSCRIPTION"] = "SUBSCRIPTION";
+  DirectiveLocation2["FIELD"] = "FIELD";
+  DirectiveLocation2["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION";
+  DirectiveLocation2["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD";
+  DirectiveLocation2["INLINE_FRAGMENT"] = "INLINE_FRAGMENT";
+  DirectiveLocation2["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION";
+  DirectiveLocation2["SCHEMA"] = "SCHEMA";
+  DirectiveLocation2["SCALAR"] = "SCALAR";
+  DirectiveLocation2["OBJECT"] = "OBJECT";
+  DirectiveLocation2["FIELD_DEFINITION"] = "FIELD_DEFINITION";
+  DirectiveLocation2["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION";
+  DirectiveLocation2["INTERFACE"] = "INTERFACE";
+  DirectiveLocation2["UNION"] = "UNION";
+  DirectiveLocation2["ENUM"] = "ENUM";
+  DirectiveLocation2["ENUM_VALUE"] = "ENUM_VALUE";
+  DirectiveLocation2["INPUT_OBJECT"] = "INPUT_OBJECT";
+  DirectiveLocation2["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
+})(DirectiveLocation || (DirectiveLocation = {}));
+var Kind;
+(function(Kind2) {
+  Kind2["NAME"] = "Name";
+  Kind2["DOCUMENT"] = "Document";
+  Kind2["OPERATION_DEFINITION"] = "OperationDefinition";
+  Kind2["VARIABLE_DEFINITION"] = "VariableDefinition";
+  Kind2["SELECTION_SET"] = "SelectionSet";
+  Kind2["FIELD"] = "Field";
+  Kind2["ARGUMENT"] = "Argument";
+  Kind2["FRAGMENT_SPREAD"] = "FragmentSpread";
+  Kind2["INLINE_FRAGMENT"] = "InlineFragment";
+  Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition";
+  Kind2["VARIABLE"] = "Variable";
+  Kind2["INT"] = "IntValue";
+  Kind2["FLOAT"] = "FloatValue";
+  Kind2["STRING"] = "StringValue";
+  Kind2["BOOLEAN"] = "BooleanValue";
+  Kind2["NULL"] = "NullValue";
+  Kind2["ENUM"] = "EnumValue";
+  Kind2["LIST"] = "ListValue";
+  Kind2["OBJECT"] = "ObjectValue";
+  Kind2["OBJECT_FIELD"] = "ObjectField";
+  Kind2["DIRECTIVE"] = "Directive";
+  Kind2["NAMED_TYPE"] = "NamedType";
+  Kind2["LIST_TYPE"] = "ListType";
+  Kind2["NON_NULL_TYPE"] = "NonNullType";
+  Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition";
+  Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
+  Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
+  Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
+  Kind2["FIELD_DEFINITION"] = "FieldDefinition";
+  Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
+  Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
+  Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
+  Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
+  Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
+  Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
+  Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
+  Kind2["SCHEMA_EXTENSION"] = "SchemaExtension";
+  Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
+  Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
+  Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
+  Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
+  Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
+  Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
+})(Kind || (Kind = {}));
+function isWhiteSpace(code2) {
+  return code2 === 9 || code2 === 32;
+}
+function isDigit(code2) {
+  return code2 >= 48 && code2 <= 57;
+}
+function isLetter(code2) {
+  return code2 >= 97 && code2 <= 122 || // A-Z
+  code2 >= 65 && code2 <= 90;
+}
+function isNameStart(code2) {
+  return isLetter(code2) || code2 === 95;
+}
+function isNameContinue(code2) {
+  return isLetter(code2) || isDigit(code2) || code2 === 95;
+}
+function dedentBlockStringLines(lines) {
+  var _firstNonEmptyLine2;
+  let commonIndent = Number.MAX_SAFE_INTEGER;
+  let firstNonEmptyLine = null;
+  let lastNonEmptyLine = -1;
+  for (let i = 0; i < lines.length; ++i) {
+    var _firstNonEmptyLine;
+    const line = lines[i];
+    const indent2 = leadingWhitespace(line);
+    if (indent2 === line.length) {
+      continue;
+    }
+    firstNonEmptyLine = (_firstNonEmptyLine = firstNonEmptyLine) !== null && _firstNonEmptyLine !== void 0 ? _firstNonEmptyLine : i;
+    lastNonEmptyLine = i;
+    if (i !== 0 && indent2 < commonIndent) {
+      commonIndent = indent2;
+    }
+  }
+  return lines.map((line, i) => i === 0 ? line : line.slice(commonIndent)).slice(
+    (_firstNonEmptyLine2 = firstNonEmptyLine) !== null && _firstNonEmptyLine2 !== void 0 ? _firstNonEmptyLine2 : 0,
+    lastNonEmptyLine + 1
+  );
+}
+function leadingWhitespace(str) {
+  let i = 0;
+  while (i < str.length && isWhiteSpace(str.charCodeAt(i))) {
+    ++i;
+  }
+  return i;
+}
+function printBlockString(value, options) {
+  const escapedValue = value.replace(/"""/g, '\\"""');
+  const lines = escapedValue.split(/\r\n|[\n\r]/g);
+  const isSingleLine = lines.length === 1;
+  const forceLeadingNewLine = lines.length > 1 && lines.slice(1).every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0)));
+  const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""');
+  const hasTrailingQuote = value.endsWith('"') && !hasTrailingTripleQuotes;
+  const hasTrailingSlash = value.endsWith("\\");
+  const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
+  const printAsMultipleLines = (
+    // add leading and trailing new lines only if it improves readability
+    !isSingleLine || value.length > 70 || forceTrailingNewline || forceLeadingNewLine || hasTrailingTripleQuotes
+  );
+  let result2 = "";
+  const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0));
+  if (printAsMultipleLines && !skipLeadingNewLine || forceLeadingNewLine) {
+    result2 += "\n";
+  }
+  result2 += escapedValue;
+  if (printAsMultipleLines || forceTrailingNewline) {
+    result2 += "\n";
+  }
+  return '"""' + result2 + '"""';
+}
+var TokenKind;
+(function(TokenKind2) {
+  TokenKind2["SOF"] = "<SOF>";
+  TokenKind2["EOF"] = "<EOF>";
+  TokenKind2["BANG"] = "!";
+  TokenKind2["DOLLAR"] = "$";
+  TokenKind2["AMP"] = "&";
+  TokenKind2["PAREN_L"] = "(";
+  TokenKind2["PAREN_R"] = ")";
+  TokenKind2["SPREAD"] = "...";
+  TokenKind2["COLON"] = ":";
+  TokenKind2["EQUALS"] = "=";
+  TokenKind2["AT"] = "@";
+  TokenKind2["BRACKET_L"] = "[";
+  TokenKind2["BRACKET_R"] = "]";
+  TokenKind2["BRACE_L"] = "{";
+  TokenKind2["PIPE"] = "|";
+  TokenKind2["BRACE_R"] = "}";
+  TokenKind2["NAME"] = "Name";
+  TokenKind2["INT"] = "Int";
+  TokenKind2["FLOAT"] = "Float";
+  TokenKind2["STRING"] = "String";
+  TokenKind2["BLOCK_STRING"] = "BlockString";
+  TokenKind2["COMMENT"] = "Comment";
+})(TokenKind || (TokenKind = {}));
+class Lexer {
+  /**
+   * The previously focused non-ignored token.
+   */
+  /**
+   * The currently focused non-ignored token.
+   */
+  /**
+   * The (1-indexed) line containing the current token.
+   */
+  /**
+   * The character offset at which the current line begins.
+   */
+  constructor(source) {
+    const startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0);
+    this.source = source;
+    this.lastToken = startOfFileToken;
+    this.token = startOfFileToken;
+    this.line = 1;
+    this.lineStart = 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "Lexer";
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+  advance() {
+    this.lastToken = this.token;
+    const token = this.token = this.lookahead();
+    return token;
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the state of Lexer.
+   */
+  lookahead() {
+    let token = this.token;
+    if (token.kind !== TokenKind.EOF) {
+      do {
+        if (token.next) {
+          token = token.next;
+        } else {
+          const nextToken = readNextToken(this, token.end);
+          token.next = nextToken;
+          nextToken.prev = token;
+          token = nextToken;
+        }
+      } while (token.kind === TokenKind.COMMENT);
+    }
+    return token;
+  }
+}
+function isPunctuatorTokenKind(kind) {
+  return kind === TokenKind.BANG || kind === TokenKind.DOLLAR || kind === TokenKind.AMP || kind === TokenKind.PAREN_L || kind === TokenKind.PAREN_R || kind === TokenKind.SPREAD || kind === TokenKind.COLON || kind === TokenKind.EQUALS || kind === TokenKind.AT || kind === TokenKind.BRACKET_L || kind === TokenKind.BRACKET_R || kind === TokenKind.BRACE_L || kind === TokenKind.PIPE || kind === TokenKind.BRACE_R;
+}
+function isUnicodeScalarValue(code2) {
+  return code2 >= 0 && code2 <= 55295 || code2 >= 57344 && code2 <= 1114111;
+}
+function isSupplementaryCodePoint(body, location) {
+  return isLeadingSurrogate(body.charCodeAt(location)) && isTrailingSurrogate(body.charCodeAt(location + 1));
+}
+function isLeadingSurrogate(code2) {
+  return code2 >= 55296 && code2 <= 56319;
+}
+function isTrailingSurrogate(code2) {
+  return code2 >= 56320 && code2 <= 57343;
+}
+function printCodePointAt(lexer, location) {
+  const code2 = lexer.source.body.codePointAt(location);
+  if (code2 === void 0) {
+    return TokenKind.EOF;
+  } else if (code2 >= 32 && code2 <= 126) {
+    const char = String.fromCodePoint(code2);
+    return char === '"' ? `'"'` : `"${char}"`;
+  }
+  return "U+" + code2.toString(16).toUpperCase().padStart(4, "0");
+}
+function createToken(lexer, kind, start, end2, value) {
+  const line = lexer.line;
+  const col = 1 + start - lexer.lineStart;
+  return new Token(kind, start, end2, line, col, value);
+}
+function readNextToken(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start;
+  while (position < bodyLength) {
+    const code2 = body.charCodeAt(position);
+    switch (code2) {
+      // Ignored ::
+      //   - UnicodeBOM
+      //   - WhiteSpace
+      //   - LineTerminator
+      //   - Comment
+      //   - Comma
+      //
+      // UnicodeBOM :: "Byte Order Mark (U+FEFF)"
+      //
+      // WhiteSpace ::
+      //   - "Horizontal Tab (U+0009)"
+      //   - "Space (U+0020)"
+      //
+      // Comma :: ,
+      case 65279:
+      // <BOM>
+      case 9:
+      // \t
+      case 32:
+      // <space>
+      case 44:
+        ++position;
+        continue;
+      // LineTerminator ::
+      //   - "New Line (U+000A)"
+      //   - "Carriage Return (U+000D)" [lookahead != "New Line (U+000A)"]
+      //   - "Carriage Return (U+000D)" "New Line (U+000A)"
+      case 10:
+        ++position;
+        ++lexer.line;
+        lexer.lineStart = position;
+        continue;
+      case 13:
+        if (body.charCodeAt(position + 1) === 10) {
+          position += 2;
+        } else {
+          ++position;
+        }
+        ++lexer.line;
+        lexer.lineStart = position;
+        continue;
+      // Comment
+      case 35:
+        return readComment(lexer, position);
+      // Token ::
+      //   - Punctuator
+      //   - Name
+      //   - IntValue
+      //   - FloatValue
+      //   - StringValue
+      //
+      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      case 33:
+        return createToken(lexer, TokenKind.BANG, position, position + 1);
+      case 36:
+        return createToken(lexer, TokenKind.DOLLAR, position, position + 1);
+      case 38:
+        return createToken(lexer, TokenKind.AMP, position, position + 1);
+      case 40:
+        return createToken(lexer, TokenKind.PAREN_L, position, position + 1);
+      case 41:
+        return createToken(lexer, TokenKind.PAREN_R, position, position + 1);
+      case 46:
+        if (body.charCodeAt(position + 1) === 46 && body.charCodeAt(position + 2) === 46) {
+          return createToken(lexer, TokenKind.SPREAD, position, position + 3);
+        }
+        break;
+      case 58:
+        return createToken(lexer, TokenKind.COLON, position, position + 1);
+      case 61:
+        return createToken(lexer, TokenKind.EQUALS, position, position + 1);
+      case 64:
+        return createToken(lexer, TokenKind.AT, position, position + 1);
+      case 91:
+        return createToken(lexer, TokenKind.BRACKET_L, position, position + 1);
+      case 93:
+        return createToken(lexer, TokenKind.BRACKET_R, position, position + 1);
+      case 123:
+        return createToken(lexer, TokenKind.BRACE_L, position, position + 1);
+      case 124:
+        return createToken(lexer, TokenKind.PIPE, position, position + 1);
+      case 125:
+        return createToken(lexer, TokenKind.BRACE_R, position, position + 1);
+      // StringValue
+      case 34:
+        if (body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) {
+          return readBlockString(lexer, position);
+        }
+        return readString(lexer, position);
+    }
+    if (isDigit(code2) || code2 === 45) {
+      return readNumber(lexer, position, code2);
+    }
+    if (isNameStart(code2)) {
+      return readName(lexer, position);
+    }
+    throw syntaxError(
+      lexer.source,
+      position,
+      code2 === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : isUnicodeScalarValue(code2) || isSupplementaryCodePoint(body, position) ? `Unexpected character: ${printCodePointAt(lexer, position)}.` : `Invalid character: ${printCodePointAt(lexer, position)}.`
+    );
+  }
+  return createToken(lexer, TokenKind.EOF, bodyLength, bodyLength);
+}
+function readComment(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start + 1;
+  while (position < bodyLength) {
+    const code2 = body.charCodeAt(position);
+    if (code2 === 10 || code2 === 13) {
+      break;
+    }
+    if (isUnicodeScalarValue(code2)) {
+      ++position;
+    } else if (isSupplementaryCodePoint(body, position)) {
+      position += 2;
+    } else {
+      break;
+    }
+  }
+  return createToken(
+    lexer,
+    TokenKind.COMMENT,
+    start,
+    position,
+    body.slice(start + 1, position)
+  );
+}
+function readNumber(lexer, start, firstCode) {
+  const body = lexer.source.body;
+  let position = start;
+  let code2 = firstCode;
+  let isFloat = false;
+  if (code2 === 45) {
+    code2 = body.charCodeAt(++position);
+  }
+  if (code2 === 48) {
+    code2 = body.charCodeAt(++position);
+    if (isDigit(code2)) {
+      throw syntaxError(
+        lexer.source,
+        position,
+        `Invalid number, unexpected digit after 0: ${printCodePointAt(
+          lexer,
+          position
+        )}.`
+      );
+    }
+  } else {
+    position = readDigits(lexer, position, code2);
+    code2 = body.charCodeAt(position);
+  }
+  if (code2 === 46) {
+    isFloat = true;
+    code2 = body.charCodeAt(++position);
+    position = readDigits(lexer, position, code2);
+    code2 = body.charCodeAt(position);
+  }
+  if (code2 === 69 || code2 === 101) {
+    isFloat = true;
+    code2 = body.charCodeAt(++position);
+    if (code2 === 43 || code2 === 45) {
+      code2 = body.charCodeAt(++position);
+    }
+    position = readDigits(lexer, position, code2);
+    code2 = body.charCodeAt(position);
+  }
+  if (code2 === 46 || isNameStart(code2)) {
+    throw syntaxError(
+      lexer.source,
+      position,
+      `Invalid number, expected digit but got: ${printCodePointAt(
+        lexer,
+        position
+      )}.`
+    );
+  }
+  return createToken(
+    lexer,
+    isFloat ? TokenKind.FLOAT : TokenKind.INT,
+    start,
+    position,
+    body.slice(start, position)
+  );
+}
+function readDigits(lexer, start, firstCode) {
+  if (!isDigit(firstCode)) {
+    throw syntaxError(
+      lexer.source,
+      start,
+      `Invalid number, expected digit but got: ${printCodePointAt(
+        lexer,
+        start
+      )}.`
+    );
+  }
+  const body = lexer.source.body;
+  let position = start + 1;
+  while (isDigit(body.charCodeAt(position))) {
+    ++position;
+  }
+  return position;
+}
+function readString(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start + 1;
+  let chunkStart = position;
+  let value = "";
+  while (position < bodyLength) {
+    const code2 = body.charCodeAt(position);
+    if (code2 === 34) {
+      value += body.slice(chunkStart, position);
+      return createToken(lexer, TokenKind.STRING, start, position + 1, value);
+    }
+    if (code2 === 92) {
+      value += body.slice(chunkStart, position);
+      const escape2 = body.charCodeAt(position + 1) === 117 ? body.charCodeAt(position + 2) === 123 ? readEscapedUnicodeVariableWidth(lexer, position) : readEscapedUnicodeFixedWidth(lexer, position) : readEscapedCharacter(lexer, position);
+      value += escape2.value;
+      position += escape2.size;
+      chunkStart = position;
+      continue;
+    }
+    if (code2 === 10 || code2 === 13) {
+      break;
+    }
+    if (isUnicodeScalarValue(code2)) {
+      ++position;
+    } else if (isSupplementaryCodePoint(body, position)) {
+      position += 2;
+    } else {
+      throw syntaxError(
+        lexer.source,
+        position,
+        `Invalid character within String: ${printCodePointAt(
+          lexer,
+          position
+        )}.`
+      );
+    }
+  }
+  throw syntaxError(lexer.source, position, "Unterminated string.");
+}
+function readEscapedUnicodeVariableWidth(lexer, position) {
+  const body = lexer.source.body;
+  let point = 0;
+  let size = 3;
+  while (size < 12) {
+    const code2 = body.charCodeAt(position + size++);
+    if (code2 === 125) {
+      if (size < 5 || !isUnicodeScalarValue(point)) {
+        break;
+      }
+      return {
+        value: String.fromCodePoint(point),
+        size
+      };
+    }
+    point = point << 4 | readHexDigit(code2);
+    if (point < 0) {
+      break;
+    }
+  }
+  throw syntaxError(
+    lexer.source,
+    position,
+    `Invalid Unicode escape sequence: "${body.slice(
+      position,
+      position + size
+    )}".`
+  );
+}
+function readEscapedUnicodeFixedWidth(lexer, position) {
+  const body = lexer.source.body;
+  const code2 = read16BitHexCode(body, position + 2);
+  if (isUnicodeScalarValue(code2)) {
+    return {
+      value: String.fromCodePoint(code2),
+      size: 6
+    };
+  }
+  if (isLeadingSurrogate(code2)) {
+    if (body.charCodeAt(position + 6) === 92 && body.charCodeAt(position + 7) === 117) {
+      const trailingCode = read16BitHexCode(body, position + 8);
+      if (isTrailingSurrogate(trailingCode)) {
+        return {
+          value: String.fromCodePoint(code2, trailingCode),
+          size: 12
+        };
+      }
+    }
+  }
+  throw syntaxError(
+    lexer.source,
+    position,
+    `Invalid Unicode escape sequence: "${body.slice(position, position + 6)}".`
+  );
+}
+function read16BitHexCode(body, position) {
+  return readHexDigit(body.charCodeAt(position)) << 12 | readHexDigit(body.charCodeAt(position + 1)) << 8 | readHexDigit(body.charCodeAt(position + 2)) << 4 | readHexDigit(body.charCodeAt(position + 3));
+}
+function readHexDigit(code2) {
+  return code2 >= 48 && code2 <= 57 ? code2 - 48 : code2 >= 65 && code2 <= 70 ? code2 - 55 : code2 >= 97 && code2 <= 102 ? code2 - 87 : -1;
+}
+function readEscapedCharacter(lexer, position) {
+  const body = lexer.source.body;
+  const code2 = body.charCodeAt(position + 1);
+  switch (code2) {
+    case 34:
+      return {
+        value: '"',
+        size: 2
+      };
+    case 92:
+      return {
+        value: "\\",
+        size: 2
+      };
+    case 47:
+      return {
+        value: "/",
+        size: 2
+      };
+    case 98:
+      return {
+        value: "\b",
+        size: 2
+      };
+    case 102:
+      return {
+        value: "\f",
+        size: 2
+      };
+    case 110:
+      return {
+        value: "\n",
+        size: 2
+      };
+    case 114:
+      return {
+        value: "\r",
+        size: 2
+      };
+    case 116:
+      return {
+        value: "	",
+        size: 2
+      };
+  }
+  throw syntaxError(
+    lexer.source,
+    position,
+    `Invalid character escape sequence: "${body.slice(
+      position,
+      position + 2
+    )}".`
+  );
+}
+function readBlockString(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let lineStart = lexer.lineStart;
+  let position = start + 3;
+  let chunkStart = position;
+  let currentLine = "";
+  const blockLines = [];
+  while (position < bodyLength) {
+    const code2 = body.charCodeAt(position);
+    if (code2 === 34 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) {
+      currentLine += body.slice(chunkStart, position);
+      blockLines.push(currentLine);
+      const token = createToken(
+        lexer,
+        TokenKind.BLOCK_STRING,
+        start,
+        position + 3,
+        // Return a string of the lines joined with U+000A.
+        dedentBlockStringLines(blockLines).join("\n")
+      );
+      lexer.line += blockLines.length - 1;
+      lexer.lineStart = lineStart;
+      return token;
+    }
+    if (code2 === 92 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34 && body.charCodeAt(position + 3) === 34) {
+      currentLine += body.slice(chunkStart, position);
+      chunkStart = position + 1;
+      position += 4;
+      continue;
+    }
+    if (code2 === 10 || code2 === 13) {
+      currentLine += body.slice(chunkStart, position);
+      blockLines.push(currentLine);
+      if (code2 === 13 && body.charCodeAt(position + 1) === 10) {
+        position += 2;
+      } else {
+        ++position;
+      }
+      currentLine = "";
+      chunkStart = position;
+      lineStart = position;
+      continue;
+    }
+    if (isUnicodeScalarValue(code2)) {
+      ++position;
+    } else if (isSupplementaryCodePoint(body, position)) {
+      position += 2;
+    } else {
+      throw syntaxError(
+        lexer.source,
+        position,
+        `Invalid character within String: ${printCodePointAt(
+          lexer,
+          position
+        )}.`
+      );
+    }
+  }
+  throw syntaxError(lexer.source, position, "Unterminated string.");
+}
+function readName(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start + 1;
+  while (position < bodyLength) {
+    const code2 = body.charCodeAt(position);
+    if (isNameContinue(code2)) {
+      ++position;
+    } else {
+      break;
+    }
+  }
+  return createToken(
+    lexer,
+    TokenKind.NAME,
+    start,
+    position,
+    body.slice(start, position)
+  );
+}
+const MAX_ARRAY_LENGTH = 10;
+const MAX_RECURSIVE_DEPTH = 2;
+function inspect(value) {
+  return formatValue(value, []);
+}
+function formatValue(value, seenValues) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "function":
+      return value.name ? `[function ${value.name}]` : "[function]";
+    case "object":
+      return formatObjectValue(value, seenValues);
+    default:
+      return String(value);
+  }
+}
+function formatObjectValue(value, previouslySeenValues) {
+  if (value === null) {
+    return "null";
+  }
+  if (previouslySeenValues.includes(value)) {
+    return "[Circular]";
+  }
+  const seenValues = [...previouslySeenValues, value];
+  if (isJSONable(value)) {
+    const jsonValue = value.toJSON();
+    if (jsonValue !== value) {
+      return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+  return formatObject(value, seenValues);
+}
+function isJSONable(value) {
+  return typeof value.toJSON === "function";
+}
+function formatObject(object, seenValues) {
+  const entries = Object.entries(object);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[" + getObjectTag(object) + "]";
+  }
+  const properties2 = entries.map(
+    ([key, value]) => key + ": " + formatValue(value, seenValues)
+  );
+  return "{ " + properties2.join(", ") + " }";
+}
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return "[]";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[Array]";
+  }
+  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  const remaining = array.length - len;
+  const items2 = [];
+  for (let i = 0; i < len; ++i) {
+    items2.push(formatValue(array[i], seenValues));
+  }
+  if (remaining === 1) {
+    items2.push("... 1 more item");
+  } else if (remaining > 1) {
+    items2.push(`... ${remaining} more items`);
+  }
+  return "[" + items2.join(", ") + "]";
+}
+function getObjectTag(object) {
+  const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
+  if (tag === "Object" && typeof object.constructor === "function") {
+    const name = object.constructor.name;
+    if (typeof name === "string" && name !== "") {
+      return name;
+    }
+  }
+  return tag;
+}
+const isProduction = globalThis.process && // eslint-disable-next-line no-undef
+process.env.NODE_ENV === "production";
+const instanceOf = (
+  /* c8 ignore next 6 */
+  // FIXME: https://github.com/graphql/graphql-js/issues/2317
+  isProduction ? function instanceOf2(value, constructor) {
+    return value instanceof constructor;
+  } : function instanceOf3(value, constructor) {
+    if (value instanceof constructor) {
+      return true;
+    }
+    if (typeof value === "object" && value !== null) {
+      var _value$constructor;
+      const className = constructor.prototype[Symbol.toStringTag];
+      const valueClassName = (
+        // We still need to support constructor's name to detect conflicts with older versions of this library.
+        Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name
+      );
+      if (className === valueClassName) {
+        const stringifiedValue = inspect(value);
+        throw new Error(`Cannot use ${className} "${stringifiedValue}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`);
+      }
+    }
+    return false;
+  }
+);
+class Source {
+  constructor(body, name = "GraphQL request", locationOffset = {
+    line: 1,
+    column: 1
+  }) {
+    typeof body === "string" || devAssert(false, `Body must be a string. Received: ${inspect(body)}.`);
+    this.body = body;
+    this.name = name;
+    this.locationOffset = locationOffset;
+    this.locationOffset.line > 0 || devAssert(
+      false,
+      "line in locationOffset is 1-indexed and must be positive."
+    );
+    this.locationOffset.column > 0 || devAssert(
+      false,
+      "column in locationOffset is 1-indexed and must be positive."
+    );
+  }
+  get [Symbol.toStringTag]() {
+    return "Source";
+  }
+}
+function isSource(source) {
+  return instanceOf(source, Source);
+}
+function parse(source, options) {
+  const parser2 = new Parser(source, options);
+  const document = parser2.parseDocument();
+  Object.defineProperty(document, "tokenCount", {
+    enumerable: false,
+    value: parser2.tokenCount
+  });
+  return document;
+}
+class Parser {
+  constructor(source, options = {}) {
+    const sourceObj = isSource(source) ? source : new Source(source);
+    this._lexer = new Lexer(sourceObj);
+    this._options = options;
+    this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   */
+  parseName() {
+    const token = this.expectToken(TokenKind.NAME);
+    return this.node(token, {
+      kind: Kind.NAME,
+      value: token.value
+    });
+  }
+  // Implements the parsing rules in the Document section.
+  /**
+   * Document : Definition+
+   */
+  parseDocument() {
+    return this.node(this._lexer.token, {
+      kind: Kind.DOCUMENT,
+      definitions: this.many(
+        TokenKind.SOF,
+        this.parseDefinition,
+        TokenKind.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   */
+  parseDefinition() {
+    if (this.peek(TokenKind.BRACE_L)) {
+      return this.parseOperationDefinition();
+    }
+    const hasDescription = this.peekDescription();
+    const keywordToken = hasDescription ? this._lexer.lookahead() : this._lexer.token;
+    if (keywordToken.kind === TokenKind.NAME) {
+      switch (keywordToken.value) {
+        case "schema":
+          return this.parseSchemaDefinition();
+        case "scalar":
+          return this.parseScalarTypeDefinition();
+        case "type":
+          return this.parseObjectTypeDefinition();
+        case "interface":
+          return this.parseInterfaceTypeDefinition();
+        case "union":
+          return this.parseUnionTypeDefinition();
+        case "enum":
+          return this.parseEnumTypeDefinition();
+        case "input":
+          return this.parseInputObjectTypeDefinition();
+        case "directive":
+          return this.parseDirectiveDefinition();
+      }
+      if (hasDescription) {
+        throw syntaxError(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, descriptions are supported only on type definitions."
+        );
+      }
+      switch (keywordToken.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+        case "extend":
+          return this.parseTypeSystemExtension();
+      }
+    }
+    throw this.unexpected(keywordToken);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   */
+  parseOperationDefinition() {
+    const start = this._lexer.token;
+    if (this.peek(TokenKind.BRACE_L)) {
+      return this.node(start, {
+        kind: Kind.OPERATION_DEFINITION,
+        operation: OperationTypeNode.QUERY,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    }
+    const operation = this.parseOperationType();
+    let name;
+    if (this.peek(TokenKind.NAME)) {
+      name = this.parseName();
+    }
+    return this.node(start, {
+      kind: Kind.OPERATION_DEFINITION,
+      operation,
+      name,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   */
+  parseOperationType() {
+    const operationToken = this.expectToken(TokenKind.NAME);
+    switch (operationToken.value) {
+      case "query":
+        return OperationTypeNode.QUERY;
+      case "mutation":
+        return OperationTypeNode.MUTATION;
+      case "subscription":
+        return OperationTypeNode.SUBSCRIPTION;
+    }
+    throw this.unexpected(operationToken);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      TokenKind.PAREN_L,
+      this.parseVariableDefinition,
+      TokenKind.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: Kind.VARIABLE_DEFINITION,
+      variable: this.parseVariable(),
+      type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(TokenKind.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   */
+  parseVariable() {
+    const start = this._lexer.token;
+    this.expectToken(TokenKind.DOLLAR);
+    return this.node(start, {
+      kind: Kind.VARIABLE,
+      name: this.parseName()
+    });
+  }
+  /**
+   * ```
+   * SelectionSet : { Selection+ }
+   * ```
+   */
+  parseSelectionSet() {
+    return this.node(this._lexer.token, {
+      kind: Kind.SELECTION_SET,
+      selections: this.many(
+        TokenKind.BRACE_L,
+        this.parseSelection,
+        TokenKind.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   */
+  parseSelection() {
+    return this.peek(TokenKind.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   */
+  parseField() {
+    const start = this._lexer.token;
+    const nameOrAlias = this.parseName();
+    let alias;
+    let name;
+    if (this.expectOptionalToken(TokenKind.COLON)) {
+      alias = nameOrAlias;
+      name = this.parseName();
+    } else {
+      name = nameOrAlias;
+    }
+    return this.node(start, {
+      kind: Kind.FIELD,
+      alias,
+      name,
+      arguments: this.parseArguments(false),
+      directives: this.parseDirectives(false),
+      selectionSet: this.peek(TokenKind.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   */
+  parseArguments(isConst) {
+    const item = isConst ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(TokenKind.PAREN_L, item, TokenKind.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   */
+  parseArgument(isConst = false) {
+    const start = this._lexer.token;
+    const name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    return this.node(start, {
+      kind: Kind.ARGUMENT,
+      name,
+      value: this.parseValueLiteral(isConst)
+    });
+  }
+  parseConstArgument() {
+    return this.parseArgument(true);
+  }
+  // Implements the parsing rules in the Fragments section.
+  /**
+   * Corresponds to both FragmentSpread and InlineFragment in the spec.
+   *
+   * FragmentSpread : ... FragmentName Directives?
+   *
+   * InlineFragment : ... TypeCondition? Directives? SelectionSet
+   */
+  parseFragment() {
+    const start = this._lexer.token;
+    this.expectToken(TokenKind.SPREAD);
+    const hasTypeCondition = this.expectOptionalKeyword("on");
+    if (!hasTypeCondition && this.peek(TokenKind.NAME)) {
+      return this.node(start, {
+        kind: Kind.FRAGMENT_SPREAD,
+        name: this.parseFragmentName(),
+        directives: this.parseDirectives(false)
+      });
+    }
+    return this.node(start, {
+      kind: Kind.INLINE_FRAGMENT,
+      typeCondition: hasTypeCondition ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentDefinition :
+   *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+   *
+   * TypeCondition : NamedType
+   */
+  parseFragmentDefinition() {
+    const start = this._lexer.token;
+    this.expectKeyword("fragment");
+    if (this._options.allowLegacyFragmentVariables === true) {
+      return this.node(start, {
+        kind: Kind.FRAGMENT_DEFINITION,
+        name: this.parseFragmentName(),
+        variableDefinitions: this.parseVariableDefinitions(),
+        typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+        directives: this.parseDirectives(false),
+        selectionSet: this.parseSelectionSet()
+      });
+    }
+    return this.node(start, {
+      kind: Kind.FRAGMENT_DEFINITION,
+      name: this.parseFragmentName(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentName : Name but not `on`
+   */
+  parseFragmentName() {
+    if (this._lexer.token.value === "on") {
+      throw this.unexpected();
+    }
+    return this.parseName();
+  }
+  // Implements the parsing rules in the Values section.
+  /**
+   * Value[Const] :
+   *   - [~Const] Variable
+   *   - IntValue
+   *   - FloatValue
+   *   - StringValue
+   *   - BooleanValue
+   *   - NullValue
+   *   - EnumValue
+   *   - ListValue[?Const]
+   *   - ObjectValue[?Const]
+   *
+   * BooleanValue : one of `true` `false`
+   *
+   * NullValue : `null`
+   *
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseValueLiteral(isConst) {
+    const token = this._lexer.token;
+    switch (token.kind) {
+      case TokenKind.BRACKET_L:
+        return this.parseList(isConst);
+      case TokenKind.BRACE_L:
+        return this.parseObject(isConst);
+      case TokenKind.INT:
+        this.advanceLexer();
+        return this.node(token, {
+          kind: Kind.INT,
+          value: token.value
+        });
+      case TokenKind.FLOAT:
+        this.advanceLexer();
+        return this.node(token, {
+          kind: Kind.FLOAT,
+          value: token.value
+        });
+      case TokenKind.STRING:
+      case TokenKind.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case TokenKind.NAME:
+        this.advanceLexer();
+        switch (token.value) {
+          case "true":
+            return this.node(token, {
+              kind: Kind.BOOLEAN,
+              value: true
+            });
+          case "false":
+            return this.node(token, {
+              kind: Kind.BOOLEAN,
+              value: false
+            });
+          case "null":
+            return this.node(token, {
+              kind: Kind.NULL
+            });
+          default:
+            return this.node(token, {
+              kind: Kind.ENUM,
+              value: token.value
+            });
+        }
+      case TokenKind.DOLLAR:
+        if (isConst) {
+          this.expectToken(TokenKind.DOLLAR);
+          if (this._lexer.token.kind === TokenKind.NAME) {
+            const varName = this._lexer.token.value;
+            throw syntaxError(
+              this._lexer.source,
+              token.start,
+              `Unexpected variable "$${varName}" in constant value.`
+            );
+          } else {
+            throw this.unexpected(token);
+          }
+        }
+        return this.parseVariable();
+      default:
+        throw this.unexpected();
+    }
+  }
+  parseConstValueLiteral() {
+    return this.parseValueLiteral(true);
+  }
+  parseStringLiteral() {
+    const token = this._lexer.token;
+    this.advanceLexer();
+    return this.node(token, {
+      kind: Kind.STRING,
+      value: token.value,
+      block: token.kind === TokenKind.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   */
+  parseList(isConst) {
+    const item = () => this.parseValueLiteral(isConst);
+    return this.node(this._lexer.token, {
+      kind: Kind.LIST,
+      values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   */
+  parseObject(isConst) {
+    const item = () => this.parseObjectField(isConst);
+    return this.node(this._lexer.token, {
+      kind: Kind.OBJECT,
+      fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   */
+  parseObjectField(isConst) {
+    const start = this._lexer.token;
+    const name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    return this.node(start, {
+      kind: Kind.OBJECT_FIELD,
+      name,
+      value: this.parseValueLiteral(isConst)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   */
+  parseDirectives(isConst) {
+    const directives = [];
+    while (this.peek(TokenKind.AT)) {
+      directives.push(this.parseDirective(isConst));
+    }
+    return directives;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(true);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   */
+  parseDirective(isConst) {
+    const start = this._lexer.token;
+    this.expectToken(TokenKind.AT);
+    return this.node(start, {
+      kind: Kind.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(isConst)
+    });
+  }
+  // Implements the parsing rules in the Types section.
+  /**
+   * Type :
+   *   - NamedType
+   *   - ListType
+   *   - NonNullType
+   */
+  parseTypeReference() {
+    const start = this._lexer.token;
+    let type2;
+    if (this.expectOptionalToken(TokenKind.BRACKET_L)) {
+      const innerType = this.parseTypeReference();
+      this.expectToken(TokenKind.BRACKET_R);
+      type2 = this.node(start, {
+        kind: Kind.LIST_TYPE,
+        type: innerType
+      });
+    } else {
+      type2 = this.parseNamedType();
+    }
+    if (this.expectOptionalToken(TokenKind.BANG)) {
+      return this.node(start, {
+        kind: Kind.NON_NULL_TYPE,
+        type: type2
+      });
+    }
+    return type2;
+  }
+  /**
+   * NamedType : Name
+   */
+  parseNamedType() {
+    return this.node(this._lexer.token, {
+      kind: Kind.NAMED_TYPE,
+      name: this.parseName()
+    });
+  }
+  // Implements the parsing rules in the Type Definition section.
+  peekDescription() {
+    return this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   */
+  parseDescription() {
+    if (this.peekDescription()) {
+      return this.parseStringLiteral();
+    }
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   */
+  parseSchemaDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("schema");
+    const directives = this.parseConstDirectives();
+    const operationTypes = this.many(
+      TokenKind.BRACE_L,
+      this.parseOperationTypeDefinition,
+      TokenKind.BRACE_R
+    );
+    return this.node(start, {
+      kind: Kind.SCHEMA_DEFINITION,
+      description: description2,
+      directives,
+      operationTypes
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   */
+  parseOperationTypeDefinition() {
+    const start = this._lexer.token;
+    const operation = this.parseOperationType();
+    this.expectToken(TokenKind.COLON);
+    const type2 = this.parseNamedType();
+    return this.node(start, {
+      kind: Kind.OPERATION_TYPE_DEFINITION,
+      operation,
+      type: type2
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   */
+  parseScalarTypeDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("scalar");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.SCALAR_TYPE_DEFINITION,
+      description: description2,
+      name,
+      directives
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   */
+  parseObjectTypeDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("type");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    return this.node(start, {
+      kind: Kind.OBJECT_TYPE_DEFINITION,
+      description: description2,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(TokenKind.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseFieldDefinition,
+      TokenKind.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   */
+  parseFieldDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    const name = this.parseName();
+    const args = this.parseArgumentDefs();
+    this.expectToken(TokenKind.COLON);
+    const type2 = this.parseTypeReference();
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.FIELD_DEFINITION,
+      description: description2,
+      name,
+      arguments: args,
+      type: type2,
+      directives
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      TokenKind.PAREN_L,
+      this.parseInputValueDef,
+      TokenKind.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   */
+  parseInputValueDef() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    const name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    const type2 = this.parseTypeReference();
+    let defaultValue;
+    if (this.expectOptionalToken(TokenKind.EQUALS)) {
+      defaultValue = this.parseConstValueLiteral();
+    }
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.INPUT_VALUE_DEFINITION,
+      description: description2,
+      name,
+      type: type2,
+      defaultValue,
+      directives
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   */
+  parseInterfaceTypeDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("interface");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    return this.node(start, {
+      kind: Kind.INTERFACE_TYPE_DEFINITION,
+      description: description2,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   */
+  parseUnionTypeDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("union");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const types2 = this.parseUnionMemberTypes();
+    return this.node(start, {
+      kind: Kind.UNION_TYPE_DEFINITION,
+      description: description2,
+      name,
+      directives,
+      types: types2
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(TokenKind.EQUALS) ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   */
+  parseEnumTypeDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("enum");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const values = this.parseEnumValuesDefinition();
+    return this.node(start, {
+      kind: Kind.ENUM_TYPE_DEFINITION,
+      description: description2,
+      name,
+      directives,
+      values
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseEnumValueDefinition,
+      TokenKind.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   */
+  parseEnumValueDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    const name = this.parseEnumValueName();
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.ENUM_VALUE_DEFINITION,
+      description: description2,
+      name,
+      directives
+    });
+  }
+  /**
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseEnumValueName() {
+    if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null") {
+      throw syntaxError(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${getTokenDesc(
+          this._lexer.token
+        )} is reserved and cannot be used for an enum value.`
+      );
+    }
+    return this.parseName();
+  }
+  /**
+   * InputObjectTypeDefinition :
+   *   - Description? input Name Directives[Const]? InputFieldsDefinition?
+   */
+  parseInputObjectTypeDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("input");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseInputFieldsDefinition();
+    return this.node(start, {
+      kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+      description: description2,
+      name,
+      directives,
+      fields
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseInputValueDef,
+      TokenKind.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   */
+  parseTypeSystemExtension() {
+    const keywordToken = this._lexer.lookahead();
+    if (keywordToken.kind === TokenKind.NAME) {
+      switch (keywordToken.value) {
+        case "schema":
+          return this.parseSchemaExtension();
+        case "scalar":
+          return this.parseScalarTypeExtension();
+        case "type":
+          return this.parseObjectTypeExtension();
+        case "interface":
+          return this.parseInterfaceTypeExtension();
+        case "union":
+          return this.parseUnionTypeExtension();
+        case "enum":
+          return this.parseEnumTypeExtension();
+        case "input":
+          return this.parseInputObjectTypeExtension();
+      }
+    }
+    throw this.unexpected(keywordToken);
+  }
+  /**
+   * ```
+   * SchemaExtension :
+   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+   *  - extend schema Directives[Const]
+   * ```
+   */
+  parseSchemaExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("schema");
+    const directives = this.parseConstDirectives();
+    const operationTypes = this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseOperationTypeDefinition,
+      TokenKind.BRACE_R
+    );
+    if (directives.length === 0 && operationTypes.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.SCHEMA_EXTENSION,
+      directives,
+      operationTypes
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   */
+  parseScalarTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("scalar");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    if (directives.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.SCALAR_TYPE_EXTENSION,
+      name,
+      directives
+    });
+  }
+  /**
+   * ObjectTypeExtension :
+   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend type Name ImplementsInterfaces? Directives[Const]
+   *  - extend type Name ImplementsInterfaces
+   */
+  parseObjectTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("type");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.OBJECT_TYPE_EXTENSION,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * InterfaceTypeExtension :
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]
+   *  - extend interface Name ImplementsInterfaces
+   */
+  parseInterfaceTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("interface");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.INTERFACE_TYPE_EXTENSION,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * UnionTypeExtension :
+   *   - extend union Name Directives[Const]? UnionMemberTypes
+   *   - extend union Name Directives[Const]
+   */
+  parseUnionTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("union");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const types2 = this.parseUnionMemberTypes();
+    if (directives.length === 0 && types2.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.UNION_TYPE_EXTENSION,
+      name,
+      directives,
+      types: types2
+    });
+  }
+  /**
+   * EnumTypeExtension :
+   *   - extend enum Name Directives[Const]? EnumValuesDefinition
+   *   - extend enum Name Directives[Const]
+   */
+  parseEnumTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("enum");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const values = this.parseEnumValuesDefinition();
+    if (directives.length === 0 && values.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.ENUM_TYPE_EXTENSION,
+      name,
+      directives,
+      values
+    });
+  }
+  /**
+   * InputObjectTypeExtension :
+   *   - extend input Name Directives[Const]? InputFieldsDefinition
+   *   - extend input Name Directives[Const]
+   */
+  parseInputObjectTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("input");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseInputFieldsDefinition();
+    if (directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
+      name,
+      directives,
+      fields
+    });
+  }
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   */
+  parseDirectiveDefinition() {
+    const start = this._lexer.token;
+    const description2 = this.parseDescription();
+    this.expectKeyword("directive");
+    this.expectToken(TokenKind.AT);
+    const name = this.parseName();
+    const args = this.parseArgumentDefs();
+    const repeatable = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const locations = this.parseDirectiveLocations();
+    return this.node(start, {
+      kind: Kind.DIRECTIVE_DEFINITION,
+      description: description2,
+      name,
+      arguments: args,
+      repeatable,
+      locations
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);
+  }
+  /*
+   * DirectiveLocation :
+   *   - ExecutableDirectiveLocation
+   *   - TypeSystemDirectiveLocation
+   *
+   * ExecutableDirectiveLocation : one of
+   *   `QUERY`
+   *   `MUTATION`
+   *   `SUBSCRIPTION`
+   *   `FIELD`
+   *   `FRAGMENT_DEFINITION`
+   *   `FRAGMENT_SPREAD`
+   *   `INLINE_FRAGMENT`
+   *
+   * TypeSystemDirectiveLocation : one of
+   *   `SCHEMA`
+   *   `SCALAR`
+   *   `OBJECT`
+   *   `FIELD_DEFINITION`
+   *   `ARGUMENT_DEFINITION`
+   *   `INTERFACE`
+   *   `UNION`
+   *   `ENUM`
+   *   `ENUM_VALUE`
+   *   `INPUT_OBJECT`
+   *   `INPUT_FIELD_DEFINITION`
+   */
+  parseDirectiveLocation() {
+    const start = this._lexer.token;
+    const name = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(DirectiveLocation, name.value)) {
+      return name;
+    }
+    throw this.unexpected(start);
+  }
+  // Core parsing utility functions
+  /**
+   * Returns a node that, if configured to do so, sets a "loc" field as a
+   * location object, used to identify the place in the source that created a
+   * given parsed object.
+   */
+  node(startToken, node2) {
+    if (this._options.noLocation !== true) {
+      node2.loc = new Location(
+        startToken,
+        this._lexer.lastToken,
+        this._lexer.source
+      );
+    }
+    return node2;
+  }
+  /**
+   * Determines if the next token is of a given kind
+   */
+  peek(kind) {
+    return this._lexer.token.kind === kind;
+  }
+  /**
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectToken(kind) {
+    const token = this._lexer.token;
+    if (token.kind === kind) {
+      this.advanceLexer();
+      return token;
+    }
+    throw syntaxError(
+      this._lexer.source,
+      token.start,
+      `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.`
+    );
+  }
+  /**
+   * If the next token is of the given kind, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalToken(kind) {
+    const token = this._lexer.token;
+    if (token.kind === kind) {
+      this.advanceLexer();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * If the next token is a given keyword, advance the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectKeyword(value) {
+    const token = this._lexer.token;
+    if (token.kind === TokenKind.NAME && token.value === value) {
+      this.advanceLexer();
+    } else {
+      throw syntaxError(
+        this._lexer.source,
+        token.start,
+        `Expected "${value}", found ${getTokenDesc(token)}.`
+      );
+    }
+  }
+  /**
+   * If the next token is a given keyword, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalKeyword(value) {
+    const token = this._lexer.token;
+    if (token.kind === TokenKind.NAME && token.value === value) {
+      this.advanceLexer();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   */
+  unexpected(atToken) {
+    const token = atToken !== null && atToken !== void 0 ? atToken : this._lexer.token;
+    return syntaxError(
+      this._lexer.source,
+      token.start,
+      `Unexpected ${getTokenDesc(token)}.`
+    );
+  }
+  /**
+   * Returns a possibly empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  any(openKind, parseFn, closeKind) {
+    this.expectToken(openKind);
+    const nodes = [];
+    while (!this.expectOptionalToken(closeKind)) {
+      nodes.push(parseFn.call(this));
+    }
+    return nodes;
+  }
+  /**
+   * Returns a list of parse nodes, determined by the parseFn.
+   * It can be empty only if open token is missing otherwise it will always return non-empty list
+   * that begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  optionalMany(openKind, parseFn, closeKind) {
+    if (this.expectOptionalToken(openKind)) {
+      const nodes = [];
+      do {
+        nodes.push(parseFn.call(this));
+      } while (!this.expectOptionalToken(closeKind));
+      return nodes;
+    }
+    return [];
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  many(openKind, parseFn, closeKind) {
+    this.expectToken(openKind);
+    const nodes = [];
+    do {
+      nodes.push(parseFn.call(this));
+    } while (!this.expectOptionalToken(closeKind));
+    return nodes;
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+   * Advances the parser to the next lex token after last item in the list.
+   */
+  delimitedMany(delimiterKind, parseFn) {
+    this.expectOptionalToken(delimiterKind);
+    const nodes = [];
+    do {
+      nodes.push(parseFn.call(this));
+    } while (this.expectOptionalToken(delimiterKind));
+    return nodes;
+  }
+  advanceLexer() {
+    const { maxTokens } = this._options;
+    const token = this._lexer.advance();
+    if (token.kind !== TokenKind.EOF) {
+      ++this._tokenCounter;
+      if (maxTokens !== void 0 && this._tokenCounter > maxTokens) {
+        throw syntaxError(
+          this._lexer.source,
+          token.start,
+          `Document contains more that ${maxTokens} tokens. Parsing aborted.`
+        );
+      }
+    }
+  }
+}
+function getTokenDesc(token) {
+  const value = token.value;
+  return getTokenKindDesc(token.kind) + (value != null ? ` "${value}"` : "");
+}
+function getTokenKindDesc(kind) {
+  return isPunctuatorTokenKind(kind) ? `"${kind}"` : kind;
+}
+function printString(str) {
+  return `"${str.replace(escapedRegExp, escapedReplacer)}"`;
+}
+const escapedRegExp = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
+function escapedReplacer(str) {
+  return escapeSequences[str.charCodeAt(0)];
+}
+const escapeSequences = [
+  "\\u0000",
+  "\\u0001",
+  "\\u0002",
+  "\\u0003",
+  "\\u0004",
+  "\\u0005",
+  "\\u0006",
+  "\\u0007",
+  "\\b",
+  "\\t",
+  "\\n",
+  "\\u000B",
+  "\\f",
+  "\\r",
+  "\\u000E",
+  "\\u000F",
+  "\\u0010",
+  "\\u0011",
+  "\\u0012",
+  "\\u0013",
+  "\\u0014",
+  "\\u0015",
+  "\\u0016",
+  "\\u0017",
+  "\\u0018",
+  "\\u0019",
+  "\\u001A",
+  "\\u001B",
+  "\\u001C",
+  "\\u001D",
+  "\\u001E",
+  "\\u001F",
+  "",
+  "",
+  '\\"',
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 2F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 3F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 4F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "\\\\",
+  "",
+  "",
+  "",
+  // 5F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 6F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "\\u007F",
+  "\\u0080",
+  "\\u0081",
+  "\\u0082",
+  "\\u0083",
+  "\\u0084",
+  "\\u0085",
+  "\\u0086",
+  "\\u0087",
+  "\\u0088",
+  "\\u0089",
+  "\\u008A",
+  "\\u008B",
+  "\\u008C",
+  "\\u008D",
+  "\\u008E",
+  "\\u008F",
+  "\\u0090",
+  "\\u0091",
+  "\\u0092",
+  "\\u0093",
+  "\\u0094",
+  "\\u0095",
+  "\\u0096",
+  "\\u0097",
+  "\\u0098",
+  "\\u0099",
+  "\\u009A",
+  "\\u009B",
+  "\\u009C",
+  "\\u009D",
+  "\\u009E",
+  "\\u009F"
+];
+const BREAK = Object.freeze({});
+function visit(root2, visitor, visitorKeys = QueryDocumentKeys) {
+  const enterLeaveMap = /* @__PURE__ */ new Map();
+  for (const kind of Object.values(Kind)) {
+    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));
+  }
+  let stack = void 0;
+  let inArray = Array.isArray(root2);
+  let keys = [root2];
+  let index2 = -1;
+  let edits = [];
+  let node2 = root2;
+  let key = void 0;
+  let parent2 = void 0;
+  const path2 = [];
+  const ancestors = [];
+  do {
+    index2++;
+    const isLeaving = index2 === keys.length;
+    const isEdited = isLeaving && edits.length !== 0;
+    if (isLeaving) {
+      key = ancestors.length === 0 ? void 0 : path2[path2.length - 1];
+      node2 = parent2;
+      parent2 = ancestors.pop();
+      if (isEdited) {
+        if (inArray) {
+          node2 = node2.slice();
+          let editOffset = 0;
+          for (const [editKey, editValue] of edits) {
+            const arrayKey = editKey - editOffset;
+            if (editValue === null) {
+              node2.splice(arrayKey, 1);
+              editOffset++;
+            } else {
+              node2[arrayKey] = editValue;
+            }
+          }
+        } else {
+          node2 = Object.defineProperties(
+            {},
+            Object.getOwnPropertyDescriptors(node2)
+          );
+          for (const [editKey, editValue] of edits) {
+            node2[editKey] = editValue;
+          }
+        }
+      }
+      index2 = stack.index;
+      keys = stack.keys;
+      edits = stack.edits;
+      inArray = stack.inArray;
+      stack = stack.prev;
+    } else if (parent2) {
+      key = inArray ? index2 : keys[index2];
+      node2 = parent2[key];
+      if (node2 === null || node2 === void 0) {
+        continue;
+      }
+      path2.push(key);
+    }
+    let result2;
+    if (!Array.isArray(node2)) {
+      var _enterLeaveMap$get, _enterLeaveMap$get2;
+      isNode(node2) || devAssert(false, `Invalid AST Node: ${inspect(node2)}.`);
+      const visitFn = isLeaving ? (_enterLeaveMap$get = enterLeaveMap.get(node2.kind)) === null || _enterLeaveMap$get === void 0 ? void 0 : _enterLeaveMap$get.leave : (_enterLeaveMap$get2 = enterLeaveMap.get(node2.kind)) === null || _enterLeaveMap$get2 === void 0 ? void 0 : _enterLeaveMap$get2.enter;
+      result2 = visitFn === null || visitFn === void 0 ? void 0 : visitFn.call(visitor, node2, key, parent2, path2, ancestors);
+      if (result2 === BREAK) {
+        break;
+      }
+      if (result2 === false) {
+        if (!isLeaving) {
+          path2.pop();
+          continue;
+        }
+      } else if (result2 !== void 0) {
+        edits.push([key, result2]);
+        if (!isLeaving) {
+          if (isNode(result2)) {
+            node2 = result2;
+          } else {
+            path2.pop();
+            continue;
+          }
+        }
+      }
+    }
+    if (result2 === void 0 && isEdited) {
+      edits.push([key, node2]);
+    }
+    if (isLeaving) {
+      path2.pop();
+    } else {
+      var _node$kind;
+      stack = {
+        inArray,
+        index: index2,
+        keys,
+        edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node2);
+      keys = inArray ? node2 : (_node$kind = visitorKeys[node2.kind]) !== null && _node$kind !== void 0 ? _node$kind : [];
+      index2 = -1;
+      edits = [];
+      if (parent2) {
+        ancestors.push(parent2);
+      }
+      parent2 = node2;
+    }
+  } while (stack !== void 0);
+  if (edits.length !== 0) {
+    return edits[edits.length - 1][1];
+  }
+  return root2;
+}
+function getEnterLeaveForKind(visitor, kind) {
+  const kindVisitor = visitor[kind];
+  if (typeof kindVisitor === "object") {
+    return kindVisitor;
+  } else if (typeof kindVisitor === "function") {
+    return {
+      enter: kindVisitor,
+      leave: void 0
+    };
+  }
+  return {
+    enter: visitor.enter,
+    leave: visitor.leave
+  };
+}
+function print(ast2) {
+  return visit(ast2, printDocASTReducer);
+}
+const MAX_LINE_LENGTH = 80;
+const printDocASTReducer = {
+  Name: {
+    leave: (node2) => node2.value
+  },
+  Variable: {
+    leave: (node2) => "$" + node2.name
+  },
+  // Document
+  Document: {
+    leave: (node2) => join(node2.definitions, "\n\n")
+  },
+  OperationDefinition: {
+    leave(node2) {
+      const varDefs = wrap("(", join(node2.variableDefinitions, ", "), ")");
+      const prefix = join(
+        [
+          node2.operation,
+          join([node2.name, varDefs]),
+          join(node2.directives, " ")
+        ],
+        " "
+      );
+      return (prefix === "query" ? "" : prefix + " ") + node2.selectionSet;
+    }
+  },
+  VariableDefinition: {
+    leave: ({ variable, type: type2, defaultValue, directives }) => variable + ": " + type2 + wrap(" = ", defaultValue) + wrap(" ", join(directives, " "))
+  },
+  SelectionSet: {
+    leave: ({ selections }) => block(selections)
+  },
+  Field: {
+    leave({ alias, name, arguments: args, directives, selectionSet }) {
+      const prefix = wrap("", alias, ": ") + name;
+      let argsLine = prefix + wrap("(", join(args, ", "), ")");
+      if (argsLine.length > MAX_LINE_LENGTH) {
+        argsLine = prefix + wrap("(\n", indent(join(args, "\n")), "\n)");
+      }
+      return join([argsLine, join(directives, " "), selectionSet], " ");
+    }
+  },
+  Argument: {
+    leave: ({ name, value }) => name + ": " + value
+  },
+  // Fragments
+  FragmentSpread: {
+    leave: ({ name, directives }) => "..." + name + wrap(" ", join(directives, " "))
+  },
+  InlineFragment: {
+    leave: ({ typeCondition, directives, selectionSet }) => join(
+      [
+        "...",
+        wrap("on ", typeCondition),
+        join(directives, " "),
+        selectionSet
+      ],
+      " "
+    )
+  },
+  FragmentDefinition: {
+    leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => (
+      // or removed in the future.
+      `fragment ${name}${wrap("(", join(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap("", join(directives, " "), " ")}` + selectionSet
+    )
+  },
+  // Value
+  IntValue: {
+    leave: ({ value }) => value
+  },
+  FloatValue: {
+    leave: ({ value }) => value
+  },
+  StringValue: {
+    leave: ({ value, block: isBlockString }) => isBlockString ? printBlockString(value) : printString(value)
+  },
+  BooleanValue: {
+    leave: ({ value }) => value ? "true" : "false"
+  },
+  NullValue: {
+    leave: () => "null"
+  },
+  EnumValue: {
+    leave: ({ value }) => value
+  },
+  ListValue: {
+    leave: ({ values }) => "[" + join(values, ", ") + "]"
+  },
+  ObjectValue: {
+    leave: ({ fields }) => "{" + join(fields, ", ") + "}"
+  },
+  ObjectField: {
+    leave: ({ name, value }) => name + ": " + value
+  },
+  // Directive
+  Directive: {
+    leave: ({ name, arguments: args }) => "@" + name + wrap("(", join(args, ", "), ")")
+  },
+  // Type
+  NamedType: {
+    leave: ({ name }) => name
+  },
+  ListType: {
+    leave: ({ type: type2 }) => "[" + type2 + "]"
+  },
+  NonNullType: {
+    leave: ({ type: type2 }) => type2 + "!"
+  },
+  // Type System Definitions
+  SchemaDefinition: {
+    leave: ({ description: description2, directives, operationTypes }) => wrap("", description2, "\n") + join(["schema", join(directives, " "), block(operationTypes)], " ")
+  },
+  OperationTypeDefinition: {
+    leave: ({ operation, type: type2 }) => operation + ": " + type2
+  },
+  ScalarTypeDefinition: {
+    leave: ({ description: description2, name, directives }) => wrap("", description2, "\n") + join(["scalar", name, join(directives, " ")], " ")
+  },
+  ObjectTypeDefinition: {
+    leave: ({ description: description2, name, interfaces, directives, fields }) => wrap("", description2, "\n") + join(
+      [
+        "type",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  FieldDefinition: {
+    leave: ({ description: description2, name, arguments: args, type: type2, directives }) => wrap("", description2, "\n") + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + ": " + type2 + wrap(" ", join(directives, " "))
+  },
+  InputValueDefinition: {
+    leave: ({ description: description2, name, type: type2, defaultValue, directives }) => wrap("", description2, "\n") + join(
+      [name + ": " + type2, wrap("= ", defaultValue), join(directives, " ")],
+      " "
+    )
+  },
+  InterfaceTypeDefinition: {
+    leave: ({ description: description2, name, interfaces, directives, fields }) => wrap("", description2, "\n") + join(
+      [
+        "interface",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeDefinition: {
+    leave: ({ description: description2, name, directives, types: types2 }) => wrap("", description2, "\n") + join(
+      ["union", name, join(directives, " "), wrap("= ", join(types2, " | "))],
+      " "
+    )
+  },
+  EnumTypeDefinition: {
+    leave: ({ description: description2, name, directives, values }) => wrap("", description2, "\n") + join(["enum", name, join(directives, " "), block(values)], " ")
+  },
+  EnumValueDefinition: {
+    leave: ({ description: description2, name, directives }) => wrap("", description2, "\n") + join([name, join(directives, " ")], " ")
+  },
+  InputObjectTypeDefinition: {
+    leave: ({ description: description2, name, directives, fields }) => wrap("", description2, "\n") + join(["input", name, join(directives, " "), block(fields)], " ")
+  },
+  DirectiveDefinition: {
+    leave: ({ description: description2, name, arguments: args, repeatable, locations }) => wrap("", description2, "\n") + "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join(locations, " | ")
+  },
+  SchemaExtension: {
+    leave: ({ directives, operationTypes }) => join(
+      ["extend schema", join(directives, " "), block(operationTypes)],
+      " "
+    )
+  },
+  ScalarTypeExtension: {
+    leave: ({ name, directives }) => join(["extend scalar", name, join(directives, " ")], " ")
+  },
+  ObjectTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) => join(
+      [
+        "extend type",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  InterfaceTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) => join(
+      [
+        "extend interface",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeExtension: {
+    leave: ({ name, directives, types: types2 }) => join(
+      [
+        "extend union",
+        name,
+        join(directives, " "),
+        wrap("= ", join(types2, " | "))
+      ],
+      " "
+    )
+  },
+  EnumTypeExtension: {
+    leave: ({ name, directives, values }) => join(["extend enum", name, join(directives, " "), block(values)], " ")
+  },
+  InputObjectTypeExtension: {
+    leave: ({ name, directives, fields }) => join(["extend input", name, join(directives, " "), block(fields)], " ")
+  }
+};
+function join(maybeArray, separator = "") {
+  var _maybeArray$filter$jo;
+  return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter((x) => x).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : "";
+}
+function block(array) {
+  return wrap("{\n", indent(join(array, "\n")), "\n}");
+}
+function wrap(start, maybeString, end2 = "") {
+  return maybeString != null && maybeString !== "" ? start + maybeString + end2 : "";
+}
+function indent(str) {
+  return wrap("  ", str.replace(/\n/g, "\n  "));
+}
+function hasMultilineItems(maybeArray) {
+  var _maybeArray$some;
+  return (_maybeArray$some = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some((str) => str.includes("\n"))) !== null && _maybeArray$some !== void 0 ? _maybeArray$some : false;
+}
+const ACCEPT_HEADER = `Accept`;
+const CONTENT_TYPE_HEADER = `Content-Type`;
+const CONTENT_TYPE_JSON = `application/json`;
+const CONTENT_TYPE_GQL = `application/graphql-response+json`;
+const cleanQuery = (str) => str.replace(/([\s,]|#[^\n\r]+)+/g, ` `).trim();
+const isGraphQLContentType = (contentType) => {
+  const contentTypeLower = contentType.toLowerCase();
+  return contentTypeLower.includes(CONTENT_TYPE_GQL) || contentTypeLower.includes(CONTENT_TYPE_JSON);
+};
+const parseGraphQLExecutionResult = (result2) => {
+  try {
+    if (Array.isArray(result2)) {
+      return {
+        _tag: `Batch`,
+        executionResults: result2.map(parseExecutionResult)
+      };
+    } else if (isPlainObject(result2)) {
+      return {
+        _tag: `Single`,
+        executionResult: parseExecutionResult(result2)
+      };
+    } else {
+      throw new Error(`Invalid execution result: result is not object or array. 
+Got:
+${String(result2)}`);
+    }
+  } catch (e) {
+    return e;
+  }
+};
+const parseExecutionResult = (result2) => {
+  if (typeof result2 !== `object` || result2 === null) {
+    throw new Error(`Invalid execution result: result is not object`);
+  }
+  let errors2 = void 0;
+  let data = void 0;
+  let extensions = void 0;
+  if (`errors` in result2) {
+    if (!isPlainObject(result2.errors) && !Array.isArray(result2.errors)) {
+      throw new Error(`Invalid execution result: errors is not plain object OR array`);
+    }
+    errors2 = result2.errors;
+  }
+  if (`data` in result2) {
+    if (!isPlainObject(result2.data) && result2.data !== null) {
+      throw new Error(`Invalid execution result: data is not plain object`);
+    }
+    data = result2.data;
+  }
+  if (`extensions` in result2) {
+    if (!isPlainObject(result2.extensions))
+      throw new Error(`Invalid execution result: extensions is not plain object`);
+    extensions = result2.extensions;
+  }
+  return {
+    data,
+    errors: errors2,
+    extensions
+  };
+};
+const isRequestResultHaveErrors = (result2) => result2._tag === `Batch` ? result2.executionResults.some(isExecutionResultHaveErrors) : isExecutionResultHaveErrors(result2.executionResult);
+const isExecutionResultHaveErrors = (result2) => Array.isArray(result2.errors) ? result2.errors.length > 0 : Boolean(result2.errors);
+const isOperationDefinitionNode = (definition) => {
+  return typeof definition === `object` && definition !== null && `kind` in definition && definition.kind === Kind.OPERATION_DEFINITION;
+};
+const extractOperationName = (document) => {
+  let operationName = void 0;
+  const defs = document.definitions.filter(isOperationDefinitionNode);
+  if (defs.length === 1) {
+    operationName = defs[0].name?.value;
+  }
+  return operationName;
+};
+const extractIsMutation = (document) => {
+  let isMutation = false;
+  const defs = document.definitions.filter(isOperationDefinitionNode);
+  if (defs.length === 1) {
+    isMutation = defs[0].operation === OperationTypeNode.MUTATION;
+  }
+  return isMutation;
+};
+const analyzeDocument = (document, excludeOperationName) => {
+  const expression = typeof document === `string` ? document : print(document);
+  let isMutation = false;
+  let operationName = void 0;
+  if (excludeOperationName) {
+    return { expression, isMutation, operationName };
+  }
+  const docNode = tryCatch(() => typeof document === `string` ? parse(document) : document);
+  if (docNode instanceof Error) {
+    return { expression, isMutation, operationName };
+  }
+  operationName = extractOperationName(docNode);
+  isMutation = extractIsMutation(docNode);
+  return { expression, operationName, isMutation };
+};
+const defaultJsonSerializer = JSON;
+const runRequest = async (input) => {
+  const config2 = {
+    ...input,
+    method: input.request._tag === `Single` ? input.request.document.isMutation ? `POST` : uppercase(input.method ?? `post`) : input.request.hasMutations ? `POST` : uppercase(input.method ?? `post`),
+    fetchOptions: {
+      ...input.fetchOptions,
+      errorPolicy: input.fetchOptions.errorPolicy ?? `none`
+    }
+  };
+  const fetcher = createFetcher(config2.method);
+  const fetchResponse = await fetcher(config2);
+  if (!fetchResponse.ok) {
+    return new ClientError({ status: fetchResponse.status, headers: fetchResponse.headers }, {
+      query: input.request._tag === `Single` ? input.request.document.expression : input.request.query,
+      variables: input.request.variables
+    });
+  }
+  const result2 = await parseResultFromResponse(fetchResponse, input.fetchOptions.jsonSerializer ?? defaultJsonSerializer);
+  if (result2 instanceof Error)
+    throw result2;
+  const clientResponseBase = {
+    status: fetchResponse.status,
+    headers: fetchResponse.headers
+  };
+  if (isRequestResultHaveErrors(result2) && config2.fetchOptions.errorPolicy === `none`) {
+    const clientResponse = result2._tag === `Batch` ? { ...result2.executionResults, ...clientResponseBase } : {
+      ...result2.executionResult,
+      ...clientResponseBase
+    };
+    return new ClientError(clientResponse, {
+      query: input.request._tag === `Single` ? input.request.document.expression : input.request.query,
+      variables: input.request.variables
+    });
+  }
+  switch (result2._tag) {
+    case `Single`:
+      return {
+        ...clientResponseBase,
+        ...executionResultClientResponseFields(config2)(result2.executionResult)
+      };
+    case `Batch`:
+      return {
+        ...clientResponseBase,
+        data: result2.executionResults.map(executionResultClientResponseFields(config2))
+      };
+    default:
+      casesExhausted(result2);
+  }
+};
+const executionResultClientResponseFields = ($params) => (executionResult) => {
+  return {
+    extensions: executionResult.extensions,
+    data: executionResult.data,
+    errors: $params.fetchOptions.errorPolicy === `all` ? executionResult.errors : void 0
+  };
+};
+const parseResultFromResponse = async (response, jsonSerializer) => {
+  const contentType = response.headers.get(CONTENT_TYPE_HEADER);
+  const text = await response.text();
+  if (contentType && isGraphQLContentType(contentType)) {
+    return parseGraphQLExecutionResult(jsonSerializer.parse(text));
+  } else {
+    return parseGraphQLExecutionResult(text);
+  }
+};
+const createFetcher = (method) => async (params) => {
+  const headers2 = new Headers(params.headers);
+  let searchParams = null;
+  let body = void 0;
+  if (!headers2.has(ACCEPT_HEADER)) {
+    headers2.set(ACCEPT_HEADER, [CONTENT_TYPE_GQL, CONTENT_TYPE_JSON].join(`, `));
+  }
+  if (method === `POST`) {
+    const $jsonSerializer = params.fetchOptions.jsonSerializer ?? defaultJsonSerializer;
+    body = $jsonSerializer.stringify(buildBody(params));
+    if (typeof body === `string` && !headers2.has(CONTENT_TYPE_HEADER)) {
+      headers2.set(CONTENT_TYPE_HEADER, CONTENT_TYPE_JSON);
+    }
+  } else {
+    searchParams = buildQueryParams(params);
+  }
+  const init = { method, headers: headers2, body, ...params.fetchOptions };
+  let url = new URL(params.url);
+  let initResolved = init;
+  if (params.middleware) {
+    const result2 = await Promise.resolve(params.middleware({
+      ...init,
+      url: params.url,
+      operationName: params.request._tag === `Single` ? params.request.document.operationName : void 0,
+      variables: params.request.variables
+    }));
+    const { url: urlNew, ...initNew } = result2;
+    url = new URL(urlNew);
+    initResolved = initNew;
+  }
+  if (searchParams) {
+    searchParams.forEach((value, name) => {
+      url.searchParams.append(name, value);
+    });
+  }
+  const $fetch = params.fetch ?? fetch;
+  return await $fetch(url, initResolved);
+};
+const buildBody = (params) => {
+  switch (params.request._tag) {
+    case `Single`:
+      return {
+        query: params.request.document.expression,
+        variables: params.request.variables,
+        operationName: params.request.document.operationName
+      };
+    case `Batch`:
+      return zip(params.request.query, params.request.variables ?? []).map(([query2, variables]) => ({
+        query: query2,
+        variables
+      }));
+    default:
+      throw casesExhausted(params.request);
+  }
+};
+const buildQueryParams = (params) => {
+  const $jsonSerializer = params.fetchOptions.jsonSerializer ?? defaultJsonSerializer;
+  const searchParams = new URLSearchParams();
+  switch (params.request._tag) {
+    case `Single`: {
+      searchParams.append(`query`, cleanQuery(params.request.document.expression));
+      if (params.request.variables) {
+        searchParams.append(`variables`, $jsonSerializer.stringify(params.request.variables));
+      }
+      if (params.request.document.operationName) {
+        searchParams.append(`operationName`, params.request.document.operationName);
+      }
+      return searchParams;
+    }
+    case `Batch`: {
+      const variablesSerialized = params.request.variables?.map((v) => $jsonSerializer.stringify(v)) ?? [];
+      const queriesCleaned = params.request.query.map(cleanQuery);
+      const payload = zip(queriesCleaned, variablesSerialized).map(([query2, variables]) => ({
+        query: query2,
+        variables
+      }));
+      searchParams.append(`query`, $jsonSerializer.stringify(payload));
+      return searchParams;
+    }
+    default:
+      throw casesExhausted(params.request);
+  }
+};
+class GraphQLClient {
+  url;
+  requestConfig;
+  constructor(url, requestConfig = {}) {
+    this.url = url;
+    this.requestConfig = requestConfig;
+  }
+  /**
+   * Send a GraphQL query to the server.
+   */
+  rawRequest = async (...args) => {
+    const [queryOrOptions, variables, requestHeaders] = args;
+    const rawRequestOptions = parseRawRequestArgs(queryOrOptions, variables, requestHeaders);
+    const { headers: headers2, fetch: fetch2 = globalThis.fetch, method = `POST`, requestMiddleware, responseMiddleware, excludeOperationName, ...fetchOptions } = this.requestConfig;
+    const { url } = this;
+    if (rawRequestOptions.signal !== void 0) {
+      fetchOptions.signal = rawRequestOptions.signal;
+    }
+    const document = analyzeDocument(rawRequestOptions.query, excludeOperationName);
+    const response = await runRequest({
+      url,
+      request: {
+        _tag: `Single`,
+        document,
+        variables: rawRequestOptions.variables
+      },
+      headers: {
+        ...HeadersInitToPlainObject(callOrIdentity(headers2)),
+        ...HeadersInitToPlainObject(rawRequestOptions.requestHeaders)
+      },
+      fetch: fetch2,
+      method,
+      fetchOptions,
+      middleware: requestMiddleware
+    });
+    if (responseMiddleware) {
+      await responseMiddleware(response, {
+        operationName: document.operationName,
+        variables,
+        url: this.url
+      });
+    }
+    if (response instanceof Error) {
+      throw response;
+    }
+    return response;
+  };
+  async request(documentOrOptions, ...variablesAndRequestHeaders) {
+    const [variables, requestHeaders] = variablesAndRequestHeaders;
+    const requestOptions = parseRequestArgs(documentOrOptions, variables, requestHeaders);
+    const { headers: headers2, fetch: fetch2 = globalThis.fetch, method = `POST`, requestMiddleware, responseMiddleware, excludeOperationName, ...fetchOptions } = this.requestConfig;
+    const { url } = this;
+    if (requestOptions.signal !== void 0) {
+      fetchOptions.signal = requestOptions.signal;
+    }
+    const analyzedDocument = analyzeDocument(requestOptions.document, excludeOperationName);
+    const response = await runRequest({
+      url,
+      request: {
+        _tag: `Single`,
+        document: analyzedDocument,
+        variables: requestOptions.variables
+      },
+      headers: {
+        ...HeadersInitToPlainObject(callOrIdentity(headers2)),
+        ...HeadersInitToPlainObject(requestOptions.requestHeaders)
+      },
+      fetch: fetch2,
+      method,
+      fetchOptions,
+      middleware: requestMiddleware
+    });
+    if (responseMiddleware) {
+      await responseMiddleware(response, {
+        operationName: analyzedDocument.operationName,
+        variables: requestOptions.variables,
+        url: this.url
+      });
+    }
+    if (response instanceof Error) {
+      throw response;
+    }
+    return response.data;
+  }
+  async batchRequests(documentsOrOptions, requestHeaders) {
+    const batchRequestOptions = parseBatchRequestArgs(documentsOrOptions, requestHeaders);
+    const { headers: headers2, excludeOperationName, ...fetchOptions } = this.requestConfig;
+    if (batchRequestOptions.signal !== void 0) {
+      fetchOptions.signal = batchRequestOptions.signal;
+    }
+    const analyzedDocuments = batchRequestOptions.documents.map(({ document }) => analyzeDocument(document, excludeOperationName));
+    const expressions = analyzedDocuments.map(({ expression }) => expression);
+    const hasMutations = analyzedDocuments.some(({ isMutation }) => isMutation);
+    const variables = batchRequestOptions.documents.map(({ variables: variables2 }) => variables2);
+    const response = await runRequest({
+      url: this.url,
+      request: {
+        _tag: `Batch`,
+        operationName: void 0,
+        query: expressions,
+        hasMutations,
+        variables
+      },
+      headers: {
+        ...HeadersInitToPlainObject(callOrIdentity(headers2)),
+        ...HeadersInitToPlainObject(batchRequestOptions.requestHeaders)
+      },
+      fetch: this.requestConfig.fetch ?? globalThis.fetch,
+      method: this.requestConfig.method || `POST`,
+      fetchOptions,
+      middleware: this.requestConfig.requestMiddleware
+    });
+    if (this.requestConfig.responseMiddleware) {
+      await this.requestConfig.responseMiddleware(response, {
+        operationName: void 0,
+        variables,
+        url: this.url
+      });
+    }
+    if (response instanceof Error) {
+      throw response;
+    }
+    return response.data;
+  }
+  setHeaders(headers2) {
+    this.requestConfig.headers = headers2;
+    return this;
+  }
+  /**
+   * Attach a header to the client. All subsequent requests will have this header.
+   */
+  setHeader(key, value) {
+    const { headers: headers2 } = this.requestConfig;
+    if (headers2) {
+      headers2[key] = value;
+    } else {
+      this.requestConfig.headers = { [key]: value };
+    }
+    return this;
+  }
+  /**
+   * Change the client endpoint. All subsequent requests will send to this endpoint.
+   */
+  setEndpoint(value) {
+    this.url = value;
+    return this;
+  }
+}
+const parseRequestArgs = (documentOrOptions, variables, requestHeaders) => {
+  return documentOrOptions.document ? documentOrOptions : {
+    document: documentOrOptions,
+    variables,
+    requestHeaders,
+    signal: void 0
+  };
+};
+const CreateExtensionVersionDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "mutation",
+      name: { kind: "Name", value: "CreateExtensionVersion" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: { kind: "Variable", name: { kind: "Name", value: "input" } },
+          type: {
+            kind: "NonNullType",
+            type: {
+              kind: "NamedType",
+              name: { kind: "Name", value: "CreateExtensionVersionInput" }
+            }
+          }
+        }
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "createExtensionVersion" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "input" },
+                value: { kind: "Variable", name: { kind: "Name", value: "input" } }
+              }
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "__typename" } },
+                {
+                  kind: "InlineFragment",
+                  typeCondition: {
+                    kind: "NamedType",
+                    name: { kind: "Name", value: "CreateExtensionVersionSuccessResult" }
+                  },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      {
+                        kind: "Field",
+                        name: { kind: "Name", value: "extensionVersion" },
+                        selectionSet: {
+                          kind: "SelectionSet",
+                          selections: [{ kind: "Field", name: { kind: "Name", value: "id" } }]
+                        }
+                      },
+                      { kind: "Field", name: { kind: "Name", value: "signedUrl" } }
+                    ]
+                  }
+                },
+                {
+                  kind: "InlineFragment",
+                  typeCondition: { kind: "NamedType", name: { kind: "Name", value: "Error" } },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [{ kind: "Field", name: { kind: "Name", value: "message" } }]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+const createExtensionVersion$1 = ({
+  client: client2,
+  variables,
+  sessionAuthToken
+}) => client2.request({
+  document: CreateExtensionVersionDocument,
+  variables,
+  requestHeaders: {
+    Authorization: `Bearer ${sessionAuthToken}`
+  }
+});
 const bytesFormat = Intl.NumberFormat("en", {
   notation: "compact",
   style: "unit",
@@ -57107,64 +60696,58 @@ const bytesFormat = Intl.NumberFormat("en", {
   minimumFractionDigits: 1,
   maximumFractionDigits: 1
 });
-const createExtensionVersionResultDataSchema = z.discriminatedUnion("__typename", [
-  z.object({
-    __typename: z.literal("CreateExtensionVersionSuccessResult"),
-    extensionVersion: z.object({
-      id: z.string()
-    }),
-    signedUrl: z.string()
-  }),
-  z.object({
-    __typename: z.literal("AuthorizationError"),
-    message: z.string()
-  }),
-  z.object({
-    __typename: z.literal("GenericInternalError"),
-    message: z.string()
-  }),
-  z.object({
-    __typename: z.literal("GenericUserError"),
-    message: z.string()
-  })
-]);
-const graphQlErrorSchema = z.object({
-  message: z.string()
-});
-const createExtensionVersionResultSchema = z.object({
-  errors: z.array(graphQlErrorSchema).optional().nullable(),
-  data: z.object({
-    createExtensionVersion: createExtensionVersionResultDataSchema
-  }).nullable()
-});
+const ignoreGlobs = [
+  "**/.git/**/*",
+  ".git/**/*",
+  "eslint.config.js",
+  "**/eslint.config.js",
+  "node_modules/**/*",
+  "**/node_modules/**/*",
+  "yalc.lock",
+  "**/yalc.lock"
+];
 const createExtensionVersion = async (opts, env2) => {
   const extensionId = requireExtensionIdOptionOrEnvVar(opts, env2);
   const apiToken = requireApiToken(env2);
   const cwd = process.cwd();
-  const extConfig = await requireValidExtensionDir(cwd);
+  const { manifest } = await requireValidExtensionDir(cwd);
   let enableServer;
   let enableDb;
-  if (extConfig.server) {
-    enableServer = !!extConfig.server.enable;
-    if (extConfig.server.database?.enable && extConfig.server.enable === false) {
+  if (manifest.server) {
+    enableServer = !!manifest.server.enable;
+    if (manifest.server.database?.enable && manifest.server.enable === false) {
       console.warn("WARNING: Automatically disabling database because server is disabled");
       enableDb = false;
-    } else if (extConfig.server.database?.enable && !extConfig.server.enable) {
+    } else if (manifest.server.database?.enable && !manifest.server.enable) {
       console.warn("WARNING: Automatically enabling server because database is enabled");
       enableServer = true;
       enableDb = true;
     } else {
-      enableDb = !!extConfig.server.database?.enable;
+      enableDb = !!manifest.server.database?.enable;
     }
   } else {
     enableServer = false;
     enableDb = false;
   }
+  let config2 = null;
+  if (opts.configFile) {
+    const configFilePath = resolve$1(cwd, opts.configFile);
+    if (opts.verbose) {
+      console.log(`Loading config file ${configFilePath}`);
+    }
+    const configFile = await readFile(configFilePath, "utf8");
+    try {
+      config2 = parseEnv$1(configFile);
+    } catch (e) {
+      console.error(`Failed to parse config file at ${configFilePath}:`, parseErrorMessage(e));
+      process.exit(1);
+    }
+  }
   const { versionName } = opts;
   console.log(`Creating extension version ${versionName} (Extension ID ${extensionId})
   Server: ${enableServer ? "enabled" : "disabled"}
   Database: ${enableDb ? "enabled" : "disabled"}
-  Components: ${Object.keys(extConfig.components ?? {}).length}`);
+  Components: ${Object.keys(manifest.components ?? {}).length}`);
   let extensionVersionId;
   let signedUrl;
   try {
@@ -57172,69 +60755,28 @@ const createExtensionVersion = async (opts, env2) => {
     if (opts.verbose) {
       console.log(`POST ${url}`);
     }
-    const createResult = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiToken}`
-      },
-      body: JSON.stringify({
-        query: `
-          mutation ($input: CreateExtensionVersionInput!) {
-            createExtensionVersion(input: $input) {
-              __typename
-              ... on CreateExtensionVersionSuccessResult {
-                extensionVersion {
-                  id
-                }
-                signedUrl
-              }
-              ... on Error {
-                message
-              }
-            }
-          }
-        `,
-        variables: {
-          input: {
-            extensionId,
-            extensionName: extConfig.name,
-            versionName,
-            enableServer,
-            enableDb
-          }
+    const result2 = await createExtensionVersion$1({
+      client: new GraphQLClient(url),
+      variables: {
+        input: {
+          extensionId,
+          extensionName: manifest.name,
+          versionName,
+          manifest: JSON.stringify(manifest),
+          enableServer,
+          enableDb,
+          config: config2 ? JSON.stringify(config2) : void 0
         }
-      })
+      },
+      sessionAuthToken: apiToken
     });
-    if (!createResult.ok) {
-      const message = `Failed to create an extension version (status ${createResult.status})`;
-      try {
-        const data2 = await createResult.json();
-        console.error(`${message}:`, parseErrorMessage(data2));
-        process.exit(1);
-      } catch {
-        console.error(message);
-        process.exit(1);
-      }
-    }
-    const data = await createResult.json();
-    const parseResult = createExtensionVersionResultSchema.safeParse(data);
-    if (!parseResult.success) {
-      console.error("Failed to create an extension version:", parseResult.error.message);
-      process.exit(1);
-    }
-    const result2 = parseResult.data;
-    if (result2.errors) {
-      console.error("Failed to create an extension version:", parseErrorMessage(result2));
-      process.exit(1);
-    }
-    if (result2.data?.createExtensionVersion.__typename === "CreateExtensionVersionSuccessResult") {
-      extensionVersionId = result2.data.createExtensionVersion.extensionVersion.id;
-      signedUrl = result2.data.createExtensionVersion.signedUrl;
+    if (result2.createExtensionVersion.__typename === "CreateExtensionVersionSuccessResult") {
+      extensionVersionId = result2.createExtensionVersion.extensionVersion.id;
+      signedUrl = result2.createExtensionVersion.signedUrl;
     } else {
       console.error(
-        `Failed to create an extension version (${result2.data?.createExtensionVersion.__typename ?? "unknown error"}):`,
-        parseErrorMessage(result2.data?.createExtensionVersion)
+        `Failed to create an extension version (${result2.createExtensionVersion.__typename}):`,
+        result2.createExtensionVersion.message
       );
       process.exit(1);
     }
@@ -57265,14 +60807,7 @@ const createExtensionVersion = async (opts, env2) => {
   }
   archive.glob("**/*", {
     cwd,
-    ignore: [
-      "**/.git/**/*",
-      ".git/**/*",
-      "eslint.config.js",
-      "**/eslint.config.js",
-      "node_modules/**/*",
-      "**/node_modules/**/*"
-    ]
+    ignore: ignoreGlobs
   });
   if (opts.verbose) {
     console.log(`Uploading files at ${cwd}`);
@@ -57456,9 +60991,11 @@ const createUser = async (opts, env2) => {
     process.exit(1);
   }
 };
-const Permission = {
+const PermissionName = {
   /** Create (i.e., add) extensions. */
   CreateExtension: "CreateExtension",
+  /** Create extension versions for existing extensions. This includes deploying new code. */
+  CreateExtensionVersion: "CreateExtensionVersion",
   /** Create sites. */
   CreateSite: "CreateSite",
   /** Create page and form templates. */
@@ -57477,7 +61014,7 @@ const Permission = {
   EditCustomField: "EditCustomField",
   /** Edit any customer site, including its pages and forms, but not necessarily domain. */
   EditCustomerSite: "EditCustomerSite",
-  /** Edit any extension. */
+  /** Edit any extension. This does not include creating extension versions (i.e., deploying new code). */
   EditExtension: "EditExtension",
   /** Edit any help ticket's status. */
   EditHelpTicketStatus: "EditHelpTicketStatus",
@@ -57522,7 +61059,7 @@ const Permission = {
   /** View any page or form template. */
   ViewTemplate: "ViewTemplate"
 };
-const allPermissions = Object.values(Permission);
+const allPermissions = Object.values(PermissionName);
 const revokeAllUserPlatformPermissions = async ({
   platformAdminId
 }, db) => {
@@ -57648,7 +61185,7 @@ const editAdmin = async (opts, env2) => {
     process.exit(1);
   }
 };
-const dbConnectInfo = async (opts, env2) => {
+const getDbUrl = async (opts, env2) => {
   const connInfo = getExtensionDbConnectInfo(opts, env2);
   const url = connInfo.url.toString();
   const cwd = process.cwd();
@@ -57778,7 +61315,7 @@ const applyExtensionPolicy = async ({
 const initDb = async (opts, env2) => {
   const coreDbUrl = requireCoreDbUrl(env2);
   const extensionId = requireExtensionIdOptionOrEnvVar(opts, env2);
-  await dbConnectInfo(opts, env2);
+  await getDbUrl(opts, env2);
   const db = await distExports$1.createPool(coreDbUrl, dbPoolOptions(opts));
   const extension = await db.maybeOne(distExports$1.sql.type(extensionSelectSchema)`
     select "id", "platformId"
@@ -57847,7 +61384,7 @@ const initDb = async (opts, env2) => {
 };
 const program = new Command().name("wirechunk").option("--verbose", "output debug logging").option(
   "--env-mode <mode>",
-  'the mode to use for finding .env files to load environment variables, such as "test" to load .env, .env.test, .env.local, and .env.test.local'
+  'the mode to use for finding .env files to load environment variables, such as "test" to load .env, .env.test, .env.local, and .env.test.local; also for finding config files to include when creating an extension or extension version, such as config.production.json'
 ).description(`The official Wirechunk CLI
 
 By default, environment variables are loaded from the .env file in the current working directory,
@@ -57875,7 +61412,10 @@ program.command("bootstrap").description("create a platform").requiredOption("--
 program.command("create-extension-version").description("create an extension version").option(
   "--extension-id <string>",
   "the ID of the extension, can be set with an EXTENSION_ID environment variable instead"
-).requiredOption("--version-name <string>", "the name of the version").action(withOptionsAndEnv(createExtensionVersion));
+).requiredOption("--version-name <string>", "the name of the version").option(
+  "--config-file <string>",
+  "the path to a file to use when creating the extension version, containing environment-style key-value pairs"
+).action(withOptionsAndEnv(createExtensionVersion));
 program.command("create-user").description("create a user").requiredOption("--email <string>", "the email address of the user").requiredOption("--password <string>", "the password of the user").requiredOption("--first-name <string>", "the first name of the user").requiredOption("--last-name <string>", "the last name of the user").option(
   "--org-id <string>",
   "the ID of the org to which the user belongs, defaults to creating a new org if not specified"
@@ -57886,12 +61426,12 @@ program.command("create-user").description("create a user").requiredOption("--em
   new Option("--role <string>", "the role the user will have").default("OrganizationOwner")
 ).option("--email-verified", "mark the email address as already verified by the user", false).option("--pending", "create the user in a pending state", false).action(withOptionsAndEnv(createUser));
 const extDev = program.command("ext-dev").description("extension development commands");
-extDev.command("db-connect-info").description(
-  "write the connection info for the extension database to a .local.env or .local.<env-mode>.env file"
+extDev.command("get-db-url").description(
+  "write the connection info for the extension database to a .env.local or .env.<env-mode>.local file"
 ).option(
   "--extension-id <string>",
   "the ID of the extension, can be set with an EXTENSION_ID environment variable instead"
-).action(withOptionsAndEnv(dbConnectInfo));
+).action(withOptionsAndEnv(getDbUrl));
 extDev.command("init-db").description(
   "initialize a development database for an extension, useful for testing, assumes the extension role exists"
 ).option(