@base44-preview/cli 0.0.31-pr.241.c74aebb → 0.0.31-pr.242.7d2e6b5

package/dist/cli/index.js

@@ -9653,12 +9653,12 @@ var require_schema = __commonJS((exports, module) => {
   var common = require_common3();
   var YAMLException = require_exception();
   var Type = require_type();
-  function compileList(schema4, name2, result) {
+  function compileList(schema5, name2, result) {
     var exclude = [];
-    schema4.include.forEach(function(includedSchema) {
+    schema5.include.forEach(function(includedSchema) {
       result = compileList(includedSchema, name2, result);
     });
-    schema4[name2].forEach(function(currentType) {
+    schema5[name2].forEach(function(currentType) {
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
           exclude.push(previousIndex);
@@ -9715,8 +9715,8 @@ var require_schema = __commonJS((exports, module) => {
     }
     schemas3 = common.toArray(schemas3);
     types = common.toArray(types);
-    if (!schemas3.every(function(schema4) {
-      return schema4 instanceof Schema;
+    if (!schemas3.every(function(schema5) {
+      return schema5 instanceof Schema;
     })) {
       throw new YAMLException("Specified list of super schemas (or a single Schema object) contains a non-Schema object.");
     }
@@ -11737,7 +11737,7 @@ var require_dumper = __commonJS((exports, module) => {
     "Off",
     "OFF"
   ];
-  function compileStyleMap(schema4, map2) {
+  function compileStyleMap(schema5, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -11749,7 +11749,7 @@ var require_dumper = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema4.compiledTypeMap["fallback"][tag];
+      type = schema5.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -108409,11 +108409,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema7 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema7);
+  const schema8 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema8);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema7, Schema.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema8, Schema.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -108670,8 +108670,8 @@ async function loadEditorconfigInternal(file2, { shouldCache }) {
   const directory = path52.dirname(file2);
   const root2 = await findProjectRoot2(directory, { shouldCache });
   const editorConfig = await import_editorconfig.default.parse(file2, { root: root2 });
-  const config9 = editorconfig_to_prettier_default(editorConfig);
-  return config9;
+  const config10 = editorconfig_to_prettier_default(editorConfig);
+  return config10;
 }
 function loadEditorconfig(file2, { shouldCache }) {
   file2 = path52.resolve(file2);
@@ -108855,7 +108855,7 @@ function unicodeEscape() {
   }
   return String.fromCodePoint(parseInt(buffer2, 16));
 }
-function push2() {
+function push3() {
   let value;
   switch (token.type) {
     case "punctuator":
@@ -110661,18 +110661,18 @@ async function loadConfig(configFile) {
   if (!load2) {
     throw new Error(`No loader specified for extension "${extension || "noExt"}"`);
   }
-  let config9 = await load2(configFile);
-  if (!config9) {
+  let config10 = await load2(configFile);
+  if (!config10) {
     return;
   }
-  if (typeof config9 === "string") {
-    config9 = await load_external_config_default(config9, configFile);
+  if (typeof config10 === "string") {
+    config10 = await load_external_config_default(config10, configFile);
   }
-  if (typeof config9 !== "object") {
-    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config9} in "${configFile}"`);
+  if (typeof config10 !== "object") {
+    throw new TypeError(`Config is only allowed to be an object, but received ${typeof config10} in "${configFile}"`);
   }
-  delete config9.$schema;
-  return config9;
+  delete config10.$schema;
+  return config10;
 }
 function clearPrettierConfigCache() {
   loadCache.clear();
@@ -110722,8 +110722,8 @@ async function loadPrettierConfig2(file2, options8) {
     return;
   }
   configFile = toPath3(configFile);
-  const config9 = await loadPrettierConfig(configFile, { shouldCache });
-  return { config: config9, configFile };
+  const config10 = await loadPrettierConfig(configFile, { shouldCache });
+  return { config: config10, configFile };
 }
 async function resolveConfig(fileUrlOrPath, options8) {
   options8 = { useCache: true, ...options8 };
@@ -110750,8 +110750,8 @@ async function resolveConfigFile(fileUrlOrPath) {
   return result ?? null;
 }
 function mergeOverrides(configResult, filePath) {
-  const { config: config9, configFile } = configResult || {};
-  const { overrides, ...options8 } = config9 || {};
+  const { config: config10, configFile } = configResult || {};
+  const { overrides, ...options8 } = config10 || {};
   if (filePath && overrides) {
     const relativeFilePath = path102.relative(path102.dirname(configFile), filePath);
     for (const override of overrides) {
@@ -111753,9 +111753,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema7, utils3) => optionInfo.exception(value) || schema7.validate(value, utils3);
+    parameters.validate = (value, schema8, utils3) => optionInfo.exception(value) || schema8.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema7, utils3) => value === undefined || schema7.validate(value, utils3);
+    parameters.validate = (value, schema8, utils3) => value === undefined || schema8.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -111770,7 +111770,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x9) => x9);
-    parameters.preprocess = (value, schema7, utils3) => schema7.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema8, utils3) => schema8.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -112860,16 +112860,16 @@ async function getFileInfo(file2, options8 = {}) {
   };
 }
 async function getParser(file2, options8) {
-  let config9;
+  let config10;
   if (options8.resolveConfig !== false) {
-    config9 = await resolveConfig(file2, {
+    config10 = await resolveConfig(file2, {
       editorconfig: false
     });
   }
-  if (config9?.parser) {
-    return config9.parser;
+  if (config10?.parser) {
+    return config10.parser;
   }
-  let plugins = options8.plugins ?? config9?.plugins ?? [];
+  let plugins = options8.plugins ?? config10?.plugins ?? [];
   plugins = (await Promise.all([load_builtin_plugins_default(), load_plugins_default(plugins)])).flat();
   return infer_parser_default({ plugins }, { physicalFile: file2 });
 }
@@ -113347,9 +113347,9 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema7 = this._utils.schemas[key2];
+      const schema8 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema7.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema8.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -113360,13 +113360,13 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema7 = this._utils.schemas[key2];
+      const schema8 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema7.postprocess(value, this._utils);
+      const newValue = schema8.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema7);
+      this._applyValidation(newValue, key2, schema8);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -113377,14 +113377,14 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema7 = this._utils.schemas[key2];
-      const value = schema7.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema7);
+      const schema8 = this._utils.schemas[key2];
+      const value = schema8.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema8);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema7.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema8.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -113402,13 +113402,13 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema7.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema8.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema7.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema8.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema7.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema8.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -113436,8 +113436,8 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     const [knownKeys, unknownKeys] = partition(Object.keys(options8).filter((key2) => !this._identifyMissing(key2, options8)), (key2) => (key2 in this._utils.schemas));
     return { knownKeys, unknownKeys };
   }
-  _applyValidation(value, key2, schema7) {
-    const validateResult = normalizeValidateResult(schema7.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema8) {
+    const validateResult = normalizeValidateResult(schema8.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -113479,8 +113479,8 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema7 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema7);
+          const schema8 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema8);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -114538,12 +114538,12 @@ var init_prettier = __esm(() => {
           return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options8);
         }
         let parts = { negatives: [], positives: [] };
-        let push2 = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
+        let push22 = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
         let range = [];
         let index = 0;
         while (descending ? a5 >= b9 : a5 <= b9) {
           if (options8.toRegex === true && step > 1) {
-            push2(a5);
+            push22(a5);
           } else {
             range.push(pad(format3(a5, index), maxLen, toNumber));
           }
@@ -114844,7 +114844,7 @@ var init_prettier = __esm(() => {
         let depth = 0;
         let value;
         const advance = () => input[index++];
-        const push2 = (node) => {
+        const push22 = (node) => {
           if (node.type === "text" && prev.type === "dot") {
             prev.type = "text";
           }
@@ -114858,7 +114858,7 @@ var init_prettier = __esm(() => {
           prev = node;
           return node;
         };
-        push2({ type: "bos" });
+        push22({ type: "bos" });
         while (index < length) {
           block = stack2[stack2.length - 1];
           value = advance();
@@ -114866,11 +114866,11 @@ var init_prettier = __esm(() => {
             continue;
           }
           if (value === CHAR_BACKSLASH) {
-            push2({ type: "text", value: (options8.keepEscaping ? value : "") + advance() });
+            push22({ type: "text", value: (options8.keepEscaping ? value : "") + advance() });
             continue;
           }
           if (value === CHAR_RIGHT_SQUARE_BRACKET) {
-            push2({ type: "text", value: "\\" + value });
+            push22({ type: "text", value: "\\" + value });
             continue;
           }
           if (value === CHAR_LEFT_SQUARE_BRACKET) {
@@ -114893,22 +114893,22 @@ var init_prettier = __esm(() => {
                 }
               }
             }
-            push2({ type: "text", value });
+            push22({ type: "text", value });
             continue;
           }
           if (value === CHAR_LEFT_PARENTHESES) {
-            block = push2({ type: "paren", nodes: [] });
+            block = push22({ type: "paren", nodes: [] });
             stack2.push(block);
-            push2({ type: "text", value });
+            push22({ type: "text", value });
             continue;
           }
           if (value === CHAR_RIGHT_PARENTHESES) {
             if (block.type !== "paren") {
-              push2({ type: "text", value });
+              push22({ type: "text", value });
               continue;
             }
             block = stack2.pop();
-            push2({ type: "text", value });
+            push22({ type: "text", value });
             block = stack2[stack2.length - 1];
             continue;
           }
@@ -114930,7 +114930,7 @@ var init_prettier = __esm(() => {
               }
               value += next;
             }
-            push2({ type: "text", value });
+            push22({ type: "text", value });
             continue;
           }
           if (value === CHAR_LEFT_CURLY_BRACE) {
@@ -114946,20 +114946,20 @@ var init_prettier = __esm(() => {
               ranges: 0,
               nodes: []
             };
-            block = push2(brace);
+            block = push22(brace);
             stack2.push(block);
-            push2({ type: "open", value });
+            push22({ type: "open", value });
             continue;
           }
           if (value === CHAR_RIGHT_CURLY_BRACE) {
             if (block.type !== "brace") {
-              push2({ type: "text", value });
+              push22({ type: "text", value });
               continue;
             }
             const type = "close";
             block = stack2.pop();
             block.close = true;
-            push2({ type, value });
+            push22({ type, value });
             depth--;
             block = stack2[stack2.length - 1];
             continue;
@@ -114970,14 +114970,14 @@ var init_prettier = __esm(() => {
               const open2 = block.nodes.shift();
               block.nodes = [open2, { type: "text", value: stringify2(block) }];
             }
-            push2({ type: "comma", value });
+            push22({ type: "comma", value });
             block.commas++;
             continue;
           }
           if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
             const siblings = block.nodes;
             if (depth === 0 || siblings.length === 0) {
-              push2({ type: "text", value });
+              push22({ type: "text", value });
               continue;
             }
             if (prev.type === "dot") {
@@ -115002,10 +115002,10 @@ var init_prettier = __esm(() => {
               block.ranges--;
               continue;
             }
-            push2({ type: "dot", value });
+            push22({ type: "dot", value });
             continue;
           }
-          push2({ type: "text", value });
+          push22({ type: "text", value });
         }
         do {
           block = stack2.pop();
@@ -115026,7 +115026,7 @@ var init_prettier = __esm(() => {
             parent.nodes.splice(index2, 1, ...block.nodes);
           }
         } while (stack2.length > 0);
-        push2({ type: "eos" });
+        push22({ type: "eos" });
         return ast;
       };
       module.exports = parse72;
@@ -115735,7 +115735,7 @@ var init_prettier = __esm(() => {
           state[type]--;
           stack2.pop();
         };
-        const push2 = (tok) => {
+        const push22 = (tok) => {
           if (prev.type === "globstar") {
             const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
             const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
@@ -115768,8 +115768,8 @@ var init_prettier = __esm(() => {
           token2.output = state.output;
           const output = (opts.capture ? "(" : "") + token2.open;
           increment2("parens");
-          push2({ type, value: value2, output: state.output ? "" : ONE_CHAR });
-          push2({ type: "paren", extglob: true, value: advance(), output });
+          push22({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+          push22({ type: "paren", extglob: true, value: advance(), output });
           extglobs.push(token2);
         };
         const extglobClose = (token2) => {
@@ -115791,7 +115791,7 @@ var init_prettier = __esm(() => {
               state.negatedExtglob = true;
             }
           }
-          push2({ type: "paren", extglob: true, value, output });
+          push22({ type: "paren", extglob: true, value, output });
           decrement("parens");
         };
         if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
@@ -115852,7 +115852,7 @@ var init_prettier = __esm(() => {
             }
             if (!next) {
               value += "\\";
-              push2({ type: "text", value });
+              push22({ type: "text", value });
               continue;
             }
             const match = /^\\+/.exec(remaining());
@@ -115870,7 +115870,7 @@ var init_prettier = __esm(() => {
               value += advance();
             }
             if (state.brackets === 0) {
-              push2({ type: "text", value });
+              push22({ type: "text", value });
               continue;
             }
           }
@@ -115918,13 +115918,13 @@ var init_prettier = __esm(() => {
           if (value === '"') {
             state.quotes = state.quotes === 1 ? 0 : 1;
             if (opts.keepQuotes === true) {
-              push2({ type: "text", value });
+              push22({ type: "text", value });
             }
             continue;
           }
           if (value === "(") {
             increment2("parens");
-            push2({ type: "paren", value });
+            push22({ type: "paren", value });
             continue;
           }
           if (value === ")") {
@@ -115936,7 +115936,7 @@ var init_prettier = __esm(() => {
               extglobClose(extglobs.pop());
               continue;
             }
-            push2({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+            push22({ type: "paren", value, output: state.parens ? ")" : "\\)" });
             decrement("parens");
             continue;
           }
@@ -115949,19 +115949,19 @@ var init_prettier = __esm(() => {
             } else {
               increment2("brackets");
             }
-            push2({ type: "bracket", value });
+            push22({ type: "bracket", value });
             continue;
           }
           if (value === "]") {
             if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
-              push2({ type: "text", value, output: `\\${value}` });
+              push22({ type: "text", value, output: `\\${value}` });
               continue;
             }
             if (state.brackets === 0) {
               if (opts.strictBrackets === true) {
                 throw new SyntaxError(syntaxError2("opening", "["));
               }
-              push2({ type: "text", value, output: `\\${value}` });
+              push22({ type: "text", value, output: `\\${value}` });
               continue;
             }
             decrement("brackets");
@@ -115995,13 +115995,13 @@ var init_prettier = __esm(() => {
               tokensIndex: state.tokens.length
             };
             braces.push(open2);
-            push2(open2);
+            push22(open2);
             continue;
           }
           if (value === "}") {
             const brace = braces[braces.length - 1];
             if (opts.nobrace === true || !brace) {
-              push2({ type: "text", value, output: value });
+              push22({ type: "text", value, output: value });
               continue;
             }
             let output = ")";
@@ -116030,7 +116030,7 @@ var init_prettier = __esm(() => {
                 state.output += t25.output || t25.value;
               }
             }
-            push2({ type: "brace", value, output });
+            push22({ type: "brace", value, output });
             decrement("braces");
             braces.pop();
             continue;
@@ -116039,7 +116039,7 @@ var init_prettier = __esm(() => {
             if (extglobs.length > 0) {
               extglobs[extglobs.length - 1].conditions++;
             }
-            push2({ type: "text", value });
+            push22({ type: "text", value });
             continue;
           }
           if (value === ",") {
@@ -116049,7 +116049,7 @@ var init_prettier = __esm(() => {
               brace.comma = true;
               output = "|";
             }
-            push2({ type: "comma", value, output });
+            push22({ type: "comma", value, output });
             continue;
           }
           if (value === "/") {
@@ -116061,7 +116061,7 @@ var init_prettier = __esm(() => {
               prev = bos;
               continue;
             }
-            push2({ type: "slash", value, output: SLASH_LITERAL });
+            push22({ type: "slash", value, output: SLASH_LITERAL });
             continue;
           }
           if (value === ".") {
@@ -116076,10 +116076,10 @@ var init_prettier = __esm(() => {
               continue;
             }
             if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
-              push2({ type: "text", value, output: DOT_LITERAL });
+              push22({ type: "text", value, output: DOT_LITERAL });
               continue;
             }
-            push2({ type: "dot", value, output: DOT_LITERAL });
+            push22({ type: "dot", value, output: DOT_LITERAL });
             continue;
           }
           if (value === "?") {
@@ -116097,14 +116097,14 @@ var init_prettier = __esm(() => {
               if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
                 output = `\\${value}`;
               }
-              push2({ type: "text", value, output });
+              push22({ type: "text", value, output });
               continue;
             }
             if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
-              push2({ type: "qmark", value, output: QMARK_NO_DOT });
+              push22({ type: "qmark", value, output: QMARK_NO_DOT });
               continue;
             }
-            push2({ type: "qmark", value, output: QMARK });
+            push22({ type: "qmark", value, output: QMARK });
             continue;
           }
           if (value === "!") {
@@ -116125,22 +116125,22 @@ var init_prettier = __esm(() => {
               continue;
             }
             if (prev && prev.value === "(" || opts.regex === false) {
-              push2({ type: "plus", value, output: PLUS_LITERAL });
+              push22({ type: "plus", value, output: PLUS_LITERAL });
               continue;
             }
             if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
-              push2({ type: "plus", value });
+              push22({ type: "plus", value });
               continue;
             }
-            push2({ type: "plus", value: PLUS_LITERAL });
+            push22({ type: "plus", value: PLUS_LITERAL });
             continue;
           }
           if (value === "@") {
             if (opts.noextglob !== true && peek2() === "(" && peek2(2) !== "?") {
-              push2({ type: "at", extglob: true, value, output: "" });
+              push22({ type: "at", extglob: true, value, output: "" });
               continue;
             }
-            push2({ type: "text", value });
+            push22({ type: "text", value });
             continue;
           }
           if (value !== "*") {
@@ -116152,7 +116152,7 @@ var init_prettier = __esm(() => {
               value += match[0];
               state.index += match[0].length;
             }
-            push2({ type: "text", value });
+            push22({ type: "text", value });
             continue;
           }
           if (prev && (prev.type === "globstar" || prev.star === true)) {
@@ -116180,13 +116180,13 @@ var init_prettier = __esm(() => {
             const isStart = prior.type === "slash" || prior.type === "bos";
             const afterStar = before && (before.type === "star" || before.type === "globstar");
             if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
-              push2({ type: "star", value, output: "" });
+              push22({ type: "star", value, output: "" });
               continue;
             }
             const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
             const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
             if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
-              push2({ type: "star", value, output: "" });
+              push22({ type: "star", value, output: "" });
               continue;
             }
             while (rest.slice(0, 3) === "/**") {
@@ -116227,7 +116227,7 @@ var init_prettier = __esm(() => {
               state.output += prior.output + prev.output;
               state.globstar = true;
               consume(value + advance());
-              push2({ type: "slash", value: "/", output: "" });
+              push22({ type: "slash", value: "/", output: "" });
               continue;
             }
             if (prior.type === "bos" && rest[0] === "/") {
@@ -116237,7 +116237,7 @@ var init_prettier = __esm(() => {
               state.output = prev.output;
               state.globstar = true;
               consume(value + advance());
-              push2({ type: "slash", value: "/", output: "" });
+              push22({ type: "slash", value: "/", output: "" });
               continue;
             }
             state.output = state.output.slice(0, -prev.output.length);
@@ -116255,12 +116255,12 @@ var init_prettier = __esm(() => {
             if (prev.type === "bos" || prev.type === "slash") {
               token2.output = nodot + token2.output;
             }
-            push2(token2);
+            push22(token2);
             continue;
           }
           if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
             token2.output = value;
-            push2(token2);
+            push22(token2);
             continue;
           }
           if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
@@ -116279,7 +116279,7 @@ var init_prettier = __esm(() => {
               prev.output += ONE_CHAR;
             }
           }
-          push2(token2);
+          push22(token2);
         }
         while (state.brackets > 0) {
           if (opts.strictBrackets === true)
@@ -116300,7 +116300,7 @@ var init_prettier = __esm(() => {
           decrement("braces");
         }
         if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
-          push2({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+          push22({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
         }
         if (state.backtrack === true) {
           state.output = "";
@@ -117648,7 +117648,7 @@ var init_prettier = __esm(() => {
         var _running = 0;
         var errorHandler = null;
         var self2 = {
-          push: push2,
+          push: push22,
           drain: noop22,
           saturated: noop22,
           pause,
@@ -117721,7 +117721,7 @@ var init_prettier = __esm(() => {
         function idle() {
           return _running === 0 && self2.length() === 0;
         }
-        function push2(value, done) {
+        function push22(value, done) {
           var current = cache3.get();
           current.context = context;
           current.release = release;
@@ -117837,11 +117837,11 @@ var init_prettier = __esm(() => {
         var queue = fastqueue(context, asyncWrapper, _concurrency);
         var pushCb = queue.push;
         var unshiftCb = queue.unshift;
-        queue.push = push2;
+        queue.push = push22;
         queue.unshift = unshift2;
         queue.drained = drained;
         return queue;
-        function push2(value) {
+        function push22(value) {
           var p4 = new Promise(function(resolve32, reject) {
             pushCb(value, function(err, result) {
               if (err) {
@@ -119683,7 +119683,7 @@ var init_prettier = __esm(() => {
       };
       Yallist2.prototype.push = function() {
         for (var i5 = 0, l7 = arguments.length;i5 < l7; i5++) {
-          push2(this, arguments[i5]);
+          push22(this, arguments[i5]);
         }
         return this.length;
       };
@@ -119885,7 +119885,7 @@ var init_prettier = __esm(() => {
         this.tail = head;
         return this;
       };
-      function push2(self2, item) {
+      function push22(self2, item) {
         self2.tail = new Node2(item, self2.tail, null, self2);
         if (!self2.head) {
           self2.head = self2.tail;
@@ -123177,7 +123177,7 @@ globstar while`, file2, fr10, pattern, pr8, swallowee);
       if (token.type === "eof") {
         throw invalidEOF();
       }
-      push2();
+      push3();
     },
     beforePropertyName() {
       switch (token.type) {
@@ -123203,7 +123203,7 @@ globstar while`, file2, fr10, pattern, pr8, swallowee);
       if (token.type === "eof") {
         throw invalidEOF();
       }
-      push2();
+      push3();
     },
     beforeArrayValue() {
       if (token.type === "eof") {
@@ -123213,7 +123213,7 @@ globstar while`, file2, fr10, pattern, pr8, swallowee);
         pop();
         return;
       }
-      push2();
+      push3();
     },
     afterPropertyValue() {
       if (token.type === "eof") {
@@ -127193,23 +127193,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema7) => {
-    const parent = schema7[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema8) => {
+    const parent = schema8[exports.Parent];
     if (!parent) {
-      return schema7;
+      return schema8;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema7) {
-    return schema7 === true || schema7 === false;
+  function isBoolean(schema8) {
+    return schema8 === true || schema8 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema7) {
-    return !(0, lodash_1.isPlainObject)(schema7);
+  function isPrimitive(schema8) {
+    return !(0, lodash_1.isPlainObject)(schema8);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema7) {
-    return Array.isArray(schema7.type) || "anyOf" in schema7 || "oneOf" in schema7;
+  function isCompound(schema8) {
+    return Array.isArray(schema8.type) || "anyOf" in schema8 || "oneOf" in schema8;
   }
   exports.isCompound = isCompound;
 });
@@ -127436,9 +127436,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema2 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema7, name2) {
+  function compileList(schema8, name2) {
     var result = [];
-    schema7[name2].forEach(function(currentType) {
+    schema8[name2].forEach(function(currentType) {
       var newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -129383,7 +129383,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema7, map2) {
+  function compileStyleMap(schema8, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -129395,7 +129395,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema7.compiledTypeMap["fallback"][tag];
+      type = schema8.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -130054,11 +130054,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k10) => traverse(s5, callback, processed, k10.toString()));
   }
-  function traverseIntersection(schema7, callback, processed) {
-    if (typeof schema7 !== "object" || !schema7) {
+  function traverseIntersection(schema8, callback, processed) {
+    if (typeof schema8 !== "object" || !schema8) {
       return;
     }
-    const r5 = schema7;
+    const r5 = schema8;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -130067,60 +130067,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema7, callback, processed = new Set, key2) {
-    if (processed.has(schema7)) {
+  function traverse(schema8, callback, processed = new Set, key2) {
+    if (processed.has(schema8)) {
       return;
     }
-    processed.add(schema7);
-    callback(schema7, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema7.anyOf) {
-      traverseArray(schema7.anyOf, callback, processed);
+    processed.add(schema8);
+    callback(schema8, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema8.anyOf) {
+      traverseArray(schema8.anyOf, callback, processed);
     }
-    if (schema7.allOf) {
-      traverseArray(schema7.allOf, callback, processed);
+    if (schema8.allOf) {
+      traverseArray(schema8.allOf, callback, processed);
     }
-    if (schema7.oneOf) {
-      traverseArray(schema7.oneOf, callback, processed);
+    if (schema8.oneOf) {
+      traverseArray(schema8.oneOf, callback, processed);
     }
-    if (schema7.properties) {
-      traverseObjectKeys(schema7.properties, callback, processed);
+    if (schema8.properties) {
+      traverseObjectKeys(schema8.properties, callback, processed);
     }
-    if (schema7.patternProperties) {
-      traverseObjectKeys(schema7.patternProperties, callback, processed);
+    if (schema8.patternProperties) {
+      traverseObjectKeys(schema8.patternProperties, callback, processed);
     }
-    if (schema7.additionalProperties && typeof schema7.additionalProperties === "object") {
-      traverse(schema7.additionalProperties, callback, processed);
+    if (schema8.additionalProperties && typeof schema8.additionalProperties === "object") {
+      traverse(schema8.additionalProperties, callback, processed);
     }
-    if (schema7.items) {
-      const { items } = schema7;
+    if (schema8.items) {
+      const { items } = schema8;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema7.additionalItems && typeof schema7.additionalItems === "object") {
-      traverse(schema7.additionalItems, callback, processed);
+    if (schema8.additionalItems && typeof schema8.additionalItems === "object") {
+      traverse(schema8.additionalItems, callback, processed);
     }
-    if (schema7.dependencies) {
-      if (Array.isArray(schema7.dependencies)) {
-        traverseArray(schema7.dependencies, callback, processed);
+    if (schema8.dependencies) {
+      if (Array.isArray(schema8.dependencies)) {
+        traverseArray(schema8.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema7.dependencies, callback, processed);
+        traverseObjectKeys(schema8.dependencies, callback, processed);
       }
     }
-    if (schema7.definitions) {
-      traverseObjectKeys(schema7.definitions, callback, processed);
+    if (schema8.definitions) {
+      traverseObjectKeys(schema8.definitions, callback, processed);
     }
-    if (schema7.$defs) {
-      traverseObjectKeys(schema7.$defs, callback, processed);
+    if (schema8.$defs) {
+      traverseObjectKeys(schema8.$defs, callback, processed);
     }
-    if (schema7.not) {
-      traverse(schema7.not, callback, processed);
+    if (schema8.not) {
+      traverse(schema8.not, callback, processed);
     }
-    traverseIntersection(schema7, callback, processed);
-    Object.keys(schema7).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema7[key3];
+    traverseIntersection(schema8, callback, processed);
+    Object.keys(schema8).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema8[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -130202,14 +130202,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema7) {
+  function escapeBlockComment(schema8) {
     const replacer = "* /";
-    if (schema7 === null || typeof schema7 !== "object") {
+    if (schema8 === null || typeof schema8 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema7)) {
-      if (key2 === "description" && typeof schema7[key2] === "string") {
-        schema7[key2] = schema7[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema8)) {
+      if (key2 === "description" && typeof schema8[key2] === "string") {
+        schema8[key2] = schema8[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -130221,45 +130221,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema7) {
-    if (!("default" in schema7)) {
-      return schema7;
+  function maybeStripDefault(schema8) {
+    if (!("default" in schema8)) {
+      return schema8;
     }
-    switch (schema7.type) {
+    switch (schema8.type) {
       case "array":
-        if (Array.isArray(schema7.default)) {
-          return schema7;
+        if (Array.isArray(schema8.default)) {
+          return schema8;
         }
         break;
       case "boolean":
-        if (typeof schema7.default === "boolean") {
-          return schema7;
+        if (typeof schema8.default === "boolean") {
+          return schema8;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema7.default === "number") {
-          return schema7;
+        if (typeof schema8.default === "number") {
+          return schema8;
         }
         break;
       case "string":
-        if (typeof schema7.default === "string") {
-          return schema7;
+        if (typeof schema8.default === "string") {
+          return schema8;
         }
         break;
       case "null":
-        if (schema7.default === null) {
-          return schema7;
+        if (schema8.default === null) {
+          return schema8;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema7.default)) {
-          return schema7;
+        if ((0, lodash_1.isPlainObject)(schema8.default)) {
+          return schema8;
         }
         break;
     }
-    delete schema7.default;
-    return schema7;
+    delete schema8.default;
+    return schema8;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -130273,11 +130273,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema7) {
-    if (!(0, lodash_1.isPlainObject)(schema7)) {
+  function isSchemaLike(schema8) {
+    if (!(0, lodash_1.isPlainObject)(schema8)) {
       return false;
     }
-    const parent = schema7[JSONSchema_1.Parent];
+    const parent = schema8[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -130294,7 +130294,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_11) => parent[_11] === schema7)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_11) => parent[_11] === schema8)) {
       return false;
     }
     return true;
@@ -130592,13 +130592,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash2();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema7) {
-    if (schema7.tsType) {
+  function typesOfSchema(schema8) {
+    if (schema8.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema7)) {
+      if (f7(schema8)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -130609,26 +130609,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema7) {
-      return "allOf" in schema7;
+    ALL_OF(schema8) {
+      return "allOf" in schema8;
     },
-    ANY(schema7) {
-      if (Object.keys(schema7).length === 0) {
+    ANY(schema8) {
+      if (Object.keys(schema8).length === 0) {
         return true;
       }
-      return schema7.type === "any";
+      return schema8.type === "any";
     },
-    ANY_OF(schema7) {
-      return "anyOf" in schema7;
+    ANY_OF(schema8) {
+      return "anyOf" in schema8;
     },
-    BOOLEAN(schema7) {
-      if ("enum" in schema7) {
+    BOOLEAN(schema8) {
+      if ("enum" in schema8) {
         return false;
       }
-      if (schema7.type === "boolean") {
+      if (schema8.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema7) && typeof schema7.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "boolean") {
         return true;
       }
       return false;
@@ -130636,74 +130636,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema7) {
-      return "enum" in schema7 && "tsEnumNames" in schema7;
+    NAMED_ENUM(schema8) {
+      return "enum" in schema8 && "tsEnumNames" in schema8;
     },
-    NAMED_SCHEMA(schema7) {
-      return "$id" in schema7 && (("patternProperties" in schema7) || ("properties" in schema7));
+    NAMED_SCHEMA(schema8) {
+      return "$id" in schema8 && (("patternProperties" in schema8) || ("properties" in schema8));
     },
-    NEVER(schema7) {
-      return schema7 === false;
+    NEVER(schema8) {
+      return schema8 === false;
     },
-    NULL(schema7) {
-      return schema7.type === "null";
+    NULL(schema8) {
+      return schema8.type === "null";
     },
-    NUMBER(schema7) {
-      if ("enum" in schema7) {
+    NUMBER(schema8) {
+      if ("enum" in schema8) {
         return false;
       }
-      if (schema7.type === "integer" || schema7.type === "number") {
+      if (schema8.type === "integer" || schema8.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema7) && typeof schema7.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema7) {
-      return schema7.type === "object" && !(0, lodash_1.isPlainObject)(schema7.additionalProperties) && !schema7.allOf && !schema7.anyOf && !schema7.oneOf && !schema7.patternProperties && !schema7.properties && !schema7.required;
+    OBJECT(schema8) {
+      return schema8.type === "object" && !(0, lodash_1.isPlainObject)(schema8.additionalProperties) && !schema8.allOf && !schema8.anyOf && !schema8.oneOf && !schema8.patternProperties && !schema8.properties && !schema8.required;
     },
-    ONE_OF(schema7) {
-      return "oneOf" in schema7;
+    ONE_OF(schema8) {
+      return "oneOf" in schema8;
     },
-    REFERENCE(schema7) {
-      return "$ref" in schema7;
+    REFERENCE(schema8) {
+      return "$ref" in schema8;
     },
-    STRING(schema7) {
-      if ("enum" in schema7) {
+    STRING(schema8) {
+      if ("enum" in schema8) {
         return false;
       }
-      if (schema7.type === "string") {
+      if (schema8.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema7) && typeof schema7.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema7) {
-      if (schema7.type && schema7.type !== "array") {
+    TYPED_ARRAY(schema8) {
+      if (schema8.type && schema8.type !== "array") {
         return false;
       }
-      return "items" in schema7;
+      return "items" in schema8;
     },
-    UNION(schema7) {
-      return Array.isArray(schema7.type);
+    UNION(schema8) {
+      return Array.isArray(schema8.type);
     },
-    UNNAMED_ENUM(schema7) {
-      if ("tsEnumNames" in schema7) {
+    UNNAMED_ENUM(schema8) {
+      if ("tsEnumNames" in schema8) {
         return false;
       }
-      if (schema7.type && schema7.type !== "boolean" && schema7.type !== "integer" && schema7.type !== "number" && schema7.type !== "string") {
+      if (schema8.type && schema8.type !== "boolean" && schema8.type !== "integer" && schema8.type !== "number" && schema8.type !== "string") {
         return false;
       }
-      return "enum" in schema7;
+      return "enum" in schema8;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema7) {
-      return schema7.type === "array" && !("items" in schema7);
+    UNTYPED_ARRAY(schema8) {
+      return schema8.type === "array" && !("items" in schema8);
     }
   };
 });
@@ -130714,10 +130714,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema7) {
+  function applySchemaTyping(schema8) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema7);
-    Object.defineProperty(schema7, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema8);
+    Object.defineProperty(schema8, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -130726,23 +130726,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema7,
+      [JSONSchema_1.Parent]: schema8,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema7.$id,
-      description: schema7.description,
-      name: schema7.name,
-      title: schema7.title,
-      allOf: (_a7 = schema7.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema8.$id,
+      description: schema8.description,
+      name: schema8.name,
+      title: schema8.title,
+      allOf: (_a7 = schema8.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema7.allOf;
-    delete schema7.$id;
-    delete schema7.description;
-    delete schema7.name;
-    delete schema7.title;
-    Object.defineProperty(schema7, JSONSchema_1.Intersection, {
+    delete schema8.allOf;
+    delete schema8.$id;
+    delete schema8.description;
+    delete schema8.name;
+    delete schema8.title;
+    Object.defineProperty(schema8, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -130760,186 +130760,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema7, type) {
-    return schema7.type === type || Array.isArray(schema7.type) && schema7.type.includes(type);
+  function hasType(schema8, type) {
+    return schema8.type === type || Array.isArray(schema8.type) && schema8.type.includes(type);
   }
-  function isObjectType(schema7) {
-    return schema7.properties !== undefined || hasType(schema7, "object") || hasType(schema7, "any");
+  function isObjectType(schema8) {
+    return schema8.properties !== undefined || hasType(schema8, "object") || hasType(schema8, "any");
   }
-  function isArrayType(schema7) {
-    return schema7.items !== undefined || hasType(schema7, "array") || hasType(schema7, "any");
+  function isArrayType(schema8) {
+    return schema8.items !== undefined || hasType(schema8, "array") || hasType(schema8, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema7) {
-    return schema7.type === "string" && schema7.enum !== undefined && schema7.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema8) {
+    return schema8.type === "string" && schema8.enum !== undefined && schema8.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema7) => {
-    if (Array.isArray(schema7.enum) && schema7.enum.some((e8) => e8 === null) && Array.isArray(schema7.type) && schema7.type.includes("null")) {
-      schema7.type = schema7.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema8) => {
+    if (Array.isArray(schema8.enum) && schema8.enum.some((e8) => e8 === null) && Array.isArray(schema8.type) && schema8.type.includes("null")) {
+      schema8.type = schema8.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema7) => {
-    if (schema7.type && Array.isArray(schema7.type) && schema7.type.length === 1) {
-      schema7.type = schema7.type[0];
+  rules.set("Destructure unary types", (schema8) => {
+    if (schema8.type && Array.isArray(schema8.type) && schema8.type.length === 1) {
+      schema8.type = schema8.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema7) => {
-    if (isObjectType(schema7) && !("required" in schema7)) {
-      schema7.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema8) => {
+    if (isObjectType(schema8) && !("required" in schema8)) {
+      schema8.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema7) => {
-    if (schema7.required === false) {
-      schema7.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema8) => {
+    if (schema8.required === false) {
+      schema8.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema7, _11, options8) => {
-    if (isObjectType(schema7) && !("additionalProperties" in schema7) && schema7.patternProperties === undefined) {
-      schema7.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema8, _11, options8) => {
+    if (isObjectType(schema8) && !("additionalProperties" in schema8) && schema8.patternProperties === undefined) {
+      schema8.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema7, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema7)) {
+  rules.set("Transform id to $id", (schema8, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema8)) {
       return;
     }
-    if (schema7.id && schema7.$id && schema7.id !== schema7.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema7.id}, $id=${schema7.$id} in ${fileName}`);
+    if (schema8.id && schema8.$id && schema8.id !== schema8.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema8.id}, $id=${schema8.$id} in ${fileName}`);
     }
-    if (schema7.id) {
-      schema7.$id = schema7.id;
-      delete schema7.id;
+    if (schema8.id) {
+      schema8.$id = schema8.id;
+      delete schema8.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema7, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema7)) {
+  rules.set("Add an $id to anything that needs it", (schema8, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema8)) {
       return;
     }
-    if (!schema7.$id && !schema7[JSONSchema_1.Parent]) {
-      schema7.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema8.$id && !schema8[JSONSchema_1.Parent]) {
+      schema8.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema7) && !isObjectType(schema7)) {
+    if (!isArrayType(schema8) && !isObjectType(schema8)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema7);
-    if (!schema7.$id && !schema7.title && dereferencedName) {
-      schema7.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema8);
+    if (!schema8.$id && !schema8.title && dereferencedName) {
+      schema8.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema7);
+      dereferencedPaths.delete(schema8);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema7) => {
-    (0, utils_1.escapeBlockComment)(schema7);
+  rules.set("Escape closing JSDoc comment", (schema8) => {
+    (0, utils_1.escapeBlockComment)(schema8);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema7) => {
-    if (!isArrayType(schema7)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema8) => {
+    if (!isArrayType(schema8)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema7 ? `@minItems ${schema7.minItems}` : "",
-      "maxItems" in schema7 ? `@maxItems ${schema7.maxItems}` : ""
+      "minItems" in schema8 ? `@minItems ${schema8.minItems}` : "",
+      "maxItems" in schema8 ? `@maxItems ${schema8.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema7.description = (0, utils_1.appendToDescription)(schema7.description, ...commentsToAppend);
+      schema8.description = (0, utils_1.appendToDescription)(schema8.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema7, _fileName, options8) => {
-    if (!isArrayType(schema7)) {
+  rules.set("Optionally remove maxItems and minItems", (schema8, _fileName, options8) => {
+    if (!isArrayType(schema8)) {
       return;
     }
-    if ("minItems" in schema7 && options8.ignoreMinAndMaxItems) {
-      delete schema7.minItems;
+    if ("minItems" in schema8 && options8.ignoreMinAndMaxItems) {
+      delete schema8.minItems;
     }
-    if ("maxItems" in schema7 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema7.maxItems;
+    if ("maxItems" in schema8 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema8.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema7, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema8, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema7)) {
+    if (!isArrayType(schema8)) {
       return;
     }
-    const { minItems } = schema7;
-    schema7.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema8;
+    schema8.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema7, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema8, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema7)) {
+    if (!isArrayType(schema8)) {
       return;
     }
-    const { maxItems, minItems } = schema7;
+    const { maxItems, minItems } = schema8;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema7.maxItems;
+      delete schema8.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema7, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema8, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema7;
+    const { maxItems, minItems } = schema8;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema7.items && !Array.isArray(schema7.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema7.items;
+    if (schema8.items && !Array.isArray(schema8.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema8.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema7.additionalItems = items;
+        schema8.additionalItems = items;
       }
-      schema7.items = newItems;
+      schema8.items = newItems;
     }
-    if (Array.isArray(schema7.items) && hasMaxItems && maxItems < schema7.items.length) {
-      schema7.items = schema7.items.slice(0, maxItems);
+    if (Array.isArray(schema8.items) && hasMaxItems && maxItems < schema8.items.length) {
+      schema8.items = schema8.items.slice(0, maxItems);
     }
-    return schema7;
+    return schema8;
   });
-  rules.set("Remove extends, if it is empty", (schema7) => {
-    if (!schema7.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema8) => {
+    if (!schema8.hasOwnProperty("extends")) {
       return;
     }
-    if (schema7.extends == null || Array.isArray(schema7.extends) && schema7.extends.length === 0) {
-      delete schema7.extends;
+    if (schema8.extends == null || Array.isArray(schema8.extends) && schema8.extends.length === 0) {
+      delete schema8.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema7) => {
-    if (schema7.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema8) => {
+    if (schema8.extends == null) {
       return;
     }
-    if (!Array.isArray(schema7.extends)) {
-      schema7.extends = [schema7.extends];
+    if (!Array.isArray(schema8.extends)) {
+      schema8.extends = [schema8.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema7, fileName) => {
-    if (schema7.definitions && schema7.$defs && !(0, util_1.isDeepStrictEqual)(schema7.definitions, schema7.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema7.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema8, fileName) => {
+    if (schema8.definitions && schema8.$defs && !(0, util_1.isDeepStrictEqual)(schema8.definitions, schema8.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema8.id} in ${fileName}`);
     }
-    if (schema7.definitions) {
-      schema7.$defs = schema7.definitions;
-      delete schema7.definitions;
+    if (schema8.definitions) {
+      schema8.$defs = schema8.definitions;
+      delete schema8.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema7) => {
-    if (schema7.const !== undefined) {
-      schema7.enum = [schema7.const];
-      delete schema7.const;
+  rules.set("Transform const to singleton enum", (schema8) => {
+    if (schema8.const !== undefined) {
+      schema8.enum = [schema8.const];
+      delete schema8.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema7, _11, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema8, _11, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema7) && options8.inferStringEnumKeysFromValues) {
-      schema7.tsEnumNames = (_a7 = schema7.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema8) && options8.inferStringEnumKeysFromValues) {
+      schema8.tsEnumNames = (_a7 = schema8.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema7) => {
-    if (schema7 !== null && typeof schema7 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema7);
+  rules.set("Pre-calculate schema types and intersections", (schema8) => {
+    if (schema8 !== null && typeof schema8 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema8);
     }
   });
   function normalize(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema7, key2) => rule(schema7, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema8, key2) => rule(schema8, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize;
@@ -131021,37 +131021,37 @@ var require_parser = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse10(schema7, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema7)) {
-      if ((0, JSONSchema_1.isBoolean)(schema7)) {
-        return parseBooleanSchema(schema7, keyName, options8);
+  function parse10(schema8, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema8)) {
+      if ((0, JSONSchema_1.isBoolean)(schema8)) {
+        return parseBooleanSchema(schema8, keyName, options8);
       }
-      return parseLiteral(schema7, keyName);
+      return parseLiteral(schema8, keyName);
     }
-    const intersection2 = schema7[JSONSchema_1.Intersection];
-    const types = schema7[JSONSchema_1.Types];
+    const intersection2 = schema8[JSONSchema_1.Intersection];
+    const types = schema8[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema7, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema8, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema7, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema8, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema7, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema7, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema8, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema8, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse10;
-  function parseAsTypeWithCache(schema7, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema7);
+  function parseAsTypeWithCache(schema8, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema8);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema7, cachedTypeMap);
+      processed.set(schema8, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -131059,10 +131059,10 @@ var require_parser = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema7, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema8, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema7, keyName, options8) {
-    if (schema7) {
+  function parseBooleanSchema(schema8, keyName, options8) {
+    if (schema8) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -131073,157 +131073,157 @@ var require_parser = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema7, keyName) {
+  function parseLiteral(schema8, keyName) {
     return {
       keyName,
-      params: schema7,
+      params: schema8,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema7, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema7));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_11) => _11 === schema7);
+  function parseNonLiteral(schema8, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema8));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_11) => _11 === schema8);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
-          params: schema7.allOf.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          params: schema8.allOf.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
           type: "INTERSECTION"
         };
       case "ANY":
-        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema7.description, deprecated: schema7.deprecated, keyName, standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema8.description, deprecated: schema8.deprecated, keyName, standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
-          params: schema7.anyOf.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          params: schema8.anyOf.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          params: schema7.tsType,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          params: schema8.tsType,
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema7.enum.map((_11, n5) => ({
+          standaloneName: standaloneName(schema8, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema8.enum.map((_11, n5) => ({
             ast: parseLiteral(_11, undefined),
-            keyName: schema7.tsEnumNames[n5]
+            keyName: schema8.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema7, options8, processed, usedNames, keyName);
+        return newInterface(schema8, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema7.description,
+          comment: schema8.description,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema7.deprecated
+          deprecated: schema8.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
-          params: schema7.oneOf.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          params: schema8.oneOf.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "REFERENCE":
-        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema7));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema8));
       case "STRING":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema7.items)) {
-          const minItems2 = schema7.minItems;
-          const maxItems2 = schema7.maxItems;
+        if (Array.isArray(schema8.items)) {
+          const minItems2 = schema8.minItems;
+          const maxItems2 = schema8.maxItems;
           const arrayType = {
-            comment: schema7.description,
-            deprecated: schema7.deprecated,
+            comment: schema8.description,
+            deprecated: schema8.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
-            params: schema7.items.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+            params: schema8.items.map((_11) => parse10(_11, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema7.additionalItems === true) {
+          if (schema8.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema7.additionalItems) {
-            arrayType.spreadParam = parse10(schema7.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema8.additionalItems) {
+            arrayType.spreadParam = parse10(schema8.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema7.description,
-            deprecated: schema7.deprecated,
+            comment: schema8.description,
+            deprecated: schema8.deprecated,
             keyName,
-            standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
-            params: parse10(schema7.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+            params: parse10(schema8.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
-          params: schema7.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema7, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          params: schema8.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema8, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
             return parse10(member, options8, undefined, processed, usedNames);
@@ -131232,80 +131232,80 @@ var require_parser = __commonJS((exports) => {
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
-          params: schema7.enum.map((_11) => parseLiteral(_11, undefined)),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          params: schema8.enum.map((_11) => parseLiteral(_11, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema7, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema8, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema7.minItems;
-        const maxItems = typeof schema7.maxItems === "number" ? schema7.maxItems : -1;
+        const minItems = schema8.minItems;
+        const maxItems = typeof schema8.maxItems === "number" ? schema8.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema7.description,
-            deprecated: schema7.deprecated,
+            comment: schema8.description,
+            deprecated: schema8.deprecated,
             keyName,
-            maxItems: schema7.maxItems,
+            maxItems: schema8.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema7.description,
-          deprecated: schema7.deprecated,
+          comment: schema8.description,
+          deprecated: schema8.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema7, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema7, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema8, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema7, keyNameFromDefinition)) || schema7.title || schema7.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema8, keyNameFromDefinition)) || schema8.title || schema8.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema7, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema7, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema8, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema8, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema7.description,
-      deprecated: schema7.deprecated,
+      comment: schema8.description,
+      deprecated: schema8.deprecated,
       keyName,
-      params: parseSchema(schema7, options8, processed, usedNames, name2),
+      params: parseSchema(schema8, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema7, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema8, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema7, options8, processed, usedNames) {
-    const superTypes = schema7.extends;
+  function parseSuperTypes(schema8, options8, processed, usedNames) {
+    const superTypes = schema8.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_11) => parse10(_11, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema7, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema7.properties, (value, key2) => ({
+  function parseSchema(schema8, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema8.properties, (value, key2) => ({
       ast: parse10(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema7.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema8.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema7.patternProperties) {
-      singlePatternProperty = !schema7.additionalProperties && Object.keys(schema7.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema7.patternProperties, (value, key2) => {
+    if (schema8.patternProperties) {
+      singlePatternProperty = !schema8.additionalProperties && Object.keys(schema8.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema8.patternProperties, (value, key2) => {
         const ast = parse10(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema definition
 via the \`patternProperty\` "${key2.replace("*/", "*\\/")}".`;
@@ -131315,14 +131315,14 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema7.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema8.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema7.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema8.$defs, (value, key2) => {
         const ast = parse10(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key2}".`;
@@ -131332,13 +131332,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema7.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema8.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema7.additionalProperties) {
+    switch (schema8.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -131355,7 +131355,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse10(schema7.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse10(schema8.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -131363,22 +131363,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema7, isSchema = true, processed = new Set) {
-    if (processed.has(schema7)) {
+  function getDefinitions(schema8, isSchema = true, processed = new Set) {
+    if (processed.has(schema8)) {
       return {};
     }
-    processed.add(schema7);
-    if (Array.isArray(schema7)) {
-      return schema7.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema8);
+    if (Array.isArray(schema8)) {
+      return schema8.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema7)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema7) ? schema7.$defs : {}), Object.keys(schema7).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema7[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema8)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema8) ? schema8.$defs : {}), Object.keys(schema8).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema8[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema7) {
-    return "$defs" in schema7;
+  function hasDefinitions(schema8) {
+    return "$defs" in schema8;
   }
 });
 
@@ -133083,9 +133083,9 @@ var require_type3 = __commonJS((exports, module) => {
 var require_schema3 = __commonJS((exports, module) => {
   var YAMLException = require_exception3();
   var Type = require_type3();
-  function compileList(schema7, name2) {
+  function compileList(schema8, name2) {
     var result = [];
-    schema7[name2].forEach(function(currentType) {
+    schema8[name2].forEach(function(currentType) {
       var newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -135030,7 +135030,7 @@ var require_dumper3 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema7, map2) {
+  function compileStyleMap(schema8, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -135042,7 +135042,7 @@ var require_dumper3 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema7.compiledTypeMap["fallback"][tag];
+      type = schema8.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -135977,7 +135977,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema7;
+    let schema8;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -135987,15 +135987,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema7 = args[1];
+        schema8 = args[1];
         options8 = args[2];
       } else {
-        schema7 = undefined;
+        schema8 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema7 = args[0];
+      schema8 = args[0];
       options8 = args[1];
     }
     try {
@@ -136003,12 +136003,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema7 === "object") {
-      schema7 = JSON.parse(JSON.stringify(schema7));
+    if (!options8.mutateInputSchema && typeof schema8 === "object") {
+      schema8 = JSON.parse(JSON.stringify(schema8));
     }
     return {
       path: path18,
-      schema: schema7,
+      schema: schema8,
       options: options8,
       callback
     };
@@ -136797,12 +136797,12 @@ var require_resolver = __commonJS((exports) => {
   var json_schema_ref_parser_1 = require_lib3();
   var utils_1 = require_utils7();
   function dereference(schema_1, _a7) {
-    return __awaiter(this, arguments, undefined, function* (schema7, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema7);
+    return __awaiter(this, arguments, undefined, function* (schema8, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema8);
       const parser = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser.dereference(cwd, schema7, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema8) {
-        dereferencedPaths.set(schema8, $ref);
+      const dereferencedSchema = yield parser.dereference(cwd, schema8, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema9) {
+        dereferencedPaths.set(schema9, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -136816,46 +136816,46 @@ var require_validator = __commonJS((exports) => {
   exports.validate = undefined;
   var utils_1 = require_utils7();
   var rules = new Map;
-  rules.set("Enum members and tsEnumNames must be of the same length", (schema7) => {
-    if (schema7.enum && schema7.tsEnumNames && schema7.enum.length !== schema7.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema8) => {
+    if (schema8.enum && schema8.tsEnumNames && schema8.enum.length !== schema8.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema7) => {
-    if (schema7.tsEnumNames && schema7.tsEnumNames.some((_11) => typeof _11 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema8) => {
+    if (schema8.tsEnumNames && schema8.tsEnumNames.some((_11) => typeof _11 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema7) => {
-    const { maxItems, minItems } = schema7;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema8) => {
+    const { maxItems, minItems } = schema8;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema7) => {
-    const { maxItems } = schema7;
+  rules.set("When maxItems exists, maxItems >= 0", (schema8) => {
+    const { maxItems } = schema8;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema7) => {
-    const { minItems } = schema7;
+  rules.set("When minItems exists, minItems >= 0", (schema8) => {
+    const { minItems } = schema8;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema7) => {
-    const typeOfDeprecated = typeof schema7.deprecated;
+  rules.set("deprecated must be a boolean", (schema8) => {
+    const typeOfDeprecated = typeof schema8.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema7, filename) {
+  function validate2(schema8, filename) {
     const errors4 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema7, (schema8, key2) => {
-        if (rule(schema8) === false) {
+      (0, utils_1.traverse)(schema8, (schema9, key2) => {
+        if (rule(schema9) === false) {
           errors4.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema8;
+        return schema9;
       });
     });
     return errors4;
@@ -136869,25 +136869,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash2();
-  function link2(schema7, parent = null) {
-    if (!Array.isArray(schema7) && !(0, lodash_1.isPlainObject)(schema7)) {
-      return schema7;
+  function link2(schema8, parent = null) {
+    if (!Array.isArray(schema8) && !(0, lodash_1.isPlainObject)(schema8)) {
+      return schema8;
     }
-    if (schema7.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema7;
+    if (schema8.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema8;
     }
-    Object.defineProperty(schema7, JSONSchema_1.Parent, {
+    Object.defineProperty(schema8, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema7)) {
-      schema7.forEach((child) => link2(child, schema7));
+    if (Array.isArray(schema8)) {
+      schema8.forEach((child) => link2(child, schema8));
     }
-    for (const key2 in schema7) {
-      link2(schema7[key2], schema7);
+    for (const key2 in schema8) {
+      link2(schema8[key2], schema8);
     }
-    return schema7;
+    return schema8;
   }
   exports.link = link2;
 });
@@ -136979,8 +136979,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema7 = parseAsJSONSchema(filename);
-    return compile(schema7, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema8 = parseAsJSONSchema(filename);
+    return compile(schema8, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -136990,7 +136990,7 @@ var require_src3 = __commonJS((exports) => {
     return (0, utils_1.parseFileAsJSONSchema)(filename, contents.toString());
   }
   function compile(schema_1, name_1) {
-    return __awaiter(this, arguments, undefined, function* (schema7, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema8, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -137000,7 +137000,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema7);
+      const _schema = (0, lodash_1.cloneDeep)(schema8);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -154726,9 +154726,9 @@ var require_stringify4 = __commonJS((exports, module) => {
     }
   };
   var isArray = Array.isArray;
-  var push3 = Array.prototype.push;
+  var push4 = Array.prototype.push;
   var pushToArray = function(arr, valueOrArray) {
-    push3.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+    push4.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
   };
   var toISO = Date.prototype.toISOString;
   var defaultFormat = formats["default"];
@@ -160853,18 +160853,18 @@ var require_common8 = __commonJS((exports) => {
     retSegs.push.apply(retSegs, lastSegs);
     return retSegs.join("?");
   };
-  common2.rewriteCookieProperty = function rewriteCookieProperty(header2, config9, property) {
+  common2.rewriteCookieProperty = function rewriteCookieProperty(header2, config10, property) {
     if (Array.isArray(header2)) {
       return header2.map(function(headerElement) {
-        return rewriteCookieProperty(headerElement, config9, property);
+        return rewriteCookieProperty(headerElement, config10, property);
       });
     }
     return header2.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), function(match, prefix, previousValue) {
       var newValue;
-      if (previousValue in config9) {
-        newValue = config9[previousValue];
-      } else if ("*" in config9) {
-        newValue = config9["*"];
+      if (previousValue in config10) {
+        newValue = config10[previousValue];
+      } else if ("*" in config10) {
+        newValue = config10["*"];
       } else {
         return match;
       }
@@ -162229,9 +162229,9 @@ var require_router2 = __commonJS((exports) => {
   var is_plain_object_1 = require_is_plain_object();
   var debug_1 = require_debug3();
   var debug = debug_1.Debug.extend("router");
-  async function getTarget(req, config9) {
+  async function getTarget(req, config10) {
     let newTarget;
-    const router = config9.router;
+    const router = config10.router;
     if ((0, is_plain_object_1.isPlainObject)(router)) {
       newTarget = getTargetFromProxyTable(req, router);
     } else if (typeof router === "function") {
@@ -177926,7 +177926,8 @@ var ProjectConfigSchema = exports_external.object({
   site: SiteConfigSchema.optional(),
   entitiesDir: exports_external.string().optional().default("entities"),
   functionsDir: exports_external.string().optional().default("functions"),
-  agentsDir: exports_external.string().optional().default("agents")
+  agentsDir: exports_external.string().optional().default("agents"),
+  connectorsDir: exports_external.string().optional().default("connectors")
 });
 var AppConfigSchema = exports_external.object({
   id: exports_external.string().min(1, "id cannot be empty")
@@ -184994,6 +184995,305 @@ var agentResource = {
   readAll: readAllAgents,
   push: pushAgents
 };
+// src/core/resources/connector/schema.ts
+var GoogleCalendarConnectorSchema = exports_external.object({
+  type: exports_external.literal("googlecalendar"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var GoogleDriveConnectorSchema = exports_external.object({
+  type: exports_external.literal("googledrive"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var GmailConnectorSchema = exports_external.object({
+  type: exports_external.literal("gmail"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var GoogleSheetsConnectorSchema = exports_external.object({
+  type: exports_external.literal("googlesheets"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var GoogleDocsConnectorSchema = exports_external.object({
+  type: exports_external.literal("googledocs"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var GoogleSlidesConnectorSchema = exports_external.object({
+  type: exports_external.literal("googleslides"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var SlackConnectorSchema = exports_external.object({
+  type: exports_external.literal("slack"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var NotionConnectorSchema = exports_external.object({
+  type: exports_external.literal("notion"),
+  scopes: exports_external.array(exports_external.string()).default([]).optional()
+});
+var SalesforceConnectorSchema = exports_external.object({
+  type: exports_external.literal("salesforce"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var HubspotConnectorSchema = exports_external.object({
+  type: exports_external.literal("hubspot"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var LinkedInConnectorSchema = exports_external.object({
+  type: exports_external.literal("linkedin"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var TikTokConnectorSchema = exports_external.object({
+  type: exports_external.literal("tiktok"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var CustomTypeSchema = exports_external.string().min(1).regex(/^[a-z0-9_-]+$/i);
+var GenericConnectorSchema = exports_external.object({
+  type: CustomTypeSchema,
+  scopes: exports_external.array(exports_external.string()).default([])
+});
+var ConnectorResourceSchema = exports_external.union([
+  GoogleCalendarConnectorSchema,
+  GoogleDriveConnectorSchema,
+  GmailConnectorSchema,
+  GoogleSheetsConnectorSchema,
+  GoogleDocsConnectorSchema,
+  GoogleSlidesConnectorSchema,
+  SlackConnectorSchema,
+  NotionConnectorSchema,
+  SalesforceConnectorSchema,
+  HubspotConnectorSchema,
+  LinkedInConnectorSchema,
+  TikTokConnectorSchema,
+  GenericConnectorSchema
+]);
+var KnownIntegrationTypes = [
+  "googlecalendar",
+  "googledrive",
+  "gmail",
+  "googlesheets",
+  "googledocs",
+  "googleslides",
+  "slack",
+  "notion",
+  "salesforce",
+  "hubspot",
+  "linkedin",
+  "tiktok"
+];
+var IntegrationTypeSchema = exports_external.union([
+  exports_external.enum(KnownIntegrationTypes),
+  CustomTypeSchema
+]);
+var ConnectorStatusSchema = exports_external.enum(["active", "disconnected", "expired"]);
+var UpstreamConnectorSchema = exports_external.object({
+  integration_type: IntegrationTypeSchema,
+  status: ConnectorStatusSchema,
+  scopes: exports_external.array(exports_external.string()),
+  user_email: exports_external.string().optional()
+});
+var ListConnectorsResponseSchema = exports_external.object({
+  integrations: exports_external.array(UpstreamConnectorSchema)
+}).transform((data) => ({
+  integrations: data.integrations.map((i) => ({
+    integrationType: i.integration_type,
+    status: i.status,
+    scopes: i.scopes,
+    userEmail: i.user_email
+  }))
+}));
+var SetConnectorResponseSchema = exports_external.object({
+  redirect_url: exports_external.string().nullable(),
+  connection_id: exports_external.string().nullable(),
+  already_authorized: exports_external.boolean(),
+  error: exports_external.string().nullable(),
+  error_message: exports_external.string().nullable(),
+  other_user_email: exports_external.string().nullable()
+}).transform((data) => ({
+  redirectUrl: data.redirect_url,
+  connectionId: data.connection_id,
+  alreadyAuthorized: data.already_authorized,
+  error: data.error,
+  errorMessage: data.error_message,
+  otherUserEmail: data.other_user_email
+}));
+var ConnectorOAuthStatusSchema = exports_external.enum([
+  "ACTIVE",
+  "FAILED",
+  "PENDING"
+]);
+var OAuthStatusResponseSchema = exports_external.object({
+  status: ConnectorOAuthStatusSchema
+});
+var RemoveConnectorResponseSchema = exports_external.object({
+  status: exports_external.literal("removed"),
+  integration_type: IntegrationTypeSchema
+}).transform((data) => ({
+  status: data.status,
+  integrationType: data.integration_type
+}));
+
+// src/core/resources/connector/api.ts
+async function listConnectors() {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("external-auth/list");
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing connectors");
+  }
+  const result = ListConnectorsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function setConnector(integrationType, scopes) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.put(`external-auth/integrations/${integrationType}`, {
+      json: {
+        scopes
+      }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "setting connector");
+  }
+  const result = SetConnectorResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function getOAuthStatus(integrationType, connectionId) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("external-auth/status", {
+      searchParams: {
+        integration_type: integrationType,
+        connection_id: connectionId
+      }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "checking OAuth status");
+  }
+  const result = OAuthStatusResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function removeConnector(integrationType) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.delete(`external-auth/integrations/${integrationType}/remove`);
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "removing connector");
+  }
+  const result = RemoveConnectorResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+// src/core/resources/connector/config.ts
+async function readConnectorFile(connectorPath) {
+  const parsed = await readJsonFile(connectorPath);
+  const result = ConnectorResourceSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid connector file", result.error, connectorPath);
+  }
+  return result.data;
+}
+async function readAllConnectors(connectorsDir) {
+  if (!await pathExists(connectorsDir)) {
+    return [];
+  }
+  const files = await globby(`*.${CONFIG_FILE_EXTENSION_GLOB}`, {
+    cwd: connectorsDir,
+    absolute: true
+  });
+  const connectors = await Promise.all(files.map((filePath) => readConnectorFile(filePath)));
+  assertNoDuplicateConnectors(connectors);
+  return connectors;
+}
+function assertNoDuplicateConnectors(connectors) {
+  const types = new Set;
+  for (const connector of connectors) {
+    if (types.has(connector.type)) {
+      throw new InvalidInputError(`Duplicate connector type "${connector.type}"`, {
+        hints: [
+          {
+            message: `Remove duplicate connectors with type "${connector.type}" - only one connector per type is allowed`
+          }
+        ]
+      });
+    }
+    types.add(connector.type);
+  }
+}
+// src/core/resources/connector/push.ts
+async function pushConnectors(connectors) {
+  const results = [];
+  const upstream = await listConnectors();
+  const localTypes = new Set(connectors.map((c) => c.type));
+  for (const connector of connectors) {
+    try {
+      const response = await setConnector(connector.type, connector.scopes ?? []);
+      results.push(getConnectorSyncResult(connector.type, response));
+    } catch (err) {
+      results.push({
+        type: connector.type,
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  for (const upstreamConnector of upstream.integrations) {
+    if (!localTypes.has(upstreamConnector.integrationType)) {
+      try {
+        await removeConnector(upstreamConnector.integrationType);
+        results.push({
+          type: upstreamConnector.integrationType,
+          action: "removed"
+        });
+      } catch (err) {
+        results.push({
+          type: upstreamConnector.integrationType,
+          action: "error",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  return { results };
+}
+function getConnectorSyncResult(type, response) {
+  if (response.error === "different_user") {
+    return {
+      type,
+      action: "error",
+      error: response.errorMessage || `Already connected by ${response.otherUserEmail ?? "another user"}`
+    };
+  }
+  if (response.alreadyAuthorized) {
+    return { type, action: "synced" };
+  }
+  if (response.redirectUrl) {
+    return {
+      type,
+      action: "needs_oauth",
+      redirectUrl: response.redirectUrl,
+      connectionId: response.connectionId ?? undefined
+    };
+  }
+  return { type, action: "synced" };
+}
+// src/core/resources/connector/resource.ts
+var connectorResource = {
+  readAll: readAllConnectors,
+  push: pushConnectors
+};
 // src/core/resources/entity/schema.ts
 var FieldConditionSchema = exports_external.union([
   exports_external.string(),
@@ -185281,9 +185581,9 @@ async function readFunctionConfig(configPath) {
   return result.data;
 }
 async function readFunction(configPath) {
-  const config4 = await readFunctionConfig(configPath);
+  const config5 = await readFunctionConfig(configPath);
   const functionDir = dirname4(configPath);
-  const entryPath = join4(functionDir, config4.entry);
+  const entryPath = join4(functionDir, config5.entry);
   if (!await pathExists(entryPath)) {
     throw new FileNotFoundError(`Function entry file not found: ${entryPath} (referenced in ${configPath})`);
   }
@@ -185291,7 +185591,7 @@ async function readFunction(configPath) {
     cwd: functionDir,
     absolute: true
   });
-  const functionData = { ...config4, entryPath, filePaths };
+  const functionData = { ...config5, entryPath, filePaths };
   return functionData;
 }
 async function readAllFunctions(functionsDir) {
@@ -185371,16 +185671,18 @@ async function readProjectConfig(projectRoot) {
   }
   const project = result.data;
   const configDir = dirname5(configPath);
-  const [entities, functions, agents] = await Promise.all([
+  const [entities, functions, agents, connectors] = await Promise.all([
     entityResource.readAll(join5(configDir, project.entitiesDir)),
     functionResource.readAll(join5(configDir, project.functionsDir)),
-    agentResource.readAll(join5(configDir, project.agentsDir))
+    agentResource.readAll(join5(configDir, project.agentsDir)),
+    connectorResource.readAll(join5(configDir, project.connectorsDir))
   ]);
   return {
     project: { ...project, root, configPath },
     entities,
     functions,
-    agents
+    agents,
+    connectors
   };
 }
 
@@ -185405,9 +185707,9 @@ async function initAppConfig() {
   if (!projectRoot) {
     throw new ConfigNotFoundError("No Base44 project found. Run this command from a project directory with a config.jsonc file.");
   }
-  const config5 = await readAppConfig(projectRoot.root);
+  const config6 = await readAppConfig(projectRoot.root);
   const appConfigPath = await findAppConfigPath(projectRoot.root);
-  if (!config5?.id) {
+  if (!config6?.id) {
     throw new ConfigInvalidError("App not configured. Create a .app.jsonc file or run 'base44 link' to link this project.", appConfigPath, {
       hints: [
         {
@@ -185417,7 +185719,7 @@ async function initAppConfig() {
       ]
     });
   }
-  cache2 = { projectRoot: projectRoot.root, id: config5.id };
+  cache2 = { projectRoot: projectRoot.root, id: config6.id };
   return cache2;
 }
 function getAppConfig() {
@@ -185426,8 +185728,8 @@ function getAppConfig() {
   }
   return cache2;
 }
-function setAppConfig(config5) {
-  cache2 = config5;
+function setAppConfig(config6) {
+  cache2 = config6;
 }
 function generateAppConfigContent(id) {
   return `// Base44 App Configuration
@@ -185681,6 +185983,7 @@ async function handleUnauthorized(request, _options, response) {
 }
 var base44Client = distribution_default.create({
   prefixUrl: getBase44ApiUrl(),
+  timeout: 180000,
   headers: {
     "User-Agent": "Base44 CLI"
   },
@@ -193990,6 +194293,129 @@ defineLazyProperty(apps, "safari", () => detectPlatformBinary({
 }));
 var open_default = open;
 
+// src/cli/commands/connectors/push.ts
+function isPendingOAuth(r2) {
+  return r2.action === "needs_oauth" && !!r2.redirectUrl && !!r2.connectionId;
+}
+function printSummary(results, oauthOutcomes) {
+  const synced = [];
+  const added = [];
+  const removed = [];
+  const failed = [];
+  for (const r2 of results) {
+    const oauthStatus = oauthOutcomes.get(r2.type);
+    if (r2.action === "synced") {
+      synced.push(r2.type);
+    } else if (r2.action === "removed") {
+      removed.push(r2.type);
+    } else if (r2.action === "error") {
+      failed.push({ type: r2.type, error: r2.error });
+    } else if (r2.action === "needs_oauth") {
+      if (oauthStatus === "ACTIVE") {
+        added.push(r2.type);
+      } else if (oauthStatus === "PENDING") {
+        failed.push({ type: r2.type, error: "authorization timed out" });
+      } else if (oauthStatus === "FAILED") {
+        failed.push({ type: r2.type, error: "authorization failed" });
+      } else {
+        failed.push({ type: r2.type, error: "needs authorization" });
+      }
+    }
+  }
+  M2.info("");
+  M2.info(theme.styles.bold("Summary:"));
+  if (synced.length > 0) {
+    M2.success(`Synced: ${synced.join(", ")}`);
+  }
+  if (added.length > 0) {
+    M2.success(`Added: ${added.join(", ")}`);
+  }
+  if (removed.length > 0) {
+    M2.info(theme.styles.dim(`Removed: ${removed.join(", ")}`));
+  }
+  for (const r2 of failed) {
+    M2.error(`Failed: ${r2.type}${r2.error ? ` - ${r2.error}` : ""}`);
+  }
+}
+async function pushConnectorsAction() {
+  const { connectors } = await readProjectConfig();
+  if (connectors.length === 0) {
+    M2.info("No local connectors found - checking for remote connectors to remove");
+  } else {
+    const connectorNames = connectors.map((c3) => c3.type).join(", ");
+    M2.info(`Found ${connectors.length} connectors to push: ${connectorNames}`);
+  }
+  const { results } = await runTask("Pushing connectors to Base44", async () => {
+    return await pushConnectors(connectors);
+  });
+  const oauthOutcomes = new Map;
+  const needsOAuth = results.filter(isPendingOAuth);
+  let outroMessage = "Connectors pushed to Base44";
+  if (needsOAuth.length === 0) {
+    printSummary(results, oauthOutcomes);
+    return { outroMessage };
+  }
+  M2.warn(`${needsOAuth.length} connector(s) require authorization in your browser:`);
+  for (const connector2 of needsOAuth) {
+    M2.info(`  '${connector2.type}': ${theme.styles.dim(connector2.redirectUrl)}`);
+  }
+  const pending = needsOAuth.map((c3) => c3.type).join(", ");
+  if (process.env.CI) {
+    outroMessage = `Skipped OAuth in CI. Pending: ${pending}. Run 'base44 connectors push' locally to authorize.`;
+  } else {
+    const shouldAuth = await ye({
+      message: "Open browser to authorize now?"
+    });
+    if (pD(shouldAuth) || !shouldAuth) {
+      outroMessage = `Authorization skipped. Pending: ${pending}. Run 'base44 connectors push' again to complete.`;
+    } else {
+      for (const connector2 of needsOAuth) {
+        try {
+          M2.info(`
+Opening browser for '${connector2.type}'...`);
+          await open_default(connector2.redirectUrl);
+          let finalStatus = "PENDING";
+          await runTask(`Waiting for '${connector2.type}' authorization...`, async () => {
+            await pWaitFor(async () => {
+              const response = await getOAuthStatus(connector2.type, connector2.connectionId);
+              finalStatus = response.status;
+              return response.status !== "PENDING";
+            }, {
+              interval: 2000,
+              timeout: 2 * 60 * 1000
+            });
+          }, {
+            successMessage: `'${connector2.type}' authorization complete`,
+            errorMessage: `'${connector2.type}' authorization failed`
+          }).catch((err) => {
+            if (err instanceof TimeoutError2) {
+              finalStatus = "PENDING";
+            } else {
+              throw err;
+            }
+          });
+          oauthOutcomes.set(connector2.type, finalStatus);
+        } catch (err) {
+          M2.error(`Failed to authorize '${connector2.type}': ${err instanceof Error ? err.message : String(err)}`);
+          oauthOutcomes.set(connector2.type, "FAILED");
+        }
+      }
+    }
+  }
+  printSummary(results, oauthOutcomes);
+  return { outroMessage };
+}
+function getConnectorsPushCommand(context) {
+  return new Command("push").description("Push local connectors to Base44 (overwrites connectors on Base44)").action(async () => {
+    await runCommand(pushConnectorsAction, { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/connectors/index.ts
+function getConnectorsCommand(context) {
+  return new Command("connectors").description("Manage project connectors (OAuth integrations)").addCommand(getConnectorsPushCommand(context));
+}
+
 // src/cli/commands/dashboard/open.ts
 async function openDashboard() {
   const dashboardUrl = getDashboardUrl();
@@ -194569,9 +194995,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, ...schema7 } = entity2;
+  const { name: name2, ...schema8 } = entity2;
   const jsonSchema = {
-    ...schema7,
+    ...schema8,
     title: name2,
     additionalProperties: false
   };
@@ -194666,8 +195092,8 @@ var getLocalHosts = () => {
   const interfaces = os9.networkInterfaces();
   const results = new Set([undefined, "0.0.0.0"]);
   for (const _interface of Object.values(interfaces)) {
-    for (const config9 of _interface) {
-      results.add(config9.address);
+    for (const config10 of _interface) {
+      results.add(config10.address);
     }
   }
   return results;
@@ -194927,6 +195353,7 @@ function createProgram(context) {
   program2.addCommand(getEjectCommand(context));
   program2.addCommand(getEntitiesPushCommand(context));
   program2.addCommand(getAgentsCommand(context));
+  program2.addCommand(getConnectorsCommand(context));
   program2.addCommand(getFunctionsDeployCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context), { hidden: true });
@@ -199197,4 +199624,4 @@ export {
   CLIExitError
 };
 
-//# debugId=7EAA39D05A855BF964756E2164756E21
+//# debugId=7A9ABB53BDDC483064756E2164756E21