apps 0.0.1-beta.9 → 0.0.1-beta.91

package/js/{es-APDZKREY.js → es-DIULA3ZF.js}

@@ -1,3 +1,13 @@
+import {
+  Ast,
+  Parser,
+  Stats,
+  Trace,
+  identifiers,
+  substitute_default,
+  test_default,
+  utilities
+} from "./chunk-OD3KFKZD.js";
 import {
   __commonJS,
   __export,
@@ -24,9 +34,9 @@ var require_function_bind_native = __commonJS({
     "use strict";
     var fails = require_fails();
     module.exports = !fails(function() {
-      var test2 = function() {
+      var test = function() {
       }.bind();
-      return typeof test2 != "function" || test2.hasOwnProperty("prototype");
+      return typeof test != "function" || test.hasOwnProperty("prototype");
     });
   }
 });
@@ -1019,9 +1029,9 @@ var require_to_string_tag_support = __commonJS({
     "use strict";
     var wellKnownSymbol = require_well_known_symbol();
     var TO_STRING_TAG = wellKnownSymbol("toStringTag");
-    var test2 = {};
-    test2[TO_STRING_TAG] = "z";
-    module.exports = String(test2) === "[object z]";
+    var test = {};
+    test[TO_STRING_TAG] = "z";
+    module.exports = String(test) === "[object z]";
   }
 });
 
@@ -1359,12 +1369,12 @@ var require_object_set_prototype_of = __commonJS({
     var aPossiblePrototype = require_a_possible_prototype();
     module.exports = Object.setPrototypeOf || ("__proto__" in {} ? (function() {
       var CORRECT_SETTER = false;
-      var test2 = {};
+      var test = {};
       var setter;
       try {
         setter = uncurryThisAccessor(Object.prototype, "__proto__", "set");
-        setter(test2, []);
-        CORRECT_SETTER = test2 instanceof Array;
+        setter(test, []);
+        CORRECT_SETTER = test instanceof Array;
       } catch (error) {
       }
       return function setPrototypeOf(O, proto) {
@@ -2257,8 +2267,8 @@ var require_iterators_core = __commonJS({
       }
     }
     var NEW_ITERATOR_PROTOTYPE = !isObject3(IteratorPrototype) || fails(function() {
-      var test2 = {};
-      return IteratorPrototype[ITERATOR].call(test2) !== test2;
+      var test = {};
+      return IteratorPrototype[ITERATOR].call(test) !== test;
     });
     if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
     else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
@@ -5800,12 +5810,12 @@ var require_Namespace = __commonJS({
        * class to use when converting existing js instances into
        * refract element.
        */
-      detect(test2, ElementClass, givenPrepend) {
+      detect(test, ElementClass, givenPrepend) {
         const prepend = givenPrepend === void 0 ? true : givenPrepend;
         if (prepend) {
-          this.elementDetection.unshift([test2, ElementClass]);
+          this.elementDetection.unshift([test, ElementClass]);
         } else {
-          this.elementDetection.push([test2, ElementClass]);
+          this.elementDetection.push([test, ElementClass]);
         }
         return this;
       }
@@ -5821,9 +5831,9 @@ var require_Namespace = __commonJS({
         }
         let element;
         for (let i = 0; i < this.elementDetection.length; i += 1) {
-          const test2 = this.elementDetection[i][0];
+          const test = this.elementDetection[i][0];
           const ElementClass = this.elementDetection[i][1];
-          if (test2(value)) {
+          if (test(value)) {
             element = new ElementClass(value);
             break;
           }
@@ -17889,7 +17899,7 @@ var dereferenceApiDOM = async (element, options) => {
 };
 
 // ../../node_modules/.bun/@swagger-api+apidom-reference@1.11.6/node_modules/@swagger-api/apidom-reference/src/parse/parsers/Parser.mjs
-var Parser = class {
+var Parser2 = class {
   name;
   /**
    * Whether to allow "empty" files. This includes zero-byte files.
@@ -17921,7 +17931,7 @@ var Parser = class {
     this.mediaTypes = mediaTypes3;
   }
 };
-var Parser_default = Parser;
+var Parser_default = Parser2;
 
 // ../../node_modules/.bun/@swagger-api+apidom-reference@1.11.6/node_modules/@swagger-api/apidom-reference/src/resolve/resolvers/Resolver.mjs
 var Resolver = class {
@@ -19914,1106 +19924,6 @@ function grammar() {
   };
 }
 
-// ../../node_modules/.bun/apg-lite@1.0.5/node_modules/apg-lite/lib/parser.js
-var Parser2 = function fnparser() {
-  const id = identifiers;
-  const utils = utilities;
-  const p = this;
-  const thisFileName = "parser.js: Parser(): ";
-  const systemData = function systemData2() {
-    this.state = id.ACTIVE;
-    this.phraseLength = 0;
-    this.refresh = () => {
-      this.state = id.ACTIVE;
-      this.phraseLength = 0;
-    };
-  };
-  p.ast = void 0;
-  p.stats = void 0;
-  p.trace = void 0;
-  p.callbacks = [];
-  let lookAhead = 0;
-  let treeDepth = 0;
-  let maxTreeDepth = 0;
-  let nodeHits = 0;
-  let maxMatched = 0;
-  let rules = void 0;
-  let udts = void 0;
-  let opcodes = void 0;
-  let chars = void 0;
-  let sysData = new systemData();
-  let ruleCallbacks = void 0;
-  let udtCallbacks = void 0;
-  let userData = void 0;
-  const clear = () => {
-    lookAhead = 0;
-    treeDepth = 0;
-    maxTreeDepth = 0;
-    nodeHits = 0;
-    maxMatched = 0;
-    rules = void 0;
-    udts = void 0;
-    opcodes = void 0;
-    chars = void 0;
-    sysData.refresh();
-    ruleCallbacks = void 0;
-    udtCallbacks = void 0;
-    userData = void 0;
-  };
-  const initializeCallbacks = () => {
-    const functionName = `${thisFileName}initializeCallbacks(): `;
-    let i;
-    ruleCallbacks = [];
-    udtCallbacks = [];
-    for (i = 0; i < rules.length; i += 1) {
-      ruleCallbacks[i] = void 0;
-    }
-    for (i = 0; i < udts.length; i += 1) {
-      udtCallbacks[i] = void 0;
-    }
-    let func;
-    const list = [];
-    for (i = 0; i < rules.length; i += 1) {
-      list.push(rules[i].lower);
-    }
-    for (i = 0; i < udts.length; i += 1) {
-      list.push(udts[i].lower);
-    }
-    for (const index in p.callbacks) {
-      if (p.callbacks.hasOwnProperty(index)) {
-        i = list.indexOf(index.toLowerCase());
-        if (i < 0) {
-          throw new Error(`${functionName}syntax callback '${index}' not a rule or udt name`);
-        }
-        func = p.callbacks[index] ? p.callbacks[index] : void 0;
-        if (typeof func === "function" || func === void 0) {
-          if (i < rules.length) {
-            ruleCallbacks[i] = func;
-          } else {
-            udtCallbacks[i - rules.length] = func;
-          }
-        } else {
-          throw new Error(`${functionName}syntax callback[${index}] must be function reference or falsy)`);
-        }
-      }
-    }
-  };
-  p.parse = (grammar18, startName, inputString, callbackData) => {
-    const functionName = `${thisFileName}parse(): `;
-    clear();
-    chars = utils.stringToChars(inputString);
-    rules = grammar18.rules;
-    udts = grammar18.udts;
-    const lower = startName.toLowerCase();
-    let startIndex = void 0;
-    for (const i in rules) {
-      if (rules.hasOwnProperty(i)) {
-        if (lower === rules[i].lower) {
-          startIndex = rules[i].index;
-          break;
-        }
-      }
-    }
-    if (startIndex === void 0) {
-      throw new Error(`${functionName}start rule name '${startRule}' not recognized`);
-    }
-    initializeCallbacks();
-    if (p.trace) {
-      p.trace.init(rules, udts, chars);
-    }
-    if (p.stats) {
-      p.stats.init(rules, udts);
-    }
-    if (p.ast) {
-      p.ast.init(rules, udts, chars);
-    }
-    userData = callbackData;
-    opcodes = [
-      {
-        type: id.RNM,
-        index: startIndex
-      }
-    ];
-    opExecute(0, 0);
-    opcodes = void 0;
-    let success = false;
-    switch (sysData.state) {
-      case id.ACTIVE:
-        throw new Error(`${functionName}final state should never be 'ACTIVE'`);
-      case id.NOMATCH:
-        success = false;
-        break;
-      case id.EMPTY:
-      case id.MATCH:
-        if (sysData.phraseLength === chars.length) {
-          success = true;
-        } else {
-          success = false;
-        }
-        break;
-      default:
-        throw new Error("unrecognized state");
-    }
-    return {
-      success,
-      state: sysData.state,
-      stateName: id.idName(sysData.state),
-      length: chars.length,
-      matched: sysData.phraseLength,
-      maxMatched,
-      maxTreeDepth,
-      nodeHits
-    };
-  };
-  const opALT = (opIndex, phraseIndex) => {
-    const op = opcodes[opIndex];
-    for (let i = 0; i < op.children.length; i += 1) {
-      opExecute(op.children[i], phraseIndex);
-      if (sysData.state !== id.NOMATCH) {
-        break;
-      }
-    }
-  };
-  const opCAT = (opIndex, phraseIndex) => {
-    let success;
-    let astLength;
-    let catCharIndex;
-    let catPhrase;
-    const op = opcodes[opIndex];
-    if (p.ast) {
-      astLength = p.ast.getLength();
-    }
-    success = true;
-    catCharIndex = phraseIndex;
-    catPhrase = 0;
-    for (let i = 0; i < op.children.length; i += 1) {
-      opExecute(op.children[i], catCharIndex);
-      if (sysData.state === id.NOMATCH) {
-        success = false;
-        break;
-      } else {
-        catCharIndex += sysData.phraseLength;
-        catPhrase += sysData.phraseLength;
-      }
-    }
-    if (success) {
-      sysData.state = catPhrase === 0 ? id.EMPTY : id.MATCH;
-      sysData.phraseLength = catPhrase;
-    } else {
-      sysData.state = id.NOMATCH;
-      sysData.phraseLength = 0;
-      if (p.ast) {
-        p.ast.setLength(astLength);
-      }
-    }
-  };
-  const opREP = (opIndex, phraseIndex) => {
-    let astLength;
-    let repCharIndex;
-    let repPhrase;
-    let repCount;
-    const op = opcodes[opIndex];
-    if (op.max === 0) {
-      sysData.state = id.EMPTY;
-      sysData.phraseLength = 0;
-      return;
-    }
-    repCharIndex = phraseIndex;
-    repPhrase = 0;
-    repCount = 0;
-    if (p.ast) {
-      astLength = p.ast.getLength();
-    }
-    while (1) {
-      if (repCharIndex >= chars.length) {
-        break;
-      }
-      opExecute(opIndex + 1, repCharIndex);
-      if (sysData.state === id.NOMATCH) {
-        break;
-      }
-      if (sysData.state === id.EMPTY) {
-        break;
-      }
-      repCount += 1;
-      repPhrase += sysData.phraseLength;
-      repCharIndex += sysData.phraseLength;
-      if (repCount === op.max) {
-        break;
-      }
-    }
-    if (sysData.state === id.EMPTY) {
-      sysData.state = repPhrase === 0 ? id.EMPTY : id.MATCH;
-      sysData.phraseLength = repPhrase;
-    } else if (repCount >= op.min) {
-      sysData.state = repPhrase === 0 ? id.EMPTY : id.MATCH;
-      sysData.phraseLength = repPhrase;
-    } else {
-      sysData.state = id.NOMATCH;
-      sysData.phraseLength = 0;
-      if (p.ast) {
-        p.ast.setLength(astLength);
-      }
-    }
-  };
-  const validateRnmCallbackResult = (rule, sysData2, charsLeft, down) => {
-    if (sysData2.phraseLength > charsLeft) {
-      let str2 = `${thisFileName}opRNM(${rule.name}): callback function error: `;
-      str2 += `sysData.phraseLength: ${sysData2.phraseLength}`;
-      str2 += ` must be <= remaining chars: ${charsLeft}`;
-      throw new Error(str2);
-    }
-    switch (sysData2.state) {
-      case id.ACTIVE:
-        if (!down) {
-          throw new Error(
-            `${thisFileName}opRNM(${rule.name}): callback function return error. ACTIVE state not allowed.`
-          );
-        }
-        break;
-      case id.EMPTY:
-        sysData2.phraseLength = 0;
-        break;
-      case id.MATCH:
-        if (sysData2.phraseLength === 0) {
-          sysData2.state = id.EMPTY;
-        }
-        break;
-      case id.NOMATCH:
-        sysData2.phraseLength = 0;
-        break;
-      default:
-        throw new Error(
-          `${thisFileName}opRNM(${rule.name}): callback function return error. Unrecognized return state: ${sysData2.state}`
-        );
-    }
-  };
-  const opRNM = (opIndex, phraseIndex) => {
-    let astLength;
-    let astDefined;
-    let savedOpcodes;
-    const op = opcodes[opIndex];
-    const rule = rules[op.index];
-    const callback = ruleCallbacks[rule.index];
-    if (!lookAhead) {
-      astDefined = p.ast && p.ast.ruleDefined(op.index);
-      if (astDefined) {
-        astLength = p.ast.getLength();
-        p.ast.down(op.index, rules[op.index].name);
-      }
-    }
-    if (callback) {
-      const charsLeft = chars.length - phraseIndex;
-      callback(sysData, chars, phraseIndex, userData);
-      validateRnmCallbackResult(rule, sysData, charsLeft, true);
-      if (sysData.state === id.ACTIVE) {
-        savedOpcodes = opcodes;
-        opcodes = rule.opcodes;
-        opExecute(0, phraseIndex);
-        opcodes = savedOpcodes;
-        callback(sysData, chars, phraseIndex, userData);
-        validateRnmCallbackResult(rule, sysData, charsLeft, false);
-      }
-    } else {
-      savedOpcodes = opcodes;
-      opcodes = rule.opcodes;
-      opExecute(0, phraseIndex, sysData);
-      opcodes = savedOpcodes;
-    }
-    if (!lookAhead) {
-      if (astDefined) {
-        if (sysData.state === id.NOMATCH) {
-          p.ast.setLength(astLength);
-        } else {
-          p.ast.up(op.index, rule.name, phraseIndex, sysData.phraseLength);
-        }
-      }
-    }
-  };
-  const opTRG = (opIndex, phraseIndex) => {
-    const op = opcodes[opIndex];
-    sysData.state = id.NOMATCH;
-    if (phraseIndex < chars.length) {
-      if (op.min <= chars[phraseIndex] && chars[phraseIndex] <= op.max) {
-        sysData.state = id.MATCH;
-        sysData.phraseLength = 1;
-      }
-    }
-  };
-  const opTBS = (opIndex, phraseIndex) => {
-    const op = opcodes[opIndex];
-    const len = op.string.length;
-    sysData.state = id.NOMATCH;
-    if (phraseIndex + len <= chars.length) {
-      for (let i = 0; i < len; i += 1) {
-        if (chars[phraseIndex + i] !== op.string[i]) {
-          return;
-        }
-      }
-      sysData.state = id.MATCH;
-      sysData.phraseLength = len;
-    }
-  };
-  const opTLS = (opIndex, phraseIndex) => {
-    let code;
-    const op = opcodes[opIndex];
-    sysData.state = id.NOMATCH;
-    const len = op.string.length;
-    if (len === 0) {
-      sysData.state = id.EMPTY;
-      return;
-    }
-    if (phraseIndex + len <= chars.length) {
-      for (let i = 0; i < len; i += 1) {
-        code = chars[phraseIndex + i];
-        if (code >= 65 && code <= 90) {
-          code += 32;
-        }
-        if (code !== op.string[i]) {
-          return;
-        }
-      }
-      sysData.state = id.MATCH;
-      sysData.phraseLength = len;
-    }
-  };
-  const validateUdtCallbackResult = (udt, sysData2, charsLeft) => {
-    if (sysData2.phraseLength > charsLeft) {
-      let str2 = `${thisFileName}opUDT(${udt.name}): callback function error: `;
-      str2 += `sysData.phraseLength: ${sysData2.phraseLength}`;
-      str2 += ` must be <= remaining chars: ${charsLeft}`;
-      throw new Error(str2);
-    }
-    switch (sysData2.state) {
-      case id.ACTIVE:
-        throw new Error(`${thisFileName}opUDT(${udt.name}) ACTIVE state return not allowed.`);
-      case id.EMPTY:
-        if (udt.empty) {
-          sysData2.phraseLength = 0;
-        } else {
-          throw new Error(`${thisFileName}opUDT(${udt.name}) may not return EMPTY.`);
-        }
-        break;
-      case id.MATCH:
-        if (sysData2.phraseLength === 0) {
-          if (udt.empty) {
-            sysData2.state = id.EMPTY;
-          } else {
-            throw new Error(`${thisFileName}opUDT(${udt.name}) may not return EMPTY.`);
-          }
-        }
-        break;
-      case id.NOMATCH:
-        sysData2.phraseLength = 0;
-        break;
-      default:
-        throw new Error(
-          `${thisFileName}opUDT(${udt.name}): callback function return error. Unrecognized return state: ${sysData2.state}`
-        );
-    }
-  };
-  const opUDT = (opIndex, phraseIndex) => {
-    let astLength;
-    let astIndex;
-    let astDefined;
-    const op = opcodes[opIndex];
-    const udt = udts[op.index];
-    sysData.UdtIndex = udt.index;
-    if (!lookAhead) {
-      astDefined = p.ast && p.ast.udtDefined(op.index);
-      if (astDefined) {
-        astIndex = rules.length + op.index;
-        astLength = p.ast.getLength();
-        p.ast.down(astIndex, udt.name);
-      }
-    }
-    const charsLeft = chars.length - phraseIndex;
-    udtCallbacks[op.index](sysData, chars, phraseIndex, userData);
-    validateUdtCallbackResult(udt, sysData, charsLeft);
-    if (!lookAhead) {
-      if (astDefined) {
-        if (sysData.state === id.NOMATCH) {
-          p.ast.setLength(astLength);
-        } else {
-          p.ast.up(astIndex, udt.name, phraseIndex, sysData.phraseLength);
-        }
-      }
-    }
-  };
-  const opAND = (opIndex, phraseIndex) => {
-    lookAhead += 1;
-    opExecute(opIndex + 1, phraseIndex);
-    lookAhead -= 1;
-    sysData.phraseLength = 0;
-    switch (sysData.state) {
-      case id.EMPTY:
-        sysData.state = id.EMPTY;
-        break;
-      case id.MATCH:
-        sysData.state = id.EMPTY;
-        break;
-      case id.NOMATCH:
-        sysData.state = id.NOMATCH;
-        break;
-      default:
-        throw new Error(`opAND: invalid state ${sysData.state}`);
-    }
-  };
-  const opNOT = (opIndex, phraseIndex) => {
-    lookAhead += 1;
-    opExecute(opIndex + 1, phraseIndex);
-    lookAhead -= 1;
-    sysData.phraseLength = 0;
-    switch (sysData.state) {
-      case id.EMPTY:
-      case id.MATCH:
-        sysData.state = id.NOMATCH;
-        break;
-      case id.NOMATCH:
-        sysData.state = id.EMPTY;
-        break;
-      default:
-        throw new Error(`opNOT: invalid state ${sysData.state}`);
-    }
-  };
-  const opExecute = (opIndex, phraseIndex) => {
-    const functionName = `${thisFileName}opExecute(): `;
-    const op = opcodes[opIndex];
-    nodeHits += 1;
-    if (treeDepth > maxTreeDepth) {
-      maxTreeDepth = treeDepth;
-    }
-    treeDepth += 1;
-    sysData.refresh();
-    if (p.trace) {
-      p.trace.down(op, phraseIndex);
-    }
-    switch (op.type) {
-      case id.ALT:
-        opALT(opIndex, phraseIndex);
-        break;
-      case id.CAT:
-        opCAT(opIndex, phraseIndex);
-        break;
-      case id.REP:
-        opREP(opIndex, phraseIndex);
-        break;
-      case id.RNM:
-        opRNM(opIndex, phraseIndex);
-        break;
-      case id.TRG:
-        opTRG(opIndex, phraseIndex);
-        break;
-      case id.TBS:
-        opTBS(opIndex, phraseIndex);
-        break;
-      case id.TLS:
-        opTLS(opIndex, phraseIndex);
-        break;
-      case id.UDT:
-        opUDT(opIndex, phraseIndex);
-        break;
-      case id.AND:
-        opAND(opIndex, phraseIndex);
-        break;
-      case id.NOT:
-        opNOT(opIndex, phraseIndex);
-        break;
-      default:
-        throw new Error(`${functionName}unrecognized operator`);
-    }
-    if (!lookAhead) {
-      if (phraseIndex + sysData.phraseLength > maxMatched) {
-        maxMatched = phraseIndex + sysData.phraseLength;
-      }
-    }
-    if (p.stats) {
-      p.stats.collect(op, sysData);
-    }
-    if (p.trace) {
-      p.trace.up(op, sysData.state, phraseIndex, sysData.phraseLength);
-    }
-    treeDepth -= 1;
-  };
-};
-var Ast = function fnast() {
-  const thisFileName = "parser.js: Ast()): ";
-  const id = identifiers;
-  const utils = utilities;
-  const a = this;
-  let rules = void 0;
-  let udts = void 0;
-  let chars = void 0;
-  let nodeCount = 0;
-  const nodeCallbacks = [];
-  const stack = [];
-  const records = [];
-  a.callbacks = [];
-  a.init = (rulesIn, udtsIn, charsIn) => {
-    stack.length = 0;
-    records.length = 0;
-    nodeCount = 0;
-    rules = rulesIn;
-    udts = udtsIn;
-    chars = charsIn;
-    let i;
-    const list = [];
-    for (i = 0; i < rules.length; i += 1) {
-      list.push(rules[i].lower);
-    }
-    for (i = 0; i < udts.length; i += 1) {
-      list.push(udts[i].lower);
-    }
-    nodeCount = rules.length + udts.length;
-    for (i = 0; i < nodeCount; i += 1) {
-      nodeCallbacks[i] = void 0;
-    }
-    for (const index in a.callbacks) {
-      if (a.callbacks.hasOwnProperty(index)) {
-        const lower = index.toLowerCase();
-        i = list.indexOf(lower);
-        if (i < 0) {
-          throw new Error(`${thisFileName}init: node '${index}' not a rule or udt name`);
-        }
-        nodeCallbacks[i] = a.callbacks[index];
-      }
-    }
-  };
-  a.ruleDefined = (index) => !!nodeCallbacks[index];
-  a.udtDefined = (index) => !!nodeCallbacks[rules.length + index];
-  a.down = (callbackIndex, name) => {
-    const thisIndex = records.length;
-    stack.push(thisIndex);
-    records.push({
-      name,
-      thisIndex,
-      thatIndex: void 0,
-      state: id.SEM_PRE,
-      callbackIndex,
-      phraseIndex: void 0,
-      phraseLength: void 0,
-      stack: stack.length
-    });
-    return thisIndex;
-  };
-  a.up = (callbackIndex, name, phraseIndex, phraseLength) => {
-    const thisIndex = records.length;
-    const thatIndex = stack.pop();
-    records.push({
-      name,
-      thisIndex,
-      thatIndex,
-      state: id.SEM_POST,
-      callbackIndex,
-      phraseIndex,
-      phraseLength,
-      stack: stack.length
-    });
-    records[thatIndex].thatIndex = thisIndex;
-    records[thatIndex].phraseIndex = phraseIndex;
-    records[thatIndex].phraseLength = phraseLength;
-    return thisIndex;
-  };
-  a.translate = (data) => {
-    let ret;
-    let callback;
-    let record;
-    for (let i = 0; i < records.length; i += 1) {
-      record = records[i];
-      callback = nodeCallbacks[record.callbackIndex];
-      if (callback) {
-        if (record.state === id.SEM_PRE) {
-          callback(id.SEM_PRE, chars, record.phraseIndex, record.phraseLength, data);
-        } else if (callback) {
-          callback(id.SEM_POST, chars, record.phraseIndex, record.phraseLength, data);
-        }
-      }
-    }
-  };
-  a.setLength = (length) => {
-    records.length = length;
-    if (length > 0) {
-      stack.length = records[length - 1].stack;
-    } else {
-      stack.length = 0;
-    }
-  };
-  a.getLength = () => records.length;
-  function indent(n) {
-    let ret = "";
-    while (n-- > 0) {
-      ret += " ";
-    }
-    return ret;
-  }
-  a.toXml = () => {
-    let xml = "";
-    let depth = 0;
-    xml += '<?xml version="1.0" encoding="utf-8"?>\n';
-    xml += `<root nodes="${records.length / 2}" characters="${chars.length}">
-`;
-    xml += `<!-- input string -->
-`;
-    xml += indent(depth + 2);
-    xml += utils.charsToString(chars);
-    xml += "\n";
-    records.forEach((rec) => {
-      if (rec.state === id.SEM_PRE) {
-        depth += 1;
-        xml += indent(depth);
-        xml += `<node name="${rec.name}" index="${rec.phraseIndex}" length="${rec.phraseLength}">
-`;
-        xml += indent(depth + 2);
-        xml += utils.charsToString(chars, rec.phraseIndex, rec.phraseLength);
-        xml += "\n";
-      } else {
-        xml += indent(depth);
-        xml += `</node><!-- name="${rec.name}" -->
-`;
-        depth -= 1;
-      }
-    });
-    xml += "</root>\n";
-    return xml;
-  };
-};
-var Trace = function fntrace() {
-  const id = identifiers;
-  const utils = utilities;
-  const thisFile = "parser.js: Trace(): ";
-  let chars = void 0;
-  let rules = void 0;
-  let udts = void 0;
-  let out = "";
-  let treeDepth = 0;
-  const MAX_PHRASE = 100;
-  const t = this;
-  const indent = (n) => {
-    let ret = "";
-    let count = 0;
-    if (n >= 0) {
-      while (n--) {
-        count += 1;
-        if (count === 5) {
-          ret += "|";
-          count = 0;
-        } else {
-          ret += ".";
-        }
-      }
-    }
-    return ret;
-  };
-  t.init = (r, u, c) => {
-    rules = r;
-    udts = u;
-    chars = c;
-  };
-  const opName = (op) => {
-    let name;
-    switch (op.type) {
-      case id.ALT:
-        name = "ALT";
-        break;
-      case id.CAT:
-        name = "CAT";
-        break;
-      case id.REP:
-        if (op.max === Infinity) {
-          name = `REP(${op.min},inf)`;
-        } else {
-          name = `REP(${op.min},${op.max})`;
-        }
-        break;
-      case id.RNM:
-        name = `RNM(${rules[op.index].name})`;
-        break;
-      case id.TRG:
-        name = `TRG(${op.min},${op.max})`;
-        break;
-      case id.TBS:
-        if (op.string.length > 6) {
-          name = `TBS(${utils.charsToString(op.string, 0, 3)}...)`;
-        } else {
-          name = `TBS(${utils.charsToString(op.string, 0, 6)})`;
-        }
-        break;
-      case id.TLS:
-        if (op.string.length > 6) {
-          name = `TLS(${utils.charsToString(op.string, 0, 3)}...)`;
-        } else {
-          name = `TLS(${utils.charsToString(op.string, 0, 6)})`;
-        }
-        break;
-      case id.UDT:
-        name = `UDT(${udts[op.index].name})`;
-        break;
-      case id.AND:
-        name = "AND";
-        break;
-      case id.NOT:
-        name = "NOT";
-        break;
-      default:
-        throw new Error(`${thisFile}Trace: opName: unrecognized opcode`);
-    }
-    return name;
-  };
-  t.down = (op, offset) => {
-    const lead = indent(treeDepth);
-    const len = Math.min(MAX_PHRASE, chars.length - offset);
-    let phrase = utils.charsToString(chars, offset, len);
-    if (len < chars.length - offset) {
-      phrase += "...";
-    }
-    phrase = `${lead}|-|[${opName(op)}]${phrase}
-`;
-    out += phrase;
-    treeDepth += 1;
-  };
-  t.up = (op, state, offset, phraseLength) => {
-    const thisFunc = `${thisFile}trace.up: `;
-    treeDepth -= 1;
-    const lead = indent(treeDepth);
-    let len;
-    let phrase;
-    let st;
-    switch (state) {
-      case id.EMPTY:
-        st = "|E|";
-        phrase = `''`;
-        break;
-      case id.MATCH:
-        st = "|M|";
-        len = Math.min(MAX_PHRASE, phraseLength);
-        if (len < phraseLength) {
-          phrase = `'${utils.charsToString(chars, offset, len)}...'`;
-        } else {
-          phrase = `'${utils.charsToString(chars, offset, len)}'`;
-        }
-        break;
-      case id.NOMATCH:
-        st = "|N|";
-        phrase = "";
-        break;
-      default:
-        throw new Error(`${thisFunc} unrecognized state`);
-    }
-    phrase = `${lead}${st}[${opName(op)}]${phrase}
-`;
-    out += phrase;
-  };
-  t.displayTrace = () => out;
-};
-var Stats = function fnstats() {
-  const id = identifiers;
-  const thisFileName = "parser.js: Stats(): ";
-  let rules;
-  let udts;
-  let totals;
-  const stats = [];
-  const ruleStats = [];
-  const udtStats = [];
-  this.init = (r, u) => {
-    rules = r;
-    udts = u;
-    clear();
-  };
-  this.collect = (op, sys) => {
-    incStat(totals, sys.state, sys.phraseLength);
-    incStat(stats[op.type], sys.state, sys.phraseLength);
-    if (op.type === id.RNM) {
-      incStat(ruleStats[op.index], sys.state, sys.phraseLength);
-    }
-    if (op.type === id.UDT) {
-      incStat(udtStats[op.index], sys.state, sys.phraseLength);
-    }
-  };
-  this.displayStats = () => {
-    let out = "";
-    const totals2 = {
-      match: 0,
-      empty: 0,
-      nomatch: 0,
-      total: 0
-    };
-    const displayRow = (op, m, e, n, t) => {
-      totals2.match += m;
-      totals2.empty += e;
-      totals2.nomatch += n;
-      totals2.total += t;
-      const mm = normalize4(m);
-      const ee = normalize4(e);
-      const nn = normalize4(n);
-      const tt = normalize4(t);
-      return `${op} | ${mm} | ${ee} | ${nn} | ${tt} |
-`;
-    };
-    out += "          OPERATOR STATS\n";
-    out += "      |   MATCH |   EMPTY | NOMATCH |   TOTAL |\n";
-    out += displayRow("  ALT", stats[id.ALT].match, stats[id.ALT].empty, stats[id.ALT].nomatch, stats[id.ALT].total);
-    out += displayRow("  CAT", stats[id.CAT].match, stats[id.CAT].empty, stats[id.CAT].nomatch, stats[id.CAT].total);
-    out += displayRow("  REP", stats[id.REP].match, stats[id.REP].empty, stats[id.REP].nomatch, stats[id.REP].total);
-    out += displayRow("  RNM", stats[id.RNM].match, stats[id.RNM].empty, stats[id.RNM].nomatch, stats[id.RNM].total);
-    out += displayRow("  TRG", stats[id.TRG].match, stats[id.TRG].empty, stats[id.TRG].nomatch, stats[id.TRG].total);
-    out += displayRow("  TBS", stats[id.TBS].match, stats[id.TBS].empty, stats[id.TBS].nomatch, stats[id.TBS].total);
-    out += displayRow("  TLS", stats[id.TLS].match, stats[id.TLS].empty, stats[id.TLS].nomatch, stats[id.TLS].total);
-    out += displayRow("  UDT", stats[id.UDT].match, stats[id.UDT].empty, stats[id.UDT].nomatch, stats[id.UDT].total);
-    out += displayRow("  AND", stats[id.AND].match, stats[id.AND].empty, stats[id.AND].nomatch, stats[id.AND].total);
-    out += displayRow("  NOT", stats[id.NOT].match, stats[id.NOT].empty, stats[id.NOT].nomatch, stats[id.NOT].total);
-    out += displayRow("TOTAL", totals2.match, totals2.empty, totals2.nomatch, totals2.total);
-    return out;
-  };
-  this.displayHits = (type4) => {
-    let out = "";
-    const displayRow = (m, e, n, t, name) => {
-      totals.match += m;
-      totals.empty += e;
-      totals.nomatch += n;
-      totals.total += t;
-      const mm = normalize4(m);
-      const ee = normalize4(e);
-      const nn = normalize4(n);
-      const tt = normalize4(t);
-      return `| ${mm} | ${ee} | ${nn} | ${tt} | ${name}
-`;
-    };
-    if (typeof type4 === "string" && type4.toLowerCase()[0] === "a") {
-      ruleStats.sort(sortAlpha);
-      udtStats.sort(sortAlpha);
-      out += "    RULES/UDTS ALPHABETICALLY\n";
-    } else if (typeof type4 === "string" && type4.toLowerCase()[0] === "i") {
-      ruleStats.sort(sortIndex);
-      udtStats.sort(sortIndex);
-      out += "    RULES/UDTS BY INDEX\n";
-    } else {
-      ruleStats.sort(sortHits);
-      udtStats.sort(sortHits);
-      out += "    RULES/UDTS BY HIT COUNT\n";
-    }
-    out += "|   MATCH |   EMPTY | NOMATCH |   TOTAL | NAME\n";
-    for (let i = 0; i < ruleStats.length; i += 1) {
-      let r = ruleStats[i];
-      if (r.total) {
-        out += displayRow(r.match, r.empty, r.nomatch, r.total, r.name);
-      }
-    }
-    for (let i = 0; i < udtStats.length; i += 1) {
-      let r = udtStats[i];
-      if (r.total) {
-        out += displayRow(r.match, r.empty, r.nomatch, r.total, r.name);
-      }
-    }
-    return out;
-  };
-  const normalize4 = (n) => {
-    if (n < 10) {
-      return `      ${n}`;
-    }
-    if (n < 100) {
-      return `     ${n}`;
-    }
-    if (n < 1e3) {
-      return `    ${n}`;
-    }
-    if (n < 1e4) {
-      return `   ${n}`;
-    }
-    if (n < 1e5) {
-      return `  ${n}`;
-    }
-    if (n < 1e6) {
-      return ` ${n}`;
-    }
-    return `${n}`;
-  };
-  const sortAlpha = (lhs, rhs) => {
-    if (lhs.lower < rhs.lower) {
-      return -1;
-    }
-    if (lhs.lower > rhs.lower) {
-      return 1;
-    }
-    return 0;
-  };
-  const sortHits = (lhs, rhs) => {
-    if (lhs.total < rhs.total) {
-      return 1;
-    }
-    if (lhs.total > rhs.total) {
-      return -1;
-    }
-    return sortAlpha(lhs, rhs);
-  };
-  const sortIndex = (lhs, rhs) => {
-    if (lhs.index < rhs.index) {
-      return -1;
-    }
-    if (lhs.index > rhs.index) {
-      return 1;
-    }
-    return 0;
-  };
-  const EmptyStat = function fnempty() {
-    this.empty = 0;
-    this.match = 0;
-    this.nomatch = 0;
-    this.total = 0;
-  };
-  const clear = () => {
-    stats.length = 0;
-    totals = new EmptyStat();
-    stats[id.ALT] = new EmptyStat();
-    stats[id.CAT] = new EmptyStat();
-    stats[id.REP] = new EmptyStat();
-    stats[id.RNM] = new EmptyStat();
-    stats[id.TRG] = new EmptyStat();
-    stats[id.TBS] = new EmptyStat();
-    stats[id.TLS] = new EmptyStat();
-    stats[id.UDT] = new EmptyStat();
-    stats[id.AND] = new EmptyStat();
-    stats[id.NOT] = new EmptyStat();
-    ruleStats.length = 0;
-    for (let i = 0; i < rules.length; i += 1) {
-      ruleStats.push({
-        empty: 0,
-        match: 0,
-        nomatch: 0,
-        total: 0,
-        name: rules[i].name,
-        lower: rules[i].lower,
-        index: rules[i].index
-      });
-    }
-    if (udts.length > 0) {
-      udtStats.length = 0;
-      for (let i = 0; i < udts.length; i += 1) {
-        udtStats.push({
-          empty: 0,
-          match: 0,
-          nomatch: 0,
-          total: 0,
-          name: udts[i].name,
-          lower: udts[i].lower,
-          index: udts[i].index
-        });
-      }
-    }
-  };
-  const incStat = (stat, state) => {
-    stat.total += 1;
-    switch (state) {
-      case id.EMPTY:
-        stat.empty += 1;
-        break;
-      case id.MATCH:
-        stat.match += 1;
-        break;
-      case id.NOMATCH:
-        stat.nomatch += 1;
-        break;
-      default:
-        throw new Error(`${thisFileName}collect(): incStat(): unrecognized state: ${state}`);
-    }
-  };
-};
-var utilities = {
-  // utility functions
-  stringToChars: (string) => [...string].map((cp) => cp.codePointAt(0)),
-  charsToString: (chars, beg, len) => {
-    let subChars = chars;
-    while (1) {
-      if (beg === void 0 || beg < 0) {
-        break;
-      }
-      if (len === void 0) {
-        subChars = chars.slice(beg);
-        break;
-      }
-      if (len <= 0) {
-        return "";
-      }
-      subChars = chars.slice(beg, beg + len);
-      break;
-    }
-    return String.fromCodePoint(...subChars);
-  }
-};
-var identifiers = {
-  // Identifies the operator type.
-  // NB: These must match the values in apg-js 4.3.0, apg-lib/identifiers.
-  /* the original ABNF operators */
-  ALT: 1,
-  CAT: 2,
-  REP: 3,
-  RNM: 4,
-  TRG: 5,
-  TBS: 6,
-  TLS: 7,
-  /* the super set, SABNF operators */
-  UDT: 11,
-  AND: 12,
-  NOT: 13,
-  // Used by the parser and the user's `RNM` and `UDT` callback functions.
-  // Identifies the parser state as it traverses the parse tree nodes.
-  // - *ACTIVE* - indicates the downward direction through the parse tree node.
-  // - *MATCH* - indicates the upward direction and a phrase, of length \> 0, has been successfully matched
-  // - *EMPTY* - indicates the upward direction and a phrase, of length = 0, has been successfully matched
-  // - *NOMATCH* - indicates the upward direction and the parser failed to match any phrase at all
-  ACTIVE: 100,
-  MATCH: 101,
-  EMPTY: 102,
-  NOMATCH: 103,
-  // Used by [`AST` translator](./ast.html) (semantic analysis) and the user's callback functions
-  // to indicate the direction of flow through the `AST` nodes.
-  // - *SEM_PRE* - indicates the downward (pre-branch) direction through the `AST` node.
-  // - *SEM_POST* - indicates the upward (post-branch) direction through the `AST` node.
-  SEM_PRE: 200,
-  SEM_POST: 201,
-  // Ignored. Retained for backwords compatibility.
-  SEM_OK: 300,
-  idName: (s) => {
-    switch (s) {
-      case identifiers.ALT:
-        return "ALT";
-      case identifiers.CAT:
-        return "CAT";
-      case identifiers.REP:
-        return "REP";
-      case identifiers.RNM:
-        return "RNM";
-      case identifiers.TRG:
-        return "TRG";
-      case identifiers.TBS:
-        return "TBS";
-      case identifiers.TLS:
-        return "TLS";
-      case identifiers.UDT:
-        return "UDT";
-      case identifiers.AND:
-        return "AND";
-      case identifiers.NOT:
-        return "NOT";
-      case identifiers.ACTIVE:
-        return "ACTIVE";
-      case identifiers.EMPTY:
-        return "EMPTY";
-      case identifiers.MATCH:
-        return "MATCH";
-      case identifiers.NOMATCH:
-        return "NOMATCH";
-      case identifiers.SEM_PRE:
-        return "SEM_PRE";
-      case identifiers.SEM_POST:
-        return "SEM_POST";
-      case identifiers.SEM_OK:
-        return "SEM_OK";
-      default:
-        return "UNRECOGNIZED STATE";
-    }
-  }
-};
-
 // ../../node_modules/.bun/@swaggerexpert+json-pointer@2.10.2/node_modules/@swaggerexpert/json-pointer/es/errors/JSONPointerError.mjs
 var JSONPointerError = class extends Error {
   constructor(message, options = void 0) {
@@ -21172,7 +20082,7 @@ var parse2 = (jsonPointer, {
     throw new TypeError("JSON Pointer must be a string");
   }
   try {
-    const parser10 = new Parser2();
+    const parser10 = new Parser();
     if (translator) parser10.ast = translator;
     if (stats) parser10.stats = new Stats();
     if (trace) parser10.trace = new Trace_default();
@@ -21194,15 +20104,15 @@ var parse_default2 = parse2;
 
 // ../../node_modules/.bun/@swaggerexpert+json-pointer@2.10.2/node_modules/@swaggerexpert/json-pointer/es/test/reference-token.mjs
 var grammar3 = new grammar();
-var parser = new Parser2();
+var parser = new Parser();
 
 // ../../node_modules/.bun/@swaggerexpert+json-pointer@2.10.2/node_modules/@swaggerexpert/json-pointer/es/test/array-location.mjs
 var grammar4 = new grammar();
-var parser2 = new Parser2();
+var parser2 = new Parser();
 
 // ../../node_modules/.bun/@swaggerexpert+json-pointer@2.10.2/node_modules/@swaggerexpert/json-pointer/es/test/array-index.mjs
 var grammar5 = new grammar();
-var parser3 = new Parser2();
+var parser3 = new Parser();
 var testArrayIndex = (referenceToken) => {
   if (typeof referenceToken !== "string") return false;
   try {
@@ -21215,7 +20125,7 @@ var array_index_default = testArrayIndex;
 
 // ../../node_modules/.bun/@swaggerexpert+json-pointer@2.10.2/node_modules/@swaggerexpert/json-pointer/es/test/array-dash.mjs
 var grammar6 = new grammar();
-var parser4 = new Parser2();
+var parser4 = new Parser();
 var testArrayDash = (referenceToken) => {
   if (typeof referenceToken !== "string") return false;
   try {
@@ -37842,515 +36752,8 @@ function mapTagOperations({
 // ../../node_modules/.bun/swagger-client@3.38.2/node_modules/swagger-client/es/execute/index.js
 var import_includes17 = __toESM(require_includes5());
 
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/server-url-templating.mjs
-function grammar7() {
-  this.grammarObject = "grammarObject";
-  this.rules = [];
-  this.rules[0] = {
-    name: "server-url-template",
-    lower: "server-url-template",
-    index: 0,
-    isBkr: false
-  };
-  this.rules[1] = {
-    name: "server-variable",
-    lower: "server-variable",
-    index: 1,
-    isBkr: false
-  };
-  this.rules[2] = {
-    name: "server-variable-name",
-    lower: "server-variable-name",
-    index: 2,
-    isBkr: false
-  };
-  this.rules[3] = {
-    name: "literals",
-    lower: "literals",
-    index: 3,
-    isBkr: false
-  };
-  this.rules[4] = {
-    name: "DIGIT",
-    lower: "digit",
-    index: 4,
-    isBkr: false
-  };
-  this.rules[5] = {
-    name: "HEXDIG",
-    lower: "hexdig",
-    index: 5,
-    isBkr: false
-  };
-  this.rules[6] = {
-    name: "pct-encoded",
-    lower: "pct-encoded",
-    index: 6,
-    isBkr: false
-  };
-  this.rules[7] = {
-    name: "ucschar",
-    lower: "ucschar",
-    index: 7,
-    isBkr: false
-  };
-  this.rules[8] = {
-    name: "iprivate",
-    lower: "iprivate",
-    index: 8,
-    isBkr: false
-  };
-  this.udts = [];
-  this.rules[0].opcodes = [];
-  this.rules[0].opcodes[0] = {
-    type: 3,
-    min: 1,
-    max: Infinity
-  };
-  this.rules[0].opcodes[1] = {
-    type: 1,
-    children: [2, 3]
-  };
-  this.rules[0].opcodes[2] = {
-    type: 4,
-    index: 3
-  };
-  this.rules[0].opcodes[3] = {
-    type: 4,
-    index: 1
-  };
-  this.rules[1].opcodes = [];
-  this.rules[1].opcodes[0] = {
-    type: 2,
-    children: [1, 2, 3]
-  };
-  this.rules[1].opcodes[1] = {
-    type: 7,
-    string: [123]
-  };
-  this.rules[1].opcodes[2] = {
-    type: 4,
-    index: 2
-  };
-  this.rules[1].opcodes[3] = {
-    type: 7,
-    string: [125]
-  };
-  this.rules[2].opcodes = [];
-  this.rules[2].opcodes[0] = {
-    type: 3,
-    min: 1,
-    max: Infinity
-  };
-  this.rules[2].opcodes[1] = {
-    type: 1,
-    children: [2, 3, 4]
-  };
-  this.rules[2].opcodes[2] = {
-    type: 5,
-    min: 0,
-    max: 122
-  };
-  this.rules[2].opcodes[3] = {
-    type: 6,
-    string: [124]
-  };
-  this.rules[2].opcodes[4] = {
-    type: 5,
-    min: 126,
-    max: 1114111
-  };
-  this.rules[3].opcodes = [];
-  this.rules[3].opcodes[0] = {
-    type: 3,
-    min: 1,
-    max: Infinity
-  };
-  this.rules[3].opcodes[1] = {
-    type: 1,
-    children: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  };
-  this.rules[3].opcodes[2] = {
-    type: 6,
-    string: [33]
-  };
-  this.rules[3].opcodes[3] = {
-    type: 5,
-    min: 35,
-    max: 36
-  };
-  this.rules[3].opcodes[4] = {
-    type: 5,
-    min: 38,
-    max: 59
-  };
-  this.rules[3].opcodes[5] = {
-    type: 6,
-    string: [61]
-  };
-  this.rules[3].opcodes[6] = {
-    type: 5,
-    min: 63,
-    max: 91
-  };
-  this.rules[3].opcodes[7] = {
-    type: 6,
-    string: [93]
-  };
-  this.rules[3].opcodes[8] = {
-    type: 6,
-    string: [95]
-  };
-  this.rules[3].opcodes[9] = {
-    type: 5,
-    min: 97,
-    max: 122
-  };
-  this.rules[3].opcodes[10] = {
-    type: 6,
-    string: [126]
-  };
-  this.rules[3].opcodes[11] = {
-    type: 4,
-    index: 7
-  };
-  this.rules[3].opcodes[12] = {
-    type: 4,
-    index: 8
-  };
-  this.rules[3].opcodes[13] = {
-    type: 4,
-    index: 6
-  };
-  this.rules[4].opcodes = [];
-  this.rules[4].opcodes[0] = {
-    type: 5,
-    min: 48,
-    max: 57
-  };
-  this.rules[5].opcodes = [];
-  this.rules[5].opcodes[0] = {
-    type: 1,
-    children: [1, 2, 3, 4, 5, 6, 7]
-  };
-  this.rules[5].opcodes[1] = {
-    type: 4,
-    index: 4
-  };
-  this.rules[5].opcodes[2] = {
-    type: 7,
-    string: [97]
-  };
-  this.rules[5].opcodes[3] = {
-    type: 7,
-    string: [98]
-  };
-  this.rules[5].opcodes[4] = {
-    type: 7,
-    string: [99]
-  };
-  this.rules[5].opcodes[5] = {
-    type: 7,
-    string: [100]
-  };
-  this.rules[5].opcodes[6] = {
-    type: 7,
-    string: [101]
-  };
-  this.rules[5].opcodes[7] = {
-    type: 7,
-    string: [102]
-  };
-  this.rules[6].opcodes = [];
-  this.rules[6].opcodes[0] = {
-    type: 2,
-    children: [1, 2, 3]
-  };
-  this.rules[6].opcodes[1] = {
-    type: 7,
-    string: [37]
-  };
-  this.rules[6].opcodes[2] = {
-    type: 4,
-    index: 5
-  };
-  this.rules[6].opcodes[3] = {
-    type: 4,
-    index: 5
-  };
-  this.rules[7].opcodes = [];
-  this.rules[7].opcodes[0] = {
-    type: 1,
-    children: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
-  };
-  this.rules[7].opcodes[1] = {
-    type: 5,
-    min: 160,
-    max: 55295
-  };
-  this.rules[7].opcodes[2] = {
-    type: 5,
-    min: 63744,
-    max: 64975
-  };
-  this.rules[7].opcodes[3] = {
-    type: 5,
-    min: 65008,
-    max: 65519
-  };
-  this.rules[7].opcodes[4] = {
-    type: 5,
-    min: 65536,
-    max: 131069
-  };
-  this.rules[7].opcodes[5] = {
-    type: 5,
-    min: 131072,
-    max: 196605
-  };
-  this.rules[7].opcodes[6] = {
-    type: 5,
-    min: 196608,
-    max: 262141
-  };
-  this.rules[7].opcodes[7] = {
-    type: 5,
-    min: 262144,
-    max: 327677
-  };
-  this.rules[7].opcodes[8] = {
-    type: 5,
-    min: 327680,
-    max: 393213
-  };
-  this.rules[7].opcodes[9] = {
-    type: 5,
-    min: 393216,
-    max: 458749
-  };
-  this.rules[7].opcodes[10] = {
-    type: 5,
-    min: 458752,
-    max: 524285
-  };
-  this.rules[7].opcodes[11] = {
-    type: 5,
-    min: 524288,
-    max: 589821
-  };
-  this.rules[7].opcodes[12] = {
-    type: 5,
-    min: 589824,
-    max: 655357
-  };
-  this.rules[7].opcodes[13] = {
-    type: 5,
-    min: 655360,
-    max: 720893
-  };
-  this.rules[7].opcodes[14] = {
-    type: 5,
-    min: 720896,
-    max: 786429
-  };
-  this.rules[7].opcodes[15] = {
-    type: 5,
-    min: 786432,
-    max: 851965
-  };
-  this.rules[7].opcodes[16] = {
-    type: 5,
-    min: 851968,
-    max: 917501
-  };
-  this.rules[7].opcodes[17] = {
-    type: 5,
-    min: 921600,
-    max: 983037
-  };
-  this.rules[8].opcodes = [];
-  this.rules[8].opcodes[0] = {
-    type: 1,
-    children: [1, 2, 3]
-  };
-  this.rules[8].opcodes[1] = {
-    type: 5,
-    min: 57344,
-    max: 63743
-  };
-  this.rules[8].opcodes[2] = {
-    type: 5,
-    min: 983040,
-    max: 1048573
-  };
-  this.rules[8].opcodes[3] = {
-    type: 5,
-    min: 1048576,
-    max: 1114109
-  };
-  this.toString = function toString4() {
-    let str2 = "";
-    str2 += "; OpenAPI Server URL templating ABNF syntax\n";
-    str2 += "server-url-template    = 1*( literals / server-variable ) ; variant of https://www.rfc-editor.org/rfc/rfc6570#section-2\n";
-    str2 += 'server-variable        = "{" server-variable-name "}"\n';
-    str2 += "server-variable-name   = 1*( %x00-7A / %x7C / %x7E-10FFFF ) ; every UTF8 character except { and } (from OpenAPI)\n";
-    str2 += "\n";
-    str2 += "; https://www.rfc-editor.org/rfc/rfc6570#section-2.1\n";
-    str2 += "; https://www.rfc-editor.org/errata/eid6937\n";
-    str2 += "literals               = 1*( %x21 / %x23-24 / %x26-3B / %x3D / %x3F-5B\n";
-    str2 += "                       / %x5D / %x5F / %x61-7A / %x7E / ucschar / iprivate\n";
-    str2 += "                       / pct-encoded)\n";
-    str2 += "                            ; any Unicode character except: CTL, SP,\n";
-    str2 += '                            ;  DQUOTE, "%" (aside from pct-encoded),\n';
-    str2 += '                            ;  "<", ">", "\\", "^", "`", "{", "|", "}"\n';
-    str2 += "\n";
-    str2 += "; https://www.rfc-editor.org/rfc/rfc6570#section-1.5\n";
-    str2 += "DIGIT          =  %x30-39             ; 0-9\n";
-    str2 += 'HEXDIG         =  DIGIT / "A" / "B" / "C" / "D" / "E" / "F" ; case-insensitive\n';
-    str2 += "\n";
-    str2 += 'pct-encoded    =  "%" HEXDIG HEXDIG\n';
-    str2 += "\n";
-    str2 += "ucschar        =  %xA0-D7FF / %xF900-FDCF / %xFDF0-FFEF\n";
-    str2 += "               /  %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD\n";
-    str2 += "               /  %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD\n";
-    str2 += "               /  %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD\n";
-    str2 += "               /  %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD\n";
-    str2 += "               /  %xD0000-DFFFD / %xE1000-EFFFD\n";
-    str2 += "\n";
-    str2 += "iprivate       =  %xE000-F8FF / %xF0000-FFFFD / %x100000-10FFFD\n";
-    return str2;
-  };
-}
-
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/parse/callbacks/server-url-template.mjs
-var serverUrlTemplate = (state, chars, phraseIndex, phraseLength, data) => {
-  if (state === identifiers.SEM_PRE) {
-    if (Array.isArray(data) === false) {
-      throw new Error("parser's user data must be an array");
-    }
-    data.push(["server-url-template", utilities.charsToString(chars, phraseIndex, phraseLength)]);
-  }
-  return identifiers.SEM_OK;
-};
-var server_url_template_default = serverUrlTemplate;
-
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/parse/callbacks/server-variable.mjs
-var serverVariable = (state, chars, phraseIndex, phraseLength, data) => {
-  if (state === identifiers.SEM_PRE) {
-    if (Array.isArray(data) === false) {
-      throw new Error("parser's user data must be an array");
-    }
-    data.push(["server-variable", utilities.charsToString(chars, phraseIndex, phraseLength)]);
-  }
-  return identifiers.SEM_OK;
-};
-var server_variable_default4 = serverVariable;
-
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/parse/callbacks/server-variable-name.mjs
-var serverVariableName = (state, chars, phraseIndex, phraseLength, data) => {
-  if (state === identifiers.SEM_PRE) {
-    if (Array.isArray(data) === false) {
-      throw new Error("parser's user data must be an array");
-    }
-    data.push(["server-variable-name", utilities.charsToString(chars, phraseIndex, phraseLength)]);
-  }
-  return identifiers.SEM_OK;
-};
-var server_variable_name_default = serverVariableName;
-
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/parse/callbacks/literals.mjs
-var literals = (state, chars, phraseIndex, phraseLength, data) => {
-  if (state === identifiers.SEM_PRE) {
-    if (Array.isArray(data) === false) {
-      throw new Error("parser's user data must be an array");
-    }
-    data.push(["literals", utilities.charsToString(chars, phraseIndex, phraseLength)]);
-  }
-  return identifiers.SEM_OK;
-};
-var literals_default = literals;
-
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/parse/index.mjs
-var grammar8 = new grammar7();
-var parse5 = (serverURLTemplate) => {
-  const parser10 = new Parser2();
-  parser10.ast = new Ast();
-  parser10.ast.callbacks["server-url-template"] = server_url_template_default;
-  parser10.ast.callbacks["server-variable"] = server_variable_default4;
-  parser10.ast.callbacks["server-variable-name"] = server_variable_name_default;
-  parser10.ast.callbacks["literals"] = literals_default;
-  const result = parser10.parse(grammar8, "server-url-template", serverURLTemplate);
-  return {
-    result,
-    ast: parser10.ast
-  };
-};
-var parse_default3 = parse5;
-
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/test.mjs
-var test = (serverURLTemplate, {
-  strict = false
-} = {}) => {
-  try {
-    const parseResult = parse_default3(serverURLTemplate);
-    if (!parseResult.result.success) return false;
-    const parts = [];
-    parseResult.ast.translate(parts);
-    const hasServerVariable = parts.some(([type4]) => type4 === "server-variable");
-    if (!strict && !hasServerVariable) {
-      try {
-        new URL(serverURLTemplate, "https://vladimirgorej.com");
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return strict ? hasServerVariable : true;
-  } catch {
-    return false;
-  }
-};
-var test_default = test;
-
-// ../../node_modules/.bun/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/substitute.mjs
-var isEncoded = (serverVariableValue) => {
-  try {
-    return typeof serverVariableValue === "string" && decodeURIComponent(serverVariableValue) !== serverVariableValue;
-  } catch {
-    return false;
-  }
-};
-var encodeServerVariable = (serverVariableValue) => {
-  if (isEncoded(serverVariableValue)) {
-    return serverVariableValue;
-  }
-  return encodeURIComponent(serverVariableValue).replace(/%5B/g, "[").replace(/%5D/g, "]");
-};
-var significantTypes = ["literals", "server-variable-name"];
-var substitute = (serverURLTemplate, serverVariables, options = {}) => {
-  const defaultOptions4 = {
-    encoder: encodeServerVariable
-  };
-  const mergedOptions = {
-    ...defaultOptions4,
-    ...options
-  };
-  const parseResult = parse_default3(serverURLTemplate);
-  if (!parseResult.result.success) return serverURLTemplate;
-  const parts = [];
-  parseResult.ast.translate(parts);
-  const substitutedParts = parts.filter(([type4]) => significantTypes.includes(type4)).map(([type4, value]) => {
-    if (type4 === "server-variable-name") {
-      return Object.hasOwn(serverVariables, value) ? mergedOptions.encoder(serverVariables[value], value) : `{${value}}`;
-    }
-    return value;
-  });
-  return substitutedParts.join("");
-};
-var substitute_default = substitute;
-
 // ../../node_modules/.bun/openapi-path-templating@2.2.1/node_modules/openapi-path-templating/es/path-templating.mjs
-function grammar9() {
+function grammar7() {
   this.grammarObject = "grammarObject";
   this.rules = [];
   this.rules[0] = {
@@ -38798,25 +37201,25 @@ var templateExpressionParamName = (state, chars, phraseIndex, phraseLength, data
 var template_expression_param_name_default = templateExpressionParamName;
 
 // ../../node_modules/.bun/openapi-path-templating@2.2.1/node_modules/openapi-path-templating/es/parse/index.mjs
-var grammar10 = new grammar9();
-var parse6 = (pathTemplate2) => {
-  const parser10 = new Parser2();
+var grammar8 = new grammar7();
+var parse5 = (pathTemplate2) => {
+  const parser10 = new Parser();
   parser10.ast = new Ast();
   parser10.ast.callbacks["path-template"] = path_template_default;
   parser10.ast.callbacks["slash"] = slash_default;
   parser10.ast.callbacks["path-literal"] = path_literal_default;
   parser10.ast.callbacks["template-expression"] = template_expression_default;
   parser10.ast.callbacks["template-expression-param-name"] = template_expression_param_name_default;
-  const result = parser10.parse(grammar10, "path-template", pathTemplate2);
+  const result = parser10.parse(grammar8, "path-template", pathTemplate2);
   return {
     result,
     ast: parser10.ast
   };
 };
-var parse_default4 = parse6;
+var parse_default3 = parse5;
 
 // ../../node_modules/.bun/openapi-path-templating@2.2.1/node_modules/openapi-path-templating/es/resolve.mjs
-var isEncoded2 = (parameterValue) => {
+var isEncoded = (parameterValue) => {
   try {
     return typeof parameterValue === "string" && decodeURIComponent(parameterValue) !== parameterValue;
   } catch {
@@ -38824,12 +37227,12 @@ var isEncoded2 = (parameterValue) => {
   }
 };
 var encodePathComponent = (parameterValue) => {
-  if (isEncoded2(parameterValue)) {
+  if (isEncoded(parameterValue)) {
     return parameterValue;
   }
   return encodeURIComponent(parameterValue).replace(/%5B/g, "[").replace(/%5D/g, "]");
 };
-var significantTypes2 = ["slash", "path-literal", "template-expression-param-name"];
+var significantTypes = ["slash", "path-literal", "template-expression-param-name"];
 var resolve3 = (pathTemplate2, parameters, options = {}) => {
   const defaultOptions4 = {
     encoder: encodePathComponent
@@ -38838,11 +37241,11 @@ var resolve3 = (pathTemplate2, parameters, options = {}) => {
     ...defaultOptions4,
     ...options
   };
-  const parseResult = parse_default4(pathTemplate2);
+  const parseResult = parse_default3(pathTemplate2);
   if (!parseResult.result.success) return pathTemplate2;
   const parts = [];
   parseResult.ast.translate(parts);
-  const resolvedParts = parts.filter(([type4]) => significantTypes2.includes(type4)).map(([type4, value]) => {
+  const resolvedParts = parts.filter(([type4]) => significantTypes.includes(type4)).map(([type4, value]) => {
     if (type4 === "template-expression-param-name") {
       return Object.prototype.hasOwnProperty.call(parameters, value) ? mergedOptions.encoder(parameters[value], value) : `{${value}}`;
     }
@@ -38853,8 +37256,8 @@ var resolve3 = (pathTemplate2, parameters, options = {}) => {
 var resolve_default3 = resolve3;
 
 // ../../node_modules/.bun/openapi-path-templating@2.2.1/node_modules/openapi-path-templating/es/normalization/percent-encoding.mjs
-var grammar11 = new grammar9();
-var parser5 = new Parser2();
+var grammar9 = new grammar7();
+var parser5 = new Parser();
 
 // ../../node_modules/.bun/swagger-client@3.38.2/node_modules/swagger-client/es/execute/swagger2/parameter-builders.js
 var parameter_builders_default = {
@@ -38975,7 +37378,7 @@ function serialize(value, mediaType) {
 }
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/grammar.mjs
-function grammar12() {
+function grammar10() {
   this.grammarObject = "grammarObject";
   this.rules = [];
   this.rules[0] = {
@@ -39834,7 +38237,7 @@ function grammar12() {
 }
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/cookie/parse/index.mjs
-var grammar13 = new grammar12();
+var grammar11 = new grammar10();
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/utils.mjs
 var percentEncodeChar = (char) => {
@@ -39863,15 +38266,15 @@ var quote = (value) => {
 var identity2 = (a) => a;
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/cookie/test/cookie-value.mjs
-var parser6 = new Parser2();
-var grammar14 = new grammar12();
+var parser6 = new Parser();
+var grammar12 = new grammar10();
 var testCookieValue = (cookieValue, {
   strict = true,
   quoted = null
 } = {}) => {
   try {
-    const startRule2 = strict ? "cookie-value" : "lenient-cookie-value";
-    const result = parser6.parse(grammar14, startRule2, cookieValue);
+    const startRule = strict ? "cookie-value" : "lenient-cookie-value";
+    const result = parser6.parse(grammar12, startRule, cookieValue);
     if (typeof quoted === "boolean") {
       return result.success && quoted === isQuoted(cookieValue);
     }
@@ -39913,14 +38316,14 @@ var cookieValueStrictBase64urlEncoder = (cookieValue) => {
 var cookie_value_strict_base64url_default = cookieValueStrictBase64urlEncoder;
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/cookie/test/cookie-name.mjs
-var parser7 = new Parser2();
-var grammar15 = new grammar12();
+var parser7 = new Parser();
+var grammar13 = new grammar10();
 var testCookieName = (cookieName, {
   strict = true
 } = {}) => {
   try {
-    const startRule2 = strict ? "cookie-name" : "lenient-cookie-name";
-    return parser7.parse(grammar15, startRule2, cookieName).success;
+    const startRule = strict ? "cookie-name" : "lenient-cookie-name";
+    return parser7.parse(grammar13, startRule, cookieName).success;
   } catch {
     return false;
   }
@@ -39983,8 +38386,8 @@ var serialize3 = (cookiePairs, options = {}) => {
 var serialize_default2 = serialize3;
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/set-cookie/serialize/encoders/cookie-value-strict-percent.mjs
-var parser8 = new Parser2();
-var grammar16 = new grammar12();
+var parser8 = new Parser();
+var grammar14 = new grammar10();
 var cookieValueStrictPercentEncoder = (cookieValue) => {
   const value = String(cookieValue);
   if (cookie_value_default2(value)) return value;
@@ -39992,15 +38395,15 @@ var cookieValueStrictPercentEncoder = (cookieValue) => {
   const valueToEncode = isQuoted2 ? unquote(value) : value;
   let result = "";
   for (const char of valueToEncode) {
-    result += parser8.parse(grammar16, "cookie-octet", char).success ? char : percentEncodeChar(char);
+    result += parser8.parse(grammar14, "cookie-octet", char).success ? char : percentEncodeChar(char);
   }
   return isQuoted2 ? quote(result) : result;
 };
 var cookie_value_strict_percent_default = cookieValueStrictPercentEncoder;
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/set-cookie/serialize/encoders/cookie-value-lenient-percent.mjs
-var parser9 = new Parser2();
-var grammar17 = new grammar12();
+var parser9 = new Parser();
+var grammar15 = new grammar10();
 
 // ../../node_modules/.bun/@swaggerexpert+cookie@2.0.2/node_modules/@swaggerexpert/cookie/es/set-cookie/serialize/validators/cookie-name-lenient.mjs
 var cookieNameLenientValidator = (cookieName) => {
@@ -40758,8 +39161,8 @@ function oas3BaseUrl({
   })) {
     const selectedServerVariables = Object.entries({
       ...selectedServerObj.variables
-    }).reduce((acc, [serverVariableName2, serverVariable2]) => {
-      acc[serverVariableName2] = serverVariable2.default;
+    }).reduce((acc, [serverVariableName, serverVariable]) => {
+      acc[serverVariableName] = serverVariable.default;
       return acc;
     }, {});
     selectedServerUrl = substitute_default(selectedServerUrl, {