@nfdi4plants/arctrl 3.2.3 → 3.3.0

package/dist/ts/ts/fable_modules/YAMLicious.2.0.0/Decode.fs.js

@@ -0,0 +1,1175 @@
+import { Record, toString, FSharpException, Union, FSharpRef } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { isEmpty, empty, cons, FSharpList__get_Head, FSharpList__get_Tail, length, toArray, map, ofArray, exists, append, ofSeq } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { value, some } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { SourceSpan_$reflection, ScalarStyle, YamlNode_$reflection } from './Model.fs.js';
+import { getEnumerator, disposeSafe, int32ToString, equals, physicalHash, comparePrimitives, safeHash, defaultOf, compare, structuralHash } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { record_type, string_type, list_type, option_type, class_type, union_type, int32_type, array_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
+import { StringBuilder_$ctor, StringBuilder__Append_Z721C83C5 } from '../../../node_modules/@fable-org/fable-library-ts/System.Text.js';
+import { replace, substring, getCharAtIndex } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { YamlTagModule_coreNamespace, YamlTagModule_identifier } from './Tag.fs.js';
+import { YamlNodeModule_isMissingValue } from './Node.fs.js';
+import { CoreSchema_isNull, CoreSchema_resolveKind, CoreSchema_isString, CoreSchema_IntegerNames_$ctor, CoreSchema_resolvesToNull, CoreSchema_IntegerNames__Name_Z721C83C5, CoreSchema_canonicalFloat, CoreSchema_tryParseInt, CoreSchema_tryParseInt64, CoreSchema_tryParseFloat, CoreSchema_tryParseBool } from './CoreSchema.fs.js';
+import { tryGetValue, getItemFromDict } from '../../../node_modules/@fable-org/fable-library-ts/MapUtil.js';
+import { item, map as map$1, fill, setItem, sortBy } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { Dictionary } from '../../../node_modules/@fable-org/fable-library-ts/MutableMap.js';
+import { minValue, tryParse } from '../../../node_modules/@fable-org/fable-library-ts/Date.js';
+import { minValue as minValue$1, tryParse as tryParse$1 } from '../../../node_modules/@fable-org/fable-library-ts/DateOffset.js';
+import { toList, delay, collect, singleton, empty as empty$1 } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { rangeDouble } from '../../../node_modules/@fable-org/fable-library-ts/Range.js';
+import { ofSeq as ofSeq$1 } from '../../../node_modules/@fable-org/fable-library-ts/Map.js';
+import { FSharpResult$2_Ok, FSharpResult$2_Error$ } from '../../../node_modules/@fable-org/fable-library-ts/Result.js';
+
+class DecodeError extends Record {
+  constructor(Message, Path, Span) {
+    super();
+    this.Message = Message;
+    this.Path = Path;
+    this.Span = Span;
+  }
+}
+function DecodeError_$reflection() {
+  return record_type("YAMLicious.DecodeError", [], DecodeError, () => [["Message", string_type], ["Path", list_type(string_type)], ["Span", option_type(SourceSpan_$reflection())]]);
+}
+function DecodeErrorModule_pathText(error) {
+  const sb = StringBuilder_$ctor();
+  let first = true;
+  const enumerator = getEnumerator(error.Path);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const segment = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      if (segment.startsWith("[") ? true : segment.startsWith("{")) {
+        StringBuilder__Append_Z721C83C5(sb, segment);
+      } else {
+        if (!first) {
+          StringBuilder__Append_Z721C83C5(sb, ".");
+        }
+        StringBuilder__Append_Z721C83C5(sb, segment);
+      }
+      first = false;
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return toString(sb);
+}
+function DecodeErrorModule_text(error) {
+  let place;
+  const matchValue = error.Span;
+  if (matchValue == null) {
+    place = "";
+  } else {
+    const span = matchValue;
+    place = " (line " + int32ToString(span.Start.Line) + ", column " + int32ToString(span.Start.Column) + ")";
+  }
+  if (isEmpty(error.Path)) {
+    return error.Message + place;
+  } else {
+    return "At " + DecodeErrorModule_pathText(error) + ": " + error.Message + place;
+  }
+}
+class YamlDecodeException extends FSharpException {
+  constructor(Data0) {
+    super();
+    this.Data0 = Data0;
+  }
+  "System.Exception.get_Message"() {
+    const this$ = this;
+    return DecodeErrorModule_text(this$.Data0);
+  }
+}
+function YamlDecodeException_$reflection() {
+  return class_type("YAMLicious.YamlDecodeException", void 0, YamlDecodeException, class_type("System.Exception"));
+}
+function PairKey$1_Null() {
+  return PairKey$1.Null;
+}
+function PairKey$1_NotANumber() {
+  return PairKey$1.NotANumber;
+}
+function PairKey$1_Value(Item) {
+  return new PairKey$1(2, [Item]);
+}
+class PairKey$1 extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Null", "NotANumber", "Value"];
+  }
+  static {
+    this.Null = new PairKey$1(0, []);
+  }
+  static {
+    this.NotANumber = new PairKey$1(1, []);
+  }
+}
+function PairKey$1_$reflection(gen0) {
+  return union_type("YAMLicious.PairKey`1", [gen0], PairKey$1, () => [[], [], [["Item", gen0]]]);
+}
+function DecodeSupport_spanText(span) {
+  return "line " + int32ToString(span.Start.Line) + ", column " + int32ToString(span.Start.Column);
+}
+function DecodeSupport_shorten(text) {
+  const flat = replace(text, "\n", "\\n");
+  if (flat.length > 40) {
+    return substring(flat, 0, 37) + "...";
+  } else {
+    return flat;
+  }
+}
+function DecodeSupport_tagText(tag) {
+  if (tag.tag === /* Named */
+  1) {
+    const name = tag.fields[0];
+    if (name.Prefix === YamlTagModule_coreNamespace) {
+      return "!!" + name.Suffix;
+    } else if (name.Prefix === "!") {
+      return "!" + name.Suffix;
+    } else {
+      return "!<" + name.Prefix + name.Suffix + ">";
+    }
+  } else {
+    return "!";
+  }
+}
+function DecodeSupport_describeNode(node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Sequence */
+    2:
+      return "a sequence";
+    case /* Alias */
+    3:
+      return "the alias *" + matchValue.fields[0];
+    case /* Scalar */
+    0: {
+      const scalar = matchValue.fields[0];
+      if (YamlNodeModule_isMissingValue(node)) {
+        return "a missing value";
+      } else {
+        let style;
+        const matchValue_1 = scalar.Style;
+        style = matchValue_1.tag === /* SingleQuoted */
+        1 ? "single-quoted" : matchValue_1.tag === /* DoubleQuoted */
+        2 ? "double-quoted" : matchValue_1.tag === /* Block */
+        3 ? matchValue_1.fields[0].tag === /* Folded */
+        1 ? "folded block" : "literal block" : "plain";
+        let tag;
+        const matchValue_2 = node.Properties.Tag;
+        tag = matchValue_2 == null ? "" : " with the tag " + DecodeSupport_tagText(matchValue_2);
+        return "the " + style + ' scalar "' + DecodeSupport_shorten(scalar.Value) + '"' + tag;
+      }
+    }
+    default:
+      return "a mapping";
+  }
+}
+function DecodeSupport_expected(what, node) {
+  return "Expected " + what + ", found " + DecodeSupport_describeNode(node) + ".";
+}
+function DecodeSupport_describeNull(node) {
+  if (YamlNodeModule_isMissingValue(node)) {
+    return "a missing value";
+  } else {
+    const matchValue = node.Kind;
+    if (matchValue.tag === /* Scalar */
+    0) {
+      return 'the null "' + DecodeSupport_shorten(matchValue.fields[0].Value) + '"';
+    } else {
+      return "a null";
+    }
+  }
+}
+function DecodeSupport_failAt(message, span) {
+  throw new YamlDecodeException(new DecodeError(message, empty(), span));
+}
+function DecodeSupport_fail(message, node) {
+  return DecodeSupport_failAt(message, node.Span);
+}
+function DecodeSupport_failAlias(name, node) {
+  let matchValue = void 0;
+  return DecodeSupport_fail("The alias *" + name + (matchValue = node.Span, matchValue == null ? "" : " at " + DecodeSupport_spanText(matchValue)) + " cannot be read as a value. Aliases stay symbolic, so only Decode.alias and Decode.node accept them.", node);
+}
+function DecodeSupport_withSegment(segment, error) {
+  return new DecodeError(error.Message, cons(segment, error.Path), error.Span);
+}
+function DecodeSupport_inSegment(segment, decoder, node) {
+  try {
+    return decoder(node);
+  } catch (matchValue) {
+    if (matchValue instanceof YamlDecodeException) {
+      const error = matchValue.Data0;
+      throw new YamlDecodeException(DecodeSupport_withSegment(segment, error));
+    } else {
+      throw matchValue;
+    }
+  }
+}
+function DecodeSupport_inItem(index, decoder, node) {
+  try {
+    return decoder(node);
+  } catch (matchValue) {
+    if (matchValue instanceof YamlDecodeException) {
+      const error = matchValue.Data0;
+      throw new YamlDecodeException(DecodeSupport_withSegment("[" + int32ToString(index) + "]", error));
+    } else {
+      throw matchValue;
+    }
+  }
+}
+function DecodeSupport_keyLabel(key) {
+  const matchValue = key.Kind;
+  switch (matchValue.tag) {
+    case /* Alias */
+    3:
+      return "*" + matchValue.fields[0];
+    case /* Mapping */
+    1:
+      return "(mapping)";
+    case /* Sequence */
+    2:
+      return "(sequence)";
+    default:
+      return matchValue.fields[0].Value;
+  }
+}
+function DecodeSupport_inEntry(key, decoder, node) {
+  try {
+    return decoder(node);
+  } catch (matchValue) {
+    if (matchValue instanceof YamlDecodeException) {
+      const error = matchValue.Data0;
+      throw new YamlDecodeException(DecodeSupport_withSegment("{" + DecodeSupport_keyLabel(key) + "}", error));
+    } else {
+      throw matchValue;
+    }
+  }
+}
+function DecodeSupport_isNullTag(tag) {
+  if (tag == null) {
+    return false;
+  } else {
+    return YamlTagModule_identifier(tag) === YamlTagModule_coreNamespace + "null";
+  }
+}
+function DecodeSupport_nullTagMessage(text) {
+  return 'The tag !!null needs null, Null, NULL, ~ or an empty text, found "' + DecodeSupport_shorten(text) + '".';
+}
+function DecodeSupport_checkNullTag(node, scalar) {
+  if (DecodeSupport_isNullTag(node.Properties.Tag) && !CoreSchema_isNull(node.Properties.Tag, scalar)) {
+    DecodeSupport_fail(DecodeSupport_nullTagMessage(scalar.Value), node);
+  }
+}
+function DecodeSupport_scalarOf(what, node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Scalar */
+    0: {
+      const scalar = matchValue.fields[0];
+      DecodeSupport_checkNullTag(node, scalar);
+      return scalar;
+    }
+    case /* Alias */
+    3:
+      return DecodeSupport_failAlias(matchValue.fields[0], node);
+    default:
+      return DecodeSupport_fail(DecodeSupport_expected(what, node), node);
+  }
+}
+function DecodeSupport_typedScalar(what, parse, node) {
+  const matchValue = parse(node.Properties.Tag, DecodeSupport_scalarOf(what, node));
+  if (matchValue == null) {
+    return DecodeSupport_fail(DecodeSupport_expected(what, node), node);
+  } else {
+    return value(matchValue);
+  }
+}
+function DecodeSupport_describeNonString(node) {
+  let scalar = void 0;
+  const matchValue = node.Kind;
+  let matchResult = void 0, scalar_1 = void 0;
+  if (matchValue.tag === /* Scalar */
+  0) {
+    if (scalar = matchValue.fields[0], node.Properties.Tag == null && equals(scalar.Style, ScalarStyle.Plain)) {
+      matchResult = 0;
+      scalar_1 = matchValue.fields[0];
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      if (scalar_1.Value === "") {
+        return "a missing value";
+      } else {
+        let resolved;
+        const matchValue_1 = CoreSchema_resolveKind(scalar_1.Value);
+        resolved = matchValue_1.tag === /* Bool */
+        1 ? "!!bool" : matchValue_1.tag === /* Integer */
+        2 ? "!!int" : matchValue_1.tag === /* Float */
+        3 ? "!!float" : matchValue_1.tag === /* Str */
+        4 ? "!!str" : "!!null";
+        return DecodeSupport_describeNode(node) + ", which resolves to " + resolved;
+      }
+    default:
+      return DecodeSupport_describeNode(node);
+  }
+}
+function DecodeSupport_stringOf(what, node) {
+  const scalar = DecodeSupport_scalarOf(what, node);
+  if (CoreSchema_isString(node.Properties.Tag, scalar)) {
+    return scalar.Value;
+  } else {
+    return DecodeSupport_fail("Expected " + what + ", found " + DecodeSupport_describeNonString(node) + ".", node);
+  }
+}
+function DecodeSupport_isNullNode(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Scalar */
+  0) {
+    const scalar = matchValue.fields[0];
+    DecodeSupport_checkNullTag(node, scalar);
+    return CoreSchema_isNull(node.Properties.Tag, scalar);
+  } else {
+    return false;
+  }
+}
+function DecodeSupport_sequenceItems(what, node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Sequence */
+    2:
+      return matchValue.fields[0].Items;
+    case /* Alias */
+    3:
+      return DecodeSupport_failAlias(matchValue.fields[0], node);
+    default:
+      return DecodeSupport_fail(DecodeSupport_expected(what, node), node);
+  }
+}
+function DecodeSupport_mappingEntries(what, node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Mapping */
+    1:
+      return matchValue.fields[0].Items;
+    case /* Alias */
+    3:
+      return DecodeSupport_failAlias(matchValue.fields[0], node);
+    default:
+      return DecodeSupport_fail(DecodeSupport_expected(what, node), node);
+  }
+}
+function DecodeSupport_decodeItems(what, decoder, node) {
+  const result = [];
+  let remaining = DecodeSupport_sequenceItems(what, node);
+  let index = 0;
+  try {
+    while (!isEmpty(remaining)) {
+      void result.push(decoder(FSharpList__get_Head(remaining).Node));
+      remaining = FSharpList__get_Tail(remaining);
+      index = index + 1 | 0;
+    }
+  } catch (matchValue) {
+    if (matchValue instanceof YamlDecodeException) {
+      const error = matchValue.Data0;
+      throw new YamlDecodeException(DecodeSupport_withSegment("[" + int32ToString(index) + "]", error));
+    } else {
+      throw matchValue;
+    }
+  }
+  return result;
+}
+function DecodeSupport_tupleNodes(size, node) {
+  const items = DecodeSupport_sequenceItems("a sequence of " + int32ToString(size) + " items", node);
+  const count = length(items) | 0;
+  if (count !== size) {
+    return DecodeSupport_fail("Expected a sequence of " + int32ToString(size) + " items, found a sequence of " + int32ToString(count) + " items.", node);
+  } else {
+    return toArray(map((item) => item.Node, items));
+  }
+}
+function DecodeSupport_coreTag(suffix) {
+  return YamlTagModule_coreNamespace + suffix;
+}
+class DecodeSupport_KeyIndex {
+  constructor() {
+    this["Numbers@"] = /* @__PURE__ */ new Map([]);
+    this["Integers@"] = CoreSchema_IntegerNames_$ctor();
+  }
+}
+function DecodeSupport_KeyIndex_$reflection() {
+  return class_type("YAMLicious.DecodeSupport.KeyIndex", void 0, DecodeSupport_KeyIndex);
+}
+function DecodeSupport_KeyIndex_$ctor() {
+  return new DecodeSupport_KeyIndex();
+}
+function DecodeSupport_KeyIndex__get_Numbers(__) {
+  return __["Numbers@"];
+}
+function DecodeSupport_KeyIndex__get_Integers(__) {
+  return __["Integers@"];
+}
+const DecodeSupport_scalarTagSuffixes = ofArray(["str", "null", "bool", "int", "float"]);
+function DecodeSupport_placeOf(key, fallback) {
+  const matchValue = key.Span;
+  if (matchValue == null) {
+    return fallback;
+  } else {
+    return "at " + DecodeSupport_spanText(matchValue);
+  }
+}
+function DecodeSupport_failRepeatedKey(first, second) {
+  const firstLabel = DecodeSupport_keyLabel(first);
+  const secondLabel = DecodeSupport_keyLabel(second);
+  const firstPlace = DecodeSupport_placeOf(first, "at an earlier entry");
+  const place = DecodeSupport_placeOf(second, "at a later entry");
+  return DecodeSupport_fail(firstLabel === secondLabel ? (secondLabel === "" ? "The empty key" : "The key " + secondLabel) + " occurs twice, " + firstPlace + " and " + place + "." : (secondLabel === "" ? "The empty key " : "The key " + secondLabel + " ") + place + " repeats " + (firstLabel === "" ? "the empty key " : "the key " + firstLabel + " ") + firstPlace + ".", second);
+}
+function DecodeSupport_scalarToken(integers, node, scalar) {
+  const text = scalar.Value;
+  if (CoreSchema_isString(node.Properties.Tag, scalar)) {
+    return "s" + text;
+  } else {
+    let identifier;
+    const matchValue = node.Properties.Tag;
+    if (matchValue == null) {
+      const matchValue_1 = CoreSchema_resolveKind(text);
+      identifier = matchValue_1.tag === /* Null */
+      0 ? DecodeSupport_coreTag("null") : matchValue_1.tag === /* Bool */
+      1 ? DecodeSupport_coreTag("bool") : matchValue_1.tag === /* Integer */
+      2 ? DecodeSupport_coreTag("int") : DecodeSupport_coreTag("float");
+    } else {
+      identifier = YamlTagModule_identifier(matchValue);
+    }
+    const wrong = (expected) => DecodeSupport_fail("The tag !!" + substring(identifier, YamlTagModule_coreNamespace.length) + " needs " + expected + ', found "' + DecodeSupport_shorten(text) + '".', node);
+    if (identifier === DecodeSupport_coreTag("null")) {
+      if (CoreSchema_resolvesToNull(text)) {
+        return "n";
+      } else {
+        return DecodeSupport_fail(DecodeSupport_nullTagMessage(text), node);
+      }
+    } else if (identifier === DecodeSupport_coreTag("bool")) {
+      switch (text) {
+        case "true":
+        case "True":
+        case "TRUE":
+          return "btrue";
+        case "false":
+        case "False":
+        case "FALSE":
+          return "bfalse";
+        default:
+          return wrong("true, True, TRUE, false, False or FALSE");
+      }
+    } else if (identifier === DecodeSupport_coreTag("int")) {
+      const matchValue_2 = CoreSchema_IntegerNames__Name_Z721C83C5(integers, text);
+      if (matchValue_2 == null) {
+        return wrong("an int of the core schema");
+      } else {
+        return "i" + matchValue_2;
+      }
+    } else if (identifier === DecodeSupport_coreTag("float")) {
+      const matchValue_3 = CoreSchema_canonicalFloat(text);
+      if (matchValue_3 == null) {
+        return wrong("a float of the core schema");
+      } else {
+        return "f" + matchValue_3;
+      }
+    } else if (identifier === DecodeSupport_coreTag("seq")) {
+      return wrong("a sequence");
+    } else if (identifier === DecodeSupport_coreTag("map")) {
+      return wrong("a mapping");
+    } else {
+      return "x" + int32ToString(identifier.length) + ":" + identifier + text;
+    }
+  }
+}
+function DecodeSupport_collectionTag(node, own) {
+  const matchValue = node.Properties.Tag;
+  let matchResult = void 0, explicit = void 0;
+  if (matchValue != null) {
+    if (matchValue.tag === /* NonSpecific */
+    0) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+      explicit = matchValue;
+    }
+  } else {
+    matchResult = 0;
+  }
+  switch (matchResult) {
+    case 0:
+      return DecodeSupport_coreTag(own);
+    default: {
+      const identifier = YamlTagModule_identifier(explicit);
+      const found = own === "seq" ? "a sequence" : "a mapping";
+      if (identifier === DecodeSupport_coreTag("seq") && own !== "seq") {
+        return DecodeSupport_fail("The tag " + DecodeSupport_tagText(explicit) + " needs a sequence, found " + found + ".", node);
+      } else if (identifier === DecodeSupport_coreTag("map") && own !== "map") {
+        return DecodeSupport_fail("The tag " + DecodeSupport_tagText(explicit) + " needs a mapping, found " + found + ".", node);
+      } else if (exists((suffix) => identifier === DecodeSupport_coreTag(suffix), DecodeSupport_scalarTagSuffixes)) {
+        return DecodeSupport_fail("The tag " + DecodeSupport_tagText(explicit) + " needs a scalar, found " + found + ".", node);
+      } else {
+        return identifier;
+      }
+    }
+  }
+}
+function DecodeSupport_TokenStep_Visit(Item) {
+  return new DecodeSupport_TokenStep(0, [Item]);
+}
+function DecodeSupport_TokenStep_FinishSequence(tag, count) {
+  return new DecodeSupport_TokenStep(1, [tag, count]);
+}
+function DecodeSupport_TokenStep_FinishMapping(tag, keys) {
+  return new DecodeSupport_TokenStep(2, [tag, keys]);
+}
+class DecodeSupport_TokenStep extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Visit", "FinishSequence", "FinishMapping"];
+  }
+  Equals(other) {
+    return this === other;
+  }
+  GetHashCode() {
+    return physicalHash(this);
+  }
+}
+function DecodeSupport_TokenStep_$reflection() {
+  return union_type("YAMLicious.DecodeSupport.TokenStep", [], DecodeSupport_TokenStep, () => [[["Item", YamlNode_$reflection()]], [["tag", string_type], ["count", int32_type]], [["tag", string_type], ["keys", array_type(YamlNode_$reflection())]]]);
+}
+function DecodeSupport_nodeToken(index, root) {
+  const interned = DecodeSupport_KeyIndex__get_Numbers(index);
+  const numberOf = (token) => {
+    let matchValue;
+    const cell = new FSharpRef(0);
+    matchValue = [tryGetValue(interned, token, cell), cell.contents];
+    if (matchValue[0]) {
+      return matchValue[1] | 0;
+    } else {
+      const number_1 = interned.size | 0;
+      interned.set(token, number_1);
+      return number_1 | 0;
+    }
+  };
+  const steps = [];
+  const tokens = [];
+  void steps.push(DecodeSupport_TokenStep_Visit(root));
+  while (steps.length > 0) {
+    const step = item(steps.length - 1, steps);
+    steps.splice(steps.length - 1, 1);
+    switch (step.tag) {
+      case /* FinishSequence */
+      1: {
+        const tag = step.fields[0];
+        const count = step.fields[1] | 0;
+        const start = tokens.length - count | 0;
+        const sb = StringBuilder_$ctor();
+        StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, "q"), int32ToString(tag.length)), ":"), tag), "[");
+        for (let i_2 = start; i_2 <= tokens.length - 1; i_2++) {
+          if (i_2 > start) {
+            StringBuilder__Append_Z721C83C5(sb, ",");
+          }
+          StringBuilder__Append_Z721C83C5(sb, int32ToString(numberOf(item(i_2, tokens))));
+        }
+        tokens.splice(start, count);
+        void tokens.push(toString(sb));
+        break;
+      }
+      case /* FinishMapping */
+      2: {
+        const tag_1 = step.fields[0];
+        const keys = step.fields[1];
+        const start_1 = tokens.length - 2 * keys.length | 0;
+        const first = /* @__PURE__ */ new Map([]);
+        const pairs = fill(new Array(keys.length), 0, keys.length, null);
+        for (let i_3 = 0; i_3 <= keys.length - 1; i_3++) {
+          const keyNumber = numberOf(item(start_1 + 2 * i_3, tokens)) | 0;
+          if (first.has(keyNumber)) {
+            DecodeSupport_failRepeatedKey(item(getItemFromDict(first, keyNumber), keys), item(i_3, keys));
+          }
+          first.set(keyNumber, i_3);
+          setItem(pairs, i_3, [keyNumber, numberOf(item(start_1 + 2 * i_3 + 1, tokens))]);
+        }
+        const sorted = sortBy((tuple) => tuple[0] | 0, pairs, {
+          Compare: (x, y) => comparePrimitives(x, y) | 0
+        });
+        const sb_1 = StringBuilder_$ctor();
+        StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb_1, "m"), int32ToString(tag_1.length)), ":"), tag_1), "{");
+        for (let i_4 = 0; i_4 <= sorted.length - 1; i_4++) {
+          if (i_4 > 0) {
+            StringBuilder__Append_Z721C83C5(sb_1, ",");
+          }
+          StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb_1, int32ToString(item(i_4, sorted)[0])), ":"), int32ToString(item(i_4, sorted)[1]));
+        }
+        tokens.splice(start_1, 2 * keys.length);
+        void tokens.push(toString(sb_1));
+        break;
+      }
+      default: {
+        const node = step.fields[0];
+        const matchValue_1 = node.Kind;
+        switch (matchValue_1.tag) {
+          case /* Alias */
+          3: {
+            DecodeSupport_failAlias(matchValue_1.fields[0], node);
+            break;
+          }
+          case /* Sequence */
+          2: {
+            const items = toArray(matchValue_1.fields[0].Items);
+            void steps.push(DecodeSupport_TokenStep_FinishSequence(DecodeSupport_collectionTag(node, "seq"), items.length));
+            for (let i = items.length - 1; i >= 0; i--) {
+              void steps.push(DecodeSupport_TokenStep_Visit(item(i, items).Node));
+            }
+            break;
+          }
+          case /* Mapping */
+          1: {
+            const entries = toArray(matchValue_1.fields[0].Items);
+            void steps.push(DecodeSupport_TokenStep_FinishMapping(DecodeSupport_collectionTag(node, "map"), map$1((entry) => entry.Key, entries)));
+            for (let i_1 = entries.length - 1; i_1 >= 0; i_1--) {
+              void steps.push(DecodeSupport_TokenStep_Visit(item(i_1, entries).Value));
+              void steps.push(DecodeSupport_TokenStep_Visit(item(i_1, entries).Key));
+            }
+            break;
+          }
+          default: {
+            const scalar = matchValue_1.fields[0];
+            void tokens.push(DecodeSupport_scalarToken(DecodeSupport_KeyIndex__get_Integers(index), node, scalar));
+          }
+        }
+      }
+    }
+  }
+  return item(0, tokens);
+}
+function DecodeSupport_keyTokens(index, entries) {
+  const tokens = fill(new Array(entries.length), 0, entries.length, "");
+  const first = /* @__PURE__ */ new Map([]);
+  for (let i = 0; i <= entries.length - 1; i++) {
+    const key = item(i, entries).Key;
+    let token;
+    const matchValue = key.Kind;
+    if (matchValue.tag === /* Scalar */
+    0) {
+      const scalar = matchValue.fields[0];
+      token = DecodeSupport_scalarToken(DecodeSupport_KeyIndex__get_Integers(index), key, scalar);
+    } else {
+      token = DecodeSupport_nodeToken(index, key);
+    }
+    if (first.has(token)) {
+      DecodeSupport_failRepeatedKey(item(getItemFromDict(first, token), entries).Key, key);
+    }
+    first.set(token, i);
+    setItem(tokens, i, token);
+  }
+  return tokens;
+}
+function DecodeSupport_keyText(token) {
+  if (getCharAtIndex(token, 0) === "s") {
+    return substring(token, 1);
+  } else {
+    return void 0;
+  }
+}
+class DecodeSupport_KeyWalkPlace extends Record {
+  constructor(Parent, Key, Index) {
+    super();
+    this.Parent = Parent;
+    this.Key = Key;
+    this.Index = Index | 0;
+  }
+  Equals(other) {
+    return this === other;
+  }
+  GetHashCode() {
+    return physicalHash(this);
+  }
+}
+function DecodeSupport_KeyWalkPlace_$reflection() {
+  return record_type("YAMLicious.DecodeSupport.KeyWalkPlace", [], DecodeSupport_KeyWalkPlace, () => [["Parent", option_type(DecodeSupport_KeyWalkPlace_$reflection())], ["Key", option_type(YamlNode_$reflection())], ["Index", int32_type]]);
+}
+function DecodeSupport_pathOf(place) {
+  let segments = empty();
+  let current = place;
+  while (current != null) {
+    const here = value(current);
+    let segment;
+    const matchValue = here.Key;
+    segment = matchValue == null ? "[" + int32ToString(here.Index) + "]" : "{" + DecodeSupport_keyLabel(matchValue) + "}";
+    segments = cons(segment, segments);
+    current = here.Parent;
+  }
+  return segments;
+}
+function DecodeSupport_checkKeysBelow(root) {
+  const index = DecodeSupport_KeyIndex_$ctor();
+  const stack = [];
+  void stack.push([root, void 0]);
+  while (stack.length > 0) {
+    const patternInput = item(stack.length - 1, stack);
+    const place = patternInput[1];
+    stack.splice(stack.length - 1, 1);
+    const matchValue = patternInput[0].Kind;
+    switch (matchValue.tag) {
+      case /* Mapping */
+      1: {
+        const entries = toArray(matchValue.fields[0].Items);
+        try {
+          DecodeSupport_keyTokens(index, entries);
+        } catch (matchValue_1) {
+          if (matchValue_1 instanceof YamlDecodeException) {
+            const error = matchValue_1.Data0;
+            throw new YamlDecodeException(new DecodeError(error.Message, append(DecodeSupport_pathOf(place), error.Path), error.Span));
+          } else {
+            throw matchValue_1;
+          }
+        }
+        for (let i = entries.length - 1; i >= 0; i--) {
+          void stack.push([item(i, entries).Value, new DecodeSupport_KeyWalkPlace(place, item(i, entries).Key, i)]);
+        }
+        break;
+      }
+      case /* Sequence */
+      2: {
+        const items = toArray(matchValue.fields[0].Items);
+        for (let i_1 = items.length - 1; i_1 >= 0; i_1--) {
+          void stack.push([item(i_1, items).Node, new DecodeSupport_KeyWalkPlace(place, void 0, i_1)]);
+        }
+        break;
+      }
+      default:
+    }
+  }
+}
+function DecodeSupport_pairKey(key) {
+  let number = void 0;
+  const boxed = key;
+  if (boxed == null) {
+    return PairKey$1.Null;
+  } else {
+    let matchResult = void 0;
+    if (typeof boxed === "number") {
+      if (number = boxed, Number.isNaN(number)) {
+        matchResult = 0;
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0: {
+        return PairKey$1.NotANumber;
+      }
+      default:
+        return PairKey$1_Value(key);
+    }
+  }
+}
+function DecodeSupport_decodePairs(allowNullKey, keyDecoder, valueDecoder, node) {
+  const entries = toArray(DecodeSupport_mappingEntries("a mapping", node));
+  DecodeSupport_keyTokens(DecodeSupport_KeyIndex_$ctor(), entries);
+  const pairs = [];
+  const seen = new Dictionary([], {
+    Equals: equals,
+    GetHashCode: (x) => safeHash(x) | 0
+  });
+  for (let idx = 0; idx <= entries.length - 1; idx++) {
+    const entry = item(idx, entries);
+    const key = DecodeSupport_inEntry(entry.Key, keyDecoder, entry.Key);
+    if (!allowNullKey && key == null) {
+      DecodeSupport_fail("The key " + DecodeSupport_keyLabel(entry.Key) + " decodes to null, which a dictionary cannot hold. Decode a map instead.", entry.Key);
+    }
+    let matchValue;
+    const cell = new FSharpRef(defaultOf());
+    matchValue = [tryGetValue(seen, DecodeSupport_pairKey(key), cell), cell.contents];
+    if (matchValue[0]) {
+      const first = matchValue[1];
+      const firstPlace = DecodeSupport_placeOf(first, "at an earlier entry");
+      const place = DecodeSupport_placeOf(entry.Key, "at a later entry");
+      DecodeSupport_fail("Distinct YAML keys decode to the same map key: " + DecodeSupport_describeNode(first) + " " + firstPlace + " and " + DecodeSupport_describeNode(entry.Key) + " " + place + ".", entry.Key);
+    } else {
+      seen.set(DecodeSupport_pairKey(key), entry.Key);
+      void pairs.push([key, DecodeSupport_inEntry(entry.Key, valueDecoder, entry.Value)]);
+    }
+  }
+  return pairs;
+}
+function DecodeSupport_digitsAt(text, start, count) {
+  if (start + count > text.length) {
+    return -1;
+  } else {
+    let value = 0;
+    let valid = true;
+    for (let i = start; i <= start + count - 1; i++) {
+      const c = getCharAtIndex(text, i);
+      if (c >= "0" && c <= "9") {
+        value = value * 10 + (~~c.charCodeAt(0) - ~~"0".charCodeAt(0)) | 0;
+      } else {
+        valid = false;
+      }
+    }
+    if (valid) {
+      return value | 0;
+    } else {
+      return -1;
+    }
+  }
+}
+function DecodeSupport_daysInMonth(year, month) {
+  if (month === 2) {
+    if (year % 4 === 0 && year % 100 !== 0 ? true : year % 400 === 0) {
+      return 29;
+    } else {
+      return 28;
+    }
+  } else if (((month === 4 ? true : month === 6) ? true : month === 9) ? true : month === 11) {
+    return 30;
+  } else {
+    return 31;
+  }
+}
+function DecodeSupport_normalizeTimestamp(text, zoneRequired) {
+  const length = text.length | 0;
+  if ((length < 10 ? true : getCharAtIndex(text, 4) !== "-") ? true : getCharAtIndex(text, 7) !== "-") {
+    return void 0;
+  } else {
+    const year = DecodeSupport_digitsAt(text, 0, 4) | 0;
+    const month = DecodeSupport_digitsAt(text, 5, 2) | 0;
+    const day = DecodeSupport_digitsAt(text, 8, 2) | 0;
+    if ((((year < 0 ? true : month < 1) ? true : month > 12) ? true : day < 1) ? true : day > DecodeSupport_daysInMonth(year, month)) {
+      return void 0;
+    } else if (length === 10) {
+      if (zoneRequired) {
+        return void 0;
+      } else {
+        return text + "T00:00:00";
+      }
+    } else if (((getCharAtIndex(text, 10) !== "T" && getCharAtIndex(text, 10) !== " " ? true : length < 19) ? true : getCharAtIndex(text, 13) !== ":") ? true : getCharAtIndex(text, 16) !== ":") {
+      return void 0;
+    } else {
+      const hour = DecodeSupport_digitsAt(text, 11, 2) | 0;
+      const minute = DecodeSupport_digitsAt(text, 14, 2) | 0;
+      const second = DecodeSupport_digitsAt(text, 17, 2) | 0;
+      if (((((hour < 0 ? true : hour > 23) ? true : minute < 0) ? true : minute > 59) ? true : second < 0) ? true : second > 59) {
+        return void 0;
+      } else {
+        let index = 19;
+        let valid = true;
+        if (index < length && getCharAtIndex(text, index) === ".") {
+          index = index + 1 | 0;
+          const start = index | 0;
+          while (index < length && getCharAtIndex(text, index) >= "0" && getCharAtIndex(text, index) <= "9") {
+            index = index + 1 | 0;
+          }
+          if (index - start < 1 ? true : index - start > 7) {
+            valid = false;
+          }
+        }
+        let hasZone = false;
+        if (valid && index < length) {
+          if (getCharAtIndex(text, index) === "Z" && index + 1 === length) {
+            hasZone = true;
+          } else if ((getCharAtIndex(text, index) === "+" ? true : getCharAtIndex(text, index) === "-") && index + 6 === length && getCharAtIndex(text, index + 3) === ":") {
+            const zoneHours = DecodeSupport_digitsAt(text, index + 1, 2) | 0;
+            const zoneMinutes = DecodeSupport_digitsAt(text, index + 4, 2) | 0;
+            if (zoneHours >= 0 && zoneMinutes >= 0 && zoneMinutes <= 59 && zoneHours * 60 + zoneMinutes <= 840) {
+              hasZone = true;
+            } else {
+              valid = false;
+            }
+          } else {
+            valid = false;
+          }
+        }
+        if (!valid ? true : zoneRequired && !hasZone) {
+          return void 0;
+        } else {
+          return substring(text, 0, 10) + "T" + substring(text, 11);
+        }
+      }
+    }
+  }
+}
+function DecodeSupport_parseDateTime(text) {
+  const matchValue = DecodeSupport_normalizeTimestamp(text, false);
+  if (matchValue != null) {
+    const normalized = matchValue;
+    let matchValue_1;
+    const cell = new FSharpRef(minValue());
+    matchValue_1 = [tryParse(normalized, cell), cell.contents];
+    if (matchValue_1[0]) {
+      return matchValue_1[1];
+    } else {
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+}
+function DecodeSupport_parseDateTimeOffset(text) {
+  const matchValue = DecodeSupport_normalizeTimestamp(text, true);
+  if (matchValue != null) {
+    const normalized = matchValue;
+    let matchValue_1;
+    const cell = new FSharpRef(minValue$1());
+    matchValue_1 = [tryParse$1(normalized, cell), cell.contents];
+    if (matchValue_1[0]) {
+      return matchValue_1[1];
+    } else {
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+}
+function Decode_createGetters(mapping) {
+  const entryList = DecodeSupport_mappingEntries("a mapping", mapping);
+  const entries = toArray(entryList);
+  const tokens = DecodeSupport_keyTokens(DecodeSupport_KeyIndex_$ctor(), entries);
+  const names = fill(new Array(entries.length), 0, entries.length, "");
+  const index = /* @__PURE__ */ new Map([]);
+  for (let i = 0; i <= entries.length - 1; i++) {
+    const matchValue = DecodeSupport_keyText(item(i, tokens));
+    if (matchValue == null) {
+      const key = item(i, entries).Key;
+      DecodeSupport_fail("Expected a string as a field name, found " + DecodeSupport_describeNonString(key) + ".", key);
+    } else {
+      const name = matchValue;
+      index.set(name, i);
+      setItem(names, i, name);
+    }
+  }
+  const required = {
+    Field(name_1, decoder) {
+      let matchValue_1;
+      const cell = new FSharpRef(0);
+      matchValue_1 = [tryGetValue(index, name_1, cell), cell.contents];
+      return matchValue_1[0] ? DecodeSupport_inSegment(name_1, decoder, item(matchValue_1[1], entries).Value) : DecodeSupport_fail("The mapping has no field " + name_1 + ".", mapping);
+    }
+  };
+  const optional = {
+    Field(name_2, decoder_1) {
+      let matchValue_2;
+      const cell_1 = new FSharpRef(0);
+      matchValue_2 = [tryGetValue(index, name_2, cell_1), cell_1.contents];
+      return matchValue_2[0] ? DecodeSupport_inSegment(name_2, (value) => {
+        if (DecodeSupport_isNullNode(value)) {
+          return void 0;
+        } else {
+          return some(decoder_1(value));
+        }
+      }, item(matchValue_2[1], entries).Value) : void 0;
+    }
+  };
+  const multipleOptional = {
+    FieldList(fieldNames) {
+      const wanted = new Set(fieldNames);
+      return toList(delay(() => collect((i_3) => wanted.has(item(i_3, names)) ? singleton(item(i_3, entries)) : empty$1(), rangeDouble(0, 1, entries.length - 1))));
+    }
+  };
+  const overflow = {
+    FieldList(fieldNames_1) {
+      const known = new Set(fieldNames_1);
+      return toList(delay(() => collect((i_4) => !known.has(item(i_4, names)) ? singleton(item(i_4, entries)) : empty$1(), rangeDouble(0, 1, entries.length - 1))));
+    }
+  };
+  return {
+    Required: required,
+    Optional: optional,
+    MultipleOptional: multipleOptional,
+    Overflow: overflow,
+    Entries: entryList
+  };
+}
+function Decode_string(node) {
+  return DecodeSupport_stringOf("a string", node);
+}
+function Decode_scalarText(node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Scalar */
+    0:
+      return matchValue.fields[0].Value;
+    case /* Alias */
+    3:
+      return DecodeSupport_failAlias(matchValue.fields[0], node);
+    default:
+      return DecodeSupport_fail(DecodeSupport_expected("a scalar", node), node);
+  }
+}
+function Decode_int(node) {
+  return DecodeSupport_typedScalar("an int", CoreSchema_tryParseInt, node) | 0;
+}
+function Decode_int64(node) {
+  return DecodeSupport_typedScalar("an int64", CoreSchema_tryParseInt64, node);
+}
+function Decode_float(node) {
+  return DecodeSupport_typedScalar("a float", CoreSchema_tryParseFloat, node);
+}
+function Decode_bool(node) {
+  return DecodeSupport_typedScalar("a bool", CoreSchema_tryParseBool, node);
+}
+function Decode_char(node) {
+  const text = DecodeSupport_stringOf("a char", node);
+  if (text.length === 1) {
+    return getCharAtIndex(text, 0);
+  } else {
+    return DecodeSupport_fail(DecodeSupport_expected("a char", node), node);
+  }
+}
+function Decode_datetime(node) {
+  const matchValue = DecodeSupport_parseDateTime(DecodeSupport_scalarOf("a DateTime", node).Value);
+  if (matchValue == null) {
+    return DecodeSupport_fail(DecodeSupport_expected("a DateTime", node), node);
+  } else {
+    return matchValue;
+  }
+}
+function Decode_datetimeOffset(node) {
+  const matchValue = DecodeSupport_parseDateTimeOffset(DecodeSupport_scalarOf("a DateTimeOffset", node).Value);
+  if (matchValue == null) {
+    return DecodeSupport_fail(DecodeSupport_expected("a DateTimeOffset", node), node);
+  } else {
+    return matchValue;
+  }
+}
+function Decode_option(decoder, node) {
+  if (DecodeSupport_isNullNode(node)) {
+    return void 0;
+  } else {
+    return some(decoder(node));
+  }
+}
+function Decode_nonNull(decoder, node) {
+  if (DecodeSupport_isNullNode(node)) {
+    return DecodeSupport_fail("Expected a value, found " + DecodeSupport_describeNull(node) + ".", node);
+  } else {
+    return decoder(node);
+  }
+}
+function Decode_list(decoder, node) {
+  return ofSeq(DecodeSupport_decodeItems("a sequence", decoder, node));
+}
+function Decode_array(decoder, node) {
+  return DecodeSupport_decodeItems("a sequence", decoder, node).slice();
+}
+function Decode_seq(decoder, node) {
+  return DecodeSupport_decodeItems("a sequence", decoder, node);
+}
+function Decode_resizearray(decoder, node) {
+  return DecodeSupport_decodeItems("a sequence", decoder, node);
+}
+function Decode_values(decoder) {
+  return (node_1) => ofSeq(DecodeSupport_decodeItems("a sequence of scalars", (node) => {
+    const matchValue = node.Kind;
+    switch (matchValue.tag) {
+      case /* Scalar */
+      0:
+        return decoder(node);
+      case /* Alias */
+      3:
+        return DecodeSupport_failAlias(matchValue.fields[0], node);
+      default:
+        return DecodeSupport_fail(DecodeSupport_expected("a scalar", node), node);
+    }
+  }, node_1));
+}
+function Decode_tuple2(decoderA, decoderB, node) {
+  const nodes = DecodeSupport_tupleNodes(2, node);
+  return [DecodeSupport_inItem(0, decoderA, item(0, nodes)), DecodeSupport_inItem(1, decoderB, item(1, nodes))];
+}
+function Decode_tuple3(decoderA, decoderB, decoderC, node) {
+  const nodes = DecodeSupport_tupleNodes(3, node);
+  return [DecodeSupport_inItem(0, decoderA, item(0, nodes)), DecodeSupport_inItem(1, decoderB, item(1, nodes)), DecodeSupport_inItem(2, decoderC, item(2, nodes))];
+}
+function Decode_tuple4(decoderA, decoderB, decoderC, decoderD, node) {
+  const nodes = DecodeSupport_tupleNodes(4, node);
+  return [DecodeSupport_inItem(0, decoderA, item(0, nodes)), DecodeSupport_inItem(1, decoderB, item(1, nodes)), DecodeSupport_inItem(2, decoderC, item(2, nodes)), DecodeSupport_inItem(3, decoderD, item(3, nodes))];
+}
+function Decode_tuple5(decoderA, decoderB, decoderC, decoderD, decoderE, node) {
+  const nodes = DecodeSupport_tupleNodes(5, node);
+  return [DecodeSupport_inItem(0, decoderA, item(0, nodes)), DecodeSupport_inItem(1, decoderB, item(1, nodes)), DecodeSupport_inItem(2, decoderC, item(2, nodes)), DecodeSupport_inItem(3, decoderD, item(3, nodes)), DecodeSupport_inItem(4, decoderE, item(4, nodes))];
+}
+function Decode_tuple6(decoderA, decoderB, decoderC, decoderD, decoderE, decoderF, node) {
+  const nodes = DecodeSupport_tupleNodes(6, node);
+  return [DecodeSupport_inItem(0, decoderA, item(0, nodes)), DecodeSupport_inItem(1, decoderB, item(1, nodes)), DecodeSupport_inItem(2, decoderC, item(2, nodes)), DecodeSupport_inItem(3, decoderD, item(3, nodes)), DecodeSupport_inItem(4, decoderE, item(4, nodes)), DecodeSupport_inItem(5, decoderF, item(5, nodes))];
+}
+function Decode_tuple7(decoderA, decoderB, decoderC, decoderD, decoderE, decoderF, decoderG, node) {
+  const nodes = DecodeSupport_tupleNodes(7, node);
+  return [DecodeSupport_inItem(0, decoderA, item(0, nodes)), DecodeSupport_inItem(1, decoderB, item(1, nodes)), DecodeSupport_inItem(2, decoderC, item(2, nodes)), DecodeSupport_inItem(3, decoderD, item(3, nodes)), DecodeSupport_inItem(4, decoderE, item(4, nodes)), DecodeSupport_inItem(5, decoderF, item(5, nodes)), DecodeSupport_inItem(6, decoderG, item(6, nodes))];
+}
+function Decode_tuple8(decoderA, decoderB, decoderC, decoderD, decoderE, decoderF, decoderG, decoderH, node) {
+  const nodes = DecodeSupport_tupleNodes(8, node);
+  return [DecodeSupport_inItem(0, decoderA, item(0, nodes)), DecodeSupport_inItem(1, decoderB, item(1, nodes)), DecodeSupport_inItem(2, decoderC, item(2, nodes)), DecodeSupport_inItem(3, decoderD, item(3, nodes)), DecodeSupport_inItem(4, decoderE, item(4, nodes)), DecodeSupport_inItem(5, decoderF, item(5, nodes)), DecodeSupport_inItem(6, decoderG, item(6, nodes)), DecodeSupport_inItem(7, decoderH, item(7, nodes))];
+}
+function Decode_map(keyDecoder, valueDecoder, node) {
+  return ofSeq$1(DecodeSupport_decodePairs(true, keyDecoder, valueDecoder, node), {
+    Compare: (x, y) => compare(x, y) | 0
+  });
+}
+function Decode_dict(keyDecoder, valueDecoder, node) {
+  const result = new Dictionary([], {
+    Equals: equals,
+    GetHashCode: (x) => structuralHash(x) | 0
+  });
+  let enumerator = getEnumerator(DecodeSupport_decodePairs(false, keyDecoder, valueDecoder, node));
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      result.set(forLoopVar[0], forLoopVar[1]);
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return result;
+}
+function Decode_entries(node) {
+  return DecodeSupport_mappingEntries("a mapping", node);
+}
+function Decode_node(node) {
+  return node;
+}
+function Decode_alias(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Alias */
+  3) {
+    return matchValue.fields[0];
+  } else {
+    return DecodeSupport_fail(DecodeSupport_expected("an alias", node), node);
+  }
+}
+function Decode_object(build, node) {
+  return build(Decode_createGetters(node));
+}
+function Decode_uniqueKeys(decoder, node) {
+  DecodeSupport_checkKeysBelow(node);
+  return decoder(node);
+}
+function Decode_tryDecode(decoder, node) {
+  try {
+    return FSharpResult$2_Ok(decoder(node));
+  } catch (matchValue) {
+    if (matchValue instanceof YamlDecodeException) {
+      const error = matchValue.Data0;
+      return FSharpResult$2_Error$(error);
+    } else {
+      throw matchValue;
+    }
+  }
+}
+
+export { DecodeError, DecodeErrorModule_pathText, DecodeErrorModule_text, DecodeError_$reflection, DecodeSupport_KeyIndex, DecodeSupport_KeyIndex_$ctor, DecodeSupport_KeyIndex_$reflection, DecodeSupport_KeyIndex__get_Integers, DecodeSupport_KeyIndex__get_Numbers, DecodeSupport_KeyWalkPlace, DecodeSupport_KeyWalkPlace_$reflection, DecodeSupport_checkKeysBelow, DecodeSupport_decodeItems, DecodeSupport_decodePairs, DecodeSupport_describeNode, DecodeSupport_describeNonString, DecodeSupport_describeNull, DecodeSupport_expected, DecodeSupport_fail, DecodeSupport_failAlias, DecodeSupport_failAt, DecodeSupport_failRepeatedKey, DecodeSupport_inEntry, DecodeSupport_inItem, DecodeSupport_inSegment, DecodeSupport_isNullNode, DecodeSupport_keyLabel, DecodeSupport_keyText, DecodeSupport_keyTokens, DecodeSupport_mappingEntries, DecodeSupport_normalizeTimestamp, DecodeSupport_parseDateTime, DecodeSupport_parseDateTimeOffset, DecodeSupport_scalarOf, DecodeSupport_sequenceItems, DecodeSupport_spanText, DecodeSupport_stringOf, DecodeSupport_tagText, DecodeSupport_tupleNodes, DecodeSupport_typedScalar, DecodeSupport_withSegment, Decode_alias, Decode_array, Decode_bool, Decode_char, Decode_datetime, Decode_datetimeOffset, Decode_dict, Decode_entries, Decode_float, Decode_int, Decode_int64, Decode_list, Decode_map, Decode_node, Decode_nonNull, Decode_object, Decode_option, Decode_resizearray, Decode_scalarText, Decode_seq, Decode_string, Decode_tryDecode, Decode_tuple2, Decode_tuple3, Decode_tuple4, Decode_tuple5, Decode_tuple6, Decode_tuple7, Decode_tuple8, Decode_uniqueKeys, Decode_values, PairKey$1, PairKey$1_$reflection, PairKey$1_NotANumber, PairKey$1_Null, PairKey$1_Value, YamlDecodeException, YamlDecodeException_$reflection };