apps 0.0.1-beta.2 → 0.0.1-beta.21

package/js/chunk-OD3KFKZD.js

@@ -0,0 +1,1617 @@
+// ../../node_modules/.bun/apg-lite@1.0.5/node_modules/apg-lite/lib/parser.js
+var Parser = 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 = (grammar3, startName, inputString, callbackData) => {
+    const functionName = `${thisFileName}parse(): `;
+    clear();
+    chars = utils.stringToChars(inputString);
+    rules = grammar3.rules;
+    udts = grammar3.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 str = `${thisFileName}opRNM(${rule.name}): callback function error: `;
+      str += `sysData.phraseLength: ${sysData2.phraseLength}`;
+      str += ` must be <= remaining chars: ${charsLeft}`;
+      throw new Error(str);
+    }
+    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 str = `${thisFileName}opUDT(${udt.name}): callback function error: `;
+      str += `sysData.phraseLength: ${sysData2.phraseLength}`;
+      str += ` must be <= remaining chars: ${charsLeft}`;
+      throw new Error(str);
+    }
+    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 = normalize(m);
+      const ee = normalize(e);
+      const nn = normalize(n);
+      const tt = normalize(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 = (type) => {
+    let out = "";
+    const displayRow = (m, e, n, t, name) => {
+      totals.match += m;
+      totals.empty += e;
+      totals.nomatch += n;
+      totals.total += t;
+      const mm = normalize(m);
+      const ee = normalize(e);
+      const nn = normalize(n);
+      const tt = normalize(t);
+      return `| ${mm} | ${ee} | ${nn} | ${tt} | ${name}
+`;
+    };
+    if (typeof type === "string" && type.toLowerCase()[0] === "a") {
+      ruleStats.sort(sortAlpha);
+      udtStats.sort(sortAlpha);
+      out += "    RULES/UDTS ALPHABETICALLY\n";
+    } else if (typeof type === "string" && type.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 normalize = (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/openapi-server-url-templating@1.3.0/node_modules/openapi-server-url-templating/es/server-url-templating.mjs
+function grammar() {
+  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 toString() {
+    let str = "";
+    str += "; OpenAPI Server URL templating ABNF syntax\n";
+    str += "server-url-template    = 1*( literals / server-variable ) ; variant of https://www.rfc-editor.org/rfc/rfc6570#section-2\n";
+    str += 'server-variable        = "{" server-variable-name "}"\n';
+    str += "server-variable-name   = 1*( %x00-7A / %x7C / %x7E-10FFFF ) ; every UTF8 character except { and } (from OpenAPI)\n";
+    str += "\n";
+    str += "; https://www.rfc-editor.org/rfc/rfc6570#section-2.1\n";
+    str += "; https://www.rfc-editor.org/errata/eid6937\n";
+    str += "literals               = 1*( %x21 / %x23-24 / %x26-3B / %x3D / %x3F-5B\n";
+    str += "                       / %x5D / %x5F / %x61-7A / %x7E / ucschar / iprivate\n";
+    str += "                       / pct-encoded)\n";
+    str += "                            ; any Unicode character except: CTL, SP,\n";
+    str += '                            ;  DQUOTE, "%" (aside from pct-encoded),\n';
+    str += '                            ;  "<", ">", "\\", "^", "`", "{", "|", "}"\n';
+    str += "\n";
+    str += "; https://www.rfc-editor.org/rfc/rfc6570#section-1.5\n";
+    str += "DIGIT          =  %x30-39             ; 0-9\n";
+    str += 'HEXDIG         =  DIGIT / "A" / "B" / "C" / "D" / "E" / "F" ; case-insensitive\n';
+    str += "\n";
+    str += 'pct-encoded    =  "%" HEXDIG HEXDIG\n';
+    str += "\n";
+    str += "ucschar        =  %xA0-D7FF / %xF900-FDCF / %xFDF0-FFEF\n";
+    str += "               /  %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD\n";
+    str += "               /  %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD\n";
+    str += "               /  %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD\n";
+    str += "               /  %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD\n";
+    str += "               /  %xD0000-DFFFD / %xE1000-EFFFD\n";
+    str += "\n";
+    str += "iprivate       =  %xE000-F8FF / %xF0000-FFFFD / %x100000-10FFFD\n";
+    return str;
+  };
+}
+
+// ../../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_default = 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 grammar2 = new grammar();
+var parse = (serverURLTemplate) => {
+  const parser = new Parser();
+  parser.ast = new Ast();
+  parser.ast.callbacks["server-url-template"] = server_url_template_default;
+  parser.ast.callbacks["server-variable"] = server_variable_default;
+  parser.ast.callbacks["server-variable-name"] = server_variable_name_default;
+  parser.ast.callbacks["literals"] = literals_default;
+  const result = parser.parse(grammar2, "server-url-template", serverURLTemplate);
+  return {
+    result,
+    ast: parser.ast
+  };
+};
+var parse_default = parse;
+
+// ../../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_default(serverURLTemplate);
+    if (!parseResult.result.success) return false;
+    const parts = [];
+    parseResult.ast.translate(parts);
+    const hasServerVariable = parts.some(([type]) => type === "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 defaultOptions = {
+    encoder: encodeServerVariable
+  };
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options
+  };
+  const parseResult = parse_default(serverURLTemplate);
+  if (!parseResult.result.success) return serverURLTemplate;
+  const parts = [];
+  parseResult.ast.translate(parts);
+  const substitutedParts = parts.filter(([type]) => significantTypes.includes(type)).map(([type, value]) => {
+    if (type === "server-variable-name") {
+      return Object.hasOwn(serverVariables, value) ? mergedOptions.encoder(serverVariables[value], value) : `{${value}}`;
+    }
+    return value;
+  });
+  return substitutedParts.join("");
+};
+var substitute_default = substitute;
+
+export {
+  Parser,
+  Ast,
+  Trace,
+  Stats,
+  utilities,
+  identifiers,
+  test_default,
+  substitute_default
+};