@swaggerexpert/arazzo-criterion 1.0.0

package/es/grammar.mjs

@@ -0,0 +1,1105 @@
+// copyright: Copyright (c) 2024 Lowell D. Thomas, all rights reserved<br>
+//   license: BSD-2-Clause (https://opensource.org/licenses/BSD-2-Clause)<br>
+//
+// Generated by apg-js, Version 4.4.0 [apg-js](https://github.com/ldthomas/apg-js)
+export default function grammar() {
+  // ```
+  // SUMMARY
+  //      rules = 34
+  //       udts = 0
+  //    opcodes = 155
+  //        ---   ABNF original opcodes
+  //        ALT = 16
+  //        CAT = 19
+  //        REP = 17
+  //        RNM = 56
+  //        TLS = 28
+  //        TBS = 7
+  //        TRG = 12
+  //        ---   SABNF superset opcodes
+  //        UDT = 0
+  //        AND = 0
+  //        NOT = 0
+  // characters = [9 - 1114111]
+  // ```
+  /* OBJECT IDENTIFIER (for internal parser use) */
+  this.grammarObject = 'grammarObject';
+
+  /* RULES */
+  this.rules = [];
+  this.rules[0] = {
+    name: 'condition',
+    lower: 'condition',
+    index: 0,
+    isBkr: false
+  };
+  this.rules[1] = {
+    name: 'logical-expr',
+    lower: 'logical-expr',
+    index: 1,
+    isBkr: false
+  };
+  this.rules[2] = {
+    name: 'logical-or-expr',
+    lower: 'logical-or-expr',
+    index: 2,
+    isBkr: false
+  };
+  this.rules[3] = {
+    name: 'logical-and-expr',
+    lower: 'logical-and-expr',
+    index: 3,
+    isBkr: false
+  };
+  this.rules[4] = {
+    name: 'basic-expr',
+    lower: 'basic-expr',
+    index: 4,
+    isBkr: false
+  };
+  this.rules[5] = {
+    name: 'paren-expr',
+    lower: 'paren-expr',
+    index: 5,
+    isBkr: false
+  };
+  this.rules[6] = {
+    name: 'test-expr',
+    lower: 'test-expr',
+    index: 6,
+    isBkr: false
+  };
+  this.rules[7] = {
+    name: 'comparison-expr',
+    lower: 'comparison-expr',
+    index: 7,
+    isBkr: false
+  };
+  this.rules[8] = {
+    name: 'logical-not-op',
+    lower: 'logical-not-op',
+    index: 8,
+    isBkr: false
+  };
+  this.rules[9] = {
+    name: 'comparison-op',
+    lower: 'comparison-op',
+    index: 9,
+    isBkr: false
+  };
+  this.rules[10] = {
+    name: 'comparable',
+    lower: 'comparable',
+    index: 10,
+    isBkr: false
+  };
+  this.rules[11] = {
+    name: 'runtime-expression-operand',
+    lower: 'runtime-expression-operand',
+    index: 11,
+    isBkr: false
+  };
+  this.rules[12] = {
+    name: 'operand-char',
+    lower: 'operand-char',
+    index: 12,
+    isBkr: false
+  };
+  this.rules[13] = {
+    name: 'runtime-expression-navigation',
+    lower: 'runtime-expression-navigation',
+    index: 13,
+    isBkr: false
+  };
+  this.rules[14] = {
+    name: 'member-access',
+    lower: 'member-access',
+    index: 14,
+    isBkr: false
+  };
+  this.rules[15] = {
+    name: 'index-access',
+    lower: 'index-access',
+    index: 15,
+    isBkr: false
+  };
+  this.rules[16] = {
+    name: 'member-name',
+    lower: 'member-name',
+    index: 16,
+    isBkr: false
+  };
+  this.rules[17] = {
+    name: 'index',
+    lower: 'index',
+    index: 17,
+    isBkr: false
+  };
+  this.rules[18] = {
+    name: 'literal',
+    lower: 'literal',
+    index: 18,
+    isBkr: false
+  };
+  this.rules[19] = {
+    name: 'boolean',
+    lower: 'boolean',
+    index: 19,
+    isBkr: false
+  };
+  this.rules[20] = {
+    name: 'null',
+    lower: 'null',
+    index: 20,
+    isBkr: false
+  };
+  this.rules[21] = {
+    name: 'number',
+    lower: 'number',
+    index: 21,
+    isBkr: false
+  };
+  this.rules[22] = {
+    name: 'int',
+    lower: 'int',
+    index: 22,
+    isBkr: false
+  };
+  this.rules[23] = {
+    name: 'frac',
+    lower: 'frac',
+    index: 23,
+    isBkr: false
+  };
+  this.rules[24] = {
+    name: 'exp',
+    lower: 'exp',
+    index: 24,
+    isBkr: false
+  };
+  this.rules[25] = {
+    name: 'DIGIT1',
+    lower: 'digit1',
+    index: 25,
+    isBkr: false
+  };
+  this.rules[26] = {
+    name: 'string',
+    lower: 'string',
+    index: 26,
+    isBkr: false
+  };
+  this.rules[27] = {
+    name: 'escaped-quote',
+    lower: 'escaped-quote',
+    index: 27,
+    isBkr: false
+  };
+  this.rules[28] = {
+    name: 'string-char',
+    lower: 'string-char',
+    index: 28,
+    isBkr: false
+  };
+  this.rules[29] = {
+    name: 'squote',
+    lower: 'squote',
+    index: 29,
+    isBkr: false
+  };
+  this.rules[30] = {
+    name: 'S',
+    lower: 's',
+    index: 30,
+    isBkr: false
+  };
+  this.rules[31] = {
+    name: 'B',
+    lower: 'b',
+    index: 31,
+    isBkr: false
+  };
+  this.rules[32] = {
+    name: 'ALPHA',
+    lower: 'alpha',
+    index: 32,
+    isBkr: false
+  };
+  this.rules[33] = {
+    name: 'DIGIT',
+    lower: 'digit',
+    index: 33,
+    isBkr: false
+  };
+
+  /* UDTS */
+  this.udts = [];
+
+  /* OPCODES */
+  /* condition */
+  this.rules[0].opcodes = [];
+  this.rules[0].opcodes[0] = {
+    type: 2,
+    children: [1, 2, 3]
+  }; // CAT
+  this.rules[0].opcodes[1] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[0].opcodes[2] = {
+    type: 4,
+    index: 1
+  }; // RNM(logical-expr)
+  this.rules[0].opcodes[3] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+
+  /* logical-expr */
+  this.rules[1].opcodes = [];
+  this.rules[1].opcodes[0] = {
+    type: 4,
+    index: 2
+  }; // RNM(logical-or-expr)
+
+  /* logical-or-expr */
+  this.rules[2].opcodes = [];
+  this.rules[2].opcodes[0] = {
+    type: 2,
+    children: [1, 2]
+  }; // CAT
+  this.rules[2].opcodes[1] = {
+    type: 4,
+    index: 3
+  }; // RNM(logical-and-expr)
+  this.rules[2].opcodes[2] = {
+    type: 3,
+    min: 0,
+    max: Infinity
+  }; // REP
+  this.rules[2].opcodes[3] = {
+    type: 2,
+    children: [4, 5, 6, 7]
+  }; // CAT
+  this.rules[2].opcodes[4] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[2].opcodes[5] = {
+    type: 7,
+    string: [124, 124]
+  }; // TLS
+  this.rules[2].opcodes[6] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[2].opcodes[7] = {
+    type: 4,
+    index: 3
+  }; // RNM(logical-and-expr)
+
+  /* logical-and-expr */
+  this.rules[3].opcodes = [];
+  this.rules[3].opcodes[0] = {
+    type: 2,
+    children: [1, 2]
+  }; // CAT
+  this.rules[3].opcodes[1] = {
+    type: 4,
+    index: 4
+  }; // RNM(basic-expr)
+  this.rules[3].opcodes[2] = {
+    type: 3,
+    min: 0,
+    max: Infinity
+  }; // REP
+  this.rules[3].opcodes[3] = {
+    type: 2,
+    children: [4, 5, 6, 7]
+  }; // CAT
+  this.rules[3].opcodes[4] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[3].opcodes[5] = {
+    type: 7,
+    string: [38, 38]
+  }; // TLS
+  this.rules[3].opcodes[6] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[3].opcodes[7] = {
+    type: 4,
+    index: 4
+  }; // RNM(basic-expr)
+
+  /* basic-expr */
+  this.rules[4].opcodes = [];
+  this.rules[4].opcodes[0] = {
+    type: 1,
+    children: [1, 2, 3]
+  }; // ALT
+  this.rules[4].opcodes[1] = {
+    type: 4,
+    index: 5
+  }; // RNM(paren-expr)
+  this.rules[4].opcodes[2] = {
+    type: 4,
+    index: 7
+  }; // RNM(comparison-expr)
+  this.rules[4].opcodes[3] = {
+    type: 4,
+    index: 6
+  }; // RNM(test-expr)
+
+  /* paren-expr */
+  this.rules[5].opcodes = [];
+  this.rules[5].opcodes[0] = {
+    type: 2,
+    children: [1, 5, 6, 7, 8, 9]
+  }; // CAT
+  this.rules[5].opcodes[1] = {
+    type: 3,
+    min: 0,
+    max: 1
+  }; // REP
+  this.rules[5].opcodes[2] = {
+    type: 2,
+    children: [3, 4]
+  }; // CAT
+  this.rules[5].opcodes[3] = {
+    type: 4,
+    index: 8
+  }; // RNM(logical-not-op)
+  this.rules[5].opcodes[4] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[5].opcodes[5] = {
+    type: 7,
+    string: [40]
+  }; // TLS
+  this.rules[5].opcodes[6] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[5].opcodes[7] = {
+    type: 4,
+    index: 1
+  }; // RNM(logical-expr)
+  this.rules[5].opcodes[8] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[5].opcodes[9] = {
+    type: 7,
+    string: [41]
+  }; // TLS
+
+  /* test-expr */
+  this.rules[6].opcodes = [];
+  this.rules[6].opcodes[0] = {
+    type: 2,
+    children: [1, 5]
+  }; // CAT
+  this.rules[6].opcodes[1] = {
+    type: 3,
+    min: 0,
+    max: 1
+  }; // REP
+  this.rules[6].opcodes[2] = {
+    type: 2,
+    children: [3, 4]
+  }; // CAT
+  this.rules[6].opcodes[3] = {
+    type: 4,
+    index: 8
+  }; // RNM(logical-not-op)
+  this.rules[6].opcodes[4] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[6].opcodes[5] = {
+    type: 4,
+    index: 10
+  }; // RNM(comparable)
+
+  /* comparison-expr */
+  this.rules[7].opcodes = [];
+  this.rules[7].opcodes[0] = {
+    type: 2,
+    children: [1, 2, 3, 4, 5]
+  }; // CAT
+  this.rules[7].opcodes[1] = {
+    type: 4,
+    index: 10
+  }; // RNM(comparable)
+  this.rules[7].opcodes[2] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[7].opcodes[3] = {
+    type: 4,
+    index: 9
+  }; // RNM(comparison-op)
+  this.rules[7].opcodes[4] = {
+    type: 4,
+    index: 30
+  }; // RNM(S)
+  this.rules[7].opcodes[5] = {
+    type: 4,
+    index: 10
+  }; // RNM(comparable)
+
+  /* logical-not-op */
+  this.rules[8].opcodes = [];
+  this.rules[8].opcodes[0] = {
+    type: 7,
+    string: [33]
+  }; // TLS
+
+  /* comparison-op */
+  this.rules[9].opcodes = [];
+  this.rules[9].opcodes[0] = {
+    type: 1,
+    children: [1, 2, 3, 4, 5, 6]
+  }; // ALT
+  this.rules[9].opcodes[1] = {
+    type: 7,
+    string: [61, 61]
+  }; // TLS
+  this.rules[9].opcodes[2] = {
+    type: 7,
+    string: [33, 61]
+  }; // TLS
+  this.rules[9].opcodes[3] = {
+    type: 7,
+    string: [60, 61]
+  }; // TLS
+  this.rules[9].opcodes[4] = {
+    type: 7,
+    string: [62, 61]
+  }; // TLS
+  this.rules[9].opcodes[5] = {
+    type: 7,
+    string: [60]
+  }; // TLS
+  this.rules[9].opcodes[6] = {
+    type: 7,
+    string: [62]
+  }; // TLS
+
+  /* comparable */
+  this.rules[10].opcodes = [];
+  this.rules[10].opcodes[0] = {
+    type: 1,
+    children: [1, 2]
+  }; // ALT
+  this.rules[10].opcodes[1] = {
+    type: 4,
+    index: 18
+  }; // RNM(literal)
+  this.rules[10].opcodes[2] = {
+    type: 4,
+    index: 11
+  }; // RNM(runtime-expression-operand)
+
+  /* runtime-expression-operand */
+  this.rules[11].opcodes = [];
+  this.rules[11].opcodes[0] = {
+    type: 2,
+    children: [1, 2]
+  }; // CAT
+  this.rules[11].opcodes[1] = {
+    type: 7,
+    string: [36]
+  }; // TLS
+  this.rules[11].opcodes[2] = {
+    type: 3,
+    min: 1,
+    max: Infinity
+  }; // REP
+  this.rules[11].opcodes[3] = {
+    type: 4,
+    index: 12
+  }; // RNM(operand-char)
+
+  /* operand-char */
+  this.rules[12].opcodes = [];
+  this.rules[12].opcodes[0] = {
+    type: 1,
+    children: [1, 2, 3, 4, 5, 6, 7, 8]
+  }; // ALT
+  this.rules[12].opcodes[1] = {
+    type: 5,
+    min: 34,
+    max: 37
+  }; // TRG
+  this.rules[12].opcodes[2] = {
+    type: 6,
+    string: [39]
+  }; // TBS
+  this.rules[12].opcodes[3] = {
+    type: 5,
+    min: 42,
+    max: 59
+  }; // TRG
+  this.rules[12].opcodes[4] = {
+    type: 5,
+    min: 63,
+    max: 90
+  }; // TRG
+  this.rules[12].opcodes[5] = {
+    type: 5,
+    min: 91,
+    max: 93
+  }; // TRG
+  this.rules[12].opcodes[6] = {
+    type: 5,
+    min: 94,
+    max: 122
+  }; // TRG
+  this.rules[12].opcodes[7] = {
+    type: 6,
+    string: [126]
+  }; // TBS
+  this.rules[12].opcodes[8] = {
+    type: 5,
+    min: 128,
+    max: 1114111
+  }; // TRG
+
+  /* runtime-expression-navigation */
+  this.rules[13].opcodes = [];
+  this.rules[13].opcodes[0] = {
+    type: 3,
+    min: 1,
+    max: Infinity
+  }; // REP
+  this.rules[13].opcodes[1] = {
+    type: 1,
+    children: [2, 3]
+  }; // ALT
+  this.rules[13].opcodes[2] = {
+    type: 4,
+    index: 14
+  }; // RNM(member-access)
+  this.rules[13].opcodes[3] = {
+    type: 4,
+    index: 15
+  }; // RNM(index-access)
+
+  /* member-access */
+  this.rules[14].opcodes = [];
+  this.rules[14].opcodes[0] = {
+    type: 2,
+    children: [1, 2]
+  }; // CAT
+  this.rules[14].opcodes[1] = {
+    type: 7,
+    string: [46]
+  }; // TLS
+  this.rules[14].opcodes[2] = {
+    type: 4,
+    index: 16
+  }; // RNM(member-name)
+
+  /* index-access */
+  this.rules[15].opcodes = [];
+  this.rules[15].opcodes[0] = {
+    type: 2,
+    children: [1, 2, 3]
+  }; // CAT
+  this.rules[15].opcodes[1] = {
+    type: 7,
+    string: [91]
+  }; // TLS
+  this.rules[15].opcodes[2] = {
+    type: 4,
+    index: 17
+  }; // RNM(index)
+  this.rules[15].opcodes[3] = {
+    type: 7,
+    string: [93]
+  }; // TLS
+
+  /* member-name */
+  this.rules[16].opcodes = [];
+  this.rules[16].opcodes[0] = {
+    type: 3,
+    min: 1,
+    max: Infinity
+  }; // REP
+  this.rules[16].opcodes[1] = {
+    type: 1,
+    children: [2, 3, 4, 5]
+  }; // ALT
+  this.rules[16].opcodes[2] = {
+    type: 4,
+    index: 32
+  }; // RNM(ALPHA)
+  this.rules[16].opcodes[3] = {
+    type: 4,
+    index: 33
+  }; // RNM(DIGIT)
+  this.rules[16].opcodes[4] = {
+    type: 7,
+    string: [95]
+  }; // TLS
+  this.rules[16].opcodes[5] = {
+    type: 7,
+    string: [45]
+  }; // TLS
+
+  /* index */
+  this.rules[17].opcodes = [];
+  this.rules[17].opcodes[0] = {
+    type: 3,
+    min: 1,
+    max: Infinity
+  }; // REP
+  this.rules[17].opcodes[1] = {
+    type: 4,
+    index: 33
+  }; // RNM(DIGIT)
+
+  /* literal */
+  this.rules[18].opcodes = [];
+  this.rules[18].opcodes[0] = {
+    type: 1,
+    children: [1, 2, 3, 4]
+  }; // ALT
+  this.rules[18].opcodes[1] = {
+    type: 4,
+    index: 21
+  }; // RNM(number)
+  this.rules[18].opcodes[2] = {
+    type: 4,
+    index: 26
+  }; // RNM(string)
+  this.rules[18].opcodes[3] = {
+    type: 4,
+    index: 19
+  }; // RNM(boolean)
+  this.rules[18].opcodes[4] = {
+    type: 4,
+    index: 20
+  }; // RNM(null)
+
+  /* boolean */
+  this.rules[19].opcodes = [];
+  this.rules[19].opcodes[0] = {
+    type: 1,
+    children: [1, 2]
+  }; // ALT
+  this.rules[19].opcodes[1] = {
+    type: 7,
+    string: [116, 114, 117, 101]
+  }; // TLS
+  this.rules[19].opcodes[2] = {
+    type: 7,
+    string: [102, 97, 108, 115, 101]
+  }; // TLS
+
+  /* null */
+  this.rules[20].opcodes = [];
+  this.rules[20].opcodes[0] = {
+    type: 7,
+    string: [110, 117, 108, 108]
+  }; // TLS
+
+  /* number */
+  this.rules[21].opcodes = [];
+  this.rules[21].opcodes[0] = {
+    type: 2,
+    children: [1, 4, 6]
+  }; // CAT
+  this.rules[21].opcodes[1] = {
+    type: 1,
+    children: [2, 3]
+  }; // ALT
+  this.rules[21].opcodes[2] = {
+    type: 4,
+    index: 22
+  }; // RNM(int)
+  this.rules[21].opcodes[3] = {
+    type: 7,
+    string: [45, 48]
+  }; // TLS
+  this.rules[21].opcodes[4] = {
+    type: 3,
+    min: 0,
+    max: 1
+  }; // REP
+  this.rules[21].opcodes[5] = {
+    type: 4,
+    index: 23
+  }; // RNM(frac)
+  this.rules[21].opcodes[6] = {
+    type: 3,
+    min: 0,
+    max: 1
+  }; // REP
+  this.rules[21].opcodes[7] = {
+    type: 4,
+    index: 24
+  }; // RNM(exp)
+
+  /* int */
+  this.rules[22].opcodes = [];
+  this.rules[22].opcodes[0] = {
+    type: 1,
+    children: [1, 2]
+  }; // ALT
+  this.rules[22].opcodes[1] = {
+    type: 7,
+    string: [48]
+  }; // TLS
+  this.rules[22].opcodes[2] = {
+    type: 2,
+    children: [3, 5, 6]
+  }; // CAT
+  this.rules[22].opcodes[3] = {
+    type: 3,
+    min: 0,
+    max: 1
+  }; // REP
+  this.rules[22].opcodes[4] = {
+    type: 7,
+    string: [45]
+  }; // TLS
+  this.rules[22].opcodes[5] = {
+    type: 4,
+    index: 25
+  }; // RNM(DIGIT1)
+  this.rules[22].opcodes[6] = {
+    type: 3,
+    min: 0,
+    max: Infinity
+  }; // REP
+  this.rules[22].opcodes[7] = {
+    type: 4,
+    index: 33
+  }; // RNM(DIGIT)
+
+  /* frac */
+  this.rules[23].opcodes = [];
+  this.rules[23].opcodes[0] = {
+    type: 2,
+    children: [1, 2]
+  }; // CAT
+  this.rules[23].opcodes[1] = {
+    type: 7,
+    string: [46]
+  }; // TLS
+  this.rules[23].opcodes[2] = {
+    type: 3,
+    min: 1,
+    max: Infinity
+  }; // REP
+  this.rules[23].opcodes[3] = {
+    type: 4,
+    index: 33
+  }; // RNM(DIGIT)
+
+  /* exp */
+  this.rules[24].opcodes = [];
+  this.rules[24].opcodes[0] = {
+    type: 2,
+    children: [1, 4, 8]
+  }; // CAT
+  this.rules[24].opcodes[1] = {
+    type: 1,
+    children: [2, 3]
+  }; // ALT
+  this.rules[24].opcodes[2] = {
+    type: 7,
+    string: [101]
+  }; // TLS
+  this.rules[24].opcodes[3] = {
+    type: 7,
+    string: [101]
+  }; // TLS
+  this.rules[24].opcodes[4] = {
+    type: 3,
+    min: 0,
+    max: 1
+  }; // REP
+  this.rules[24].opcodes[5] = {
+    type: 1,
+    children: [6, 7]
+  }; // ALT
+  this.rules[24].opcodes[6] = {
+    type: 7,
+    string: [45]
+  }; // TLS
+  this.rules[24].opcodes[7] = {
+    type: 7,
+    string: [43]
+  }; // TLS
+  this.rules[24].opcodes[8] = {
+    type: 3,
+    min: 1,
+    max: Infinity
+  }; // REP
+  this.rules[24].opcodes[9] = {
+    type: 4,
+    index: 33
+  }; // RNM(DIGIT)
+
+  /* DIGIT1 */
+  this.rules[25].opcodes = [];
+  this.rules[25].opcodes[0] = {
+    type: 5,
+    min: 49,
+    max: 57
+  }; // TRG
+
+  /* string */
+  this.rules[26].opcodes = [];
+  this.rules[26].opcodes[0] = {
+    type: 2,
+    children: [1, 2, 6]
+  }; // CAT
+  this.rules[26].opcodes[1] = {
+    type: 4,
+    index: 29
+  }; // RNM(squote)
+  this.rules[26].opcodes[2] = {
+    type: 3,
+    min: 0,
+    max: Infinity
+  }; // REP
+  this.rules[26].opcodes[3] = {
+    type: 1,
+    children: [4, 5]
+  }; // ALT
+  this.rules[26].opcodes[4] = {
+    type: 4,
+    index: 27
+  }; // RNM(escaped-quote)
+  this.rules[26].opcodes[5] = {
+    type: 4,
+    index: 28
+  }; // RNM(string-char)
+  this.rules[26].opcodes[6] = {
+    type: 4,
+    index: 29
+  }; // RNM(squote)
+
+  /* escaped-quote */
+  this.rules[27].opcodes = [];
+  this.rules[27].opcodes[0] = {
+    type: 2,
+    children: [1, 2]
+  }; // CAT
+  this.rules[27].opcodes[1] = {
+    type: 4,
+    index: 29
+  }; // RNM(squote)
+  this.rules[27].opcodes[2] = {
+    type: 4,
+    index: 29
+  }; // RNM(squote)
+
+  /* string-char */
+  this.rules[28].opcodes = [];
+  this.rules[28].opcodes[0] = {
+    type: 1,
+    children: [1, 2]
+  }; // ALT
+  this.rules[28].opcodes[1] = {
+    type: 5,
+    min: 32,
+    max: 38
+  }; // TRG
+  this.rules[28].opcodes[2] = {
+    type: 5,
+    min: 40,
+    max: 1114111
+  }; // TRG
+
+  /* squote */
+  this.rules[29].opcodes = [];
+  this.rules[29].opcodes[0] = {
+    type: 6,
+    string: [39]
+  }; // TBS
+
+  /* S */
+  this.rules[30].opcodes = [];
+  this.rules[30].opcodes[0] = {
+    type: 3,
+    min: 0,
+    max: Infinity
+  }; // REP
+  this.rules[30].opcodes[1] = {
+    type: 4,
+    index: 31
+  }; // RNM(B)
+
+  /* B */
+  this.rules[31].opcodes = [];
+  this.rules[31].opcodes[0] = {
+    type: 1,
+    children: [1, 2, 3, 4]
+  }; // ALT
+  this.rules[31].opcodes[1] = {
+    type: 6,
+    string: [32]
+  }; // TBS
+  this.rules[31].opcodes[2] = {
+    type: 6,
+    string: [9]
+  }; // TBS
+  this.rules[31].opcodes[3] = {
+    type: 6,
+    string: [10]
+  }; // TBS
+  this.rules[31].opcodes[4] = {
+    type: 6,
+    string: [13]
+  }; // TBS
+
+  /* ALPHA */
+  this.rules[32].opcodes = [];
+  this.rules[32].opcodes[0] = {
+    type: 1,
+    children: [1, 2]
+  }; // ALT
+  this.rules[32].opcodes[1] = {
+    type: 5,
+    min: 65,
+    max: 90
+  }; // TRG
+  this.rules[32].opcodes[2] = {
+    type: 5,
+    min: 97,
+    max: 122
+  }; // TRG
+
+  /* DIGIT */
+  this.rules[33].opcodes = [];
+  this.rules[33].opcodes[0] = {
+    type: 5,
+    min: 48,
+    max: 57
+  }; // TRG
+
+  // The `toString()` function will display the original grammar file(s) that produced these opcodes.
+  this.toString = function toString() {
+    let str = "";
+    str += "; Arazzo Criterion Object - \"simple\" condition ABNF syntax\n";
+    str += "; https://spec.openapis.org/arazzo/v1.1.0.html#criterion-object\n";
+    str += ";\n";
+    str += "; This grammar is self-contained and uses only standard ABNF (RFC 5234) - no\n";
+    str += "; parser-specific extensions. It describes the criterion language and does NOT\n";
+    str += "; embed the Arazzo Runtime Expressions grammar: an operand is captured as a single\n";
+    str += "; bounded token, and the fact that this token is a runtime expression is resolved\n";
+    str += "; separately by @swaggerexpert/arazzo-runtime-expression during AST construction.\n";
+    str += ";\n";
+    str += "; The logical / comparison spine (logical-or-expr, logical-and-expr, basic-expr,\n";
+    str += "; paren-expr, test-expr, comparison-expr, logical-not-op, comparison-op, number,\n";
+    str += "; frac, exp, S, B) is derived from RFC 9535 (JSONPath) section 2.3.5.1. It cleanly\n";
+    str += "; separates a logical layer (||, &&, !, grouping) that composes only booleans from a\n";
+    str += "; flat, non-recursive comparison layer (comparable OP comparable), which rejects\n";
+    str += "; nonsense such as chained comparisons (a < b < c) at the grammar level.\n";
+    str += ";\n";
+    str += "; SPDX-FileCopyrightText: Copyright (c) 2024 IETF Trust and the persons identified\n";
+    str += ";   as the document authors. All rights reserved. https://www.rfc-editor.org/rfc/rfc9535\n";
+    str += "; SPDX-License-Identifier: BSD-3-Clause (for the RFC 9535-derived rules above)\n";
+    str += ";\n";
+    str += "; About the operand: a runtime expression and the criterion accessors (\".member\",\n";
+    str += "; \"[n]\") both use \".\" as a separator, so the boundary between them cannot be\n";
+    str += "; expressed in a context-free grammar. The operand is therefore matched here as one\n";
+    str += "; maximal token - a run of characters that excludes whitespace and the criterion-\n";
+    str += "; significant characters\n";
+    str += ";   \"!\" %x21  \"&\" %x26  \"(\" %x28  \")\" %x29  \"<\" %x3C  \"=\" %x3D  \">\" %x3E\n";
+    str += ";   \"{\" %x7B  \"|\" %x7C  \"}\" %x7D\n";
+    str += "; The AST builder then splits it into the runtime-expression base and the trailing\n";
+    str += "; accessors by delegating the base to @swaggerexpert/arazzo-runtime-expression.\n";
+    str += ";\n";
+    str += "; The equivalent normative structure, as it would appear in a specification that\n";
+    str += "; references the Runtime Expressions grammar by name, is:\n";
+    str += ";\n";
+    str += ";   comparable                 = literal / runtime-expression-operand\n";
+    str += ";   runtime-expression-operand = runtime-expression *( \".\" member-name / \"[\" index \"]\" )\n";
+    str += ";                                ; runtime-expression is defined in the Runtime Expressions section\n";
+    str += "\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "; Criterion condition (simple type)\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "\n";
+    str += "condition        = S logical-expr S\n";
+    str += "\n";
+    str += "logical-expr     = logical-or-expr\n";
+    str += "logical-or-expr  = logical-and-expr *( S \"||\" S logical-and-expr )\n";
+    str += "logical-and-expr = basic-expr *( S \"&&\" S basic-expr )\n";
+    str += "\n";
+    str += "basic-expr       = paren-expr / comparison-expr / test-expr\n";
+    str += "paren-expr       = [ logical-not-op S ] \"(\" S logical-expr S \")\"\n";
+    str += "test-expr        = [ logical-not-op S ] comparable\n";
+    str += "comparison-expr  = comparable S comparison-op S comparable\n";
+    str += "\n";
+    str += "logical-not-op   = \"!\"\n";
+    str += "comparison-op    = \"==\" / \"!=\" / \"<=\" / \">=\" / \"<\" / \">\"\n";
+    str += "\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "; Comparables: literals or operands (runtime expression + navigation, matched as\n";
+    str += "; one bounded token; see the header note)\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "\n";
+    str += "comparable                 = literal / runtime-expression-operand\n";
+    str += "runtime-expression-operand = \"$\" 1*operand-char\n";
+    str += "operand-char               = %x22-25 / %x27 / %x2A-3B / %x3F-5A / %x5B-5D / %x5E-7A / %x7E / %x80-10FFFF\n";
+    str += "\n";
+    str += "; Navigation over the resolved runtime-expression value. This is NOT referenced\n";
+    str += "; from `condition` - the operand is matched as a single token there (see the header\n";
+    str += "; note). It is a secondary entry point: after the runtime-expression base is split\n";
+    str += "; off an operand token, the remainder is parsed against `runtime-expression-navigation`\n";
+    str += "; so that the \".member\" / \"[index]\" accessors are validated and structured by this\n";
+    str += "; grammar rather than by ad-hoc code.\n";
+    str += "runtime-expression-navigation = 1*( member-access / index-access )\n";
+    str += "member-access                 = \".\" member-name\n";
+    str += "index-access                  = \"[\" index \"]\"\n";
+    str += "member-name                   = 1*( ALPHA / DIGIT / \"_\" / \"-\" )\n";
+    str += "index                         = 1*DIGIT\n";
+    str += "\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "; Literals\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "\n";
+    str += "literal          = number / string / boolean / null\n";
+    str += "boolean          = \"true\" / \"false\"\n";
+    str += "null             = \"null\"\n";
+    str += "\n";
+    str += "; number - decimal, mirrors RFC 9535\n";
+    str += "number           = ( int / \"-0\" ) [ frac ] [ exp ]\n";
+    str += "int              = \"0\" / ( [ \"-\" ] DIGIT1 *DIGIT )\n";
+    str += "frac             = \".\" 1*DIGIT\n";
+    str += "exp              = ( \"e\" / \"E\" ) [ \"-\" / \"+\" ] 1*DIGIT\n";
+    str += "DIGIT1           = %x31-39   ; 1-9 non-zero digit\n";
+    str += "\n";
+    str += "; string - single-quoted; a literal quote is escaped by doubling it ('')\n";
+    str += "string           = squote *( escaped-quote / string-char ) squote\n";
+    str += "escaped-quote    = squote squote                 ; '' represents a single '\n";
+    str += "string-char      = %x20-26 / %x28-10FFFF         ; any char except squote (%x27)\n";
+    str += "squote           = %x27                           ; '\n";
+    str += "\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "; Whitespace (optional blank space), per RFC 9535\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "\n";
+    str += "S                = *B\n";
+    str += "B                = %x20 / %x09 / %x0A / %x0D      ; space, tab, LF, CR\n";
+    str += "\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "; Core rules (RFC 5234 B.1)\n";
+    str += "; ---------------------------------------------------------------------------\n";
+    str += "\n";
+    str += "ALPHA          = %x41-5A / %x61-7A   ; A-Z / a-z\n";
+    str += "DIGIT          = %x30-39             ; 0-9\n";
+    return str;
+  };
+}