@nfdi4plants/arctrl 3.2.3 → 3.3.1

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

@@ -0,0 +1,1502 @@
+import { getCharAtIndex, toText, printf } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { TagToken_Verbatim, TagToken_Shorthand, Lexeme, GrammarContext, Lexeme_Scalar, Lexeme_Directive, Lexeme_Tag, Lexeme_Alias, Lexeme_Anchor, Lexeme_Comment$, Lexeme_LineStart } from './Lexeme.fs.js';
+import { Cursor__get_Origin, Cursor__get_Text, LexFailure, YamlError, Cursor__SpanOf_Z37302880, Cursor__MarkAt_Z524259A4, YamlErrorCode, Cursor__set_Index_Z524259A4, Cursor__set_LineBegin_Z1FBCCD16, Located$1, Cursor__get_FirstOnLine, Cursor__get_LeadingTab, Cursor__get_AfterIndicator, Cursor__get_JsonLike, Cursor__set_JsonLikeEnd_Z524259A4, Cursor__get_InPrelude, Cursor__get_JsonLikeEnd, Cursor__get_Index, Cursor__set_SeparationHadTab_Z1FBCCD16, Cursor__set_LeadingTab_Z1FBCCD16, Cursor__get_Started, Cursor__set_Started_Z1FBCCD16, Cursor__get_LineBegin, Cursor__get_Length, Cursor__set_JsonLike_Z1FBCCD16, Cursor__set_FirstOnLine_Z1FBCCD16, Cursor__set_AfterIndicator_Z1FBCCD16, Cursor__set_InPrelude_Z1FBCCD16 } from './Source.fs.js';
+import { StringBuilder_$ctor, StringBuilder__Append_244C7CD6 } from '../../../node_modules/@fable-org/fable-library-ts/System.Text.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { defaultOf, equals } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { LayoutBoundary, ScalarLayout, SourceSpan, SourceMark, DirectiveKind_ReservedDirective, DirectiveKind_TagDirective, DirectiveKind_YamlVersion, LayoutKind_Fold, LayoutKind_EscapedBreak, ChompingMode, YamlComment, BlockScalarStyle, YamlScalar, ScalarStyle_Block, ScalarStyle } from './Model.fs.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
+import { ofSeq, empty, singleton } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { min, max } from '../../../node_modules/@fable-org/fable-library-ts/Double.js';
+import { item } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { FSharpResult$2_Ok, FSharpResult$2_Error$ } from '../../../node_modules/@fable-org/fable-library-ts/Result.js';
+
+function isBlank(c) {
+  if (c === " ") {
+    return true;
+  } else {
+    return c === "	";
+  }
+}
+function isBreak(c) {
+  if (c === "\n") {
+    return true;
+  } else {
+    return c === "\r";
+  }
+}
+function pairedSurrogate(text, k) {
+  if (~~getCharAtIndex(text, k).charCodeAt(0) < 56320) {
+    if (k + 1 < text.length && ~~getCharAtIndex(text, k + 1).charCodeAt(0) >= 56320) {
+      return ~~getCharAtIndex(text, k + 1).charCodeAt(0) < 57344;
+    } else {
+      return false;
+    }
+  } else if (k > 0 && ~~getCharAtIndex(text, k - 1).charCodeAt(0) >= 55296) {
+    return ~~getCharAtIndex(text, k - 1).charCodeAt(0) < 56320;
+  } else {
+    return false;
+  }
+}
+function isNbChar(text, k) {
+  const c = getCharAtIndex(text, k);
+  if (c >= " " && c <= "~") {
+    return true;
+  } else if (c === "	") {
+    return true;
+  } else {
+    const code = ~~c.charCodeAt(0) | 0;
+    if (code < 160) {
+      return code === 133;
+    } else if (code < 55296) {
+      return true;
+    } else if (code < 57344) {
+      return pairedSurrogate(text, k);
+    } else if (code !== 65279) {
+      if (code < 65534) {
+        return true;
+      } else {
+        return code > 65535;
+      }
+    } else {
+      return false;
+    }
+  }
+}
+function isJsonChar(text, k) {
+  const c = getCharAtIndex(text, k);
+  if (c >= " " && c <= "~") {
+    return true;
+  } else if (c === "	") {
+    return true;
+  } else {
+    const code = ~~c.charCodeAt(0) | 0;
+    if (code < 32) {
+      return false;
+    } else if (code >= 55296 && code < 57344) {
+      return pairedSurrogate(text, k);
+    } else {
+      return true;
+    }
+  }
+}
+function isFlowIndicator(c) {
+  if (((c === "," ? true : c === "[") ? true : c === "]") ? true : c === "{") {
+    return true;
+  } else {
+    return c === "}";
+  }
+}
+function isFlowGrammar(grammar) {
+  switch (grammar.tag) {
+    case /* FlowIn */
+    2:
+      return true;
+    case /* FlowKey */
+    5:
+      return true;
+    default:
+      return false;
+  }
+}
+function isKeyGrammar(grammar) {
+  switch (grammar.tag) {
+    case /* BlockKey */
+    4:
+      return true;
+    case /* FlowKey */
+    5:
+      return true;
+    default:
+      return false;
+  }
+}
+function skipBlanks(text, from) {
+  let p = from;
+  while (p < text.length && isBlank(getCharAtIndex(text, p))) {
+    p = p + 1 | 0;
+  }
+  return p | 0;
+}
+function afterBreak(text, k) {
+  if (getCharAtIndex(text, k) === "\r" && k + 1 < text.length && getCharAtIndex(text, k + 1) === "\n") {
+    return k + 2 | 0;
+  } else {
+    return k + 1 | 0;
+  }
+}
+function blankOrEnd(text, k) {
+  if (k >= text.length ? true : isBlank(getCharAtIndex(text, k))) {
+    return true;
+  } else {
+    return isBreak(getCharAtIndex(text, k));
+  }
+}
+function lineEnd(text, from) {
+  let p = from;
+  while (p < text.length && !isBreak(getCharAtIndex(text, p))) {
+    p = p + 1 | 0;
+  }
+  return p | 0;
+}
+function atLineStart(cursor, k) {
+  let j = k;
+  while (j > Cursor__get_Origin(cursor) && getCharAtIndex(Cursor__get_Text(cursor), j - 1) === "\uFEFF") {
+    j = j - 1 | 0;
+  }
+  if (j <= Cursor__get_Origin(cursor)) {
+    return true;
+  } else {
+    return isBreak(getCharAtIndex(Cursor__get_Text(cursor), j - 1));
+  }
+}
+function markerAt(text, k) {
+  if (k + 2 >= text.length) {
+    return false;
+  } else {
+    const c = getCharAtIndex(text, k);
+    if ((c === "-" ? true : c === ".") && getCharAtIndex(text, k + 1) === c && getCharAtIndex(text, k + 2) === c) {
+      return blankOrEnd(text, k + 3);
+    } else {
+      return false;
+    }
+  }
+}
+function copyRange(text, first, finish) {
+  const sb = StringBuilder_$ctor();
+  for (let k = first; k <= finish - 1; k++) {
+    StringBuilder__Append_244C7CD6(sb, getCharAtIndex(text, k));
+  }
+  return toString(sb);
+}
+function appendCodePoint(sb, codePoint) {
+  if (codePoint < 65536) {
+    StringBuilder__Append_244C7CD6(sb, String.fromCharCode(~~codePoint & 65535));
+  } else {
+    const offset = codePoint - 65536 | 0;
+    StringBuilder__Append_244C7CD6(StringBuilder__Append_244C7CD6(sb, String.fromCharCode(~~(55296 + ~~(offset / 1024)) & 65535)), String.fromCharCode(~~(56320 + offset % 1024) & 65535));
+  }
+}
+function codePointUnits(codePoint) {
+  if (codePoint < 65536) {
+    return 1;
+  } else {
+    return 2;
+  }
+}
+class Cooked {
+  constructor() {
+    this.sb = StringBuilder_$ctor();
+    this.length = 0;
+    this.marks = defaultOf();
+  }
+}
+function Cooked_$reflection() {
+  return class_type("YAMLicious.Lexer.Cooked", void 0, Cooked);
+}
+function Cooked_$ctor() {
+  return new Cooked();
+}
+function Cooked__AppendChar_244C7CD6(_, c) {
+  StringBuilder__Append_244C7CD6(_.sb, c);
+  _.length = _.length + 1 | 0;
+}
+function Cooked__AppendRange_487EF8FB(_, text, first, finish) {
+  for (let k = first; k <= finish - 1; k++) {
+    StringBuilder__Append_244C7CD6(_.sb, getCharAtIndex(text, k));
+  }
+  if (finish > first) {
+    _.length = _.length + (finish - first) | 0;
+  }
+}
+function Cooked__AppendLineFeeds_Z524259A4(_, count) {
+  for (let forLoopVar = 1; forLoopVar <= count; forLoopVar++) {
+    StringBuilder__Append_244C7CD6(_.sb, "\n");
+  }
+  if (count > 0) {
+    _.length = _.length + count | 0;
+  }
+}
+function Cooked__AppendCodePoint_Z524259A4(_, codePoint) {
+  appendCodePoint(_.sb, codePoint);
+  _.length = _.length + codePointUnits(codePoint) | 0;
+}
+function Cooked__Mark_Z20A902D6(_, kind) {
+  if (_.marks == null) {
+    _.marks = [];
+  }
+  void _.marks.push(new LayoutBoundary(_.length, kind));
+}
+function Cooked__get_Layout(_) {
+  if (_.marks == null) {
+    return void 0;
+  } else {
+    return new ScalarLayout(ofSeq(_.marks));
+  }
+}
+function Cooked__get_Text(_) {
+  return toString(_.sb);
+}
+function hexValue(c) {
+  if (c >= "0" && c <= "9") {
+    return ~~c.charCodeAt(0) - ~~"0".charCodeAt(0) | 0;
+  } else if (c >= "a" && c <= "f") {
+    return ~~c.charCodeAt(0) - ~~"a".charCodeAt(0) + 10 | 0;
+  } else if (c >= "A" && c <= "F") {
+    return ~~c.charCodeAt(0) - ~~"A".charCodeAt(0) + 10 | 0;
+  } else {
+    return -1;
+  }
+}
+function fail(cursor, code, message, first, finish, related) {
+  const text = Cursor__get_Text(cursor);
+  const limit = lineEnd(text, first) | 0;
+  const clipped = min(finish, text.length) | 0;
+  throw new LexFailure(new YamlError(code, message, Cursor__SpanOf_Z37302880(cursor, first, (clipped <= limit ? true : clipped > limit && atLineStart(cursor, first) && isBreak(getCharAtIndex(text, clipped - 1)) && !(getCharAtIndex(text, clipped - 1) === "\r" && clipped < text.length && getCharAtIndex(text, clipped) === "\n")) ? clipped : limit), related));
+}
+function bomSpan(cursor, position) {
+  const start = Cursor__MarkAt_Z524259A4(cursor, position);
+  return new SourceSpan(start, new SourceMark(start.Line, start.Column + 1));
+}
+function failBom(cursor, position) {
+  throw new LexFailure(new YamlError(YamlErrorCode.InvalidCharacter, "A byte order mark is valid inside a quoted scalar and at the start of a line outside a flow collection, and nowhere else.", bomSpan(cursor, position), empty()));
+}
+function hex4(code) {
+  return toString(StringBuilder__Append_244C7CD6(StringBuilder__Append_244C7CD6(StringBuilder__Append_244C7CD6(StringBuilder__Append_244C7CD6(StringBuilder_$ctor(), getCharAtIndex("0123456789ABCDEF", code >> 12 & 15)), getCharAtIndex("0123456789ABCDEF", code >> 8 & 15)), getCharAtIndex("0123456789ABCDEF", code >> 4 & 15)), getCharAtIndex("0123456789ABCDEF", code & 15)));
+}
+function failChar(cursor, position) {
+  let arg = void 0;
+  const code = ~~getCharAtIndex(Cursor__get_Text(cursor), position).charCodeAt(0) | 0;
+  return fail(cursor, YamlErrorCode.InvalidCharacter, code >= 55296 && code < 57344 ? "A surrogate without its partner is no character, so YAML text cannot hold it." : (arg = hex4(code), toText(printf("U+%s cannot stand in YAML text at this place. A double-quoted scalar can spell it as an escape."))(arg)), position, position + 1, empty());
+}
+function checkNbChars(cursor, first, finish) {
+  const text = Cursor__get_Text(cursor);
+  let k = first;
+  while (k < finish) {
+    if (!isNbChar(text, k)) {
+      if (getCharAtIndex(text, k) === "\uFEFF") {
+        failBom(cursor, k);
+      } else {
+        failChar(cursor, k);
+      }
+    }
+    k = k + 1 | 0;
+  }
+}
+function commentLineEnd(cursor, from) {
+  const text = Cursor__get_Text(cursor);
+  let p = from;
+  while (p < text.length && !isBreak(getCharAtIndex(text, p))) {
+    if (!isNbChar(text, p)) {
+      if (getCharAtIndex(text, p) === "\uFEFF") {
+        failBom(cursor, p);
+      } else {
+        failChar(cursor, p);
+      }
+    }
+    p = p + 1 | 0;
+  }
+  return p | 0;
+}
+function nameEnd(cursor, from) {
+  const text = Cursor__get_Text(cursor);
+  let p = from;
+  let scanning = true;
+  while (scanning && p < text.length) {
+    const c = getCharAtIndex(text, p);
+    if (((isBlank(c) ? true : isBreak(c)) ? true : isFlowIndicator(c)) ? true : c === "\uFEFF") {
+      scanning = false;
+    } else if (isNbChar(text, p)) {
+      p = p + 1 | 0;
+    } else {
+      failChar(cursor, p);
+    }
+  }
+  return p | 0;
+}
+function isWordChar(c) {
+  if ((c >= "0" && c <= "9" ? true : c >= "a" && c <= "z") ? true : c >= "A" && c <= "Z") {
+    return true;
+  } else {
+    return c === "-";
+  }
+}
+function isTagPunctuation(c) {
+  if (((((((((((((((c === "#" ? true : c === ";") ? true : c === "/") ? true : c === "?") ? true : c === ":") ? true : c === "@") ? true : c === "&") ? true : c === "=") ? true : c === "+") ? true : c === "$") ? true : c === "_") ? true : c === ".") ? true : c === "~") ? true : c === "*") ? true : c === "'") ? true : c === "(") {
+    return true;
+  } else {
+    return c === ")";
+  }
+}
+function uriCharLength(text, p) {
+  const c = getCharAtIndex(text, p);
+  if (c === "%") {
+    if (p + 2 < text.length && hexValue(getCharAtIndex(text, p + 1)) >= 0 && hexValue(getCharAtIndex(text, p + 2)) >= 0) {
+      return 3;
+    } else {
+      return 0;
+    }
+  } else if (((((isWordChar(c) ? true : isTagPunctuation(c)) ? true : c === "!") ? true : c === ",") ? true : c === "[") ? true : c === "]") {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+function tagSuffixEnd(cursor, from) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  let p = from;
+  let scanning = true;
+  while (scanning && p < n) {
+    const c = getCharAtIndex(text, p);
+    if (isWordChar(c) ? true : isTagPunctuation(c)) {
+      p = p + 1 | 0;
+    } else if (c === "%") {
+      if (p + 2 < n && hexValue(getCharAtIndex(text, p + 1)) >= 0 && hexValue(getCharAtIndex(text, p + 2)) >= 0) {
+        p = p + 3 | 0;
+      } else {
+        fail(cursor, YamlErrorCode.InvalidTag, "A `%` in a tag has to be followed by two hexadecimal digits.", p, min(n, p + 3), empty());
+      }
+    } else {
+      scanning = false;
+    }
+  }
+  return p | 0;
+}
+function scanTag(cursor, q) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  if (q + 1 < n && getCharAtIndex(text, q + 1) === "<") {
+    let p = q + 2;
+    while (p < n && getCharAtIndex(text, p) !== ">" && !isBlank(getCharAtIndex(text, p)) && !isBreak(getCharAtIndex(text, p))) {
+      const length = uriCharLength(text, p) | 0;
+      if (length === 0) {
+        fail(cursor, YamlErrorCode.InvalidTag, "A verbatim tag holds URI characters only, and a `%` has to be followed by two hexadecimal digits.", p, getCharAtIndex(text, p) === "%" ? p + 3 : p + 1, empty());
+      }
+      p = p + length | 0;
+    }
+    if (p >= n ? true : getCharAtIndex(text, p) !== ">") {
+      fail(cursor, YamlErrorCode.InvalidTag, "A verbatim tag needs a closing `>`.", q, p, empty());
+    }
+    if (p === q + 2) {
+      fail(cursor, YamlErrorCode.InvalidTag, "A verbatim tag needs a name between the angle brackets.", q, p + 1, empty());
+    }
+    if (p + 1 < n && getCharAtIndex(text, p + 1) === "#") {
+      fail(cursor, YamlErrorCode.GluedComment, "A comment needs a space or a tab before the #.", p + 1, p + 2, empty());
+    }
+    return [TagToken_Verbatim(copyRange(text, q + 2, p)), p + 1];
+  } else if (q + 1 < n && getCharAtIndex(text, q + 1) === "!") {
+    const finish = tagSuffixEnd(cursor, q + 2) | 0;
+    if (finish === q + 2) {
+      fail(cursor, YamlErrorCode.InvalidTag, "A tag needs a name behind its handle.", q, finish, empty());
+    }
+    return [TagToken_Shorthand("!!", copyRange(text, q + 2, finish)), finish];
+  } else {
+    let w = q + 1;
+    while (w < n && isWordChar(getCharAtIndex(text, w))) {
+      w = w + 1 | 0;
+    }
+    if (w > q + 1 && w < n && getCharAtIndex(text, w) === "!") {
+      const finish_1 = tagSuffixEnd(cursor, w + 1) | 0;
+      if (finish_1 === w + 1) {
+        fail(cursor, YamlErrorCode.InvalidTag, "A tag needs a name behind its handle.", q, finish_1, empty());
+      }
+      return [TagToken_Shorthand(copyRange(text, q, w + 1), copyRange(text, w + 1, finish_1)), finish_1];
+    } else {
+      const finish_2 = tagSuffixEnd(cursor, q + 1) | 0;
+      return [TagToken_Shorthand("!", copyRange(text, q + 1, finish_2)), finish_2];
+    }
+  }
+}
+function digitsValue(text, first, finish) {
+  if (finish <= first ? true : finish - first > 9) {
+    return -1;
+  } else {
+    let value = 0;
+    let valid = true;
+    for (let k = first; k <= finish - 1; k++) {
+      const c = getCharAtIndex(text, k);
+      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 scanDirective(cursor, q) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  let p = q + 1;
+  let scanning = true;
+  while (scanning && p < n) {
+    const c = getCharAtIndex(text, p);
+    if (isBreak(c)) {
+      scanning = false;
+    } else if (c === "#" && isBlank(getCharAtIndex(text, p - 1))) {
+      scanning = false;
+    } else if (isNbChar(text, p)) {
+      p = p + 1 | 0;
+    } else if (c === "\uFEFF") {
+      failBom(cursor, p);
+    } else {
+      failChar(cursor, p);
+    }
+  }
+  let finish = p;
+  while (finish > q + 1 && isBlank(getCharAtIndex(text, finish - 1))) {
+    finish = finish - 1 | 0;
+  }
+  const starts = [];
+  const ends = [];
+  let k = q + 1;
+  while (k < finish) {
+    const s = skipBlanks(text, k) | 0;
+    if (s >= finish) {
+      k = finish | 0;
+    } else {
+      let w = s;
+      while (w < finish && !isBlank(getCharAtIndex(text, w))) {
+        w = w + 1 | 0;
+      }
+      void starts.push(s);
+      void ends.push(w);
+      k = w | 0;
+    }
+  }
+  if (starts.length === 0 ? true : item(0, starts) > q + 1) {
+    fail(cursor, YamlErrorCode.InvalidDirective, "A directive needs a name right behind the `%`.", q, q + 1, empty());
+  }
+  const directiveName = copyRange(text, item(0, starts), item(0, ends));
+  const arguments$ = starts.length - 1 | 0;
+  switch (directiveName) {
+    case "YAML": {
+      if (arguments$ !== 1) {
+        fail(cursor, YamlErrorCode.InvalidDirective, "The %YAML directive needs exactly one version.", q, finish, empty());
+      }
+      const first = item(1, starts) | 0;
+      const last = item(1, ends) | 0;
+      let dot = first;
+      while (dot < last && getCharAtIndex(text, dot) !== ".") {
+        dot = dot + 1 | 0;
+      }
+      const major = digitsValue(text, first, dot) | 0;
+      const minor = digitsValue(text, dot + 1, last) | 0;
+      if ((dot >= last ? true : major < 0) ? true : minor < 0) {
+        fail(cursor, YamlErrorCode.InvalidDirective, "The version of the %YAML directive has the form 1.2.", first, last, empty());
+      }
+      return [DirectiveKind_YamlVersion(major, minor), finish];
+    }
+    case "TAG": {
+      if (arguments$ !== 2) {
+        fail(cursor, YamlErrorCode.InvalidDirective, "The %TAG directive needs a handle and a prefix.", q, finish, empty());
+      }
+      const handleFirst = item(1, starts) | 0;
+      const handleLast = item(1, ends) | 0;
+      let valid = getCharAtIndex(text, handleFirst) === "!";
+      if (valid && handleLast - handleFirst > 1) {
+        valid = getCharAtIndex(text, handleLast - 1) === "!";
+        for (let j = handleFirst + 1; j <= handleLast - 2; j++) {
+          if (!isWordChar(getCharAtIndex(text, j))) {
+            valid = false;
+          }
+        }
+      }
+      if (!valid) {
+        fail(cursor, YamlErrorCode.InvalidDirective, "A tag handle is `!`, `!!` or a word between two `!`.", handleFirst, handleLast, empty());
+      }
+      const prefixFirst = item(2, starts) | 0;
+      const prefixLast = item(2, ends) | 0;
+      const firstChar = getCharAtIndex(text, prefixFirst);
+      if ((firstChar === "," ? true : firstChar === "[") ? true : firstChar === "]") {
+        fail(cursor, YamlErrorCode.InvalidDirective, "A global tag prefix cannot start with a flow indicator.", prefixFirst, prefixFirst + 1, empty());
+      }
+      let k_1 = prefixFirst;
+      while (k_1 < prefixLast) {
+        const length = uriCharLength(text, k_1) | 0;
+        if (length === 0) {
+          fail(cursor, YamlErrorCode.InvalidDirective, "A tag prefix holds URI characters only, and a `%` has to be followed by two hexadecimal digits.", k_1, getCharAtIndex(text, k_1) === "%" ? k_1 + 3 : k_1 + 1, empty());
+        }
+        k_1 = k_1 + length | 0;
+      }
+      return [DirectiveKind_TagDirective(copyRange(text, handleFirst, handleLast), copyRange(text, item(2, starts), item(2, ends))), finish];
+    }
+    default: {
+      const words = [];
+      for (let j_1 = 1; j_1 <= starts.length - 1; j_1++) {
+        void words.push(copyRange(text, item(j_1, starts), item(j_1, ends)));
+      }
+      return [DirectiveKind_ReservedDirective(directiveName, ofSeq(words)), finish];
+    }
+  }
+}
+function plainLine(text, from, flow) {
+  const n = text.length | 0;
+  let p = from;
+  let textEnd = from;
+  let scanning = true;
+  while (scanning && p < n) {
+    const c = getCharAtIndex(text, p);
+    if (isBreak(c)) {
+      scanning = false;
+    } else if (isBlank(c)) {
+      p = p + 1 | 0;
+    } else {
+      switch (c) {
+        case ":": {
+          if (blankOrEnd(text, p + 1) ? true : flow && isFlowIndicator(getCharAtIndex(text, p + 1))) {
+            scanning = false;
+          } else {
+            p = p + 1 | 0;
+            textEnd = p | 0;
+          }
+          break;
+        }
+        case "#": {
+          if (p > from && isBlank(getCharAtIndex(text, p - 1))) {
+            scanning = false;
+          } else {
+            p = p + 1 | 0;
+            textEnd = p | 0;
+          }
+          break;
+        }
+        default:
+          if (flow && isFlowIndicator(c) ? true : !isNbChar(text, p)) {
+            scanning = false;
+          } else {
+            p = p + 1 | 0;
+            textEnd = p | 0;
+          }
+      }
+    }
+  }
+  return [textEnd, p];
+}
+function tabbedEmptyLine(text, first, finish, parentIndent) {
+  let p = first;
+  while (p < finish && getCharAtIndex(text, p) === " ") {
+    p = p + 1 | 0;
+  }
+  if (p < finish) {
+    return p - first <= parentIndent;
+  } else {
+    return false;
+  }
+}
+function scanPlain(ctx, cursor, start) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  const flow = isFlowGrammar(ctx.Grammar);
+  const singleLine = ctx.SimpleKey ? true : isKeyGrammar(ctx.Grammar);
+  const patternInput = plainLine(text, start, flow);
+  const firstEnd = patternInput[0] | 0;
+  let textEnd = firstEnd;
+  let builder = defaultOf();
+  let stop = patternInput[1];
+  let more = !singleLine && (stop >= n ? true : isBreak(getCharAtIndex(text, stop)));
+  while (more) {
+    if (stop >= n) {
+      more = false;
+    } else {
+      let r = afterBreak(text, stop);
+      let empties = 0;
+      let contentAt = -1;
+      let looking = true;
+      while (looking) {
+        const s = skipBlanks(text, r) | 0;
+        if (s >= n) {
+          looking = false;
+        } else if (isBreak(getCharAtIndex(text, s))) {
+          if (tabbedEmptyLine(text, r, s, ctx.ParentIndent)) {
+            looking = false;
+          } else {
+            empties = empties + 1 | 0;
+            r = afterBreak(text, s) | 0;
+          }
+        } else {
+          contentAt = s | 0;
+          looking = false;
+        }
+      }
+      if (contentAt < 0) {
+        more = false;
+      } else {
+        let spaces = r;
+        while (getCharAtIndex(text, spaces) === " ") {
+          spaces = spaces + 1 | 0;
+        }
+        const c = getCharAtIndex(text, contentAt);
+        if (((((markerAt(text, r) ? true : spaces - r <= ctx.ParentIndent && (!flow ? true : contentAt > spaces)) ? true : c === "#") ? true : !isNbChar(text, contentAt)) ? true : c === ":" && (blankOrEnd(text, contentAt + 1) ? true : flow && isFlowIndicator(getCharAtIndex(text, contentAt + 1)))) ? true : flow && isFlowIndicator(c)) {
+          more = false;
+        } else {
+          const patternInput_1 = plainLine(text, contentAt, flow);
+          const lineTextEnd = patternInput_1[0] | 0;
+          if (builder == null) {
+            builder = Cooked_$ctor();
+            Cooked__AppendRange_487EF8FB(builder, text, start, firstEnd);
+          }
+          if (empties === 0) {
+            Cooked__Mark_Z20A902D6(builder, LayoutKind_Fold(0));
+            Cooked__AppendChar_244C7CD6(builder, " ");
+          } else {
+            Cooked__AppendLineFeeds_Z524259A4(builder, empties);
+          }
+          Cooked__AppendRange_487EF8FB(builder, text, contentAt, lineTextEnd);
+          textEnd = lineTextEnd | 0;
+          stop = patternInput_1[1] | 0;
+          more = stop >= n ? true : isBreak(getCharAtIndex(text, stop));
+        }
+      }
+    }
+  }
+  return [builder == null ? copyRange(text, start, firstEnd) : Cooked__get_Text(builder), textEnd, builder == null ? void 0 : Cooked__get_Layout(builder)];
+}
+function foldBreak(cursor, opening, p) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  let r = afterBreak(text, p);
+  let empties = 0;
+  let result = -1;
+  while (result < 0) {
+    if (markerAt(text, r)) {
+      fail(cursor, YamlErrorCode.MarkerInQuote, "A document marker cannot stand inside a quoted scalar.", r, r + 3, singleton(opening));
+    }
+    const s = skipBlanks(text, r) | 0;
+    if (s >= n) {
+      result = s | 0;
+    } else if (isBreak(getCharAtIndex(text, s))) {
+      empties = empties + 1 | 0;
+      r = afterBreak(text, s) | 0;
+    } else {
+      result = s | 0;
+    }
+  }
+  return [empties, result];
+}
+function readHex(text, first, count) {
+  if (first + count > text.length) {
+    return -1;
+  } else {
+    let value = 0;
+    let valid = true;
+    for (let k = first; k <= first + count - 1; k++) {
+      const digit = hexValue(getCharAtIndex(text, k)) | 0;
+      if (digit < 0) {
+        valid = false;
+      } else {
+        value = value * 16 + digit | 0;
+      }
+    }
+    if (valid) {
+      return value | 0;
+    } else {
+      return -1;
+    }
+  }
+}
+function scanEscape(cursor, opening, sb, p, singleLine) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  if (p + 1 >= n) {
+    throw new LexFailure(new YamlError(YamlErrorCode.UnclosedQuote, toText(printf("The quoted scalar that starts on line %d is not closed."))(opening.Start.Line), opening, empty()));
+  }
+  const e = getCharAtIndex(text, p + 1);
+  switch (e) {
+    case "	": {
+      Cooked__AppendChar_244C7CD6(sb, "	");
+      return p + 2 | 0;
+    }
+    case "\n":
+    case "\r": {
+      if (singleLine) {
+        fail(cursor, YamlErrorCode.ImplicitKeyMultiline, "An implicit key has to stay on one line.", p, p + 2, empty());
+      }
+      const patternInput = foldBreak(cursor, opening, p + 1);
+      const empties = patternInput[0] | 0;
+      Cooked__Mark_Z20A902D6(sb, LayoutKind_EscapedBreak(empties));
+      Cooked__AppendLineFeeds_Z524259A4(sb, empties);
+      return patternInput[1] | 0;
+    }
+    case " ": {
+      Cooked__AppendChar_244C7CD6(sb, " ");
+      return p + 2 | 0;
+    }
+    case '"': {
+      Cooked__AppendChar_244C7CD6(sb, '"');
+      return p + 2 | 0;
+    }
+    case "/": {
+      Cooked__AppendChar_244C7CD6(sb, "/");
+      return p + 2 | 0;
+    }
+    case "0": {
+      Cooked__AppendChar_244C7CD6(sb, "\0");
+      return p + 2 | 0;
+    }
+    case "L": {
+      Cooked__AppendChar_244C7CD6(sb, "\u2028");
+      return p + 2 | 0;
+    }
+    case "N": {
+      Cooked__AppendChar_244C7CD6(sb, "…");
+      return p + 2 | 0;
+    }
+    case "P": {
+      Cooked__AppendChar_244C7CD6(sb, "\u2029");
+      return p + 2 | 0;
+    }
+    case "U": {
+      const value_2 = readHex(text, p + 2, 8) | 0;
+      if (value_2 < 0) {
+        fail(cursor, YamlErrorCode.InvalidEscape, "The escape \\U needs eight hexadecimal digits.", p, min(n, p + 10), singleton(opening));
+      }
+      if (value_2 > 1114111 ? true : value_2 >= 55296 && value_2 <= 57343) {
+        fail(cursor, YamlErrorCode.InvalidEscape, "The escape \\U does not name a Unicode scalar value.", p, p + 10, singleton(opening));
+      }
+      Cooked__AppendCodePoint_Z524259A4(sb, value_2);
+      return p + 10 | 0;
+    }
+    case "\\": {
+      Cooked__AppendChar_244C7CD6(sb, "\\");
+      return p + 2 | 0;
+    }
+    case "_": {
+      Cooked__AppendChar_244C7CD6(sb, " ");
+      return p + 2 | 0;
+    }
+    case "a": {
+      Cooked__AppendChar_244C7CD6(sb, "\x07");
+      return p + 2 | 0;
+    }
+    case "b": {
+      Cooked__AppendChar_244C7CD6(sb, "\b");
+      return p + 2 | 0;
+    }
+    case "e": {
+      Cooked__AppendChar_244C7CD6(sb, "\x1B");
+      return p + 2 | 0;
+    }
+    case "f": {
+      Cooked__AppendChar_244C7CD6(sb, "\f");
+      return p + 2 | 0;
+    }
+    case "n": {
+      Cooked__AppendChar_244C7CD6(sb, "\n");
+      return p + 2 | 0;
+    }
+    case "r": {
+      Cooked__AppendChar_244C7CD6(sb, "\r");
+      return p + 2 | 0;
+    }
+    case "t": {
+      Cooked__AppendChar_244C7CD6(sb, "	");
+      return p + 2 | 0;
+    }
+    case "u": {
+      const value_1 = readHex(text, p + 2, 4) | 0;
+      if (value_1 < 0) {
+        fail(cursor, YamlErrorCode.InvalidEscape, "The escape \\u needs four hexadecimal digits.", p, min(n, p + 6), singleton(opening));
+      }
+      const low = (value_1 >= 55296 && value_1 <= 56319 && p + 11 < n && getCharAtIndex(text, p + 6) === "\\" && getCharAtIndex(text, p + 7) === "u" ? readHex(text, p + 8, 4) : -1) | 0;
+      if (low >= 56320 && low <= 57343) {
+        Cooked__AppendCodePoint_Z524259A4(sb, 65536 + (value_1 - 55296) * 1024 + (low - 56320));
+        return p + 12 | 0;
+      } else if (value_1 >= 55296 && value_1 <= 57343) {
+        return fail(cursor, YamlErrorCode.InvalidEscape, "The escape \\u names a surrogate that no second escape completes to a character.", p, p + 6, singleton(opening)) | 0;
+      } else {
+        Cooked__AppendChar_244C7CD6(sb, String.fromCharCode(~~value_1 & 65535));
+        return p + 6 | 0;
+      }
+    }
+    case "v": {
+      Cooked__AppendChar_244C7CD6(sb, "\v");
+      return p + 2 | 0;
+    }
+    case "x": {
+      const value = readHex(text, p + 2, 2) | 0;
+      if (value < 0) {
+        fail(cursor, YamlErrorCode.InvalidEscape, "The escape \\x needs two hexadecimal digits.", p, min(n, p + 4), singleton(opening));
+      }
+      Cooked__AppendChar_244C7CD6(sb, String.fromCharCode(~~value & 65535));
+      return p + 4 | 0;
+    }
+    default:
+      return fail(cursor, YamlErrorCode.InvalidEscape, "The backslash starts an escape that YAML does not define.", p, p + 2, singleton(opening)) | 0;
+  }
+}
+function scanQuoted(ctx, cursor, q) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  const quote = getCharAtIndex(text, q);
+  const isDouble = quote === '"';
+  const opening = Cursor__SpanOf_Z37302880(cursor, q, q + 1);
+  const singleLine = ctx.SimpleKey ? true : isKeyGrammar(ctx.Grammar);
+  const sb = Cooked_$ctor();
+  let p = q + 1;
+  let runStart = p;
+  let closed = false;
+  while (!closed) {
+    if (p >= n) {
+      fail(cursor, YamlErrorCode.UnclosedQuote, toText(printf("The quoted scalar that starts on line %d is not closed."))(opening.Start.Line), q, q + 1, empty());
+    }
+    const c = getCharAtIndex(text, p);
+    if (c === quote) {
+      if (!isDouble && p + 1 < n && getCharAtIndex(text, p + 1) === "'") {
+        Cooked__AppendRange_487EF8FB(sb, text, runStart, p);
+        Cooked__AppendChar_244C7CD6(sb, "'");
+        p = p + 2 | 0;
+        runStart = p | 0;
+      } else {
+        Cooked__AppendRange_487EF8FB(sb, text, runStart, p);
+        closed = true;
+      }
+    } else if (isDouble && c === "\\") {
+      Cooked__AppendRange_487EF8FB(sb, text, runStart, p);
+      p = scanEscape(cursor, opening, sb, p, singleLine) | 0;
+      runStart = p | 0;
+    } else if (isBlank(c)) {
+      const r = skipBlanks(text, p) | 0;
+      if (r < n && isBreak(getCharAtIndex(text, r))) {
+        Cooked__AppendRange_487EF8FB(sb, text, runStart, p);
+        p = r | 0;
+        runStart = r | 0;
+      } else {
+        p = r | 0;
+      }
+    } else if (isBreak(c)) {
+      if (singleLine) {
+        fail(cursor, YamlErrorCode.ImplicitKeyMultiline, "An implicit key has to stay on one line.", q, p, empty());
+      }
+      Cooked__AppendRange_487EF8FB(sb, text, runStart, p);
+      const patternInput = foldBreak(cursor, opening, p);
+      const next_1 = patternInput[1] | 0;
+      const empties = patternInput[0] | 0;
+      if (empties === 0) {
+        Cooked__Mark_Z20A902D6(sb, LayoutKind_Fold(0));
+        Cooked__AppendChar_244C7CD6(sb, " ");
+      } else {
+        if (isDouble) {
+          Cooked__Mark_Z20A902D6(sb, LayoutKind_Fold(empties));
+        }
+        Cooked__AppendLineFeeds_Z524259A4(sb, empties);
+      }
+      p = next_1 | 0;
+      runStart = next_1 | 0;
+    } else if (isJsonChar(text, p)) {
+      p = p + 1 | 0;
+    } else {
+      failChar(cursor, p);
+    }
+  }
+  return [Cooked__get_Text(sb), p, Cooked__get_Layout(sb)];
+}
+function scanBlockScalar(ctx, cursor, q) {
+  let arg = void 0, arg_1 = void 0;
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  const literal = getCharAtIndex(text, q) === "|";
+  let p = q + 1;
+  let chomping = ChompingMode.Clip;
+  let chompingSet = false;
+  let digit = 0;
+  let inHeader = true;
+  while (inHeader && p < n) {
+    const c = getCharAtIndex(text, p);
+    if (c >= "1" && c <= "9") {
+      if (digit !== 0) {
+        fail(cursor, YamlErrorCode.InvalidBlockHeader, "A block scalar header holds one indentation digit.", p, p + 1, empty());
+      }
+      digit = ~~c.charCodeAt(0) - ~~"0".charCodeAt(0) | 0;
+      p = p + 1 | 0;
+    } else if (c === "-" ? true : c === "+") {
+      if (chompingSet) {
+        fail(cursor, YamlErrorCode.InvalidBlockHeader, "A block scalar header holds one chomping sign.", p, p + 1, empty());
+      }
+      chompingSet = true;
+      chomping = c === "-" ? ChompingMode.Strip : ChompingMode.Keep;
+      p = p + 1 | 0;
+    } else {
+      inHeader = false;
+    }
+  }
+  const headerEnd = p | 0;
+  const afterBlanks = skipBlanks(text, p) | 0;
+  let commentEnd = -1;
+  let headerLineEnd = afterBlanks;
+  if (afterBlanks < n && !isBreak(getCharAtIndex(text, afterBlanks))) {
+    if (getCharAtIndex(text, afterBlanks) === "#") {
+      if (afterBlanks === headerEnd) {
+        fail(cursor, YamlErrorCode.GluedComment, "A comment needs a space or a tab before the #.", afterBlanks, afterBlanks + 1, empty());
+      }
+      commentEnd = commentLineEnd(cursor, afterBlanks) | 0;
+      headerLineEnd = commentEnd | 0;
+    } else {
+      let bad = afterBlanks;
+      while (bad < n && !isBlank(getCharAtIndex(text, bad)) && !isBreak(getCharAtIndex(text, bad))) {
+        bad = bad + 1 | 0;
+      }
+      fail(cursor, YamlErrorCode.InvalidBlockHeader, "A block scalar header allows only an indentation digit and a chomping sign behind the indicator.", q, bad, empty());
+    }
+  }
+  const bodyStart = (headerLineEnd >= n ? n : afterBreak(text, headerLineEnd)) | 0;
+  const headerMark = Cursor__MarkAt_Z524259A4(cursor, headerEnd);
+  const headerComment = commentEnd < 0 ? void 0 : new YamlComment(copyRange(text, afterBlanks + 1, commentEnd), Cursor__SpanOf_Z37302880(cursor, afterBlanks, commentEnd));
+  let indent = 0;
+  if (digit > 0) {
+    indent = (ctx.ParentIndent < 0 ? 0 : ctx.ParentIndent) + digit | 0;
+  } else {
+    let r = bodyStart;
+    let longestEmpty = 0;
+    let firstSpaces = -1;
+    let seeking = true;
+    while (seeking && r < n) {
+      const le = lineEnd(text, r) | 0;
+      let spaces = r;
+      while (spaces < le && getCharAtIndex(text, spaces) === " ") {
+        spaces = spaces + 1 | 0;
+      }
+      if (spaces === le) {
+        if (le - r > longestEmpty) {
+          longestEmpty = le - r | 0;
+        }
+        r = (le >= n ? n : afterBreak(text, le)) | 0;
+      } else if ((markerAt(text, r) ? true : getCharAtIndex(text, r) === "\uFEFF") ? true : spaces - r <= ctx.ParentIndent) {
+        seeking = false;
+      } else {
+        firstSpaces = spaces - r | 0;
+        seeking = false;
+      }
+    }
+    indent = max(ctx.ParentIndent + 1, firstSpaces >= 0 ? firstSpaces : longestEmpty) | 0;
+    if (firstSpaces >= 0 && longestEmpty > indent) {
+      fail(cursor, YamlErrorCode.LeadingEmptyLine, (arg = longestEmpty | 0, arg_1 = indent | 0, toText(printf("A line of spaces in front of the first content line of a block scalar has %d spaces, more than the %d spaces of the content."))(arg)(arg_1)), bodyStart, r, empty());
+    }
+  }
+  const sb = Cooked_$ctor();
+  let r_1 = bodyStart;
+  let hasContent = false;
+  let empties = 0;
+  let previousMoreIndented = false;
+  let lastContentEnd = headerEnd;
+  let afterContent = bodyStart;
+  let reading = true;
+  while (reading && r_1 < n) {
+    const le_1 = lineEnd(text, r_1) | 0;
+    let spaces_1 = r_1;
+    while (spaces_1 < le_1 && getCharAtIndex(text, spaces_1) === " ") {
+      spaces_1 = spaces_1 + 1 | 0;
+    }
+    const onlySpaces = spaces_1 === le_1;
+    if (markerAt(text, r_1) ? true : getCharAtIndex(text, r_1) === "\uFEFF") {
+      reading = false;
+    } else if (!onlySpaces && spaces_1 - r_1 < indent) {
+      const blanksEnd = skipBlanks(text, spaces_1) | 0;
+      const tabLine = getCharAtIndex(text, spaces_1) !== "#" && (blanksEnd >= le_1 ? true : getCharAtIndex(text, blanksEnd) === "#");
+      if (getCharAtIndex(text, spaces_1) !== "#" && !tabLine && spaces_1 - r_1 > ctx.ParentIndent) {
+        fail(cursor, YamlErrorCode.BlockIndent, "A line that is more indented than the node of a block scalar, but not enough to continue the scalar, is invalid.", spaces_1, spaces_1 + 1, empty());
+      }
+      if (tabLine && ctx.ParentIndent >= 0) {
+        fail(cursor, YamlErrorCode.BlockIndent, "A line of blanks with a tab, with or without a comment, cannot follow a block scalar below the root.", spaces_1, spaces_1 + 1, empty());
+      }
+      reading = false;
+    } else {
+      if (onlySpaces && le_1 - r_1 <= indent) {
+        if (le_1 < n) {
+          empties = empties + 1 | 0;
+        }
+      } else {
+        const first = r_1 + indent | 0;
+        checkNbChars(cursor, first, le_1);
+        const moreIndented = first < le_1 && (getCharAtIndex(text, first) === " " ? true : getCharAtIndex(text, first) === "	");
+        if (literal) {
+          Cooked__AppendLineFeeds_Z524259A4(sb, hasContent ? empties + 1 : empties);
+        } else if (!hasContent) {
+          Cooked__AppendLineFeeds_Z524259A4(sb, empties);
+        } else if (previousMoreIndented ? true : moreIndented) {
+          Cooked__AppendLineFeeds_Z524259A4(sb, empties + 1);
+        } else if (empties === 0) {
+          Cooked__Mark_Z20A902D6(sb, LayoutKind_Fold(0));
+          Cooked__AppendChar_244C7CD6(sb, " ");
+        } else {
+          Cooked__AppendLineFeeds_Z524259A4(sb, empties);
+        }
+        Cooked__AppendRange_487EF8FB(sb, text, first, le_1);
+        hasContent = true;
+        previousMoreIndented = moreIndented;
+        lastContentEnd = le_1 | 0;
+        afterContent = (le_1 >= n ? n : afterBreak(text, le_1)) | 0;
+        empties = 0;
+      }
+      r_1 = (le_1 >= n ? n : afterBreak(text, le_1)) | 0;
+    }
+  }
+  const lastLineBroken = lastContentEnd < n;
+  Cooked__AppendLineFeeds_Z524259A4(sb, chomping.tag === /* Clip */
+  1 ? hasContent && lastLineBroken ? 1 : 0 : chomping.tag === /* Keep */
+  2 ? hasContent ? lastLineBroken ? empties + 1 : 0 : empties : 0);
+  const finishMark = hasContent ? Cursor__MarkAt_Z524259A4(cursor, lastContentEnd) : headerMark;
+  Cursor__set_Index_Z524259A4(cursor, equals(chomping, ChompingMode.Keep) ? r_1 : afterContent);
+  Cursor__set_LineBegin_Z1FBCCD16(cursor, true);
+  const style = literal ? BlockScalarStyle.Literal : BlockScalarStyle.Folded;
+  const indicator = digit > 0 ? digit : void 0;
+  return [new YamlScalar(Cooked__get_Text(sb), ScalarStyle_Block(style, chomping, indicator), headerComment, literal ? void 0 : Cooked__get_Layout(sb)), finishMark];
+}
+function located(cursor, start, finish, lexeme) {
+  return new Located$1(lexeme, new SourceSpan(start, Cursor__MarkAt_Z524259A4(cursor, finish)));
+}
+function single(cursor, q, start, lexeme) {
+  Cursor__set_Index_Z524259A4(cursor, q + 1);
+  return located(cursor, start, q + 1, lexeme);
+}
+function checkIndicatorTab(cursor, q, tab, separation) {
+  if (Cursor__get_FirstOnLine(cursor) && Cursor__get_LeadingTab(cursor)) {
+    let lineBegin_1 = q;
+    while (lineBegin_1 > Cursor__get_Origin(cursor) && !isBreak(getCharAtIndex(Cursor__get_Text(cursor), lineBegin_1 - 1))) {
+      lineBegin_1 = lineBegin_1 - 1 | 0;
+    }
+    fail(cursor, YamlErrorCode.TabIndentation, "A tab cannot be part of the indentation of a line.", lineBegin_1, q, empty());
+  } else if (tab && Cursor__get_AfterIndicator(cursor)) {
+    fail(cursor, YamlErrorCode.TabIndentation, "A tab cannot separate a block collection from the indicator in front of it.", separation, q, empty());
+  }
+}
+function scanToken(ctx, cursor, q, separation, tab) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  const c = getCharAtIndex(text, q);
+  const flow = isFlowGrammar(ctx.Grammar);
+  const start = Cursor__MarkAt_Z524259A4(cursor, q);
+  if ((c === "-" ? true : c === ".") && q + 2 < n && getCharAtIndex(text, q + 1) === c && getCharAtIndex(text, q + 2) === c && blankOrEnd(text, q + 3) && atLineStart(cursor, q)) {
+    Cursor__set_Index_Z524259A4(cursor, q + 3);
+    return located(cursor, start, q + 3, c === "-" ? Lexeme.DocumentStart : Lexeme.DocumentEnd);
+  } else if (c === "-" && (blankOrEnd(text, q + 1) ? true : flow && isFlowIndicator(getCharAtIndex(text, q + 1)))) {
+    if (flow) {
+      fail(cursor, YamlErrorCode.FlowDash, "Inside a flow collection a `-` needs a plain character behind it.", q, q + 1, empty());
+    }
+    checkIndicatorTab(cursor, q, tab, separation);
+    return single(cursor, q, start, Lexeme.BlockEntry);
+  } else if (c === "?" && blankOrEnd(text, q + 1)) {
+    if (!flow) {
+      checkIndicatorTab(cursor, q, tab, separation);
+    }
+    return single(cursor, q, start, Lexeme.ExplicitKey);
+  } else if (c === "?" && flow && isFlowIndicator(getCharAtIndex(text, q + 1))) {
+    return fail(cursor, YamlErrorCode.ReservedIndicator, "A `?` in front of a flow indicator starts no explicit key and no plain scalar.", q, q + 1, empty());
+  } else if (c === ":" && (blankOrEnd(text, q + 1) ? true : flow && (isFlowIndicator(getCharAtIndex(text, q + 1)) ? true : Cursor__get_JsonLike(cursor)))) {
+    if (!flow) {
+      checkIndicatorTab(cursor, q, tab, separation);
+    }
+    return single(cursor, q, start, Lexeme.Value);
+  } else {
+    switch (c) {
+      case ",": {
+        if (!flow) {
+          fail(cursor, YamlErrorCode.ReservedIndicator, "A plain scalar cannot start with a `,`.", q, q + 1, empty());
+        }
+        return single(cursor, q, start, Lexeme.FlowEntry);
+      }
+      case "[":
+        return single(cursor, q, start, Lexeme.FlowSequenceStart);
+      case "{":
+        return single(cursor, q, start, Lexeme.FlowMappingStart);
+      default:
+        if (c === "]" ? true : c === "}") {
+          if (!flow) {
+            fail(cursor, YamlErrorCode.UnopenedFlow, toText(printf("A `%c` closes no flow collection."))(c), q, q + 1, empty());
+          }
+          Cursor__set_JsonLikeEnd_Z524259A4(cursor, q + 1);
+          return single(cursor, q, start, c === "]" ? Lexeme.FlowSequenceEnd : Lexeme.FlowMappingEnd);
+        } else {
+          switch (c) {
+            case "&": {
+              const finish = nameEnd(cursor, q + 1) | 0;
+              if (finish === q + 1) {
+                fail(cursor, YamlErrorCode.EmptyAnchor, "An anchor needs a name behind the `&`.", q, q + 1, empty());
+              }
+              Cursor__set_Index_Z524259A4(cursor, finish);
+              return located(cursor, start, finish, Lexeme_Anchor(copyRange(text, q + 1, finish)));
+            }
+            case "*": {
+              const finish_1 = nameEnd(cursor, q + 1) | 0;
+              if (finish_1 === q + 1) {
+                fail(cursor, YamlErrorCode.EmptyAlias, "An alias needs a name behind the `*`.", q, q + 1, empty());
+              }
+              Cursor__set_Index_Z524259A4(cursor, finish_1);
+              return located(cursor, start, finish_1, Lexeme_Alias(copyRange(text, q + 1, finish_1)));
+            }
+            case "!": {
+              const patternInput = scanTag(cursor, q);
+              const finish_2 = patternInput[1] | 0;
+              Cursor__set_Index_Z524259A4(cursor, finish_2);
+              return located(cursor, start, finish_2, Lexeme_Tag(patternInput[0]));
+            }
+            default:
+              if (c === "|" ? true : c === ">") {
+                if (flow ? true : equals(ctx.Grammar, GrammarContext.BlockKey)) {
+                  fail(cursor, YamlErrorCode.BlockScalarPosition, "A block scalar cannot start inside a flow collection or as an implicit key.", q, q + 1, empty());
+                }
+                const patternInput_1 = scanBlockScalar(ctx, cursor, q);
+                return new Located$1(Lexeme_Scalar(patternInput_1[0]), new SourceSpan(start, patternInput_1[1]));
+              } else if (c === "'" ? true : c === '"') {
+                const patternInput_2 = scanQuoted(ctx, cursor, q);
+                const closing = patternInput_2[1] | 0;
+                Cursor__set_Index_Z524259A4(cursor, closing + 1);
+                Cursor__set_JsonLikeEnd_Z524259A4(cursor, closing + 1);
+                const finish_3 = Cursor__MarkAt_Z524259A4(cursor, closing + 1);
+                if ((ctx.SimpleKey ? true : isKeyGrammar(ctx.Grammar)) && finish_3.Column - start.Column > 1024) {
+                  fail(cursor, YamlErrorCode.ImplicitKeyLength, "An implicit key can have at most 1024 characters.", q, closing + 1, empty());
+                }
+                return new Located$1(Lexeme_Scalar(new YamlScalar(patternInput_2[0], c === '"' ? ScalarStyle.DoubleQuoted : ScalarStyle.SingleQuoted, void 0, patternInput_2[2])), new SourceSpan(start, finish_3));
+              } else if (c === "%") {
+                if (atLineStart(cursor, q) && Cursor__get_InPrelude(cursor)) {
+                  const patternInput_3 = scanDirective(cursor, q);
+                  const finish_4 = patternInput_3[1] | 0;
+                  Cursor__set_Index_Z524259A4(cursor, finish_4);
+                  return located(cursor, start, finish_4, Lexeme_Directive(patternInput_3[0]));
+                } else {
+                  return fail(cursor, YamlErrorCode.ReservedIndicator, "A plain scalar cannot start with a `%`.", q, q + 1, empty());
+                }
+              } else if (c === "@" ? true : c === "`") {
+                return fail(cursor, YamlErrorCode.ReservedIndicator, toText(printf("A plain scalar cannot start with a `%c`."))(c), q, q + 1, empty());
+              } else {
+                switch (c) {
+                  case "#":
+                    if (q === Cursor__get_JsonLikeEnd(cursor)) {
+                      return fail(cursor, YamlErrorCode.GluedComment, "A comment needs a space or a tab before the #.", q, q + 1, empty());
+                    } else {
+                      return fail(cursor, YamlErrorCode.ReservedIndicator, "A plain scalar cannot start with a `#`.", q, q + 1, empty());
+                    }
+                  case "\uFEFF":
+                    return failBom(cursor, q);
+                  default:
+                    if (!isNbChar(text, q)) {
+                      return failChar(cursor, q);
+                    } else {
+                      const patternInput_4 = scanPlain(ctx, cursor, q);
+                      const finish_5 = patternInput_4[1] | 0;
+                      Cursor__set_Index_Z524259A4(cursor, finish_5);
+                      const finishMark_1 = Cursor__MarkAt_Z524259A4(cursor, finish_5);
+                      if ((ctx.SimpleKey ? true : isKeyGrammar(ctx.Grammar)) && finishMark_1.Column - start.Column > 1024) {
+                        fail(cursor, YamlErrorCode.ImplicitKeyLength, "An implicit key can have at most 1024 characters.", q, finish_5, empty());
+                      }
+                      return new Located$1(Lexeme_Scalar(new YamlScalar(patternInput_4[0], ScalarStyle.Plain, void 0, patternInput_4[2])), new SourceSpan(start, finishMark_1));
+                    }
+                }
+              }
+          }
+        }
+    }
+  }
+}
+function lineContent(ctx, cursor) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  const i = Cursor__get_Index(cursor) | 0;
+  let q = i;
+  let tabbed = false;
+  while (q < n && isBlank(getCharAtIndex(text, q))) {
+    if (getCharAtIndex(text, q) === "	") {
+      tabbed = true;
+    }
+    q = q + 1 | 0;
+  }
+  let spaces = i;
+  while (spaces < q && getCharAtIndex(text, spaces) === " ") {
+    spaces = spaces + 1 | 0;
+  }
+  const indent = spaces - i | 0;
+  const start = Cursor__MarkAt_Z524259A4(cursor, i);
+  if (q >= n) {
+    Cursor__set_Index_Z524259A4(cursor, q);
+    Cursor__set_LineBegin_Z1FBCCD16(cursor, false);
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, false);
+    return located(cursor, start, q, Lexeme.BlankLine);
+  } else if (isBreak(getCharAtIndex(text, q))) {
+    const lexeme = located(cursor, start, q, Lexeme.BlankLine);
+    Cursor__set_Index_Z524259A4(cursor, afterBreak(text, q));
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, false);
+    return lexeme;
+  } else if (getCharAtIndex(text, q) === "#") {
+    const finish = commentLineEnd(cursor, q) | 0;
+    const span = Cursor__SpanOf_Z37302880(cursor, q, finish);
+    Cursor__set_Index_Z524259A4(cursor, finish);
+    Cursor__set_LineBegin_Z1FBCCD16(cursor, false);
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, tabbed);
+    return new Located$1(Lexeme_Comment$(new YamlComment(copyRange(text, q + 1, finish), span), true), span);
+  } else if (isFlowGrammar(ctx.Grammar)) {
+    if (i === q && markerAt(text, i)) {
+      fail(cursor, YamlErrorCode.MarkerInFlow, "A document marker cannot stand inside a flow collection.", i, i + 3, empty());
+    }
+    Cursor__set_Index_Z524259A4(cursor, q);
+    Cursor__set_LineBegin_Z1FBCCD16(cursor, false);
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, false);
+    return void 0;
+  } else {
+    Cursor__set_Index_Z524259A4(cursor, q);
+    Cursor__set_LineBegin_Z1FBCCD16(cursor, false);
+    Cursor__set_LeadingTab_Z1FBCCD16(cursor, tabbed);
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, tabbed);
+    return located(cursor, start, q, Lexeme_LineStart(indent, tabbed));
+  }
+}
+function lineBegin(ctx, cursor) {
+  const text = Cursor__get_Text(cursor);
+  if (!isFlowGrammar(ctx.Grammar) && Cursor__get_Index(cursor) < text.length && getCharAtIndex(text, Cursor__get_Index(cursor)) === "\uFEFF") {
+    const span = bomSpan(cursor, Cursor__get_Index(cursor));
+    let bomEnd = Cursor__get_Index(cursor) + 1;
+    while (bomEnd < text.length && getCharAtIndex(text, bomEnd) === "\uFEFF") {
+      bomEnd = bomEnd + 1 | 0;
+    }
+    Cursor__set_Index_Z524259A4(cursor, bomEnd);
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, false);
+    return new Located$1(Lexeme.ByteOrderMark, span);
+  } else {
+    return lineContent(ctx, cursor);
+  }
+}
+function inLine(ctx, cursor) {
+  const text = Cursor__get_Text(cursor);
+  const n = text.length | 0;
+  const i = Cursor__get_Index(cursor) | 0;
+  const q = skipBlanks(text, i) | 0;
+  let tab = false;
+  for (let k = i; k <= q - 1; k++) {
+    if (getCharAtIndex(text, k) === "	") {
+      tab = true;
+    }
+  }
+  Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, tab);
+  if (q >= n) {
+    Cursor__set_Index_Z524259A4(cursor, n);
+    const mark = Cursor__MarkAt_Z524259A4(cursor, n);
+    return new Located$1(Lexeme.StreamEnd, new SourceSpan(mark, mark));
+  } else if (isBreak(getCharAtIndex(text, q))) {
+    Cursor__set_Index_Z524259A4(cursor, afterBreak(text, q));
+    Cursor__set_LineBegin_Z1FBCCD16(cursor, true);
+    return void 0;
+  } else if (getCharAtIndex(text, q) === "#" && q > i) {
+    const finish = commentLineEnd(cursor, q) | 0;
+    const span = Cursor__SpanOf_Z37302880(cursor, q, finish);
+    Cursor__set_Index_Z524259A4(cursor, finish);
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, tab);
+    return new Located$1(Lexeme_Comment$(new YamlComment(copyRange(text, q + 1, finish), span), false), span);
+  } else {
+    Cursor__set_Index_Z524259A4(cursor, q);
+    Cursor__set_SeparationHadTab_Z1FBCCD16(cursor, tab);
+    return scanToken(ctx, cursor, q, i, tab);
+  }
+}
+function lexNext(ctx, cursor) {
+  if (!Cursor__get_Started(cursor)) {
+    Cursor__set_Started_Z1FBCCD16(cursor, true);
+    const mark = Cursor__MarkAt_Z524259A4(cursor, Cursor__get_Origin(cursor));
+    return new Located$1(Lexeme.StreamStart, new SourceSpan(mark, mark));
+  } else {
+    let result = void 0;
+    while (result == null) {
+      if (Cursor__get_LineBegin(cursor)) {
+        if (Cursor__get_Index(cursor) >= Cursor__get_Length(cursor)) {
+          const mark_1 = Cursor__MarkAt_Z524259A4(cursor, Cursor__get_Length(cursor));
+          result = new Located$1(Lexeme.StreamEnd, new SourceSpan(mark_1, mark_1));
+        } else {
+          result = lineBegin(ctx, cursor);
+        }
+      } else {
+        result = inLine(ctx, cursor);
+      }
+    }
+    return value(result);
+  }
+}
+function next(ctx, cursor) {
+  try {
+    const lexeme = lexNext(ctx, cursor);
+    const matchValue = lexeme.Value;
+    switch (matchValue.tag) {
+      case /* Comment */
+      19: {
+        break;
+      }
+      case /* BlankLine */
+      20: {
+        break;
+      }
+      case /* LineStart */
+      6: {
+        break;
+      }
+      case /* ByteOrderMark */
+      4: {
+        break;
+      }
+      case /* FlowSequenceEnd */
+      11: {
+        Cursor__set_JsonLike_Z1FBCCD16(cursor, true);
+        break;
+      }
+      case /* FlowMappingEnd */
+      13: {
+        Cursor__set_JsonLike_Z1FBCCD16(cursor, true);
+        break;
+      }
+      case /* Scalar */
+      18: {
+        const scalar = matchValue.fields[0];
+        Cursor__set_JsonLike_Z1FBCCD16(cursor, equals(scalar.Style, ScalarStyle.SingleQuoted) ? true : equals(scalar.Style, ScalarStyle.DoubleQuoted));
+        break;
+      }
+      default:
+        Cursor__set_JsonLike_Z1FBCCD16(cursor, false);
+    }
+    const matchValue_1 = lexeme.Value;
+    switch (matchValue_1.tag) {
+      case /* LineStart */
+      6: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, true);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* BlockEntry */
+      7: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, true);
+        Cursor__set_InPrelude_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* ExplicitKey */
+      8: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, true);
+        Cursor__set_InPrelude_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* Value */
+      9: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, true);
+        Cursor__set_InPrelude_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* DocumentEnd */
+      3: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        Cursor__set_InPrelude_Z1FBCCD16(cursor, true);
+        break;
+      }
+      case /* Directive */
+      5: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* Comment */
+      19: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* ByteOrderMark */
+      4: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        Cursor__set_InPrelude_Z1FBCCD16(cursor, true);
+        break;
+      }
+      case /* BlankLine */
+      20: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* StreamStart */
+      0: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        break;
+      }
+      case /* StreamEnd */
+      1: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        break;
+      }
+      default: {
+        Cursor__set_FirstOnLine_Z1FBCCD16(cursor, false);
+        Cursor__set_AfterIndicator_Z1FBCCD16(cursor, false);
+        Cursor__set_InPrelude_Z1FBCCD16(cursor, false);
+      }
+    }
+    return FSharpResult$2_Ok(lexeme);
+  } catch (matchValue_2) {
+    if (matchValue_2 instanceof LexFailure) {
+      const error = matchValue_2.Data0;
+      return FSharpResult$2_Error$(error);
+    } else {
+      throw matchValue_2;
+    }
+  }
+}
+function nextIsBlockEntry(cursor) {
+  if (Cursor__get_Index(cursor) < Cursor__get_Length(cursor) && getCharAtIndex(Cursor__get_Text(cursor), Cursor__get_Index(cursor)) === "-") {
+    return blankOrEnd(Cursor__get_Text(cursor), Cursor__get_Index(cursor) + 1);
+  } else {
+    return false;
+  }
+}
+function decodeTagEscapes(text) {
+  if (text.indexOf("%") < 0) {
+    return text;
+  } else {
+    const sb = StringBuilder_$ctor();
+    let valid = true;
+    let i = 0;
+    const byteAt = (index) => hexValue(getCharAtIndex(text, index + 1)) * 16 + hexValue(getCharAtIndex(text, index + 2)) | 0;
+    while (valid && i < text.length) {
+      if (getCharAtIndex(text, i) !== "%") {
+        StringBuilder__Append_244C7CD6(sb, getCharAtIndex(text, i));
+        i = i + 1 | 0;
+      } else {
+        const lead = byteAt(i) | 0;
+        const extra = (lead < 128 ? 0 : lead >= 194 && lead <= 223 ? 1 : lead >= 224 && lead <= 239 ? 2 : lead >= 240 && lead <= 244 ? 3 : -1) | 0;
+        if (extra < 0 ? true : i + 3 * (extra + 1) > text.length) {
+          valid = false;
+        } else {
+          let codePoint = extra === 0 ? lead : extra === 1 ? lead & 31 : extra === 2 ? lead & 15 : lead & 7;
+          for (let k = 1; k <= extra; k++) {
+            const at = i + 3 * k | 0;
+            if (getCharAtIndex(text, at) !== "%") {
+              valid = false;
+            } else {
+              const next_1 = byteAt(at) | 0;
+              if ((next_1 & 192) !== 128) {
+                valid = false;
+              }
+              codePoint = codePoint << 6 | next_1 & 63 | 0;
+            }
+          }
+          if (((extra === 2 && codePoint < 2048 ? true : extra === 3 && codePoint < 65536) ? true : codePoint > 1114111) ? true : codePoint >= 55296 && codePoint <= 57343) {
+            valid = false;
+          }
+          if (valid) {
+            appendCodePoint(sb, codePoint);
+          }
+          i = i + 3 * (extra + 1) | 0;
+        }
+      }
+    }
+    if (valid) {
+      return toString(sb);
+    } else {
+      return void 0;
+    }
+  }
+}
+
+export { decodeTagEscapes, next, nextIsBlockEntry };