@temperlang/std 0.2.1 → 0.4.0

package/json.js

@@ -0,0 +1,2033 @@
+const {
+  trunc: trunc__711
+} = globalThis.Math;
+import {
+  type as type__383, requireInstanceOf as requireInstanceOf__570, requireStringIndex as requireStringIndex__836, cmpFloat as cmpFloat__948, mappedGetOr as mappedGetOr_411, listedGet as listedGet_413, mappedForEach as mappedForEach_426, float64ToString as float64ToString_463, float64ToInt as float64ToInt_465, stringToInt as stringToInt_477, stringToFloat64 as stringToFloat64_478, listBuilderAdd as listBuilderAdd_490, listedGetOr as listedGetOr_494, listBuilderSet as listBuilderSet_502, listBuilderRemoveLast as listBuilderRemoveLast_507, mapBuilderConstructor as mapBuilderConstructor_564, mappedGet as mappedGet_575, mapBuilderSet as mapBuilderSet_576, listBuilderToList as listBuilderToList_582, mappedToMap as mappedToMap_583, stringGet as stringGet_628, stringNext as stringNext_731, stringHasAtLeast as stringHasAtLeast_805, stringBuilderAppendCodePoint as stringBuilderAppendCodePoint_810
+} from "@temperlang/core";
+export class InterchangeContext extends type__383() {
+};
+export class NullInterchangeContext extends type__383(InterchangeContext) {
+  /**
+   * @param {string} headerName_385
+   * @returns {string | null}
+   */
+  getHeader(headerName_385) {
+    return null;
+  }
+  /** @type {NullInterchangeContext} */
+  static #instance_386 = new NullInterchangeContext();
+  /** @returns {NullInterchangeContext} */
+  static get instance() {
+    return this.#instance_386;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+};
+export class JsonProducer extends type__383() {
+  startObject() {
+    null;
+    return;
+  }
+  endObject() {
+    null;
+    return;
+  }
+  /** @param {string} key_390 */
+  objectKey(key_390) {
+    null;
+    return;
+  }
+  startArray() {
+    null;
+    return;
+  }
+  endArray() {
+    null;
+    return;
+  }
+  nullValue() {
+    null;
+    return;
+  }
+  /** @param {boolean} x_395 */
+  booleanValue(x_395) {
+    null;
+    return;
+  }
+  /** @param {number} x_397 */
+  intValue(x_397) {
+    null;
+    return;
+  }
+  /** @param {number} x_399 */
+  float64Value(x_399) {
+    null;
+    return;
+  }
+  /** @param {string} x_401 */
+  numericTokenValue(x_401) {
+    null;
+    return;
+  }
+  /** @param {string} x_403 */
+  stringValue(x_403) {
+    null;
+    return;
+  }
+};
+export class JsonSyntaxTree extends type__383() {
+  /** @param {JsonProducer} p_405 */
+  produce(p_405) {
+    null;
+    return;
+  }
+};
+export class JsonObject extends type__383(JsonSyntaxTree) {
+  /** @type {Map<string, Array<JsonSyntaxTree>>} */
+  #properties_406;
+  /**
+   * @param {string} propertyKey_408
+   * @returns {JsonSyntaxTree | null}
+   */
+  propertyValueOrNull(propertyKey_408) {
+    let return_409;
+    const treeList_410 = mappedGetOr_411(this.#properties_406, propertyKey_408, Object.freeze([]));
+    const lastIndex_412 = treeList_410.length - 1;
+    if (lastIndex_412 >= 0) {
+      return_409 = listedGet_413(treeList_410, lastIndex_412);
+    } else {
+      return_409 = null;
+    }
+    return return_409;
+  }
+  /**
+   * @param {string} propertyKey_415
+   * @returns {JsonSyntaxTree}
+   */
+  propertyValueOrBubble(propertyKey_415) {
+    let return_416;
+    let t_417;
+    t_417 = this.propertyValueOrNull(propertyKey_415);
+    const t_418 = t_417;
+    if (t_418 == null) {
+      throw Error();
+    } else {
+      return_416 = t_418;
+    }
+    return return_416;
+  }
+  /** @param {JsonProducer} p_420 */
+  produce(p_420) {
+    p_420.startObject();
+    function fn_421(k_422, vs_423) {
+      function fn_424(v_425) {
+        p_420.objectKey(k_422);
+        v_425.produce(p_420);
+        return;
+      }
+      vs_423.forEach(fn_424);
+      return;
+    }
+    mappedForEach_426(this.#properties_406, fn_421);
+    p_420.endObject();
+    return;
+  }
+  /** @param {Map<string, Array<JsonSyntaxTree>>} properties_427 */
+  constructor(properties_427) {
+    super ();
+    this.#properties_406 = properties_427;
+    return;
+  }
+  /** @returns {Map<string, Array<JsonSyntaxTree>>} */
+  get properties() {
+    return this.#properties_406;
+  }
+};
+export class JsonArray extends type__383(JsonSyntaxTree) {
+  /** @type {Array<JsonSyntaxTree>} */
+  #elements_429;
+  /** @param {JsonProducer} p_431 */
+  produce(p_431) {
+    p_431.startArray();
+    function fn_432(v_433) {
+      v_433.produce(p_431);
+      return;
+    }
+    this.#elements_429.forEach(fn_432);
+    p_431.endArray();
+    return;
+  }
+  /** @param {Array<JsonSyntaxTree>} elements_434 */
+  constructor(elements_434) {
+    super ();
+    this.#elements_429 = elements_434;
+    return;
+  }
+  /** @returns {Array<JsonSyntaxTree>} */
+  get elements() {
+    return this.#elements_429;
+  }
+};
+export class JsonBoolean extends type__383(JsonSyntaxTree) {
+  /** @type {boolean} */
+  #content_436;
+  /** @param {JsonProducer} p_438 */
+  produce(p_438) {
+    p_438.booleanValue(this.#content_436);
+    return;
+  }
+  /** @param {boolean} content_439 */
+  constructor(content_439) {
+    super ();
+    this.#content_436 = content_439;
+    return;
+  }
+  /** @returns {boolean} */
+  get content() {
+    return this.#content_436;
+  }
+};
+export class JsonNull extends type__383(JsonSyntaxTree) {
+  /** @param {JsonProducer} p_442 */
+  produce(p_442) {
+    p_442.nullValue();
+    return;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+};
+export class JsonString extends type__383(JsonSyntaxTree) {
+  /** @type {string} */
+  #content_443;
+  /** @param {JsonProducer} p_445 */
+  produce(p_445) {
+    p_445.stringValue(this.#content_443);
+    return;
+  }
+  /** @param {string} content_446 */
+  constructor(content_446) {
+    super ();
+    this.#content_443 = content_446;
+    return;
+  }
+  /** @returns {string} */
+  get content() {
+    return this.#content_443;
+  }
+};
+export class JsonNumeric extends type__383(JsonSyntaxTree) {
+};
+export class JsonInt extends type__383(JsonNumeric) {
+  /** @type {number} */
+  #content_451;
+  /** @param {JsonProducer} p_453 */
+  produce(p_453) {
+    p_453.intValue(this.#content_451);
+    return;
+  }
+  /** @returns {string} */
+  asJsonNumericToken() {
+    return this.#content_451.toString();
+  }
+  /** @returns {number} */
+  asInt() {
+    return this.#content_451;
+  }
+  /** @returns {number} */
+  asFloat64() {
+    return this.#content_451;
+  }
+  /** @param {number} content_457 */
+  constructor(content_457) {
+    super ();
+    this.#content_451 = content_457;
+    return;
+  }
+  /** @returns {number} */
+  get content() {
+    return this.#content_451;
+  }
+};
+export class JsonFloat64 extends type__383(JsonNumeric) {
+  /** @type {number} */
+  #content_459;
+  /** @param {JsonProducer} p_461 */
+  produce(p_461) {
+    p_461.float64Value(this.#content_459);
+    return;
+  }
+  /** @returns {string} */
+  asJsonNumericToken() {
+    return float64ToString_463(this.#content_459);
+  }
+  /** @returns {number} */
+  asInt() {
+    return float64ToInt_465(this.#content_459);
+  }
+  /** @returns {number} */
+  asFloat64() {
+    return this.#content_459;
+  }
+  /** @param {number} content_467 */
+  constructor(content_467) {
+    super ();
+    this.#content_459 = content_467;
+    return;
+  }
+  /** @returns {number} */
+  get content() {
+    return this.#content_459;
+  }
+};
+export class JsonNumericToken extends type__383(JsonNumeric) {
+  /** @type {string} */
+  #content_469;
+  /** @param {JsonProducer} p_471 */
+  produce(p_471) {
+    p_471.numericTokenValue(this.#content_469);
+    return;
+  }
+  /** @returns {string} */
+  asJsonNumericToken() {
+    return this.#content_469;
+  }
+  /** @returns {number} */
+  asInt() {
+    let return_474;
+    let t_475;
+    let t_476;
+    try {
+      t_475 = stringToInt_477(this.#content_469);
+      return_474 = t_475;
+    } catch {
+      t_476 = stringToFloat64_478(this.#content_469);
+      return_474 = float64ToInt_465(t_476);
+    }
+    return return_474;
+  }
+  /** @returns {number} */
+  asFloat64() {
+    return stringToFloat64_478(this.#content_469);
+  }
+  /** @param {string} content_480 */
+  constructor(content_480) {
+    super ();
+    this.#content_469 = content_480;
+    return;
+  }
+  /** @returns {string} */
+  get content() {
+    return this.#content_469;
+  }
+};
+export class JsonTextProducer extends type__383(JsonProducer) {
+  /** @type {InterchangeContext} */
+  #interchangeContext_482;
+  /** @type {globalThis.Array<string>} */
+  #buffer_483;
+  /** @type {Array<number>} */
+  #stack_484;
+  /** @type {boolean} */
+  #wellFormed_485;
+  /** @param {InterchangeContext | null} [interchangeContext_486] */
+  constructor(interchangeContext_486) {
+    super ();
+    let interchangeContext_487;
+    if (interchangeContext_486 == null) {
+      interchangeContext_487 = NullInterchangeContext.instance;
+    } else {
+      interchangeContext_487 = interchangeContext_486;
+    }
+    this.#interchangeContext_482 = interchangeContext_487;
+    let t_488 = [""];
+    this.#buffer_483 = t_488;
+    let t_489 = [];
+    this.#stack_484 = t_489;
+    listBuilderAdd_490(this.#stack_484, 5);
+    this.#wellFormed_485 = true;
+    return;
+  }
+  /** @returns {number} */
+  #state_492() {
+    let t_493 = this.#stack_484.length;
+    return listedGetOr_494(this.#stack_484, t_493 - 1, -1);
+  }
+  #beforeValue_496() {
+    let t_497;
+    let t_498;
+    let t_499;
+    let t_500;
+    const currentState_501 = this.#state_492();
+    if (currentState_501 === 3) {
+      t_497 = this.#stack_484.length;
+      listBuilderSet_502(this.#stack_484, t_497 - 1, 4);
+    } else if (currentState_501 === 4) {
+      this.#buffer_483[0] += ",";
+    } else if (currentState_501 === 1) {
+      t_498 = this.#stack_484.length;
+      listBuilderSet_502(this.#stack_484, t_498 - 1, 2);
+    } else if (currentState_501 === 5) {
+      t_499 = this.#stack_484.length;
+      listBuilderSet_502(this.#stack_484, t_499 - 1, 6);
+    } else {
+      if (currentState_501 === 6) {
+        t_500 = true;
+      } else {
+        t_500 = currentState_501 === 2;
+      }
+      if (t_500) {
+        this.#wellFormed_485 = false;
+      }
+    }
+    return;
+  }
+  startObject() {
+    this.#beforeValue_496();
+    this.#buffer_483[0] += "{";
+    listBuilderAdd_490(this.#stack_484, 0);
+    return;
+  }
+  endObject() {
+    let t_505;
+    this.#buffer_483[0] += "}";
+    const currentState_506 = this.#state_492();
+    if (0 === currentState_506) {
+      t_505 = true;
+    } else {
+      t_505 = 2 === currentState_506;
+    }
+    if (t_505) {
+      listBuilderRemoveLast_507(this.#stack_484);
+    } else {
+      this.#wellFormed_485 = false;
+    }
+    return;
+  }
+  /** @param {string} key_509 */
+  objectKey(key_509) {
+    let t_510;
+    const currentState_511 = this.#state_492();
+    if (!(currentState_511 === 0)) {
+      if (currentState_511 === 2) {
+        this.#buffer_483[0] += ",";
+      } else {
+        this.#wellFormed_485 = false;
+      }
+    }
+    encodeJsonString_512(key_509, this.#buffer_483);
+    this.#buffer_483[0] += ":";
+    if (currentState_511 >= 0) {
+      t_510 = this.#stack_484.length;
+      listBuilderSet_502(this.#stack_484, t_510 - 1, 1);
+    }
+    return;
+  }
+  startArray() {
+    this.#beforeValue_496();
+    this.#buffer_483[0] += "[";
+    listBuilderAdd_490(this.#stack_484, 3);
+    return;
+  }
+  endArray() {
+    let t_515;
+    this.#buffer_483[0] += "]";
+    const currentState_516 = this.#state_492();
+    if (3 === currentState_516) {
+      t_515 = true;
+    } else {
+      t_515 = 4 === currentState_516;
+    }
+    if (t_515) {
+      listBuilderRemoveLast_507(this.#stack_484);
+    } else {
+      this.#wellFormed_485 = false;
+    }
+    return;
+  }
+  nullValue() {
+    this.#beforeValue_496();
+    this.#buffer_483[0] += "null";
+    return;
+  }
+  /** @param {boolean} x_519 */
+  booleanValue(x_519) {
+    let t_520;
+    this.#beforeValue_496();
+    if (x_519) {
+      t_520 = "true";
+    } else {
+      t_520 = "false";
+    }
+    this.#buffer_483[0] += t_520;
+    return;
+  }
+  /** @param {number} x_522 */
+  intValue(x_522) {
+    this.#beforeValue_496();
+    let t_523 = x_522.toString();
+    this.#buffer_483[0] += t_523;
+    return;
+  }
+  /** @param {number} x_525 */
+  float64Value(x_525) {
+    this.#beforeValue_496();
+    let t_526 = float64ToString_463(x_525);
+    this.#buffer_483[0] += t_526;
+    return;
+  }
+  /** @param {string} x_528 */
+  numericTokenValue(x_528) {
+    this.#beforeValue_496();
+    this.#buffer_483[0] += x_528;
+    return;
+  }
+  /** @param {string} x_530 */
+  stringValue(x_530) {
+    this.#beforeValue_496();
+    encodeJsonString_512(x_530, this.#buffer_483);
+    return;
+  }
+  /** @returns {string} */
+  toJsonString() {
+    let return_532;
+    let t_533;
+    let t_534;
+    let t_535;
+    if (this.#wellFormed_485) {
+      if (this.#stack_484.length === 1) {
+        t_533 = this.#state_492();
+        t_534 = t_533 === 6;
+      } else {
+        t_534 = false;
+      }
+      t_535 = t_534;
+    } else {
+      t_535 = false;
+    }
+    if (t_535) {
+      return_532 = this.#buffer_483[0];
+    } else {
+      throw Error();
+    }
+    return return_532;
+  }
+  /** @returns {InterchangeContext} */
+  get interchangeContext() {
+    return this.#interchangeContext_482;
+  }
+};
+export class JsonParseErrorReceiver extends type__383() {
+  /** @param {string} explanation_538 */
+  explainJsonError(explanation_538) {
+    null;
+    return;
+  }
+};
+export class JsonSyntaxTreeProducer extends type__383(JsonProducer, JsonParseErrorReceiver) {
+  /** @type {Array<Array<JsonSyntaxTree>>} */
+  #stack_539;
+  /** @type {string | null} */
+  #error_540;
+  /** @returns {InterchangeContext} */
+  get interchangeContext() {
+    return NullInterchangeContext.instance;
+  }
+  constructor() {
+    super ();
+    let t_542 = [];
+    this.#stack_539 = t_542;
+    let t_543 = [];
+    listBuilderAdd_490(this.#stack_539, t_543);
+    this.#error_540 = null;
+    return;
+  }
+  /** @param {JsonSyntaxTree} v_546 */
+  #storeValue_545(v_546) {
+    let t_547;
+    let t_548;
+    if (! ! this.#stack_539.length) {
+      t_547 = this.#stack_539.length;
+      t_548 = listedGet_413(this.#stack_539, t_547 - 1);
+      listBuilderAdd_490(t_548, v_546);
+    }
+    return;
+  }
+  startObject() {
+    let t_550 = [];
+    listBuilderAdd_490(this.#stack_539, t_550);
+    return;
+  }
+  endObject() {
+    let return_552;
+    let t_553;
+    let t_554;
+    let t_555;
+    let t_556;
+    let t_557;
+    let t_558;
+    let t_559;
+    let t_560;
+    fn_561: {
+      if (! this.#stack_539.length) {
+        return_552 = void 0;
+        break fn_561;
+      }
+      let ls_562;
+      ls_562 = listBuilderRemoveLast_507(this.#stack_539);
+      const m_563 = mapBuilderConstructor_564();
+      let multis_565 = null;
+      let i_566 = 0;
+      let n_567 = ls_562.length & -2;
+      while (i_566 < n_567) {
+        const postfixReturn_568 = i_566;
+        i_566 = i_566 + 1;
+        t_555 = listedGet_413(ls_562, postfixReturn_568);
+        const keyTree_569 = t_555;
+        if (!(keyTree_569 instanceof JsonString)) {
+          break;
+        }
+        t_556 = requireInstanceOf__570(keyTree_569, JsonString);
+        const key_571 = t_556.content;
+        const postfixReturn_572 = i_566;
+        i_566 = i_566 + 1;
+        t_557 = listedGet_413(ls_562, postfixReturn_572);
+        const value_573 = t_557;
+        if (m_563.has(key_571)) {
+          if (multis_565 == null) {
+            t_553 = mapBuilderConstructor_564();
+            multis_565 = t_553;
+          }
+          if (multis_565 == null) {
+            throw Error();
+          } else {
+            t_558 = multis_565;
+          }
+          const mb_574 = t_558;
+          if (! mb_574.has(key_571)) {
+            t_559 = mappedGet_575(m_563, key_571);
+            mapBuilderSet_576(mb_574, key_571, t_559.slice());
+          }
+          t_560 = mappedGet_575(mb_574, key_571);
+          listBuilderAdd_490(t_560, value_573);
+        } else {
+          mapBuilderSet_576(m_563, key_571, Object.freeze([value_573]));
+        }
+      }
+      const multis_577 = multis_565;
+      if (!(multis_577 == null)) {
+        function fn_578(k_579, vs_580) {
+          let t_581 = listBuilderToList_582(vs_580);
+          mapBuilderSet_576(m_563, k_579, t_581);
+          return;
+        }
+        mappedForEach_426(multis_577, fn_578);
+      }
+      t_554 = new JsonObject(mappedToMap_583(m_563));
+      this.#storeValue_545(t_554);
+      return_552 = void 0;
+    }
+    return return_552;
+  }
+  /** @param {string} key_585 */
+  objectKey(key_585) {
+    let t_586 = new JsonString(key_585);
+    this.#storeValue_545(t_586);
+    return;
+  }
+  startArray() {
+    let t_588 = [];
+    listBuilderAdd_490(this.#stack_539, t_588);
+    return;
+  }
+  endArray() {
+    let return_590;
+    let t_591;
+    fn_592: {
+      if (! this.#stack_539.length) {
+        return_590 = void 0;
+        break fn_592;
+      }
+      let ls_593;
+      ls_593 = listBuilderRemoveLast_507(this.#stack_539);
+      t_591 = new JsonArray(listBuilderToList_582(ls_593));
+      this.#storeValue_545(t_591);
+      return_590 = void 0;
+    }
+    return return_590;
+  }
+  nullValue() {
+    let t_595 = new JsonNull();
+    this.#storeValue_545(t_595);
+    return;
+  }
+  /** @param {boolean} x_597 */
+  booleanValue(x_597) {
+    let t_598 = new JsonBoolean(x_597);
+    this.#storeValue_545(t_598);
+    return;
+  }
+  /** @param {number} x_600 */
+  intValue(x_600) {
+    let t_601 = new JsonInt(x_600);
+    this.#storeValue_545(t_601);
+    return;
+  }
+  /** @param {number} x_603 */
+  float64Value(x_603) {
+    let t_604 = new JsonFloat64(x_603);
+    this.#storeValue_545(t_604);
+    return;
+  }
+  /** @param {string} x_606 */
+  numericTokenValue(x_606) {
+    let t_607 = new JsonNumericToken(x_606);
+    this.#storeValue_545(t_607);
+    return;
+  }
+  /** @param {string} x_609 */
+  stringValue(x_609) {
+    let t_610 = new JsonString(x_609);
+    this.#storeValue_545(t_610);
+    return;
+  }
+  /** @returns {JsonSyntaxTree} */
+  toJsonSyntaxTree() {
+    let t_612;
+    if (this.#stack_539.length !== 1) {
+      t_612 = true;
+    } else {
+      t_612 = !(this.#error_540 == null);
+    }
+    if (t_612) {
+      throw Error();
+    }
+    let ls_613;
+    ls_613 = listedGet_413(this.#stack_539, 0);
+    if (ls_613.length !== 1) {
+      throw Error();
+    }
+    return listedGet_413(ls_613, 0);
+  }
+  /** @returns {string | null} */
+  get jsonError() {
+    return this.#error_540;
+  }
+  /** @param {string} error_616 */
+  explainJsonError(error_616) {
+    this.#error_540 = error_616;
+    return;
+  }
+};
+/**
+ * @param {string} sourceText_618
+ * @param {globalThis.number} i_619
+ * @param {JsonProducer} out_620
+ * @returns {globalThis.number}
+ */
+function parseJsonValue_617(sourceText_618, i_619, out_620) {
+  let return_621;
+  let t_622;
+  let t_623;
+  let t_624;
+  fn_625: {
+    t_622 = skipJsonSpaces_626(sourceText_618, i_619);
+    i_619 = t_622;
+    if (!(sourceText_618.length > i_619)) {
+      expectedTokenError_627(sourceText_618, i_619, out_620, "JSON value");
+      return_621 = -1;
+      break fn_625;
+    }
+    t_623 = stringGet_628(sourceText_618, i_619);
+    if (t_623 === 123) {
+      return_621 = parseJsonObject_629(sourceText_618, i_619, out_620);
+    } else if (t_623 === 91) {
+      return_621 = parseJsonArray_630(sourceText_618, i_619, out_620);
+    } else if (t_623 === 34) {
+      return_621 = parseJsonString_631(sourceText_618, i_619, out_620);
+    } else {
+      if (t_623 === 116) {
+        t_624 = true;
+      } else {
+        t_624 = t_623 === 102;
+      }
+      if (t_624) {
+        return_621 = parseJsonBoolean_632(sourceText_618, i_619, out_620);
+      } else if (t_623 === 110) {
+        return_621 = parseJsonNull_633(sourceText_618, i_619, out_620);
+      } else {
+        return_621 = parseJsonNumber_634(sourceText_618, i_619, out_620);
+      }
+    }
+  }
+  return return_621;
+}
+/** @template T_638 */
+export class JsonAdapter extends type__383() {
+  /**
+   * @param {T_638} x_636
+   * @param {JsonProducer} p_637
+   */
+  encodeToJson(x_636, p_637) {
+    null;
+    return;
+  }
+};
+class BooleanJsonAdapter_642 extends type__383(JsonAdapter) {
+  /**
+   * @param {boolean} x_644
+   * @param {JsonProducer} p_645
+   */
+  encodeToJson(x_644, p_645) {
+    p_645.booleanValue(x_644);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_647
+   * @param {InterchangeContext} ic_648
+   * @returns {boolean}
+   */
+  decodeFromJson(t_647, ic_648) {
+    let t_649;
+    t_649 = requireInstanceOf__570(t_647, JsonBoolean);
+    return t_649.content;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+class Float64JsonAdapter_650 extends type__383(JsonAdapter) {
+  /**
+   * @param {number} x_652
+   * @param {JsonProducer} p_653
+   */
+  encodeToJson(x_652, p_653) {
+    p_653.float64Value(x_652);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_655
+   * @param {InterchangeContext} ic_656
+   * @returns {number}
+   */
+  decodeFromJson(t_655, ic_656) {
+    let t_657;
+    t_657 = requireInstanceOf__570(t_655, JsonFloat64);
+    return t_657.content;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+class IntJsonAdapter_658 extends type__383(JsonAdapter) {
+  /**
+   * @param {number} x_660
+   * @param {JsonProducer} p_661
+   */
+  encodeToJson(x_660, p_661) {
+    p_661.intValue(x_660);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_663
+   * @param {InterchangeContext} ic_664
+   * @returns {number}
+   */
+  decodeFromJson(t_663, ic_664) {
+    let t_665;
+    t_665 = requireInstanceOf__570(t_663, JsonInt);
+    return t_665.content;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+class StringJsonAdapter_666 extends type__383(JsonAdapter) {
+  /**
+   * @param {string} x_668
+   * @param {JsonProducer} p_669
+   */
+  encodeToJson(x_668, p_669) {
+    p_669.stringValue(x_668);
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_671
+   * @param {InterchangeContext} ic_672
+   * @returns {string}
+   */
+  decodeFromJson(t_671, ic_672) {
+    let t_673;
+    t_673 = requireInstanceOf__570(t_671, JsonString);
+    return t_673.content;
+  }
+  constructor() {
+    super ();
+    return;
+  }
+}
+/** @template T_676 */
+class ListJsonAdapter_674 extends type__383(JsonAdapter) {
+  /** @type {JsonAdapter<T_676>} */
+  #adapterForT_675;
+  /**
+   * @param {Array<T_676>} x_678
+   * @param {JsonProducer} p_679
+   */
+  encodeToJson(x_678, p_679) {
+    const this682 = this;
+    p_679.startArray();
+    function fn_680(el_681) {
+      this682.#adapterForT_675.encodeToJson(el_681, p_679);
+      return;
+    }
+    x_678.forEach(fn_680);
+    p_679.endArray();
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_684
+   * @param {InterchangeContext} ic_685
+   * @returns {Array<T_676>}
+   */
+  decodeFromJson(t_684, ic_685) {
+    let t_686;
+    let t_687;
+    const b_688 = [];
+    let t_689;
+    t_689 = requireInstanceOf__570(t_684, JsonArray);
+    const elements_690 = t_689.elements;
+    const n_691 = elements_690.length;
+    let i_692 = 0;
+    while (i_692 < n_691) {
+      t_686 = listedGet_413(elements_690, i_692);
+      const el_693 = t_686;
+      i_692 = i_692 + 1;
+      t_687 = this.#adapterForT_675.decodeFromJson(el_693, ic_685);
+      listBuilderAdd_490(b_688, t_687);
+    }
+    return listBuilderToList_582(b_688);
+  }
+  /** @param {JsonAdapter<T_676>} adapterForT_694 */
+  constructor(adapterForT_694) {
+    super ();
+    this.#adapterForT_675 = adapterForT_694;
+    return;
+  }
+}
+/** @template T_696 */
+export class OrNullJsonAdapter extends type__383(JsonAdapter) {
+  /** @type {JsonAdapter<T_696>} */
+  #adapterForT_695;
+  /**
+   * @param {T_696 | null} x_698
+   * @param {JsonProducer} p_699
+   */
+  encodeToJson(x_698, p_699) {
+    if (x_698 == null) {
+      p_699.nullValue();
+    } else {
+      const x_700 = x_698;
+      this.#adapterForT_695.encodeToJson(x_700, p_699);
+    }
+    return;
+  }
+  /**
+   * @param {JsonSyntaxTree} t_702
+   * @param {InterchangeContext} ic_703
+   * @returns {T_696 | null}
+   */
+  decodeFromJson(t_702, ic_703) {
+    let return_704;
+    if (t_702 instanceof JsonNull) {
+      return_704 = null;
+    } else {
+      return_704 = this.#adapterForT_695.decodeFromJson(t_702, ic_703);
+    }
+    return return_704;
+  }
+  /** @param {JsonAdapter<T_696>} adapterForT_705 */
+  constructor(adapterForT_705) {
+    super ();
+    this.#adapterForT_695 = adapterForT_705;
+    return;
+  }
+};
+/** @type {Array<string>} */
+const hexDigits_706 = Object.freeze(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"]);
+/**
+ * @param {number} cp_708
+ * @param {globalThis.Array<string>} buffer_709
+ */
+function encodeHex4_707(cp_708, buffer_709) {
+  const b0_710 = trunc__711(cp_708 / 4096) & 15;
+  const b1_712 = trunc__711(cp_708 / 256) & 15;
+  const b2_713 = trunc__711(cp_708 / 16) & 15;
+  const b3_714 = cp_708 & 15;
+  let t_715;
+  t_715 = listedGet_413(hexDigits_706, b0_710);
+  buffer_709[0] += t_715;
+  let t_716;
+  t_716 = listedGet_413(hexDigits_706, b1_712);
+  buffer_709[0] += t_716;
+  let t_717;
+  t_717 = listedGet_413(hexDigits_706, b2_713);
+  buffer_709[0] += t_717;
+  let t_718;
+  t_718 = listedGet_413(hexDigits_706, b3_714);
+  buffer_709[0] += t_718;
+  return;
+}
+/**
+ * @param {string} x_719
+ * @param {globalThis.Array<string>} buffer_720
+ */
+function encodeJsonString_512(x_719, buffer_720) {
+  let t_721;
+  let t_722;
+  let t_723;
+  let t_724;
+  let t_725;
+  buffer_720[0] += "\u0022";
+  let i_726 = 0;
+  let emitted_727 = i_726;
+  while (true) {
+    if (!(x_719.length > i_726)) {
+      break;
+    }
+    t_721 = stringGet_628(x_719, i_726);
+    const cp_728 = t_721;
+    if (cp_728 === 8) {
+      t_725 = "\\b";
+    } else if (cp_728 === 9) {
+      t_725 = "\\t";
+    } else if (cp_728 === 10) {
+      t_725 = "\\n";
+    } else if (cp_728 === 12) {
+      t_725 = "\\f";
+    } else if (cp_728 === 13) {
+      t_725 = "\\r";
+    } else if (cp_728 === 34) {
+      t_725 = "\\\u0022";
+    } else if (cp_728 === 92) {
+      t_725 = "\\\\";
+    } else {
+      if (cp_728 < 32) {
+        t_723 = true;
+      } else {
+        if (55296 <= cp_728) {
+          t_722 = cp_728 <= 57343;
+        } else {
+          t_722 = false;
+        }
+        t_723 = t_722;
+      }
+      if (t_723) {
+        t_724 = "\\u";
+      } else {
+        t_724 = "";
+      }
+      t_725 = t_724;
+    }
+    const replacement_729 = t_725;
+    const nextI_730 = stringNext_731(x_719, i_726);
+    if (replacement_729 !== "") {
+      buffer_720[0] += x_719.substring(emitted_727, i_726);
+      buffer_720[0] += replacement_729;
+      if (replacement_729 === "\\u") {
+        encodeHex4_707(cp_728, buffer_720);
+      }
+      emitted_727 = nextI_730;
+    }
+    i_726 = nextI_730;
+  }
+  buffer_720[0] += x_719.substring(emitted_727, i_726);
+  buffer_720[0] += "\u0022";
+  return;
+}
+/**
+ * @param {JsonProducer} out_733
+ * @param {string} explanation_734
+ */
+function storeJsonError_732(out_733, explanation_734) {
+  if (out_733 instanceof JsonParseErrorReceiver) {
+    let errorReceiver_735;
+    errorReceiver_735 = requireInstanceOf__570(out_733, JsonParseErrorReceiver);
+    errorReceiver_735.explainJsonError(explanation_734);
+  }
+  return;
+}
+/**
+ * @param {string} sourceText_736
+ * @param {globalThis.number} i_737
+ * @param {JsonProducer} out_738
+ * @param {string} shortExplanation_739
+ */
+function expectedTokenError_627(sourceText_736, i_737, out_738, shortExplanation_739) {
+  let t_740;
+  let t_741;
+  let gotten_742;
+  if (sourceText_736.length > i_737) {
+    t_740 = sourceText_736.length;
+    t_741 = sourceText_736.substring(i_737, t_740);
+    gotten_742 = "`" + t_741 + "`";
+  } else {
+    gotten_742 = "end-of-file";
+  }
+  storeJsonError_732(out_738, "Expected " + shortExplanation_739 + ", but got " + gotten_742);
+  return;
+}
+/**
+ * @param {string} sourceText_743
+ * @param {globalThis.number} i_744
+ * @returns {globalThis.number}
+ */
+function skipJsonSpaces_626(sourceText_743, i_744) {
+  let t_745;
+  let t_746;
+  let t_747;
+  let t_748;
+  let t_749;
+  while (true) {
+    if (!(sourceText_743.length > i_744)) {
+      break;
+    }
+    t_746 = stringGet_628(sourceText_743, i_744);
+    if (t_746 === 9) {
+      t_749 = true;
+    } else {
+      if (t_746 === 10) {
+        t_748 = true;
+      } else {
+        if (t_746 === 13) {
+          t_747 = true;
+        } else {
+          t_747 = t_746 === 32;
+        }
+        t_748 = t_747;
+      }
+      t_749 = t_748;
+    }
+    if (! t_749) {
+      break;
+    }
+    t_745 = stringNext_731(sourceText_743, i_744);
+    i_744 = t_745;
+  }
+  return i_744;
+}
+/**
+ * @param {string} sourceText_751
+ * @param {globalThis.number} start_752
+ * @param {globalThis.number} limit_753
+ * @returns {number}
+ */
+function decodeHexUnsigned_750(sourceText_751, start_752, limit_753) {
+  let return_754;
+  let t_755;
+  let t_756;
+  let t_757;
+  let t_758;
+  let t_759;
+  let t_760;
+  fn_761: {
+    let n_762 = 0;
+    let i_763 = start_752;
+    while (true) {
+      if (!(i_763 - limit_753 < 0)) {
+        break;
+      }
+      t_756 = stringGet_628(sourceText_751, i_763);
+      const cp_764 = t_756;
+      if (48 <= cp_764) {
+        t_757 = cp_764 <= 48;
+      } else {
+        t_757 = false;
+      }
+      if (t_757) {
+        t_760 = cp_764 - 48;
+      } else {
+        if (65 <= cp_764) {
+          t_758 = cp_764 <= 70;
+        } else {
+          t_758 = false;
+        }
+        if (t_758) {
+          t_760 = cp_764 - 65 + 10;
+        } else {
+          if (97 <= cp_764) {
+            t_759 = cp_764 <= 102;
+          } else {
+            t_759 = false;
+          }
+          if (t_759) {
+            t_760 = cp_764 - 97 + 10;
+          } else {
+            return_754 = -1;
+            break fn_761;
+          }
+        }
+      }
+      const digit_765 = t_760;
+      n_762 = n_762 * 16 + digit_765;
+      t_755 = stringNext_731(sourceText_751, i_763);
+      i_763 = t_755;
+    }
+    return_754 = n_762;
+  }
+  return return_754;
+}
+/**
+ * @param {string} sourceText_766
+ * @param {globalThis.number} i_767
+ * @param {JsonProducer} out_768
+ * @returns {globalThis.number}
+ */
+function parseJsonString_631(sourceText_766, i_767, out_768) {
+  let return_769;
+  let t_770;
+  let t_771;
+  let t_772;
+  let t_773;
+  let t_774;
+  let t_775;
+  let t_776;
+  let t_777;
+  let t_778;
+  let t_779;
+  let t_780;
+  let t_781;
+  let t_782;
+  let t_783;
+  let t_784;
+  let t_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;
+  fn_796: {
+    if (!(sourceText_766.length > i_767)) {
+      t_781 = true;
+    } else {
+      t_780 = stringGet_628(sourceText_766, i_767);
+      t_781 = t_780 !== 34;
+    }
+    if (t_781) {
+      expectedTokenError_627(sourceText_766, i_767, out_768, "\u0022");
+      return_769 = -1;
+      break fn_796;
+    }
+    t_770 = stringNext_731(sourceText_766, i_767);
+    i_767 = t_770;
+    const sb_797 = [""];
+    let leadSurrogate_798 = -1;
+    let consumed_799 = i_767;
+    while (true) {
+      if (!(sourceText_766.length > i_767)) {
+        break;
+      }
+      t_782 = stringGet_628(sourceText_766, i_767);
+      const cp_800 = t_782;
+      if (cp_800 === 34) {
+        break;
+      }
+      t_771 = stringNext_731(sourceText_766, i_767);
+      let iNext_801 = t_771;
+      const end_802 = sourceText_766.length;
+      let needToFlush_803 = false;
+      if (cp_800 !== 92) {
+        t_789 = cp_800;
+      } else {
+        needToFlush_803 = true;
+        if (!(sourceText_766.length > iNext_801)) {
+          expectedTokenError_627(sourceText_766, iNext_801, out_768, "escape sequence");
+          return_769 = -1;
+          break fn_796;
+        }
+        t_783 = stringGet_628(sourceText_766, iNext_801);
+        const esc0_804 = t_783;
+        t_772 = stringNext_731(sourceText_766, iNext_801);
+        iNext_801 = t_772;
+        if (esc0_804 === 34) {
+          t_785 = true;
+        } else {
+          if (esc0_804 === 92) {
+            t_784 = true;
+          } else {
+            t_784 = esc0_804 === 47;
+          }
+          t_785 = t_784;
+        }
+        if (t_785) {
+          t_788 = esc0_804;
+        } else if (esc0_804 === 98) {
+          t_788 = 8;
+        } else if (esc0_804 === 102) {
+          t_788 = 12;
+        } else if (esc0_804 === 110) {
+          t_788 = 10;
+        } else if (esc0_804 === 114) {
+          t_788 = 13;
+        } else if (esc0_804 === 116) {
+          t_788 = 9;
+        } else if (esc0_804 === 117) {
+          if (stringHasAtLeast_805(sourceText_766, iNext_801, end_802, 4)) {
+            const startHex_806 = iNext_801;
+            t_773 = stringNext_731(sourceText_766, iNext_801);
+            iNext_801 = t_773;
+            t_774 = stringNext_731(sourceText_766, iNext_801);
+            iNext_801 = t_774;
+            t_775 = stringNext_731(sourceText_766, iNext_801);
+            iNext_801 = t_775;
+            t_776 = stringNext_731(sourceText_766, iNext_801);
+            iNext_801 = t_776;
+            t_777 = decodeHexUnsigned_750(sourceText_766, startHex_806, iNext_801);
+            t_786 = t_777;
+          } else {
+            t_786 = -1;
+          }
+          const hex_807 = t_786;
+          if (hex_807 < 0) {
+            expectedTokenError_627(sourceText_766, iNext_801, out_768, "four hex digits");
+            return_769 = -1;
+            break fn_796;
+          }
+          t_787 = hex_807;
+          t_788 = t_787;
+        } else {
+          expectedTokenError_627(sourceText_766, iNext_801, out_768, "escape sequence");
+          return_769 = -1;
+          break fn_796;
+        }
+        t_789 = t_788;
+      }
+      let decodedCp_808 = t_789;
+      if (leadSurrogate_798 >= 0) {
+        needToFlush_803 = true;
+        const lead_809 = leadSurrogate_798;
+        if (56320 <= decodedCp_808) {
+          t_790 = decodedCp_808 <= 57343;
+        } else {
+          t_790 = false;
+        }
+        if (t_790) {
+          leadSurrogate_798 = -1;
+          t_791 = (lead_809 - 55296) * 1024 | decodedCp_808 - 56320;
+          decodedCp_808 = 65536 + t_791;
+        }
+      } else {
+        if (55296 <= decodedCp_808) {
+          t_792 = decodedCp_808 <= 56319;
+        } else {
+          t_792 = false;
+        }
+        if (t_792) {
+          needToFlush_803 = true;
+        }
+      }
+      if (needToFlush_803) {
+        sb_797[0] += sourceText_766.substring(consumed_799, i_767);
+        if (leadSurrogate_798 >= 0) {
+          stringBuilderAppendCodePoint_810(sb_797, leadSurrogate_798);
+        }
+        if (55296 <= decodedCp_808) {
+          t_793 = decodedCp_808 <= 56319;
+        } else {
+          t_793 = false;
+        }
+        if (t_793) {
+          leadSurrogate_798 = decodedCp_808;
+        } else {
+          leadSurrogate_798 = -1;
+          stringBuilderAppendCodePoint_810(sb_797, decodedCp_808);
+        }
+        consumed_799 = iNext_801;
+      }
+      i_767 = iNext_801;
+    }
+    if (!(sourceText_766.length > i_767)) {
+      t_795 = true;
+    } else {
+      t_794 = stringGet_628(sourceText_766, i_767);
+      t_795 = t_794 !== 34;
+    }
+    if (t_795) {
+      expectedTokenError_627(sourceText_766, i_767, out_768, "\u0022");
+      return_769 = -1;
+    } else {
+      if (leadSurrogate_798 >= 0) {
+        stringBuilderAppendCodePoint_810(sb_797, leadSurrogate_798);
+      } else {
+        sb_797[0] += sourceText_766.substring(consumed_799, i_767);
+      }
+      t_778 = stringNext_731(sourceText_766, i_767);
+      i_767 = t_778;
+      t_779 = sb_797[0];
+      out_768.stringValue(t_779);
+      return_769 = i_767;
+    }
+  }
+  return return_769;
+}
+/**
+ * @param {string} sourceText_811
+ * @param {globalThis.number} i_812
+ * @param {JsonProducer} out_813
+ * @returns {globalThis.number}
+ */
+function parseJsonObject_629(sourceText_811, i_812, out_813) {
+  let return_814;
+  let t_815;
+  let t_816;
+  let t_817;
+  let t_818;
+  let t_819;
+  let t_820;
+  let t_821;
+  let t_822;
+  let t_823;
+  let t_824;
+  let t_825;
+  let t_826;
+  let t_827;
+  let t_828;
+  let t_829;
+  let t_830;
+  let t_831;
+  let t_832;
+  let t_833;
+  fn_834: {
+    if (!(sourceText_811.length > i_812)) {
+      t_823 = true;
+    } else {
+      t_822 = stringGet_628(sourceText_811, i_812);
+      t_823 = t_822 !== 123;
+    }
+    if (t_823) {
+      expectedTokenError_627(sourceText_811, i_812, out_813, "'{'");
+      return_814 = -1;
+      break fn_834;
+    }
+    out_813.startObject();
+    t_815 = stringNext_731(sourceText_811, i_812);
+    t_816 = skipJsonSpaces_626(sourceText_811, t_815);
+    i_812 = t_816;
+    if (sourceText_811.length > i_812) {
+      t_824 = stringGet_628(sourceText_811, i_812);
+      t_825 = t_824 !== 125;
+    } else {
+      t_825 = false;
+    }
+    if (t_825) {
+      while (true) {
+        const afterKey_835 = parseJsonString_631(sourceText_811, i_812, out_813);
+        if (!(afterKey_835 >= 0)) {
+          return_814 = -1;
+          break fn_834;
+        }
+        t_826 = requireStringIndex__836(afterKey_835);
+        t_817 = skipJsonSpaces_626(sourceText_811, t_826);
+        i_812 = t_817;
+        if (sourceText_811.length > i_812) {
+          t_827 = stringGet_628(sourceText_811, i_812);
+          t_828 = t_827 === 58;
+        } else {
+          t_828 = false;
+        }
+        if (t_828) {
+          t_818 = stringNext_731(sourceText_811, i_812);
+          i_812 = t_818;
+          const afterPropertyValue_837 = parseJsonValue_617(sourceText_811, i_812, out_813);
+          if (!(afterPropertyValue_837 >= 0)) {
+            return_814 = -1;
+            break fn_834;
+          }
+          t_829 = requireStringIndex__836(afterPropertyValue_837);
+          i_812 = t_829;
+        } else {
+          expectedTokenError_627(sourceText_811, i_812, out_813, "':'");
+          return_814 = -1;
+          break fn_834;
+        }
+        t_819 = skipJsonSpaces_626(sourceText_811, i_812);
+        i_812 = t_819;
+        if (sourceText_811.length > i_812) {
+          t_830 = stringGet_628(sourceText_811, i_812);
+          t_831 = t_830 === 44;
+        } else {
+          t_831 = false;
+        }
+        if (t_831) {
+          t_820 = stringNext_731(sourceText_811, i_812);
+          t_821 = skipJsonSpaces_626(sourceText_811, t_820);
+          i_812 = t_821;
+        } else {
+          break;
+        }
+      }
+    }
+    if (sourceText_811.length > i_812) {
+      t_832 = stringGet_628(sourceText_811, i_812);
+      t_833 = t_832 === 125;
+    } else {
+      t_833 = false;
+    }
+    if (t_833) {
+      out_813.endObject();
+      return_814 = stringNext_731(sourceText_811, i_812);
+    } else {
+      expectedTokenError_627(sourceText_811, i_812, out_813, "'}'");
+      return_814 = -1;
+    }
+  }
+  return return_814;
+}
+/**
+ * @param {string} sourceText_838
+ * @param {globalThis.number} i_839
+ * @param {JsonProducer} out_840
+ * @returns {globalThis.number}
+ */
+function parseJsonArray_630(sourceText_838, i_839, out_840) {
+  let return_841;
+  let t_842;
+  let t_843;
+  let t_844;
+  let t_845;
+  let t_846;
+  let t_847;
+  let t_848;
+  let t_849;
+  let t_850;
+  let t_851;
+  let t_852;
+  let t_853;
+  let t_854;
+  let t_855;
+  fn_856: {
+    if (!(sourceText_838.length > i_839)) {
+      t_848 = true;
+    } else {
+      t_847 = stringGet_628(sourceText_838, i_839);
+      t_848 = t_847 !== 91;
+    }
+    if (t_848) {
+      expectedTokenError_627(sourceText_838, i_839, out_840, "'['");
+      return_841 = -1;
+      break fn_856;
+    }
+    out_840.startArray();
+    t_842 = stringNext_731(sourceText_838, i_839);
+    t_843 = skipJsonSpaces_626(sourceText_838, t_842);
+    i_839 = t_843;
+    if (sourceText_838.length > i_839) {
+      t_849 = stringGet_628(sourceText_838, i_839);
+      t_850 = t_849 !== 93;
+    } else {
+      t_850 = false;
+    }
+    if (t_850) {
+      while (true) {
+        const afterElementValue_857 = parseJsonValue_617(sourceText_838, i_839, out_840);
+        if (!(afterElementValue_857 >= 0)) {
+          return_841 = -1;
+          break fn_856;
+        }
+        t_851 = requireStringIndex__836(afterElementValue_857);
+        i_839 = t_851;
+        t_844 = skipJsonSpaces_626(sourceText_838, i_839);
+        i_839 = t_844;
+        if (sourceText_838.length > i_839) {
+          t_852 = stringGet_628(sourceText_838, i_839);
+          t_853 = t_852 === 44;
+        } else {
+          t_853 = false;
+        }
+        if (t_853) {
+          t_845 = stringNext_731(sourceText_838, i_839);
+          t_846 = skipJsonSpaces_626(sourceText_838, t_845);
+          i_839 = t_846;
+        } else {
+          break;
+        }
+      }
+    }
+    if (sourceText_838.length > i_839) {
+      t_854 = stringGet_628(sourceText_838, i_839);
+      t_855 = t_854 === 93;
+    } else {
+      t_855 = false;
+    }
+    if (t_855) {
+      out_840.endArray();
+      return_841 = stringNext_731(sourceText_838, i_839);
+    } else {
+      expectedTokenError_627(sourceText_838, i_839, out_840, "']'");
+      return_841 = -1;
+    }
+  }
+  return return_841;
+}
+/**
+ * @param {string} string_859
+ * @param {globalThis.number} inString_860
+ * @param {string} substring_861
+ * @returns {globalThis.number}
+ */
+function afterSubstring_858(string_859, inString_860, substring_861) {
+  let return_862;
+  let t_863;
+  let t_864;
+  let t_865;
+  let t_866;
+  fn_867: {
+    let i_868 = inString_860;
+    let j_869 = 0;
+    while (true) {
+      if (!(substring_861.length > j_869)) {
+        break;
+      }
+      if (!(string_859.length > i_868)) {
+        return_862 = -1;
+        break fn_867;
+      }
+      t_865 = stringGet_628(string_859, i_868);
+      t_866 = stringGet_628(substring_861, j_869);
+      if (t_865 !== t_866) {
+        return_862 = -1;
+        break fn_867;
+      }
+      t_863 = stringNext_731(string_859, i_868);
+      i_868 = t_863;
+      t_864 = stringNext_731(substring_861, j_869);
+      j_869 = t_864;
+    }
+    return_862 = i_868;
+  }
+  return return_862;
+}
+/**
+ * @param {string} sourceText_870
+ * @param {globalThis.number} i_871
+ * @param {JsonProducer} out_872
+ * @returns {globalThis.number}
+ */
+function parseJsonBoolean_632(sourceText_870, i_871, out_872) {
+  let return_873;
+  let t_874;
+  let t_875;
+  let t_876;
+  let t_877;
+  fn_878: {
+    let ch0_879;
+    if (sourceText_870.length > i_871) {
+      t_875 = stringGet_628(sourceText_870, i_871);
+      ch0_879 = t_875;
+    } else {
+      ch0_879 = 0;
+    }
+    const end_880 = sourceText_870.length;
+    let keyword_881;
+    let n_882;
+    if (ch0_879 === 102) {
+      keyword_881 = "false";
+      n_882 = 5;
+    } else if (ch0_879 === 116) {
+      keyword_881 = "true";
+      n_882 = 4;
+    } else {
+      keyword_881 = null;
+      n_882 = 0;
+    }
+    if (!(keyword_881 == null)) {
+      t_874 = stringHasAtLeast_805(sourceText_870, i_871, end_880, n_882);
+      t_876 = t_874;
+    } else {
+      t_876 = false;
+    }
+    if (t_876) {
+      if (keyword_881 == null) {
+        throw Error();
+      } else {
+        t_877 = keyword_881;
+      }
+      const after_883 = afterSubstring_858(sourceText_870, i_871, t_877);
+      if (after_883 >= 0) {
+        out_872.booleanValue(n_882 === 4);
+        return_873 = after_883;
+        break fn_878;
+      }
+    }
+    expectedTokenError_627(sourceText_870, i_871, out_872, "`false` or `true`");
+    return_873 = -1;
+  }
+  return return_873;
+}
+/**
+ * @param {string} sourceText_884
+ * @param {globalThis.number} i_885
+ * @param {JsonProducer} out_886
+ * @returns {globalThis.number}
+ */
+function parseJsonNull_633(sourceText_884, i_885, out_886) {
+  let return_887;
+  fn_888: {
+    const after_889 = afterSubstring_858(sourceText_884, i_885, "null");
+    if (after_889 >= 0) {
+      out_886.nullValue();
+      return_887 = requireStringIndex__836(after_889);
+      break fn_888;
+    }
+    expectedTokenError_627(sourceText_884, i_885, out_886, "`null`");
+    return_887 = -1;
+  }
+  return return_887;
+}
+/**
+ * @param {string} sourceText_890
+ * @param {globalThis.number} i_891
+ * @param {JsonProducer} out_892
+ * @returns {globalThis.number}
+ */
+function parseJsonNumber_634(sourceText_890, i_891, out_892) {
+  let return_893;
+  let t_894;
+  let t_895;
+  let t_896;
+  let t_897;
+  let t_898;
+  let t_899;
+  let t_900;
+  let t_901;
+  let t_902;
+  let t_903;
+  let t_904;
+  let t_905;
+  let t_906;
+  let t_907;
+  let t_908;
+  let t_909;
+  let t_910;
+  let t_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;
+  fn_932: {
+    let isNegative_933 = false;
+    const startOfNumber_934 = i_891;
+    if (sourceText_890.length > i_891) {
+      t_902 = stringGet_628(sourceText_890, i_891);
+      t_903 = t_902 === 45;
+    } else {
+      t_903 = false;
+    }
+    if (t_903) {
+      isNegative_933 = true;
+      t_894 = stringNext_731(sourceText_890, i_891);
+      i_891 = t_894;
+    }
+    let digit0_935;
+    if (sourceText_890.length > i_891) {
+      t_904 = stringGet_628(sourceText_890, i_891);
+      digit0_935 = t_904;
+    } else {
+      digit0_935 = -1;
+    }
+    if (digit0_935 < 48) {
+      t_905 = true;
+    } else {
+      t_905 = 57 < digit0_935;
+    }
+    if (t_905) {
+      let error_936;
+      if (! isNegative_933) {
+        t_906 = digit0_935 !== 46;
+      } else {
+        t_906 = false;
+      }
+      if (t_906) {
+        error_936 = "JSON value";
+      } else {
+        error_936 = "digit";
+      }
+      expectedTokenError_627(sourceText_890, i_891, out_892, error_936);
+      return_893 = -1;
+      break fn_932;
+    }
+    t_895 = stringNext_731(sourceText_890, i_891);
+    i_891 = t_895;
+    let nDigits_937 = 1;
+    t_907 = digit0_935 - 48;
+    let tentativeValue_938 = t_907;
+    if (48 !== digit0_935) {
+      while (true) {
+        if (!(sourceText_890.length > i_891)) {
+          break;
+        }
+        t_908 = stringGet_628(sourceText_890, i_891);
+        const possibleDigit_939 = t_908;
+        if (48 <= possibleDigit_939) {
+          t_909 = possibleDigit_939 <= 57;
+        } else {
+          t_909 = false;
+        }
+        if (t_909) {
+          t_896 = stringNext_731(sourceText_890, i_891);
+          i_891 = t_896;
+          nDigits_937 = nDigits_937 + 1;
+          t_911 = tentativeValue_938 * 10.0;
+          t_910 = possibleDigit_939 - 48;
+          tentativeValue_938 = t_911 + t_910;
+        } else {
+          break;
+        }
+      }
+    }
+    let nDigitsAfterPoint_940 = 0;
+    if (sourceText_890.length > i_891) {
+      t_912 = stringGet_628(sourceText_890, i_891);
+      t_913 = 46 === t_912;
+    } else {
+      t_913 = false;
+    }
+    if (t_913) {
+      t_897 = stringNext_731(sourceText_890, i_891);
+      i_891 = t_897;
+      const afterPoint_941 = i_891;
+      while (true) {
+        if (!(sourceText_890.length > i_891)) {
+          break;
+        }
+        t_914 = stringGet_628(sourceText_890, i_891);
+        const possibleDigit_942 = t_914;
+        if (48 <= possibleDigit_942) {
+          t_915 = possibleDigit_942 <= 57;
+        } else {
+          t_915 = false;
+        }
+        if (t_915) {
+          t_898 = stringNext_731(sourceText_890, i_891);
+          i_891 = t_898;
+          nDigits_937 = nDigits_937 + 1;
+          nDigitsAfterPoint_940 = nDigitsAfterPoint_940 + 1;
+          t_917 = tentativeValue_938 * 10.0;
+          t_916 = possibleDigit_942 - 48;
+          tentativeValue_938 = t_917 + t_916;
+        } else {
+          break;
+        }
+      }
+      if (Object.is(i_891, afterPoint_941)) {
+        expectedTokenError_627(sourceText_890, i_891, out_892, "digit");
+        return_893 = -1;
+        break fn_932;
+      }
+    }
+    let nExponentDigits_943 = 0;
+    if (sourceText_890.length > i_891) {
+      t_918 = stringGet_628(sourceText_890, i_891);
+      t_919 = t_918 | 32;
+      t_920 = 101 === t_919;
+    } else {
+      t_920 = false;
+    }
+    if (t_920) {
+      t_899 = stringNext_731(sourceText_890, i_891);
+      i_891 = t_899;
+      if (!(sourceText_890.length > i_891)) {
+        expectedTokenError_627(sourceText_890, i_891, out_892, "sign or digit");
+        return_893 = -1;
+        break fn_932;
+      }
+      let afterE_944;
+      afterE_944 = stringGet_628(sourceText_890, i_891);
+      if (afterE_944 === 43) {
+        t_921 = true;
+      } else {
+        t_921 = afterE_944 === 45;
+      }
+      if (t_921) {
+        t_900 = stringNext_731(sourceText_890, i_891);
+        i_891 = t_900;
+      }
+      while (true) {
+        if (!(sourceText_890.length > i_891)) {
+          break;
+        }
+        t_922 = stringGet_628(sourceText_890, i_891);
+        const possibleDigit_945 = t_922;
+        if (48 <= possibleDigit_945) {
+          t_923 = possibleDigit_945 <= 57;
+        } else {
+          t_923 = false;
+        }
+        if (t_923) {
+          t_901 = stringNext_731(sourceText_890, i_891);
+          i_891 = t_901;
+          nExponentDigits_943 = nExponentDigits_943 + 1;
+        } else {
+          break;
+        }
+      }
+      if (nExponentDigits_943 === 0) {
+        expectedTokenError_627(sourceText_890, i_891, out_892, "exponent digit");
+        return_893 = -1;
+        break fn_932;
+      }
+    }
+    const afterExponent_946 = i_891;
+    if (nExponentDigits_943 === 0) {
+      t_924 = nDigitsAfterPoint_940 === 0;
+    } else {
+      t_924 = false;
+    }
+    if (t_924) {
+      let value_947;
+      if (isNegative_933) {
+        value_947 = - tentativeValue_938;
+      } else {
+        value_947 = tentativeValue_938;
+      }
+      if (nDigits_937 <= 10) {
+        if (cmpFloat__948(-2.147483648E9, value_947) <= 0) {
+          t_925 = cmpFloat__948(value_947, 2.147483647E9) <= 0;
+        } else {
+          t_925 = false;
+        }
+        t_926 = t_925;
+      } else {
+        t_926 = false;
+      }
+      if (t_926) {
+        t_927 = float64ToInt_465(value_947);
+        out_892.intValue(t_927);
+        return_893 = i_891;
+        break fn_932;
+      }
+    }
+    const numericTokenString_949 = sourceText_890.substring(startOfNumber_934, i_891);
+    let doubleValue_950 = NaN;
+    if (nExponentDigits_943 !== 0) {
+      t_928 = true;
+    } else {
+      t_928 = nDigitsAfterPoint_940 !== 0;
+    }
+    if (t_928) {
+      try {
+        t_929 = stringToFloat64_478(numericTokenString_949);
+        doubleValue_950 = t_929;
+      } catch {
+      }
+    }
+    if (cmpFloat__948(doubleValue_950, -Infinity) !== 0) {
+      if (cmpFloat__948(doubleValue_950, Infinity) !== 0) {
+        t_930 = cmpFloat__948(doubleValue_950, NaN) !== 0;
+      } else {
+        t_930 = false;
+      }
+      t_931 = t_930;
+    } else {
+      t_931 = false;
+    }
+    if (t_931) {
+      out_892.float64Value(doubleValue_950);
+    } else {
+      out_892.numericTokenValue(numericTokenString_949);
+    }
+    return_893 = i_891;
+  }
+  return return_893;
+}
+/**
+ * @param {string} sourceText_951
+ * @param {JsonProducer} out_952
+ */
+export function parseJsonToProducer(sourceText_951, out_952) {
+  let t_953;
+  let t_954;
+  let t_955;
+  let t_956;
+  let t_957;
+  let t_958;
+  let i_959 = 0;
+  const afterValue_960 = parseJsonValue_617(sourceText_951, i_959, out_952);
+  if (afterValue_960 >= 0) {
+    t_957 = requireStringIndex__836(afterValue_960);
+    t_953 = skipJsonSpaces_626(sourceText_951, t_957);
+    i_959 = t_953;
+    if (sourceText_951.length > i_959) {
+      t_954 = out_952 instanceof JsonParseErrorReceiver;
+      t_958 = t_954;
+    } else {
+      t_958 = false;
+    }
+    if (t_958) {
+      t_955 = sourceText_951.length;
+      t_956 = sourceText_951.substring(i_959, t_955);
+      storeJsonError_732(out_952, "Extraneous JSON `" + t_956 + "`");
+    }
+  }
+  return;
+};
+/**
+ * @param {string} sourceText_961
+ * @returns {JsonSyntaxTree}
+ */
+export function parseJson(sourceText_961) {
+  const p_962 = new JsonSyntaxTreeProducer();
+  parseJsonToProducer(sourceText_961, p_962);
+  return p_962.toJsonSyntaxTree();
+};
+/** @returns {JsonAdapter<boolean>} */
+export function booleanJsonAdapter() {
+  return new BooleanJsonAdapter_642();
+};
+/** @returns {JsonAdapter<number>} */
+export function float64JsonAdapter() {
+  return new Float64JsonAdapter_650();
+};
+/** @returns {JsonAdapter<number>} */
+export function intJsonAdapter() {
+  return new IntJsonAdapter_658();
+};
+/** @returns {JsonAdapter<string>} */
+export function stringJsonAdapter() {
+  return new StringJsonAdapter_666();
+};
+/**
+ * @template {unknown} T_964
+ * @param {JsonAdapter<T_964>} adapterForT_963
+ * @returns {JsonAdapter<Array<T_964>>}
+ */
+export function listJsonAdapter(adapterForT_963) {
+  return new ListJsonAdapter_674(adapterForT_963);
+};