@temperlang/std 0.3.0 → 0.5.0

package/json.js

@@ -0,0 +1,2101 @@
+const {
+  trunc: trunc__727
+} = globalThis.Math;
+import {
+  type as type__392, requireInstanceOf as requireInstanceOf__585, requireStringIndex as requireStringIndex__852, cmpFloat as cmpFloat__966, mappedGetOr as mappedGetOr_422, listedGet as listedGet_424, mappedForEach as mappedForEach_436, float64ToString as float64ToString_473, float64ToInt as float64ToInt_475, stringToInt as stringToInt_487, stringToFloat64 as stringToFloat64_488, listBuilderAdd as listBuilderAdd_500, listedGetOr as listedGetOr_504, listBuilderSet as listBuilderSet_512, listBuilderRemoveLast as listBuilderRemoveLast_517, mapBuilderConstructor as mapBuilderConstructor_579, panic as panic_586, mappedGet as mappedGet_591, mapBuilderSet as mapBuilderSet_592, listBuilderToList as listBuilderToList_598, mappedToMap as mappedToMap_599, stringGet as stringGet_645, stringNext as stringNext_746, stringHasAtLeast as stringHasAtLeast_817, stringBuilderAppendCodePoint as stringBuilderAppendCodePoint_822
+} from "@temperlang/core";
+export class InterchangeContext extends type__392() {
+  /**
+   * @param {string} headerName_391
+   * @returns {string | null}
+   */
+  getHeader(headerName_391) {
+    null;
+  }
+};
+export class NullInterchangeContext extends type__392(InterchangeContext) {
+  /**
+   * @param {string} headerName_394
+   * @returns {string | null}
+   */
+  getHeader(headerName_394) {
+    return null;
+  }
+  /** @type {NullInterchangeContext} */
+  static #instance_395 = new NullInterchangeContext();
+  /** @returns {NullInterchangeContext} */
+  static get instance() {
+    return this.#instance_395;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+};
+export class JsonProducer extends type__392() {
+  startObject() {
+    null;
+  }
+  endObject() {
+    null;
+  }
+  /** @param {string} key_400 */
+  objectKey(key_400) {
+    null;
+  }
+  startArray() {
+    null;
+  }
+  endArray() {
+    null;
+  }
+  nullValue() {
+    null;
+  }
+  /** @param {boolean} x_405 */
+  booleanValue(x_405) {
+    null;
+  }
+  /** @param {number} x_407 */
+  intValue(x_407) {
+    null;
+  }
+  /** @param {number} x_409 */
+  float64Value(x_409) {
+    null;
+  }
+  /** @param {string} x_411 */
+  numericTokenValue(x_411) {
+    null;
+  }
+  /** @param {string} x_413 */
+  stringValue(x_413) {
+    null;
+  }
+  /** @returns {JsonParseErrorReceiver | null} */
+  get parseErrorReceiver() {
+    return null;
+  }
+};
+export class JsonSyntaxTree extends type__392() {
+  /** @param {JsonProducer} p_416 */
+  produce(p_416) {
+    null;
+  }
+};
+export class JsonObject extends type__392(JsonSyntaxTree) {
+  /** @type {Map<string, Array<JsonSyntaxTree>>} */
+  #properties_417;
+  /**
+   * @param {string} propertyKey_419
+   * @returns {JsonSyntaxTree | null}
+   */
+  propertyValueOrNull(propertyKey_419) {
+    let return_420;
+    const treeList_421 = mappedGetOr_422(this.#properties_417, propertyKey_419, Object.freeze([]));
+    const lastIndex_423 = treeList_421.length - 1;
+    if (lastIndex_423 >= 0) {
+      return_420 = listedGet_424(treeList_421, lastIndex_423);
+    } else {
+      return_420 = null;
+    }
+    return return_420;
+  }
+  /**
+   * @param {string} propertyKey_426
+   * @returns {JsonSyntaxTree}
+   */
+  propertyValueOrBubble(propertyKey_426) {
+    let return_427;
+    let t_428 = this.propertyValueOrNull(propertyKey_426);
+    if (t_428 == null) {
+      throw Error();
+    } else {
+      return_427 = t_428;
+    }
+    return return_427;
+  }
+  /** @param {JsonProducer} p_430 */
+  produce(p_430) {
+    p_430.startObject();
+    function fn_431(k_432, vs_433) {
+      function fn_434(v_435) {
+        p_430.objectKey(k_432);
+        v_435.produce(p_430);
+        return;
+      }
+      vs_433.forEach(fn_434);
+      return;
+    }
+    mappedForEach_436(this.#properties_417, fn_431);
+    p_430.endObject();
+    return;
+  }
+  /** @param {Map<string, Array<JsonSyntaxTree>>} properties_437 */
+  constructor(properties_437) {
+    super ();
+    this.#properties_417 = properties_437;
+    return;
+  }
+  /** @returns {Map<string, Array<JsonSyntaxTree>>} */
+  get properties() {
+    return this.#properties_417;
+  }
+};
+export class JsonArray extends type__392(JsonSyntaxTree) {
+  /** @type {Array<JsonSyntaxTree>} */
+  #elements_439;
+  /** @param {JsonProducer} p_441 */
+  produce(p_441) {
+    p_441.startArray();
+    function fn_442(v_443) {
+      v_443.produce(p_441);
+      return;
+    }
+    this.#elements_439.forEach(fn_442);
+    p_441.endArray();
+    return;
+  }
+  /** @param {Array<JsonSyntaxTree>} elements_444 */
+  constructor(elements_444) {
+    super ();
+    this.#elements_439 = elements_444;
+    return;
+  }
+  /** @returns {Array<JsonSyntaxTree>} */
+  get elements() {
+    return this.#elements_439;
+  }
+};
+export class JsonBoolean extends type__392(JsonSyntaxTree) {
+  /** @type {boolean} */
+  #content_446;
+  /** @param {JsonProducer} p_448 */
+  produce(p_448) {
+    p_448.booleanValue(this.#content_446);
+    return;
+  }
+  /** @param {boolean} content_449 */
+  constructor(content_449) {
+    super ();
+    this.#content_446 = content_449;
+    return;
+  }
+  /** @returns {boolean} */
+  get content() {
+    return this.#content_446;
+  }
+};
+export class JsonNull extends type__392(JsonSyntaxTree) {
+  /** @param {JsonProducer} p_452 */
+  produce(p_452) {
+    p_452.nullValue();
+    return;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+};
+export class JsonString extends type__392(JsonSyntaxTree) {
+  /** @type {string} */
+  #content_453;
+  /** @param {JsonProducer} p_455 */
+  produce(p_455) {
+    p_455.stringValue(this.#content_453);
+    return;
+  }
+  /** @param {string} content_456 */
+  constructor(content_456) {
+    super ();
+    this.#content_453 = content_456;
+    return;
+  }
+  /** @returns {string} */
+  get content() {
+    return this.#content_453;
+  }
+};
+export class JsonNumeric extends type__392(JsonSyntaxTree) {
+  /** @returns {string} */
+  asJsonNumericToken() {
+    null;
+  }
+  /** @returns {number} */
+  asInt() {
+    null;
+  }
+  /** @returns {number} */
+  asFloat64() {
+    null;
+  }
+};
+export class JsonInt extends type__392(JsonNumeric) {
+  /** @type {number} */
+  #content_461;
+  /** @param {JsonProducer} p_463 */
+  produce(p_463) {
+    p_463.intValue(this.#content_461);
+    return;
+  }
+  /** @returns {string} */
+  asJsonNumericToken() {
+    return this.#content_461.toString();
+  }
+  /** @returns {number} */
+  asInt() {
+    return this.#content_461;
+  }
+  /** @returns {number} */
+  asFloat64() {
+    return this.#content_461;
+  }
+  /** @param {number} content_467 */
+  constructor(content_467) {
+    super ();
+    this.#content_461 = content_467;
+    return;
+  }
+  /** @returns {number} */
+  get content() {
+    return this.#content_461;
+  }
+};
+export class JsonFloat64 extends type__392(JsonNumeric) {
+  /** @type {number} */
+  #content_469;
+  /** @param {JsonProducer} p_471 */
+  produce(p_471) {
+    p_471.float64Value(this.#content_469);
+    return;
+  }
+  /** @returns {string} */
+  asJsonNumericToken() {
+    return float64ToString_473(this.#content_469);
+  }
+  /** @returns {number} */
+  asInt() {
+    return float64ToInt_475(this.#content_469);
+  }
+  /** @returns {number} */
+  asFloat64() {
+    return this.#content_469;
+  }
+  /** @param {number} content_477 */
+  constructor(content_477) {
+    super ();
+    this.#content_469 = content_477;
+    return;
+  }
+  /** @returns {number} */
+  get content() {
+    return this.#content_469;
+  }
+};
+export class JsonNumericToken extends type__392(JsonNumeric) {
+  /** @type {string} */
+  #content_479;
+  /** @param {JsonProducer} p_481 */
+  produce(p_481) {
+    p_481.numericTokenValue(this.#content_479);
+    return;
+  }
+  /** @returns {string} */
+  asJsonNumericToken() {
+    return this.#content_479;
+  }
+  /** @returns {number} */
+  asInt() {
+    let return_484;
+    let t_485;
+    let t_486;
+    try {
+      t_485 = stringToInt_487(this.#content_479);
+      return_484 = t_485;
+    } catch {
+      t_486 = stringToFloat64_488(this.#content_479);
+      return_484 = float64ToInt_475(t_486);
+    }
+    return return_484;
+  }
+  /** @returns {number} */
+  asFloat64() {
+    return stringToFloat64_488(this.#content_479);
+  }
+  /** @param {string} content_490 */
+  constructor(content_490) {
+    super ();
+    this.#content_479 = content_490;
+    return;
+  }
+  /** @returns {string} */
+  get content() {
+    return this.#content_479;
+  }
+};
+export class JsonTextProducer extends type__392(JsonProducer) {
+  /** @type {InterchangeContext} */
+  #interchangeContext_492;
+  /** @type {globalThis.Array<string>} */
+  #buffer_493;
+  /** @type {Array<number>} */
+  #stack_494;
+  /** @type {boolean} */
+  #wellFormed_495;
+  /** @param {InterchangeContext | null} [interchangeContext_496] */
+  constructor(interchangeContext_496) {
+    super ();
+    let interchangeContext_497;
+    if (interchangeContext_496 == null) {
+      interchangeContext_497 = NullInterchangeContext.instance;
+    } else {
+      interchangeContext_497 = interchangeContext_496;
+    }
+    this.#interchangeContext_492 = interchangeContext_497;
+    let t_498 = [""];
+    this.#buffer_493 = t_498;
+    let t_499 = [];
+    this.#stack_494 = t_499;
+    listBuilderAdd_500(this.#stack_494, 5);
+    this.#wellFormed_495 = true;
+    return;
+  }
+  /** @returns {number} */
+  #state_502() {
+    let t_503 = this.#stack_494.length;
+    return listedGetOr_504(this.#stack_494, t_503 - 1, -1);
+  }
+  #beforeValue_506() {
+    let t_507;
+    let t_508;
+    let t_509;
+    let t_510;
+    const currentState_511 = this.#state_502();
+    if (currentState_511 === 3) {
+      t_507 = this.#stack_494.length;
+      listBuilderSet_512(this.#stack_494, t_507 - 1, 4);
+    } else if (currentState_511 === 4) {
+      this.#buffer_493[0] += ",";
+    } else if (currentState_511 === 1) {
+      t_508 = this.#stack_494.length;
+      listBuilderSet_512(this.#stack_494, t_508 - 1, 2);
+    } else if (currentState_511 === 5) {
+      t_509 = this.#stack_494.length;
+      listBuilderSet_512(this.#stack_494, t_509 - 1, 6);
+    } else {
+      if (currentState_511 === 6) {
+        t_510 = true;
+      } else {
+        t_510 = currentState_511 === 2;
+      }
+      if (t_510) {
+        this.#wellFormed_495 = false;
+      }
+    }
+    return;
+  }
+  startObject() {
+    this.#beforeValue_506();
+    this.#buffer_493[0] += "{";
+    listBuilderAdd_500(this.#stack_494, 0);
+    return;
+  }
+  endObject() {
+    let t_515;
+    this.#buffer_493[0] += "}";
+    const currentState_516 = this.#state_502();
+    if (0 === currentState_516) {
+      t_515 = true;
+    } else {
+      t_515 = 2 === currentState_516;
+    }
+    if (t_515) {
+      listBuilderRemoveLast_517(this.#stack_494);
+    } else {
+      this.#wellFormed_495 = false;
+    }
+    return;
+  }
+  /** @param {string} key_519 */
+  objectKey(key_519) {
+    let t_520;
+    const currentState_521 = this.#state_502();
+    if (!(currentState_521 === 0)) {
+      if (currentState_521 === 2) {
+        this.#buffer_493[0] += ",";
+      } else {
+        this.#wellFormed_495 = false;
+      }
+    }
+    encodeJsonString_522(key_519, this.#buffer_493);
+    this.#buffer_493[0] += ":";
+    if (currentState_521 >= 0) {
+      t_520 = this.#stack_494.length;
+      listBuilderSet_512(this.#stack_494, t_520 - 1, 1);
+    }
+    return;
+  }
+  startArray() {
+    this.#beforeValue_506();
+    this.#buffer_493[0] += "[";
+    listBuilderAdd_500(this.#stack_494, 3);
+    return;
+  }
+  endArray() {
+    let t_525;
+    this.#buffer_493[0] += "]";
+    const currentState_526 = this.#state_502();
+    if (3 === currentState_526) {
+      t_525 = true;
+    } else {
+      t_525 = 4 === currentState_526;
+    }
+    if (t_525) {
+      listBuilderRemoveLast_517(this.#stack_494);
+    } else {
+      this.#wellFormed_495 = false;
+    }
+    return;
+  }
+  nullValue() {
+    this.#beforeValue_506();
+    this.#buffer_493[0] += "null";
+    return;
+  }
+  /** @param {boolean} x_529 */
+  booleanValue(x_529) {
+    let t_530;
+    this.#beforeValue_506();
+    if (x_529) {
+      t_530 = "true";
+    } else {
+      t_530 = "false";
+    }
+    this.#buffer_493[0] += t_530;
+    return;
+  }
+  /** @param {number} x_532 */
+  intValue(x_532) {
+    this.#beforeValue_506();
+    let t_533 = x_532.toString();
+    this.#buffer_493[0] += t_533;
+    return;
+  }
+  /** @param {number} x_535 */
+  float64Value(x_535) {
+    this.#beforeValue_506();
+    let t_536 = float64ToString_473(x_535);
+    this.#buffer_493[0] += t_536;
+    return;
+  }
+  /** @param {string} x_538 */
+  numericTokenValue(x_538) {
+    this.#beforeValue_506();
+    this.#buffer_493[0] += x_538;
+    return;
+  }
+  /** @param {string} x_540 */
+  stringValue(x_540) {
+    this.#beforeValue_506();
+    encodeJsonString_522(x_540, this.#buffer_493);
+    return;
+  }
+  /** @returns {string} */
+  toJsonString() {
+    let return_542;
+    let t_543;
+    let t_544;
+    let t_545;
+    if (this.#wellFormed_495) {
+      if (this.#stack_494.length === 1) {
+        t_543 = this.#state_502();
+        t_544 = t_543 === 6;
+      } else {
+        t_544 = false;
+      }
+      t_545 = t_544;
+    } else {
+      t_545 = false;
+    }
+    if (t_545) {
+      return_542 = this.#buffer_493[0];
+    } else {
+      throw Error();
+    }
+    return return_542;
+  }
+  /** @returns {InterchangeContext} */
+  get interchangeContext() {
+    return this.#interchangeContext_492;
+  }
+};
+export class JsonParseErrorReceiver extends type__392() {
+  /** @param {string} explanation_548 */
+  explainJsonError(explanation_548) {
+    null;
+  }
+};
+export class JsonSyntaxTreeProducer extends type__392(JsonProducer, JsonParseErrorReceiver) {
+  /** @type {Array<Array<JsonSyntaxTree>>} */
+  #stack_549;
+  /** @type {string | null} */
+  #error_550;
+  /** @returns {InterchangeContext} */
+  get interchangeContext() {
+    return NullInterchangeContext.instance;
+  }
+  constructor() {
+    super ();
+    let t_552 = [];
+    this.#stack_549 = t_552;
+    let t_553 = [];
+    listBuilderAdd_500(this.#stack_549, t_553);
+    this.#error_550 = null;
+    return;
+  }
+  /** @param {JsonSyntaxTree} v_556 */
+  #storeValue_555(v_556) {
+    let t_557;
+    if (! ! this.#stack_549.length) {
+      t_557 = this.#stack_549.length;
+      listBuilderAdd_500(listedGet_424(this.#stack_549, t_557 - 1), v_556);
+    }
+    return;
+  }
+  startObject() {
+    let t_559 = [];
+    listBuilderAdd_500(this.#stack_549, t_559);
+    return;
+  }
+  endObject() {
+    let return_561;
+    let t_562;
+    let t_563;
+    let t_564;
+    let t_565;
+    let t_566;
+    let t_567;
+    let t_568;
+    let t_569;
+    let t_570;
+    let t_571;
+    let t_572;
+    let t_573;
+    let t_574;
+    let t_575;
+    fn_576: {
+      if (! this.#stack_549.length) {
+        return_561 = void 0;
+        break fn_576;
+      }
+      const ls_577 = listBuilderRemoveLast_517(this.#stack_549);
+      const m_578 = mapBuilderConstructor_579();
+      let multis_580 = null;
+      let i_581 = 0;
+      let n_582 = ls_577.length & -2;
+      while (i_581 < n_582) {
+        const postfixReturn_583 = i_581;
+        i_581 = i_581 + 1;
+        const keyTree_584 = listedGet_424(ls_577, postfixReturn_583);
+        if (!(keyTree_584 instanceof JsonString)) {
+          break;
+        }
+        try {
+          t_568 = requireInstanceOf__585(keyTree_584, JsonString);
+          t_569 = t_568;
+        } catch {
+          t_562 = panic_586();
+          t_569 = t_562;
+        }
+        const key_587 = t_569.content;
+        const postfixReturn_588 = i_581;
+        i_581 = i_581 + 1;
+        const value_589 = listedGet_424(ls_577, postfixReturn_588);
+        if (m_578.has(key_587)) {
+          if (multis_580 == null) {
+            t_563 = mapBuilderConstructor_579();
+            multis_580 = t_563;
+          }
+          try {
+            if (multis_580 == null) {
+              throw Error();
+            } else {
+              t_570 = multis_580;
+            }
+            t_571 = t_570;
+          } catch {
+            t_564 = panic_586();
+            t_571 = t_564;
+          }
+          const mb_590 = t_571;
+          if (! mb_590.has(key_587)) {
+            try {
+              t_572 = mappedGet_591(m_578, key_587);
+              t_573 = t_572;
+            } catch {
+              t_565 = panic_586();
+              t_573 = t_565;
+            }
+            mapBuilderSet_592(mb_590, key_587, t_573.slice());
+          }
+          try {
+            t_574 = mappedGet_591(mb_590, key_587);
+            t_575 = t_574;
+          } catch {
+            t_566 = panic_586();
+            t_575 = t_566;
+          }
+          listBuilderAdd_500(t_575, value_589);
+        } else {
+          mapBuilderSet_592(m_578, key_587, Object.freeze([value_589]));
+        }
+      }
+      const multis_593 = multis_580;
+      if (!(multis_593 == null)) {
+        function fn_594(k_595, vs_596) {
+          let t_597 = listBuilderToList_598(vs_596);
+          mapBuilderSet_592(m_578, k_595, t_597);
+          return;
+        }
+        mappedForEach_436(multis_593, fn_594);
+      }
+      t_567 = new JsonObject(mappedToMap_599(m_578));
+      this.#storeValue_555(t_567);
+      return_561 = void 0;
+    }
+    return return_561;
+  }
+  /** @param {string} key_601 */
+  objectKey(key_601) {
+    let t_602 = new JsonString(key_601);
+    this.#storeValue_555(t_602);
+    return;
+  }
+  startArray() {
+    let t_604 = [];
+    listBuilderAdd_500(this.#stack_549, t_604);
+    return;
+  }
+  endArray() {
+    let return_606;
+    let t_607;
+    fn_608: {
+      if (! this.#stack_549.length) {
+        return_606 = void 0;
+        break fn_608;
+      }
+      const ls_609 = listBuilderRemoveLast_517(this.#stack_549);
+      t_607 = new JsonArray(listBuilderToList_598(ls_609));
+      this.#storeValue_555(t_607);
+      return_606 = void 0;
+    }
+    return return_606;
+  }
+  nullValue() {
+    let t_611 = new JsonNull();
+    this.#storeValue_555(t_611);
+    return;
+  }
+  /** @param {boolean} x_613 */
+  booleanValue(x_613) {
+    let t_614 = new JsonBoolean(x_613);
+    this.#storeValue_555(t_614);
+    return;
+  }
+  /** @param {number} x_616 */
+  intValue(x_616) {
+    let t_617 = new JsonInt(x_616);
+    this.#storeValue_555(t_617);
+    return;
+  }
+  /** @param {number} x_619 */
+  float64Value(x_619) {
+    let t_620 = new JsonFloat64(x_619);
+    this.#storeValue_555(t_620);
+    return;
+  }
+  /** @param {string} x_622 */
+  numericTokenValue(x_622) {
+    let t_623 = new JsonNumericToken(x_622);
+    this.#storeValue_555(t_623);
+    return;
+  }
+  /** @param {string} x_625 */
+  stringValue(x_625) {
+    let t_626 = new JsonString(x_625);
+    this.#storeValue_555(t_626);
+    return;
+  }
+  /** @returns {JsonSyntaxTree} */
+  toJsonSyntaxTree() {
+    let t_628;
+    if (this.#stack_549.length !== 1) {
+      t_628 = true;
+    } else {
+      t_628 = !(this.#error_550 == null);
+    }
+    if (t_628) {
+      throw Error();
+    }
+    const ls_629 = listedGet_424(this.#stack_549, 0);
+    if (ls_629.length !== 1) {
+      throw Error();
+    }
+    return listedGet_424(ls_629, 0);
+  }
+  /** @returns {string | null} */
+  get jsonError() {
+    return this.#error_550;
+  }
+  /** @returns {JsonParseErrorReceiver} */
+  get parseErrorReceiver() {
+    return this;
+  }
+  /** @param {string} error_633 */
+  explainJsonError(error_633) {
+    this.#error_550 = error_633;
+    return;
+  }
+};
+/**
+ * @param {string} sourceText_635
+ * @param {globalThis.number} i_636
+ * @param {JsonProducer} out_637
+ * @returns {globalThis.number}
+ */
+function parseJsonValue_634(sourceText_635, i_636, out_637) {
+  let return_638;
+  let t_639;
+  let t_640;
+  let t_641;
+  fn_642: {
+    t_639 = skipJsonSpaces_643(sourceText_635, i_636);
+    i_636 = t_639;
+    if (!(sourceText_635.length > i_636)) {
+      expectedTokenError_644(sourceText_635, i_636, out_637, "JSON value");
+      return_638 = -1;
+      break fn_642;
+    }
+    t_640 = stringGet_645(sourceText_635, i_636);
+    if (t_640 === 123) {
+      return_638 = parseJsonObject_646(sourceText_635, i_636, out_637);
+    } else if (t_640 === 91) {
+      return_638 = parseJsonArray_647(sourceText_635, i_636, out_637);
+    } else if (t_640 === 34) {
+      return_638 = parseJsonString_648(sourceText_635, i_636, out_637);
+    } else {
+      if (t_640 === 116) {
+        t_641 = true;
+      } else {
+        t_641 = t_640 === 102;
+      }
+      if (t_641) {
+        return_638 = parseJsonBoolean_649(sourceText_635, i_636, out_637);
+      } else if (t_640 === 110) {
+        return_638 = parseJsonNull_650(sourceText_635, i_636, out_637);
+      } else {
+        return_638 = parseJsonNumber_651(sourceText_635, i_636, out_637);
+      }
+    }
+  }
+  return return_638;
+}
+/** @template T_652 */
+export class JsonAdapter extends type__392() {
+  /**
+   * @param {T_652} x_654
+   * @param {JsonProducer} p_655
+   */
+  encodeToJson(x_654, p_655) {
+    null;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_657
+   * @param {InterchangeContext} ic_658
+   * @returns {T_652}
+   */
+  decodeFromJson(t_657, ic_658) {
+    null;
+  }
+};
+class BooleanJsonAdapter_659 extends type__392(JsonAdapter) {
+  /**
+   * @param {boolean} x_661
+   * @param {JsonProducer} p_662
+   */
+  encodeToJson(x_661, p_662) {
+    p_662.booleanValue(x_661);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_664
+   * @param {InterchangeContext} ic_665
+   * @returns {boolean}
+   */
+  decodeFromJson(t_664, ic_665) {
+    let t_666;
+    t_666 = requireInstanceOf__585(t_664, JsonBoolean);
+    return t_666.content;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+class Float64JsonAdapter_667 extends type__392(JsonAdapter) {
+  /**
+   * @param {number} x_669
+   * @param {JsonProducer} p_670
+   */
+  encodeToJson(x_669, p_670) {
+    p_670.float64Value(x_669);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_672
+   * @param {InterchangeContext} ic_673
+   * @returns {number}
+   */
+  decodeFromJson(t_672, ic_673) {
+    let t_674;
+    t_674 = requireInstanceOf__585(t_672, JsonNumeric);
+    return t_674.asFloat64();
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+class IntJsonAdapter_675 extends type__392(JsonAdapter) {
+  /**
+   * @param {number} x_677
+   * @param {JsonProducer} p_678
+   */
+  encodeToJson(x_677, p_678) {
+    p_678.intValue(x_677);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_680
+   * @param {InterchangeContext} ic_681
+   * @returns {number}
+   */
+  decodeFromJson(t_680, ic_681) {
+    let t_682;
+    t_682 = requireInstanceOf__585(t_680, JsonNumeric);
+    return t_682.asInt();
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+class StringJsonAdapter_683 extends type__392(JsonAdapter) {
+  /**
+   * @param {string} x_685
+   * @param {JsonProducer} p_686
+   */
+  encodeToJson(x_685, p_686) {
+    p_686.stringValue(x_685);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_688
+   * @param {InterchangeContext} ic_689
+   * @returns {string}
+   */
+  decodeFromJson(t_688, ic_689) {
+    let t_690;
+    t_690 = requireInstanceOf__585(t_688, JsonString);
+    return t_690.content;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+/** @template T_692 */
+class ListJsonAdapter_691 extends type__392(JsonAdapter) {
+  /** @type {JsonAdapter<T_692>} */
+  #adapterForT_693;
+  /**
+   * @param {Array<T_692>} x_695
+   * @param {JsonProducer} p_696
+   */
+  encodeToJson(x_695, p_696) {
+    const this699 = this;
+    p_696.startArray();
+    function fn_697(el_698) {
+      this699.#adapterForT_693.encodeToJson(el_698, p_696);
+      return;
+    }
+    x_695.forEach(fn_697);
+    p_696.endArray();
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_701
+   * @param {InterchangeContext} ic_702
+   * @returns {Array<T_692>}
+   */
+  decodeFromJson(t_701, ic_702) {
+    let t_703;
+    const b_704 = [];
+    let t_705;
+    t_705 = requireInstanceOf__585(t_701, JsonArray);
+    const elements_706 = t_705.elements;
+    const n_707 = elements_706.length;
+    let i_708 = 0;
+    while (i_708 < n_707) {
+      const el_709 = listedGet_424(elements_706, i_708);
+      i_708 = i_708 + 1;
+      t_703 = this.#adapterForT_693.decodeFromJson(el_709, ic_702);
+      listBuilderAdd_500(b_704, t_703);
+    }
+    return listBuilderToList_598(b_704);
+  }
+  /** @param {JsonAdapter<T_692>} adapterForT_710 */
+  constructor(adapterForT_710) {
+    super ();
+    this.#adapterForT_693 = adapterForT_710;
+    return;
+  }
+}
+/** @template T_711 */
+export class OrNullJsonAdapter extends type__392(JsonAdapter) {
+  /** @type {JsonAdapter<T_711>} */
+  #adapterForT_712;
+  /**
+   * @param {T_711 | null} x_714
+   * @param {JsonProducer} p_715
+   */
+  encodeToJson(x_714, p_715) {
+    if (x_714 == null) {
+      p_715.nullValue();
+    } else {
+      const x_716 = x_714;
+      this.#adapterForT_712.encodeToJson(x_716, p_715);
+    }
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_718
+   * @param {InterchangeContext} ic_719
+   * @returns {T_711 | null}
+   */
+  decodeFromJson(t_718, ic_719) {
+    let return_720;
+    if (t_718 instanceof JsonNull) {
+      return_720 = null;
+    } else {
+      return_720 = this.#adapterForT_712.decodeFromJson(t_718, ic_719);
+    }
+    return return_720;
+  }
+  /** @param {JsonAdapter<T_711>} adapterForT_721 */
+  constructor(adapterForT_721) {
+    super ();
+    this.#adapterForT_712 = adapterForT_721;
+    return;
+  }
+};
+/** @type {Array<string>} */
+const hexDigits_722 = Object.freeze(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"]);
+/**
+ * @param {number} cp_724
+ * @param {globalThis.Array<string>} buffer_725
+ */
+function encodeHex4_723(cp_724, buffer_725) {
+  const b0_726 = trunc__727(cp_724 / 4096) & 15;
+  const b1_728 = trunc__727(cp_724 / 256) & 15;
+  const b2_729 = trunc__727(cp_724 / 16) & 15;
+  const b3_730 = cp_724 & 15;
+  let t_731 = listedGet_424(hexDigits_722, b0_726);
+  buffer_725[0] += t_731;
+  let t_732 = listedGet_424(hexDigits_722, b1_728);
+  buffer_725[0] += t_732;
+  let t_733 = listedGet_424(hexDigits_722, b2_729);
+  buffer_725[0] += t_733;
+  let t_734 = listedGet_424(hexDigits_722, b3_730);
+  buffer_725[0] += t_734;
+  return;
+}
+/**
+ * @param {string} x_735
+ * @param {globalThis.Array<string>} buffer_736
+ */
+function encodeJsonString_522(x_735, buffer_736) {
+  let t_737;
+  let t_738;
+  let t_739;
+  let t_740;
+  buffer_736[0] += "\u0022";
+  let i_741 = 0;
+  let emitted_742 = i_741;
+  while (true) {
+    if (!(x_735.length > i_741)) {
+      break;
+    }
+    const cp_743 = stringGet_645(x_735, i_741);
+    if (cp_743 === 8) {
+      t_740 = "\\b";
+    } else if (cp_743 === 9) {
+      t_740 = "\\t";
+    } else if (cp_743 === 10) {
+      t_740 = "\\n";
+    } else if (cp_743 === 12) {
+      t_740 = "\\f";
+    } else if (cp_743 === 13) {
+      t_740 = "\\r";
+    } else if (cp_743 === 34) {
+      t_740 = "\\\u0022";
+    } else if (cp_743 === 92) {
+      t_740 = "\\\\";
+    } else {
+      if (cp_743 < 32) {
+        t_738 = true;
+      } else {
+        if (55296 <= cp_743) {
+          t_737 = cp_743 <= 57343;
+        } else {
+          t_737 = false;
+        }
+        t_738 = t_737;
+      }
+      if (t_738) {
+        t_739 = "\\u";
+      } else {
+        t_739 = "";
+      }
+      t_740 = t_739;
+    }
+    const replacement_744 = t_740;
+    const nextI_745 = stringNext_746(x_735, i_741);
+    if (replacement_744 !== "") {
+      buffer_736[0] += x_735.substring(emitted_742, i_741);
+      buffer_736[0] += replacement_744;
+      if (replacement_744 === "\\u") {
+        encodeHex4_723(cp_743, buffer_736);
+      }
+      emitted_742 = nextI_745;
+    }
+    i_741 = nextI_745;
+  }
+  buffer_736[0] += x_735.substring(emitted_742, i_741);
+  buffer_736[0] += "\u0022";
+  return;
+}
+/**
+ * @param {JsonProducer} out_748
+ * @param {string} explanation_749
+ */
+function storeJsonError_747(out_748, explanation_749) {
+  let t_750 = out_748.parseErrorReceiver;
+  if (!(t_750 == null)) {
+    t_750.explainJsonError(explanation_749);
+  }
+  return;
+}
+/**
+ * @param {string} sourceText_751
+ * @param {globalThis.number} i_752
+ * @param {JsonProducer} out_753
+ * @param {string} shortExplanation_754
+ */
+function expectedTokenError_644(sourceText_751, i_752, out_753, shortExplanation_754) {
+  let t_755;
+  let t_756;
+  let gotten_757;
+  if (sourceText_751.length > i_752) {
+    t_755 = sourceText_751.length;
+    t_756 = sourceText_751.substring(i_752, t_755);
+    gotten_757 = "`" + t_756 + "`";
+  } else {
+    gotten_757 = "end-of-file";
+  }
+  storeJsonError_747(out_753, "Expected " + shortExplanation_754 + ", but got " + gotten_757);
+  return;
+}
+/**
+ * @param {string} sourceText_758
+ * @param {globalThis.number} i_759
+ * @returns {globalThis.number}
+ */
+function skipJsonSpaces_643(sourceText_758, i_759) {
+  let t_760;
+  let t_761;
+  let t_762;
+  let t_763;
+  let t_764;
+  while (true) {
+    if (!(sourceText_758.length > i_759)) {
+      break;
+    }
+    t_760 = stringGet_645(sourceText_758, i_759);
+    if (t_760 === 9) {
+      t_764 = true;
+    } else {
+      if (t_760 === 10) {
+        t_763 = true;
+      } else {
+        if (t_760 === 13) {
+          t_762 = true;
+        } else {
+          t_762 = t_760 === 32;
+        }
+        t_763 = t_762;
+      }
+      t_764 = t_763;
+    }
+    if (! t_764) {
+      break;
+    }
+    t_761 = stringNext_746(sourceText_758, i_759);
+    i_759 = t_761;
+  }
+  return i_759;
+}
+/**
+ * @param {string} sourceText_766
+ * @param {globalThis.number} start_767
+ * @param {globalThis.number} limit_768
+ * @returns {number}
+ */
+function decodeHexUnsigned_765(sourceText_766, start_767, limit_768) {
+  let return_769;
+  let t_770;
+  let t_771;
+  let t_772;
+  let t_773;
+  let t_774;
+  fn_775: {
+    let n_776 = 0;
+    let i_777 = start_767;
+    while (true) {
+      if (!(i_777 - limit_768 < 0)) {
+        break;
+      }
+      const cp_778 = stringGet_645(sourceText_766, i_777);
+      if (48 <= cp_778) {
+        t_771 = cp_778 <= 48;
+      } else {
+        t_771 = false;
+      }
+      if (t_771) {
+        t_774 = cp_778 - 48;
+      } else {
+        if (65 <= cp_778) {
+          t_772 = cp_778 <= 70;
+        } else {
+          t_772 = false;
+        }
+        if (t_772) {
+          t_774 = cp_778 - 65 + 10;
+        } else {
+          if (97 <= cp_778) {
+            t_773 = cp_778 <= 102;
+          } else {
+            t_773 = false;
+          }
+          if (t_773) {
+            t_774 = cp_778 - 97 + 10;
+          } else {
+            return_769 = -1;
+            break fn_775;
+          }
+        }
+      }
+      const digit_779 = t_774;
+      n_776 = n_776 * 16 + digit_779;
+      t_770 = stringNext_746(sourceText_766, i_777);
+      i_777 = t_770;
+    }
+    return_769 = n_776;
+  }
+  return return_769;
+}
+/**
+ * @param {string} sourceText_781
+ * @param {globalThis.number} i_782
+ * @param {globalThis.Array<string>} sb_783
+ * @param {JsonProducer} errOut_784
+ * @returns {globalThis.number}
+ */
+function parseJsonStringTo_780(sourceText_781, i_782, sb_783, errOut_784) {
+  let return_785;
+  let t_786;
+  let t_787;
+  let t_788;
+  let t_789;
+  let t_790;
+  let t_791;
+  let t_792;
+  let t_793;
+  let t_794;
+  let t_795;
+  let t_796;
+  let t_797;
+  let t_798;
+  let t_799;
+  let t_800;
+  let t_801;
+  let t_802;
+  let t_803;
+  let t_804;
+  let t_805;
+  let t_806;
+  let t_807;
+  let t_808;
+  fn_809: {
+    if (!(sourceText_781.length > i_782)) {
+      t_797 = true;
+    } else {
+      t_786 = stringGet_645(sourceText_781, i_782);
+      t_797 = t_786 !== 34;
+    }
+    if (t_797) {
+      expectedTokenError_644(sourceText_781, i_782, errOut_784, "\u0022");
+      return_785 = -1;
+      break fn_809;
+    }
+    t_787 = stringNext_746(sourceText_781, i_782);
+    i_782 = t_787;
+    let leadSurrogate_810 = -1;
+    let consumed_811 = i_782;
+    while (true) {
+      if (!(sourceText_781.length > i_782)) {
+        break;
+      }
+      const cp_812 = stringGet_645(sourceText_781, i_782);
+      if (cp_812 === 34) {
+        break;
+      }
+      t_788 = stringNext_746(sourceText_781, i_782);
+      let iNext_813 = t_788;
+      const end_814 = sourceText_781.length;
+      let needToFlush_815 = false;
+      if (cp_812 !== 92) {
+        t_803 = cp_812;
+      } else {
+        needToFlush_815 = true;
+        if (!(sourceText_781.length > iNext_813)) {
+          expectedTokenError_644(sourceText_781, iNext_813, errOut_784, "escape sequence");
+          return_785 = -1;
+          break fn_809;
+        }
+        const esc0_816 = stringGet_645(sourceText_781, iNext_813);
+        t_789 = stringNext_746(sourceText_781, iNext_813);
+        iNext_813 = t_789;
+        if (esc0_816 === 34) {
+          t_799 = true;
+        } else {
+          if (esc0_816 === 92) {
+            t_798 = true;
+          } else {
+            t_798 = esc0_816 === 47;
+          }
+          t_799 = t_798;
+        }
+        if (t_799) {
+          t_802 = esc0_816;
+        } else if (esc0_816 === 98) {
+          t_802 = 8;
+        } else if (esc0_816 === 102) {
+          t_802 = 12;
+        } else if (esc0_816 === 110) {
+          t_802 = 10;
+        } else if (esc0_816 === 114) {
+          t_802 = 13;
+        } else if (esc0_816 === 116) {
+          t_802 = 9;
+        } else if (esc0_816 === 117) {
+          if (stringHasAtLeast_817(sourceText_781, iNext_813, end_814, 4)) {
+            const startHex_818 = iNext_813;
+            t_790 = stringNext_746(sourceText_781, iNext_813);
+            iNext_813 = t_790;
+            t_791 = stringNext_746(sourceText_781, iNext_813);
+            iNext_813 = t_791;
+            t_792 = stringNext_746(sourceText_781, iNext_813);
+            iNext_813 = t_792;
+            t_793 = stringNext_746(sourceText_781, iNext_813);
+            iNext_813 = t_793;
+            t_794 = decodeHexUnsigned_765(sourceText_781, startHex_818, iNext_813);
+            t_800 = t_794;
+          } else {
+            t_800 = -1;
+          }
+          const hex_819 = t_800;
+          if (hex_819 < 0) {
+            expectedTokenError_644(sourceText_781, iNext_813, errOut_784, "four hex digits");
+            return_785 = -1;
+            break fn_809;
+          }
+          t_801 = hex_819;
+          t_802 = t_801;
+        } else {
+          expectedTokenError_644(sourceText_781, iNext_813, errOut_784, "escape sequence");
+          return_785 = -1;
+          break fn_809;
+        }
+        t_803 = t_802;
+      }
+      let decodedCp_820 = t_803;
+      if (leadSurrogate_810 >= 0) {
+        needToFlush_815 = true;
+        const lead_821 = leadSurrogate_810;
+        if (56320 <= decodedCp_820) {
+          t_804 = decodedCp_820 <= 57343;
+        } else {
+          t_804 = false;
+        }
+        if (t_804) {
+          leadSurrogate_810 = -1;
+          t_805 = (lead_821 - 55296) * 1024 | decodedCp_820 - 56320;
+          decodedCp_820 = 65536 + t_805;
+        }
+      } else {
+        if (55296 <= decodedCp_820) {
+          t_806 = decodedCp_820 <= 56319;
+        } else {
+          t_806 = false;
+        }
+        if (t_806) {
+          needToFlush_815 = true;
+        }
+      }
+      if (needToFlush_815) {
+        sb_783[0] += sourceText_781.substring(consumed_811, i_782);
+        if (leadSurrogate_810 >= 0) {
+          try {
+            stringBuilderAppendCodePoint_822(sb_783, leadSurrogate_810);
+          } catch {
+            throw Error();
+          }
+        }
+        if (55296 <= decodedCp_820) {
+          t_807 = decodedCp_820 <= 56319;
+        } else {
+          t_807 = false;
+        }
+        if (t_807) {
+          leadSurrogate_810 = decodedCp_820;
+        } else {
+          leadSurrogate_810 = -1;
+          try {
+            stringBuilderAppendCodePoint_822(sb_783, decodedCp_820);
+          } catch {
+            throw Error();
+          }
+        }
+        consumed_811 = iNext_813;
+      }
+      i_782 = iNext_813;
+    }
+    if (!(sourceText_781.length > i_782)) {
+      t_808 = true;
+    } else {
+      t_795 = stringGet_645(sourceText_781, i_782);
+      t_808 = t_795 !== 34;
+    }
+    if (t_808) {
+      expectedTokenError_644(sourceText_781, i_782, errOut_784, "\u0022");
+      return_785 = -1;
+    } else {
+      if (leadSurrogate_810 >= 0) {
+        try {
+          stringBuilderAppendCodePoint_822(sb_783, leadSurrogate_810);
+        } catch {
+          throw Error();
+        }
+      } else {
+        sb_783[0] += sourceText_781.substring(consumed_811, i_782);
+      }
+      t_796 = stringNext_746(sourceText_781, i_782);
+      i_782 = t_796;
+      return_785 = i_782;
+    }
+  }
+  return return_785;
+}
+/**
+ * @param {string} sourceText_823
+ * @param {globalThis.number} i_824
+ * @param {JsonProducer} out_825
+ * @returns {globalThis.number}
+ */
+function parseJsonObject_646(sourceText_823, i_824, out_825) {
+  let return_826;
+  let t_827;
+  let t_828;
+  let t_829;
+  let t_830;
+  let t_831;
+  let t_832;
+  let t_833;
+  let t_834;
+  let t_835;
+  let t_836;
+  let t_837;
+  let t_838;
+  let t_839;
+  let t_840;
+  let t_841;
+  let t_842;
+  let t_843;
+  let t_844;
+  let t_845;
+  let t_846;
+  let t_847;
+  let t_848;
+  fn_849: {
+    try {
+      if (!(sourceText_823.length > i_824)) {
+        t_841 = true;
+      } else {
+        t_827 = stringGet_645(sourceText_823, i_824);
+        t_841 = t_827 !== 123;
+      }
+      if (t_841) {
+        expectedTokenError_644(sourceText_823, i_824, out_825, "'{'");
+        return_826 = -1;
+        break fn_849;
+      }
+      out_825.startObject();
+      t_828 = stringNext_746(sourceText_823, i_824);
+      t_829 = skipJsonSpaces_643(sourceText_823, t_828);
+      i_824 = t_829;
+      if (sourceText_823.length > i_824) {
+        t_830 = stringGet_645(sourceText_823, i_824);
+        t_842 = t_830 !== 125;
+      } else {
+        t_842 = false;
+      }
+      if (t_842) {
+        while (true) {
+          const keyBuffer_850 = [""];
+          const afterKey_851 = parseJsonStringTo_780(sourceText_823, i_824, keyBuffer_850, out_825);
+          if (!(afterKey_851 >= 0)) {
+            return_826 = -1;
+            break fn_849;
+          }
+          t_831 = keyBuffer_850[0];
+          out_825.objectKey(t_831);
+          try {
+            t_843 = requireStringIndex__852(afterKey_851);
+            t_844 = t_843;
+          } catch {
+            t_832 = panic_586();
+            t_844 = t_832;
+          }
+          t_833 = skipJsonSpaces_643(sourceText_823, t_844);
+          i_824 = t_833;
+          if (sourceText_823.length > i_824) {
+            t_834 = stringGet_645(sourceText_823, i_824);
+            t_845 = t_834 === 58;
+          } else {
+            t_845 = false;
+          }
+          if (t_845) {
+            t_835 = stringNext_746(sourceText_823, i_824);
+            i_824 = t_835;
+            const afterPropertyValue_853 = parseJsonValue_634(sourceText_823, i_824, out_825);
+            if (!(afterPropertyValue_853 >= 0)) {
+              return_826 = -1;
+              break fn_849;
+            }
+            t_846 = requireStringIndex__852(afterPropertyValue_853);
+            i_824 = t_846;
+          } else {
+            expectedTokenError_644(sourceText_823, i_824, out_825, "':'");
+            return_826 = -1;
+            break fn_849;
+          }
+          t_836 = skipJsonSpaces_643(sourceText_823, i_824);
+          i_824 = t_836;
+          if (sourceText_823.length > i_824) {
+            t_837 = stringGet_645(sourceText_823, i_824);
+            t_847 = t_837 === 44;
+          } else {
+            t_847 = false;
+          }
+          if (t_847) {
+            t_838 = stringNext_746(sourceText_823, i_824);
+            t_839 = skipJsonSpaces_643(sourceText_823, t_838);
+            i_824 = t_839;
+          } else {
+            break;
+          }
+        }
+      }
+      if (sourceText_823.length > i_824) {
+        t_840 = stringGet_645(sourceText_823, i_824);
+        t_848 = t_840 === 125;
+      } else {
+        t_848 = false;
+      }
+      if (t_848) {
+        out_825.endObject();
+        return_826 = stringNext_746(sourceText_823, i_824);
+      } else {
+        expectedTokenError_644(sourceText_823, i_824, out_825, "'}'");
+        return_826 = -1;
+      }
+    } catch {
+      return_826 = panic_586();
+    }
+  }
+  return return_826;
+}
+/**
+ * @param {string} sourceText_854
+ * @param {globalThis.number} i_855
+ * @param {JsonProducer} out_856
+ * @returns {globalThis.number}
+ */
+function parseJsonArray_647(sourceText_854, i_855, out_856) {
+  let return_857;
+  let t_858;
+  let t_859;
+  let t_860;
+  let t_861;
+  let t_862;
+  let t_863;
+  let t_864;
+  let t_865;
+  let t_866;
+  let t_867;
+  let t_868;
+  let t_869;
+  let t_870;
+  let t_871;
+  fn_872: {
+    try {
+      if (!(sourceText_854.length > i_855)) {
+        t_867 = true;
+      } else {
+        t_858 = stringGet_645(sourceText_854, i_855);
+        t_867 = t_858 !== 91;
+      }
+      if (t_867) {
+        expectedTokenError_644(sourceText_854, i_855, out_856, "'['");
+        return_857 = -1;
+        break fn_872;
+      }
+      out_856.startArray();
+      t_859 = stringNext_746(sourceText_854, i_855);
+      t_860 = skipJsonSpaces_643(sourceText_854, t_859);
+      i_855 = t_860;
+      if (sourceText_854.length > i_855) {
+        t_861 = stringGet_645(sourceText_854, i_855);
+        t_868 = t_861 !== 93;
+      } else {
+        t_868 = false;
+      }
+      if (t_868) {
+        while (true) {
+          const afterElementValue_873 = parseJsonValue_634(sourceText_854, i_855, out_856);
+          if (!(afterElementValue_873 >= 0)) {
+            return_857 = -1;
+            break fn_872;
+          }
+          t_869 = requireStringIndex__852(afterElementValue_873);
+          i_855 = t_869;
+          t_862 = skipJsonSpaces_643(sourceText_854, i_855);
+          i_855 = t_862;
+          if (sourceText_854.length > i_855) {
+            t_863 = stringGet_645(sourceText_854, i_855);
+            t_870 = t_863 === 44;
+          } else {
+            t_870 = false;
+          }
+          if (t_870) {
+            t_864 = stringNext_746(sourceText_854, i_855);
+            t_865 = skipJsonSpaces_643(sourceText_854, t_864);
+            i_855 = t_865;
+          } else {
+            break;
+          }
+        }
+      }
+      if (sourceText_854.length > i_855) {
+        t_866 = stringGet_645(sourceText_854, i_855);
+        t_871 = t_866 === 93;
+      } else {
+        t_871 = false;
+      }
+      if (t_871) {
+        out_856.endArray();
+        return_857 = stringNext_746(sourceText_854, i_855);
+      } else {
+        expectedTokenError_644(sourceText_854, i_855, out_856, "']'");
+        return_857 = -1;
+      }
+    } catch {
+      return_857 = panic_586();
+    }
+  }
+  return return_857;
+}
+/**
+ * @param {string} sourceText_874
+ * @param {globalThis.number} i_875
+ * @param {JsonProducer} out_876
+ * @returns {globalThis.number}
+ */
+function parseJsonString_648(sourceText_874, i_875, out_876) {
+  let t_877;
+  const sb_878 = [""];
+  const after_879 = parseJsonStringTo_780(sourceText_874, i_875, sb_878, out_876);
+  if (after_879 >= 0) {
+    t_877 = sb_878[0];
+    out_876.stringValue(t_877);
+  }
+  return after_879;
+}
+/**
+ * @param {string} string_881
+ * @param {globalThis.number} inString_882
+ * @param {string} substring_883
+ * @returns {globalThis.number}
+ */
+function afterSubstring_880(string_881, inString_882, substring_883) {
+  let return_884;
+  let t_885;
+  let t_886;
+  fn_887: {
+    let i_888 = inString_882;
+    let j_889 = 0;
+    while (true) {
+      if (!(substring_883.length > j_889)) {
+        break;
+      }
+      if (!(string_881.length > i_888)) {
+        return_884 = -1;
+        break fn_887;
+      }
+      if (stringGet_645(string_881, i_888) !== stringGet_645(substring_883, j_889)) {
+        return_884 = -1;
+        break fn_887;
+      }
+      t_885 = stringNext_746(string_881, i_888);
+      i_888 = t_885;
+      t_886 = stringNext_746(substring_883, j_889);
+      j_889 = t_886;
+    }
+    return_884 = i_888;
+  }
+  return return_884;
+}
+/**
+ * @param {string} sourceText_890
+ * @param {globalThis.number} i_891
+ * @param {JsonProducer} out_892
+ * @returns {globalThis.number}
+ */
+function parseJsonBoolean_649(sourceText_890, i_891, out_892) {
+  let return_893;
+  let t_894;
+  fn_895: {
+    let ch0_896;
+    if (sourceText_890.length > i_891) {
+      t_894 = stringGet_645(sourceText_890, i_891);
+      ch0_896 = t_894;
+    } else {
+      ch0_896 = 0;
+    }
+    const end_897 = sourceText_890.length;
+    let keyword_898;
+    let n_899;
+    if (ch0_896 === 102) {
+      keyword_898 = "false";
+      n_899 = 5;
+    } else if (ch0_896 === 116) {
+      keyword_898 = "true";
+      n_899 = 4;
+    } else {
+      keyword_898 = null;
+      n_899 = 0;
+    }
+    if (!(keyword_898 == null)) {
+      const keyword_900 = keyword_898;
+      if (stringHasAtLeast_817(sourceText_890, i_891, end_897, n_899)) {
+        const after_901 = afterSubstring_880(sourceText_890, i_891, keyword_900);
+        if (after_901 >= 0) {
+          return_893 = requireStringIndex__852(after_901);
+          out_892.booleanValue(n_899 === 4);
+          break fn_895;
+        }
+      }
+    }
+    expectedTokenError_644(sourceText_890, i_891, out_892, "`false` or `true`");
+    return_893 = -1;
+  }
+  return return_893;
+}
+/**
+ * @param {string} sourceText_902
+ * @param {globalThis.number} i_903
+ * @param {JsonProducer} out_904
+ * @returns {globalThis.number}
+ */
+function parseJsonNull_650(sourceText_902, i_903, out_904) {
+  let return_905;
+  fn_906: {
+    const after_907 = afterSubstring_880(sourceText_902, i_903, "null");
+    if (after_907 >= 0) {
+      return_905 = requireStringIndex__852(after_907);
+      out_904.nullValue();
+      break fn_906;
+    }
+    expectedTokenError_644(sourceText_902, i_903, out_904, "`null`");
+    return_905 = -1;
+  }
+  return return_905;
+}
+/**
+ * @param {string} sourceText_908
+ * @param {globalThis.number} i_909
+ * @param {JsonProducer} out_910
+ * @returns {globalThis.number}
+ */
+function parseJsonNumber_651(sourceText_908, i_909, out_910) {
+  let return_911;
+  let t_912;
+  let t_913;
+  let t_914;
+  let t_915;
+  let t_916;
+  let t_917;
+  let t_918;
+  let t_919;
+  let t_920;
+  let t_921;
+  let t_922;
+  let t_923;
+  let t_924;
+  let t_925;
+  let t_926;
+  let t_927;
+  let t_928;
+  let t_929;
+  let t_930;
+  let t_931;
+  let t_932;
+  let t_933;
+  let t_934;
+  let t_935;
+  let t_936;
+  let t_937;
+  let t_938;
+  let t_939;
+  let t_940;
+  let t_941;
+  let t_942;
+  let t_943;
+  let t_944;
+  let t_945;
+  let t_946;
+  let t_947;
+  let t_948;
+  let t_949;
+  fn_950: {
+    try {
+      let isNegative_951 = false;
+      const startOfNumber_952 = i_909;
+      if (sourceText_908.length > i_909) {
+        t_912 = stringGet_645(sourceText_908, i_909);
+        t_925 = t_912 === 45;
+      } else {
+        t_925 = false;
+      }
+      if (t_925) {
+        isNegative_951 = true;
+        t_913 = stringNext_746(sourceText_908, i_909);
+        i_909 = t_913;
+      }
+      let digit0_953;
+      if (sourceText_908.length > i_909) {
+        t_914 = stringGet_645(sourceText_908, i_909);
+        digit0_953 = t_914;
+      } else {
+        digit0_953 = -1;
+      }
+      if (digit0_953 < 48) {
+        t_926 = true;
+      } else {
+        t_926 = 57 < digit0_953;
+      }
+      if (t_926) {
+        let error_954;
+        if (! isNegative_951) {
+          t_927 = digit0_953 !== 46;
+        } else {
+          t_927 = false;
+        }
+        if (t_927) {
+          error_954 = "JSON value";
+        } else {
+          error_954 = "digit";
+        }
+        expectedTokenError_644(sourceText_908, i_909, out_910, error_954);
+        return_911 = -1;
+        break fn_950;
+      }
+      t_915 = stringNext_746(sourceText_908, i_909);
+      i_909 = t_915;
+      let nDigits_955 = 1;
+      try {
+        t_928 = digit0_953 - 48;
+        t_929 = t_928;
+      } catch {
+        t_916 = panic_586();
+        t_929 = t_916;
+      }
+      let tentativeValue_956 = t_929;
+      if (48 !== digit0_953) {
+        while (true) {
+          if (!(sourceText_908.length > i_909)) {
+            break;
+          }
+          const possibleDigit_957 = stringGet_645(sourceText_908, i_909);
+          if (48 <= possibleDigit_957) {
+            t_930 = possibleDigit_957 <= 57;
+          } else {
+            t_930 = false;
+          }
+          if (t_930) {
+            t_917 = stringNext_746(sourceText_908, i_909);
+            i_909 = t_917;
+            nDigits_955 = nDigits_955 + 1;
+            t_932 = tentativeValue_956 * 10.0;
+            t_931 = possibleDigit_957 - 48;
+            tentativeValue_956 = t_932 + t_931;
+          } else {
+            break;
+          }
+        }
+      }
+      let nDigitsAfterPoint_958 = 0;
+      if (sourceText_908.length > i_909) {
+        t_918 = stringGet_645(sourceText_908, i_909);
+        t_933 = 46 === t_918;
+      } else {
+        t_933 = false;
+      }
+      if (t_933) {
+        t_919 = stringNext_746(sourceText_908, i_909);
+        i_909 = t_919;
+        const afterPoint_959 = i_909;
+        while (true) {
+          if (!(sourceText_908.length > i_909)) {
+            break;
+          }
+          const possibleDigit_960 = stringGet_645(sourceText_908, i_909);
+          if (48 <= possibleDigit_960) {
+            t_934 = possibleDigit_960 <= 57;
+          } else {
+            t_934 = false;
+          }
+          if (t_934) {
+            t_920 = stringNext_746(sourceText_908, i_909);
+            i_909 = t_920;
+            nDigits_955 = nDigits_955 + 1;
+            nDigitsAfterPoint_958 = nDigitsAfterPoint_958 + 1;
+            t_936 = tentativeValue_956 * 10.0;
+            t_935 = possibleDigit_960 - 48;
+            tentativeValue_956 = t_936 + t_935;
+          } else {
+            break;
+          }
+        }
+        if (i_909 === afterPoint_959) {
+          expectedTokenError_644(sourceText_908, i_909, out_910, "digit");
+          return_911 = -1;
+          break fn_950;
+        }
+      }
+      let nExponentDigits_961 = 0;
+      if (sourceText_908.length > i_909) {
+        t_937 = stringGet_645(sourceText_908, i_909) | 32;
+        t_938 = 101 === t_937;
+      } else {
+        t_938 = false;
+      }
+      if (t_938) {
+        t_921 = stringNext_746(sourceText_908, i_909);
+        i_909 = t_921;
+        if (!(sourceText_908.length > i_909)) {
+          expectedTokenError_644(sourceText_908, i_909, out_910, "sign or digit");
+          return_911 = -1;
+          break fn_950;
+        }
+        const afterE_962 = stringGet_645(sourceText_908, i_909);
+        if (afterE_962 === 43) {
+          t_939 = true;
+        } else {
+          t_939 = afterE_962 === 45;
+        }
+        if (t_939) {
+          t_922 = stringNext_746(sourceText_908, i_909);
+          i_909 = t_922;
+        }
+        while (true) {
+          if (!(sourceText_908.length > i_909)) {
+            break;
+          }
+          const possibleDigit_963 = stringGet_645(sourceText_908, i_909);
+          if (48 <= possibleDigit_963) {
+            t_940 = possibleDigit_963 <= 57;
+          } else {
+            t_940 = false;
+          }
+          if (t_940) {
+            t_923 = stringNext_746(sourceText_908, i_909);
+            i_909 = t_923;
+            nExponentDigits_961 = nExponentDigits_961 + 1;
+          } else {
+            break;
+          }
+        }
+        if (nExponentDigits_961 === 0) {
+          expectedTokenError_644(sourceText_908, i_909, out_910, "exponent digit");
+          return_911 = -1;
+          break fn_950;
+        }
+      }
+      const afterExponent_964 = i_909;
+      if (nExponentDigits_961 === 0) {
+        t_941 = nDigitsAfterPoint_958 === 0;
+      } else {
+        t_941 = false;
+      }
+      if (t_941) {
+        let value_965;
+        if (isNegative_951) {
+          value_965 = - tentativeValue_956;
+        } else {
+          value_965 = tentativeValue_956;
+        }
+        if (nDigits_955 <= 10) {
+          if (cmpFloat__966(-2.147483648E9, value_965) <= 0) {
+            t_942 = cmpFloat__966(value_965, 2.147483647E9) <= 0;
+          } else {
+            t_942 = false;
+          }
+          t_943 = t_942;
+        } else {
+          t_943 = false;
+        }
+        if (t_943) {
+          try {
+            t_944 = float64ToInt_475(value_965);
+            t_945 = t_944;
+          } catch {
+            t_924 = panic_586();
+            t_945 = t_924;
+          }
+          out_910.intValue(t_945);
+          return_911 = i_909;
+          break fn_950;
+        }
+      }
+      const numericTokenString_967 = sourceText_908.substring(startOfNumber_952, i_909);
+      let doubleValue_968 = NaN;
+      if (nExponentDigits_961 !== 0) {
+        t_946 = true;
+      } else {
+        t_946 = nDigitsAfterPoint_958 !== 0;
+      }
+      if (t_946) {
+        try {
+          t_947 = stringToFloat64_488(numericTokenString_967);
+          doubleValue_968 = t_947;
+        } catch {
+        }
+      }
+      if (cmpFloat__966(doubleValue_968, -Infinity) !== 0) {
+        if (cmpFloat__966(doubleValue_968, Infinity) !== 0) {
+          t_948 = cmpFloat__966(doubleValue_968, NaN) !== 0;
+        } else {
+          t_948 = false;
+        }
+        t_949 = t_948;
+      } else {
+        t_949 = false;
+      }
+      if (t_949) {
+        out_910.float64Value(doubleValue_968);
+      } else {
+        out_910.numericTokenValue(numericTokenString_967);
+      }
+      return_911 = i_909;
+    } catch {
+      return_911 = panic_586();
+    }
+  }
+  return return_911;
+}
+/**
+ * @param {string} sourceText_969
+ * @param {JsonProducer} out_970
+ */
+export function parseJsonToProducer(sourceText_969, out_970) {
+  let t_971;
+  let t_972;
+  let t_973;
+  let t_974;
+  let t_975;
+  let t_976;
+  let i_977 = 0;
+  const afterValue_978 = parseJsonValue_634(sourceText_969, i_977, out_970);
+  if (afterValue_978 >= 0) {
+    t_976 = requireStringIndex__852(afterValue_978);
+    t_971 = skipJsonSpaces_643(sourceText_969, t_976);
+    i_977 = t_971;
+    if (sourceText_969.length > i_977) {
+      t_972 = out_970.parseErrorReceiver;
+      t_975 = !(t_972 == null);
+    } else {
+      t_975 = false;
+    }
+    if (t_975) {
+      t_973 = sourceText_969.length;
+      t_974 = sourceText_969.substring(i_977, t_973);
+      storeJsonError_747(out_970, "Extraneous JSON `" + t_974 + "`");
+    }
+  }
+  return;
+};
+/**
+ * @param {string} sourceText_979
+ * @returns {JsonSyntaxTree}
+ */
+export function parseJson(sourceText_979) {
+  const p_980 = new JsonSyntaxTreeProducer();
+  parseJsonToProducer(sourceText_979, p_980);
+  return p_980.toJsonSyntaxTree();
+};
+/** @returns {JsonAdapter<boolean>} */
+export function booleanJsonAdapter() {
+  return new BooleanJsonAdapter_659();
+};
+/** @returns {JsonAdapter<number>} */
+export function float64JsonAdapter() {
+  return new Float64JsonAdapter_667();
+};
+/** @returns {JsonAdapter<number>} */
+export function intJsonAdapter() {
+  return new IntJsonAdapter_675();
+};
+/** @returns {JsonAdapter<string>} */
+export function stringJsonAdapter() {
+  return new StringJsonAdapter_683();
+};
+/**
+ * @template {unknown} T_982
+ * @param {JsonAdapter<T_982>} adapterForT_981
+ * @returns {JsonAdapter<Array<T_982>>}
+ */
+export function listJsonAdapter(adapterForT_981) {
+  return new ListJsonAdapter_691(adapterForT_981);
+};