@nfdi4plants/arctrl 3.2.2 → 3.3.0

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

@@ -0,0 +1,1084 @@
+import { Record, toString } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { int32ToString, equals, getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { record_type, option_type, string_type, int32_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 { item, fill, setItem } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { CollectionStyle, ChompingMode, PropertyName, Separation } from './Model.fs.js';
+import { empty, isEmpty, head, exists, FSharpList__get_Tail, FSharpList__get_Head, length, filter, toArray, tryLast, last, ofSeq } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { toList, delay, collect, empty as empty$1, singleton } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { getCharAtIndex } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { addToSet } from '../../../node_modules/@fable-org/fable-library-ts/MapUtil.js';
+import { YamlNodeModule_isMissingValue, YamlNodeModule_isPropertyOnly } from './Node.fs.js';
+
+class NodePath_PathInfo extends Record {
+  constructor(Parent, Segment, Depth) {
+    super();
+    this.Parent = Parent;
+    this.Segment = Segment;
+    this.Depth = Depth | 0;
+  }
+}
+function NodePath_PathInfo_$reflection() {
+  return record_type("YAMLicious.NodePath.PathInfo", [], NodePath_PathInfo, () => [["Parent", option_type(NodePath_PathInfo_$reflection())], ["Segment", string_type], ["Depth", int32_type]]);
+}
+const NodePath_fullPathDepth = 64;
+const NodePath_tailSegments = 8;
+function NodePath_materialize(path, head) {
+  const segments = [];
+  let current = path;
+  let remaining = path.Depth <= NodePath_fullPathDepth ? 2147483647 : NodePath_tailSegments;
+  while (remaining > 0 && current != null) {
+    const here = value(current);
+    void segments.push(here.Segment);
+    remaining = remaining - 1 | 0;
+    current = here.Parent;
+  }
+  const sb = StringBuilder_$ctor();
+  if (path.Depth > NodePath_fullPathDepth) {
+    StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, head), "("), int32ToString(path.Depth)), ")");
+  }
+  for (let i = segments.length - 1; i >= 0; i--) {
+    StringBuilder__Append_Z721C83C5(sb, item(i, segments));
+  }
+  return toString(sb);
+}
+function NodePath_slotOf(path) {
+  return NodePath_materialize(path, "root");
+}
+function NodePath_child(parent, segment) {
+  return new NodePath_PathInfo(parent, segment, parent.Depth + 1);
+}
+const NodePath_rootPath = new NodePath_PathInfo(void 0, "root", 0);
+function Validate_isBlockCollection(node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Mapping */
+    1:
+      return equals(matchValue.fields[0].Style, CollectionStyle.Block);
+    case /* Sequence */
+    2:
+      return equals(matchValue.fields[0].Style, CollectionStyle.Block);
+    default:
+      return false;
+  }
+}
+function Validate_isBareBlockCollection(node) {
+  if (Validate_isBlockCollection(node) && node.Properties.Tag == null) {
+    return node.Properties.Anchor == null;
+  } else {
+    return false;
+  }
+}
+function Validate_isBlockScalar(scalar) {
+  if (scalar.Style.tag === /* Block */
+  3) {
+    return true;
+  } else {
+    return false;
+  }
+}
+function Validate_followingOf(separation) {
+  let matchResult = void 0, lineBreak = void 0;
+  if (separation != null) {
+    if (separation.tag === /* NewLine */
+    1) {
+      matchResult = 0;
+      lineBreak = separation.fields[0];
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return lineBreak.Following;
+    default:
+      return empty();
+  }
+}
+function Validate_startsWithBlankLine(lines) {
+  let matchResult = void 0;
+  if (!isEmpty(lines)) {
+    if (head(lines).tag === /* BlankLine */
+    1) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    default:
+      return false;
+  }
+}
+function Validate_linesBehindRoot(document$, next) {
+  if (!isEmpty(document$.AfterRoot)) {
+    return document$.AfterRoot;
+  } else if (document$.EndMarker != null) {
+    return empty();
+  } else if (next == null) {
+    return empty();
+  } else {
+    const following = next;
+    if (exists((item) => {
+      if (item.tag === /* PreludeTrivia */
+      1) {
+        return false;
+      } else {
+        return true;
+      }
+    }, following.Prelude)) {
+      return empty();
+    } else {
+      return toList(delay(() => collect((item_1) => {
+        const matchValue = item_1;
+        if (matchValue.tag === /* Directive */
+        0) {
+          return empty$1();
+        } else {
+          return singleton(matchValue.fields[0]);
+        }
+      }, following.Prelude)));
+    }
+  }
+}
+function Validate_blankLineFollowsRoot(document$, next) {
+  return Validate_startsWithBlankLine(Validate_linesBehindRoot(document$, next));
+}
+function Validate_commentFollowsRoot(document$, next) {
+  let rest = Validate_linesBehindRoot(document$, next);
+  while (Validate_startsWithBlankLine(rest)) {
+    rest = FSharpList__get_Tail(rest);
+  }
+  let matchResult = void 0;
+  if (!isEmpty(rest)) {
+    if (head(rest).tag === /* FullLineComment */
+    0) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    default:
+      return false;
+  }
+}
+function Validate_isNbChar(c) {
+  const code = ~~c.charCodeAt(0) | 0;
+  if ((((code === 9 ? true : code >= 32 && code <= 126) ? true : code === 133) ? true : code >= 160 && code <= 55295) ? true : code >= 57344 && code <= 65533 && code !== 65279) {
+    return true;
+  } else {
+    return code >= 65536;
+  }
+}
+function Validate_isNsChar(c) {
+  if (Validate_isNbChar(c) && c !== " ") {
+    return c !== "	";
+  } else {
+    return false;
+  }
+}
+function Validate_isFlowIndicatorChar(c) {
+  if (((c === "," ? true : c === "[") ? true : c === "]") ? true : c === "{") {
+    return true;
+  } else {
+    return c === "}";
+  }
+}
+function Validate_isAnchorChar(c) {
+  if (Validate_isNsChar(c)) {
+    return !Validate_isFlowIndicatorChar(c);
+  } else {
+    return false;
+  }
+}
+function Validate_allChars(accept, text) {
+  let ok = true;
+  let i = 0;
+  while (ok && i < text.length) {
+    const code = ~~getCharAtIndex(text, i).charCodeAt(0) | 0;
+    if (code >= 55296 && code <= 56319) {
+      if (i + 1 < text.length && ~~getCharAtIndex(text, i + 1).charCodeAt(0) >= 56320 && ~~getCharAtIndex(text, i + 1).charCodeAt(0) <= 57343) {
+        i = i + 2 | 0;
+      } else {
+        ok = false;
+      }
+    } else if (code >= 56320 && code <= 57343) {
+      ok = false;
+    } else if (accept(getCharAtIndex(text, i))) {
+      i = i + 1 | 0;
+    } else {
+      ok = false;
+    }
+  }
+  return ok;
+}
+function Validate_isCommentText(text) {
+  return Validate_allChars(Validate_isNbChar, text);
+}
+function Validate_isAnchorName(text) {
+  if (text.length > 0) {
+    return Validate_allChars(Validate_isAnchorChar, text);
+  } else {
+    return false;
+  }
+}
+function Validate_isDirectiveWord(text) {
+  if (text.length > 0) {
+    return Validate_allChars(Validate_isNsChar, text);
+  } else {
+    return false;
+  }
+}
+function Validate_isBlockChar(c) {
+  if (c === "\n") {
+    return true;
+  } else {
+    return Validate_isNbChar(c);
+  }
+}
+function Validate_isBlockText(text) {
+  return Validate_allChars(Validate_isBlockChar, text);
+}
+function Validate_blockChomping(value, stored, endsText) {
+  const n = value.length | 0;
+  let bodyEnd = n;
+  while (bodyEnd > 0 && getCharAtIndex(value, bodyEnd - 1) === "\n") {
+    bodyEnd = bodyEnd - 1 | 0;
+  }
+  const breaks = n - bodyEnd | 0;
+  const onlyBreaks = n > 0 && bodyEnd === 0;
+  const derived = breaks === 0 ? ChompingMode.Strip : onlyBreaks ? ChompingMode.Keep : breaks === 1 ? ChompingMode.Clip : ChompingMode.Keep;
+  const fits = stored.tag === /* Clip */
+  1 ? (n === 0 ? true : breaks === 1 && !onlyBreaks) ? true : endsText : stored.tag === /* Keep */
+  2 ? (n === 0 ? true : breaks >= 1) ? true : endsText : breaks === 0;
+  return [fits ? stored : derived, fits];
+}
+function Validate_storedKeepApplies(style, value) {
+  let matchResult = void 0;
+  if (style.tag === /* Block */
+  3) {
+    if (style.fields[1].tag === /* Keep */
+    2) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      if (Validate_isBlockText(value)) {
+        return Validate_blockChomping(value, ChompingMode.Keep, false)[1];
+      } else {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+const Validate_keepText = "a blank line directly behind a block scalar with the stored chomping Keep belongs to the value of the scalar when more content follows and the Keep fits the value, so the trivia cannot hold it (l-chomped-empty, [165] to [169])";
+const Validate_followingText = "the trivia belong to the Before of the first entry or item of the block collection behind the line break (R2)";
+const Validate_missingText = "the content behind the indicator is missing, so the trivia belong to the Before of the next entry or item, or to BeforeColon behind a question mark when a colon follows (R2)";
+const Validate_endText = "the trivia behind a block collection belong to its End only when the collection is the last node of its document, and otherwise to the Before of the next entry or item (R4)";
+const Validate_startsLaterText = "a block collection starts on a later line than its last property, so a line break follows that property (R1)";
+const Validate_colonText = "a block collection without a property starts on a later line than the colon of an implicit entry, so a line break follows the colon (R1)";
+const Validate_compactText = "a block collection that continues the line of an indicator has no trivia in front of its first entry or item, because they would stand in front of the indicator (R2, R4)";
+const Validate_commentText = "a comment holds a character that a comment line cannot hold: a line break, a control character, a byte order mark or half of a surrogate pair (nb-char, [27])";
+const Validate_nameText = "a name behind & or * has one or more ns-anchor-char characters ([102]), so it holds no blank, line break, flow indicator, control character or byte order mark";
+const Validate_colonValueText = "an entry with a value has a colon, because the value indicator is omitted only behind a key without a value";
+const Validate_tagText = "a named tag has a suffix of one or more characters, because a shorthand tag is a handle followed by ns-tag-char characters ([99]) and a verbatim tag holds a URI ([98])";
+const Validate_endBlankText = "a blank line goes with the comment that follows it, so the End of a nested block collection ends with a comment unless it holds the last comment behind the last node (R4)";
+const Validate_endAfterText = "the lines behind the last comment of the trivia behind the last node stay in the End that holds that comment, and trivia without a comment stay in the End of the root collection (R4)";
+const Validate_implicitColonText = "the entry of a block mapping without a question mark has a colon, because its key stands on one line with the colon";
+function Validate_checkComment(report, slot, comment) {
+  let matchResult = void 0, found_1 = void 0;
+  if (comment != null) {
+    if (!Validate_isCommentText(comment.Text)) {
+      matchResult = 0;
+      found_1 = comment;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      report(slot, Validate_commentText);
+      break;
+    }
+    case 1: {
+      break;
+    }
+  }
+}
+function Validate_checkTrivia(report, slot, lines) {
+  let rest = lines;
+  let index = 0;
+  while (!isEmpty(rest)) {
+    const matchValue = FSharpList__get_Head(rest);
+    if (matchValue.tag === /* BlankLine */
+    1) {
+    } else {
+      const found = matchValue.fields[0];
+      Validate_checkComment(report, slot + "[" + int32ToString(index) + "]", found);
+    }
+    rest = FSharpList__get_Tail(rest);
+    index = index + 1 | 0;
+  }
+}
+function Validate_checkSeparation(report, slot, separation) {
+  let matchResult = void 0, lineBreak = void 0;
+  if (separation != null) {
+    if (separation.tag === /* NewLine */
+    1) {
+      matchResult = 0;
+      lineBreak = separation.fields[0];
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0: {
+      Validate_checkComment(report, slot + ".Comment", lineBreak.Comment);
+      Validate_checkTrivia(report, slot + ".Following", lineBreak.Following);
+      break;
+    }
+    case 1: {
+      break;
+    }
+  }
+}
+function Validate_isWordChar(c) {
+  if ((c >= "0" && c <= "9" ? true : c >= "a" && c <= "z") ? true : c >= "A" && c <= "Z") {
+    return true;
+  } else {
+    return c === "-";
+  }
+}
+function Validate_isHexChar(c) {
+  if (c >= "0" && c <= "9" ? true : c >= "a" && c <= "f") {
+    return true;
+  } else if (c >= "A") {
+    return c <= "F";
+  } else {
+    return false;
+  }
+}
+function Validate_isUriPunctuation(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 === "(") ? true : c === ")") ? true : c === "!") ? true : c === ",") ? true : c === "[") {
+    return true;
+  } else {
+    return c === "]";
+  }
+}
+function Validate_isTagHandle(handle) {
+  if (handle === "!" ? true : handle === "!!") {
+    return true;
+  } else if (handle.length >= 3 && getCharAtIndex(handle, 0) === "!" && getCharAtIndex(handle, handle.length - 1) === "!") {
+    let ok = true;
+    for (let i = 1; i <= handle.length - 2; i++) {
+      if (!Validate_isWordChar(getCharAtIndex(handle, i))) {
+        ok = false;
+      }
+    }
+    return ok;
+  } else {
+    return false;
+  }
+}
+function Validate_isTagPrefix(prefix) {
+  let ok = prefix.length > 0 && !((getCharAtIndex(prefix, 0) === "," ? true : getCharAtIndex(prefix, 0) === "[") ? true : getCharAtIndex(prefix, 0) === "]");
+  let i = 0;
+  while (ok && i < prefix.length) {
+    const c = getCharAtIndex(prefix, i);
+    if (c === "%") {
+      if (i + 2 < prefix.length && Validate_isHexChar(getCharAtIndex(prefix, i + 1)) && Validate_isHexChar(getCharAtIndex(prefix, i + 2))) {
+        i = i + 3 | 0;
+      } else {
+        ok = false;
+      }
+    } else if (Validate_isWordChar(c) ? true : Validate_isUriPunctuation(c)) {
+      i = i + 1 | 0;
+    } else {
+      ok = false;
+    }
+  }
+  return ok;
+}
+function Validate_checkPrelude(errors, prefix, prelude) {
+  const handles = /* @__PURE__ */ new Set([]);
+  let versions = 0;
+  let index = 0;
+  const enumerator = getEnumerator(prelude);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      const slot = prefix + "Prelude[" + int32ToString(index) + "]";
+      const report = (suffix, text) => {
+        void errors.push(slot + suffix + ": " + text);
+      };
+      if (item.tag === /* Directive */
+      0) {
+        const directive = item.fields[0];
+        Validate_checkComment(report, ".TrailingComment", directive.TrailingComment);
+        const matchValue = directive.Kind;
+        switch (matchValue.tag) {
+          case /* TagDirective */
+          1: {
+            const tagPrefix = matchValue.fields[1];
+            const handle = matchValue.fields[0];
+            if (!Validate_isTagHandle(handle)) {
+              report(".Kind", "a tag handle is !, !! or a word between two !");
+            } else if (!addToSet(handle, handles)) {
+              report(".Kind", "a tag handle is declared once in a document");
+            }
+            if (!Validate_isTagPrefix(tagPrefix)) {
+              report(".Kind", "a tag prefix holds URI characters and no flow indicator at the start");
+            }
+            break;
+          }
+          case /* ReservedDirective */
+          2: {
+            const name = matchValue.fields[0];
+            const arguments$ = matchValue.fields[1];
+            if ((!Validate_isDirectiveWord(name) ? true : name === "YAML") ? true : name === "TAG") {
+              report(".Kind", "a reserved directive has a name of ns-char characters that is neither YAML nor TAG");
+            }
+            const enumerator_1 = getEnumerator(arguments$);
+            try {
+              while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                const argument = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                if (!Validate_isDirectiveWord(argument) ? true : getCharAtIndex(argument, 0) === "#") {
+                  report(".Kind", "a parameter of a reserved directive has ns-char characters and does not start with a # that would begin a comment");
+                }
+              }
+            } finally {
+              disposeSafe(enumerator_1);
+            }
+            break;
+          }
+          default: {
+            const minor = matchValue.fields[1] | 0;
+            const major = matchValue.fields[0] | 0;
+            versions = versions + 1 | 0;
+            if (versions > 1) {
+              report(".Kind", "a document has at most one %YAML directive");
+            }
+            if ((major !== 1 ? true : minor < 0) ? true : minor > 999999999) {
+              report(".Kind", "the %YAML directive names a version 1.x with a minor number of at most nine digits");
+            }
+          }
+        }
+      } else if (item.fields[0].tag === /* BlankLine */
+      1) {
+      } else {
+        const found = item.fields[0].fields[0];
+        Validate_checkComment(report, "", found);
+      }
+      index = index + 1 | 0;
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+}
+function Validate_checkCompact(report, slot, content) {
+  if (Validate_isBareBlockCollection(content)) {
+    const matchValue = content.Kind;
+    switch (matchValue.tag) {
+      case /* Mapping */
+      1: {
+        const matchValue_1 = matchValue.fields[0].Items;
+        let matchResult = void 0, first_1 = void 0;
+        if (!isEmpty(matchValue_1)) {
+          if (!isEmpty(head(matchValue_1).Before)) {
+            matchResult = 0;
+            first_1 = head(matchValue_1);
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0: {
+            report(slot + ".entries[0].Before", Validate_compactText);
+            break;
+          }
+          case 1: {
+            break;
+          }
+        }
+        break;
+      }
+      case /* Sequence */
+      2: {
+        const matchValue_2 = matchValue.fields[0].Items;
+        let matchResult_1 = void 0, first_3 = void 0;
+        if (!isEmpty(matchValue_2)) {
+          if (!isEmpty(head(matchValue_2).Before)) {
+            matchResult_1 = 0;
+            first_3 = head(matchValue_2);
+          } else {
+            matchResult_1 = 1;
+          }
+        } else {
+          matchResult_1 = 1;
+        }
+        switch (matchResult_1) {
+          case 0: {
+            report(slot + ".items[0].Before", Validate_compactText);
+            break;
+          }
+          case 1: {
+            break;
+          }
+        }
+        break;
+      }
+      default:
+    }
+  }
+}
+function Validate_checkFollowing(report, slot, separation, content) {
+  if (!isEmpty(Validate_followingOf(separation))) {
+    if (Validate_isBareBlockCollection(content)) {
+      report(slot, Validate_followingText);
+    } else if (YamlNodeModule_isMissingValue(content)) {
+      report(slot, Validate_missingText);
+    }
+  }
+}
+function Validate_walkNode(errors, prefix, canEnd, blankAfterRoot, root) {
+  const stack = [];
+  void stack.push([root, NodePath_rootPath, false, canEnd, blankAfterRoot]);
+  while (stack.length > 0) {
+    let name_3 = void 0;
+    const last = stack.length - 1 | 0;
+    const patternInput = item(last, stack);
+    const path = patternInput[1];
+    const node = patternInput[0];
+    const isLastNode = patternInput[3];
+    const blankFollows = patternInput[4] | 0;
+    stack.splice(last, 1);
+    const report = (suffix, text) => {
+      void errors.push(prefix + NodePath_slotOf(path) + suffix + ": " + text);
+    };
+    const layoutCount = (name) => length(filter((placement) => equals(placement.Property, name), node.PropertyLayout)) | 0;
+    if (layoutCount(PropertyName.Tag) !== (node.Properties.Tag != null ? 1 : 0)) {
+      report(".PropertyLayout", "the layout names the tag once when the node has a tag and never otherwise");
+    }
+    if (layoutCount(PropertyName.Anchor) !== (node.Properties.Anchor != null ? 1 : 0)) {
+      report(".PropertyLayout", "the layout names the anchor once when the node has an anchor and never otherwise");
+    }
+    if ((Validate_isBlockCollection(node) ? true : YamlNodeModule_isPropertyOnly(node)) && !isEmpty(node.PropertyLayout)) {
+      const placements = toArray(node.PropertyLayout);
+      const lastIndex = placements.length - 1 | 0;
+      if (!isEmpty(Validate_followingOf(item(lastIndex, placements).After))) {
+        report(".PropertyLayout[" + int32ToString(lastIndex) + "].After.Following", Validate_isBlockCollection(node) ? Validate_followingText : Validate_missingText);
+      }
+      if (Validate_isBlockCollection(node) && equals(item(lastIndex, placements).After, Separation.Inline)) {
+        report(".PropertyLayout[" + int32ToString(lastIndex) + "].After", Validate_startsLaterText);
+      }
+    }
+    Validate_checkComment(report, ".TrailingComment", node.TrailingComment);
+    const matchValue = node.Properties.Anchor;
+    let matchResult = void 0, name_2 = void 0;
+    if (matchValue != null) {
+      if (!Validate_isAnchorName(matchValue)) {
+        matchResult = 0;
+        name_2 = matchValue;
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0: {
+        report(".Properties.Anchor", Validate_nameText);
+        break;
+      }
+    }
+    const matchValue_1 = node.Properties.Tag;
+    let matchResult_1 = void 0, name_4 = void 0;
+    if (matchValue_1 != null) {
+      if (matchValue_1.tag === /* Named */
+      1) {
+        if (name_3 = matchValue_1.fields[0], name_3.Suffix.length === 0) {
+          matchResult_1 = 0;
+          name_4 = matchValue_1.fields[0];
+        } else {
+          matchResult_1 = 1;
+        }
+      } else {
+        matchResult_1 = 1;
+      }
+    } else {
+      matchResult_1 = 1;
+    }
+    switch (matchResult_1) {
+      case 0: {
+        report(".Properties.Tag", Validate_tagText);
+        break;
+      }
+    }
+    let placementIndex = 0;
+    const enumerator = getEnumerator(node.PropertyLayout);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const placement_1 = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        Validate_checkSeparation(report, ".PropertyLayout[" + int32ToString(placementIndex) + "].After", placement_1.After);
+        placementIndex = placementIndex + 1 | 0;
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    const matchValue_2 = node.Kind;
+    switch (matchValue_2.tag) {
+      case /* Scalar */
+      0: {
+        const scalar = matchValue_2.fields[0];
+        Validate_checkComment(report, ".HeaderComment", scalar.HeaderComment);
+        if (scalar.HeaderComment != null && !Validate_isBlockScalar(scalar)) {
+          report(".HeaderComment", "only a block scalar has a header comment (R8)");
+        }
+        if (node.TrailingComment != null) {
+          if (Validate_isBlockScalar(scalar)) {
+            report(".TrailingComment", "a block scalar takes the comment behind its header as HeaderComment (R8)");
+          } else if (YamlNodeModule_isMissingValue(node)) {
+            report(".TrailingComment", "a missing value has no trailing comment, the comment belongs to the separation behind the indicator (R1)");
+          } else if (YamlNodeModule_isPropertyOnly(node) && !patternInput[2]) {
+            report(".TrailingComment", "a node with properties and no content has no trailing comment outside a flow collection, the comment belongs to the After of its last property (R1)");
+          }
+        }
+        if (blankFollows === 1 && Validate_storedKeepApplies(scalar.Style, scalar.Value)) {
+          report(".Style", Validate_keepText);
+        }
+        break;
+      }
+      case /* Mapping */
+      1: {
+        const collection = matchValue_2.fields[0];
+        Validate_checkComment(report, ".OpeningComment", collection.OpeningComment);
+        Validate_checkTrivia(report, ".End", collection.End);
+        if (equals(collection.Style, CollectionStyle.Block)) {
+          if (node.TrailingComment != null) {
+            report(".TrailingComment", "a block mapping has no closing token to hang a trailing comment on (R8)");
+          }
+          if (collection.OpeningComment != null) {
+            report(".OpeningComment", "only a flow collection has an opening comment");
+          }
+          if (isEmpty(collection.Items)) {
+            report("", "an empty collection is a flow collection");
+          }
+          if (!isEmpty(collection.End) && !isLastNode) {
+            report(".End", Validate_endText);
+          }
+        }
+        const entries = toArray(collection.Items);
+        for (let i = 0; i <= entries.length - 1; i++) {
+          const entry = item(i, entries);
+          const at = ".entries[" + int32ToString(i) + "]";
+          Validate_checkTrivia(report, at + ".Before", entry.Before);
+          Validate_checkSeparation(report, at + ".Question", entry.Question);
+          Validate_checkTrivia(report, at + ".BeforeColon", entry.BeforeColon);
+          Validate_checkSeparation(report, at + ".Colon", entry.Colon);
+          if (entry.Colon == null && !YamlNodeModule_isMissingValue(entry.Value)) {
+            report(at + ".Colon", Validate_colonValueText);
+          } else if (equals(collection.Style, CollectionStyle.Block) && entry.Question == null && entry.Colon == null) {
+            report(at + ".Colon", Validate_implicitColonText);
+          }
+          Validate_checkFollowing(report, at + ".Question.Following", entry.Question, entry.Key);
+          Validate_checkFollowing(report, at + ".Colon.Following", entry.Colon, entry.Value);
+          if (equals(collection.Style, CollectionStyle.Block) && entry.Question == null && equals(entry.Colon, Separation.Inline) && Validate_isBareBlockCollection(entry.Value)) {
+            report(at + ".Colon", Validate_colonText);
+          }
+          if (equals(collection.Style, CollectionStyle.Block) && equals(entry.Question, Separation.Inline)) {
+            Validate_checkCompact(report, at + ".Key", entry.Key);
+          }
+          if (equals(collection.Style, CollectionStyle.Block) && entry.Question != null && equals(entry.Colon, Separation.Inline)) {
+            Validate_checkCompact(report, at + ".Value", entry.Value);
+          }
+          if (entry.Colon == null && !isEmpty(entry.BeforeColon)) {
+            report(at + ".BeforeColon", "an entry without a colon has no gap before it, the trivia belong to the Before of the next entry or item (R7)");
+          } else if (equals(collection.Style, CollectionStyle.Block) && entry.Question == null && !isEmpty(entry.BeforeColon)) {
+            report(at + ".BeforeColon", "the key of an entry without a question mark stands on one line with its colon in a block mapping (R7)");
+          }
+        }
+        const childInFlow = equals(collection.Style, CollectionStyle.Flow);
+        for (let i_1 = entries.length - 1; i_1 >= 0; i_1--) {
+          const at_1 = ".entries[" + int32ToString(i_1) + "]";
+          const lastEntry = isLastNode && !childInFlow && i_1 === entries.length - 1;
+          const blankBehind = (childInFlow ? 0 : i_1 < entries.length - 1 ? Validate_startsWithBlankLine(item(i_1 + 1, entries).Before) ? 1 : 0 : !isEmpty(collection.End) ? Validate_startsWithBlankLine(collection.End) ? 2 : 0 : blankFollows) | 0;
+          const blankBehindKey = (item(i_1, entries).Colon != null ? Validate_startsWithBlankLine(item(i_1, entries).BeforeColon) ? 1 : 0 : blankBehind) | 0;
+          void stack.push([item(i_1, entries).Value, NodePath_child(path, at_1 + ".Value"), childInFlow, lastEntry && item(i_1, entries).Colon != null, blankBehind]);
+          void stack.push([item(i_1, entries).Key, NodePath_child(path, at_1 + ".Key"), childInFlow, lastEntry && item(i_1, entries).Colon == null, blankBehindKey]);
+        }
+        break;
+      }
+      case /* Sequence */
+      2: {
+        const collection_1 = matchValue_2.fields[0];
+        Validate_checkComment(report, ".OpeningComment", collection_1.OpeningComment);
+        Validate_checkTrivia(report, ".End", collection_1.End);
+        if (equals(collection_1.Style, CollectionStyle.Block)) {
+          if (node.TrailingComment != null) {
+            report(".TrailingComment", "a block sequence has no closing token to hang a trailing comment on (R8)");
+          }
+          if (collection_1.OpeningComment != null) {
+            report(".OpeningComment", "only a flow collection has an opening comment");
+          }
+          if (isEmpty(collection_1.Items)) {
+            report("", "an empty collection is a flow collection");
+          }
+          if (!isEmpty(collection_1.End) && !isLastNode) {
+            report(".End", Validate_endText);
+          }
+        }
+        const items = toArray(collection_1.Items);
+        for (let i_2 = 0; i_2 <= items.length - 1; i_2++) {
+          const item$1 = item(i_2, items);
+          const at_2 = ".items[" + int32ToString(i_2) + "]";
+          Validate_checkTrivia(report, at_2 + ".Before", item$1.Before);
+          Validate_checkSeparation(report, at_2 + ".Dash", item$1.Dash);
+          if (equals(collection_1.Style, CollectionStyle.Block) && item$1.Dash == null) {
+            report(at_2 + ".Dash", "an item of a block sequence has a dash");
+          } else if (equals(collection_1.Style, CollectionStyle.Flow) && item$1.Dash != null) {
+            report(at_2 + ".Dash", "an item of a flow sequence has no dash");
+          }
+          Validate_checkFollowing(report, at_2 + ".Dash.Following", item$1.Dash, item$1.Node);
+          if (equals(collection_1.Style, CollectionStyle.Block) && equals(item$1.Dash, Separation.Inline)) {
+            Validate_checkCompact(report, at_2 + ".Node", item$1.Node);
+          }
+        }
+        const childInFlow_1 = equals(collection_1.Style, CollectionStyle.Flow);
+        for (let i_3 = items.length - 1; i_3 >= 0; i_3--) {
+          const lastItem = isLastNode && !childInFlow_1 && i_3 === items.length - 1;
+          const blankBehind_1 = (childInFlow_1 ? 0 : i_3 < items.length - 1 ? Validate_startsWithBlankLine(item(i_3 + 1, items).Before) ? 1 : 0 : !isEmpty(collection_1.End) ? Validate_startsWithBlankLine(collection_1.End) ? 2 : 0 : blankFollows) | 0;
+          void stack.push([item(i_3, items).Node, NodePath_child(path, ".items[" + int32ToString(i_3) + "].Node"), childInFlow_1, lastItem, blankBehind_1]);
+        }
+        break;
+      }
+      default: {
+        const name_5 = matchValue_2.fields[0];
+        if ((node.Properties.Tag != null ? true : node.Properties.Anchor != null) ? true : !isEmpty(node.PropertyLayout)) {
+          report(".Properties", "an alias has no properties");
+        }
+        if (!Validate_isAnchorName(name_5)) {
+          report("", Validate_nameText);
+        }
+      }
+    }
+  }
+}
+function Validate_endsWithComment(lines) {
+  const matchValue = tryLast(lines);
+  let matchResult = void 0;
+  if (matchValue != null) {
+    if (matchValue.tag === /* FullLineComment */
+    0) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    default:
+      return false;
+  }
+}
+function Validate_hasComment(lines) {
+  return exists((line) => {
+    if (line.tag === /* BlankLine */
+    1) {
+      return false;
+    } else {
+      return true;
+    }
+  }, lines);
+}
+function Validate_checkEnds(errors, prefix, root) {
+  const ends = [];
+  let current = root;
+  let path = NodePath_rootPath;
+  let walking = true;
+  while (walking) {
+    let collection = void 0, collection_1 = void 0;
+    const matchValue = current.Kind;
+    let matchResult = void 0, collection_2 = void 0, collection_3 = void 0;
+    switch (matchValue.tag) {
+      case /* Mapping */
+      1: {
+        if (collection = matchValue.fields[0], equals(collection.Style, CollectionStyle.Block) && !isEmpty(collection.Items)) {
+          matchResult = 0;
+          collection_2 = matchValue.fields[0];
+        } else {
+          matchResult = 2;
+        }
+        break;
+      }
+      case /* Sequence */
+      2: {
+        if (collection_1 = matchValue.fields[0], equals(collection_1.Style, CollectionStyle.Block) && !isEmpty(collection_1.Items)) {
+          matchResult = 1;
+          collection_3 = matchValue.fields[0];
+        } else {
+          matchResult = 2;
+        }
+        break;
+      }
+      default:
+        matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0: {
+        void ends.push([path, collection_2.End]);
+        const index = length(collection_2.Items) - 1 | 0;
+        const last$1 = last(collection_2.Items);
+        if (last$1.Colon != null) {
+          current = last$1.Value;
+          path = NodePath_child(path, ".entries[" + int32ToString(index) + "].Value");
+        } else {
+          current = last$1.Key;
+          path = NodePath_child(path, ".entries[" + int32ToString(index) + "].Key");
+        }
+        break;
+      }
+      case 1: {
+        void ends.push([path, collection_3.End]);
+        const index_1 = length(collection_3.Items) - 1 | 0;
+        current = last(collection_3.Items).Node;
+        path = NodePath_child(path, ".items[" + int32ToString(index_1) + "].Node");
+        break;
+      }
+      case 2: {
+        walking = false;
+        break;
+      }
+    }
+  }
+  let lastComment = -1;
+  for (let k = ends.length - 1; k >= 0; k--) {
+    if (Validate_hasComment(item(k, ends)[1])) {
+      lastComment = k | 0;
+    }
+  }
+  for (let k_1 = 0; k_1 <= ends.length - 1; k_1++) {
+    const patternInput = item(k_1, ends);
+    const lines = patternInput[1];
+    if (!isEmpty(lines)) {
+      const slot = prefix + NodePath_slotOf(patternInput[0]) + ".End: ";
+      if (lastComment < 0) {
+        if (k_1 > 0) {
+          void errors.push(slot + Validate_endAfterText);
+        }
+      } else if (k_1 < lastComment) {
+        void errors.push(slot + Validate_endAfterText);
+      } else if (k_1 > lastComment && !Validate_endsWithComment(lines)) {
+        void errors.push(slot + Validate_endBlankText);
+      }
+    }
+  }
+}
+function Validate_walkDocument(errors, prefix, next, document$) {
+  const root = document$.Root;
+  const followedByDocument = next != null;
+  const report = (slot, text) => {
+    void errors.push(prefix + slot + ": " + text);
+  };
+  const markerComment = (marker) => {
+    if (marker == null) {
+      return void 0;
+    } else {
+      return marker.TrailingComment;
+    }
+  };
+  Validate_checkPrelude(errors, prefix, document$.Prelude);
+  Validate_checkComment(report, "StartMarker.TrailingComment", markerComment(document$.StartMarker));
+  Validate_checkComment(report, "EndMarker.TrailingComment", markerComment(document$.EndMarker));
+  Validate_checkTrivia(report, "BeforeRoot", document$.BeforeRoot);
+  Validate_checkTrivia(report, "AfterRoot", document$.AfterRoot);
+  Validate_checkTrivia(report, "AfterEndMarker", document$.AfterEndMarker);
+  if (!isEmpty(document$.BeforeRoot) && Validate_isBareBlockCollection(root)) {
+    void errors.push(prefix + "BeforeRoot: the trivia belong to the Before of the first entry or item of the root collection (R3)");
+  }
+  const blankAfterRoot = (Validate_blankLineFollowsRoot(document$, next) ? 2 : 0) | 0;
+  const canEnd = !(followedByDocument && document$.EndMarker == null);
+  Validate_walkNode(errors, prefix, canEnd, blankAfterRoot, root);
+  if (canEnd) {
+    Validate_checkEnds(errors, prefix, root);
+  }
+  if (!isEmpty(document$.AfterRoot)) {
+    if (Validate_isBlockCollection(root)) {
+      void errors.push(prefix + "AfterRoot: the trivia behind a block collection belong to its End (R3)");
+    } else if (YamlNodeModule_isMissingValue(root)) {
+      void errors.push(prefix + "AfterRoot: a document whose root is missing keeps all its trivia in BeforeRoot (R3)");
+    } else if (followedByDocument && document$.EndMarker == null) {
+      void errors.push(prefix + "AfterRoot: the trivia in front of the next document belong to its Prelude when no `...` stands between (R3)");
+    }
+  }
+  if (!isEmpty(document$.AfterEndMarker)) {
+    if (document$.EndMarker == null) {
+      void errors.push(prefix + "AfterEndMarker: a document without a `...` keeps the trivia behind its root in AfterRoot or in the End of the root collection (R3)");
+    } else if (followedByDocument) {
+      void errors.push(prefix + "AfterEndMarker: the trivia in front of the next document belong to that document (R3)");
+    }
+  }
+}
+function Validate_document(document$) {
+  const errors = [];
+  Validate_walkDocument(errors, "", void 0, document$);
+  return ofSeq(errors);
+}
+function Validate_stream(stream) {
+  const errors = [];
+  const parts = toArray(stream.Parts);
+  const hasDocument = parts.some((part) => {
+    if (part.tag === /* Document */
+    0) {
+      return true;
+    } else {
+      return false;
+    }
+  });
+  const following = fill(new Array(parts.length), 0, parts.length, void 0);
+  let next = void 0;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    setItem(following, i, next);
+    const matchValue = item(i, parts);
+    if (matchValue.tag === /* Trivia */
+    1) {
+    } else {
+      next = matchValue;
+    }
+  }
+  let previous = void 0;
+  for (let i_1 = 0; i_1 <= parts.length - 1; i_1++) {
+    let part_1 = void 0, document$_2 = void 0, matchValue_2 = void 0, next_1 = void 0;
+    const at = "Parts[" + int32ToString(i_1) + "]";
+    const matchValue_1 = item(i_1, parts);
+    switch (matchValue_1.tag) {
+      case /* ExtraEndMarker */
+      2: {
+        Validate_checkComment((slot, text) => {
+          void errors.push(at + "." + slot + ": " + text);
+        }, "TrailingComment", matchValue_1.fields[0].TrailingComment);
+        let matchResult = void 0, part_3 = void 0;
+        if (previous != null) {
+          if (!(part_1 = previous, part_1.tag === /* ExtraEndMarker */
+          2 ? true : part_1.tag === /* Trivia */
+          1 ? false : part_1.fields[0].EndMarker != null)) {
+            matchResult = 0;
+            part_3 = previous;
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0: {
+            void errors.push(at + ": an extra end marker stands at the start of the stream or behind a `...`, and behind a document without an end marker it is the end marker of that document (R3)");
+            break;
+          }
+        }
+        previous = item(i_1, parts);
+        break;
+      }
+      case /* Trivia */
+      1: {
+        const trivia = matchValue_1.fields[0];
+        if (trivia.tag === /* BlankLine */
+        1) {
+        } else {
+          Validate_checkComment((slot_1, text_1) => {
+            void errors.push(at + slot_1 + ": " + text_1);
+          }, "", trivia.fields[0]);
+        }
+        let beforeDocument;
+        const matchValue_3 = item(i_1, following);
+        let matchResult_1 = void 0;
+        if (matchValue_3 != null) {
+          if (matchValue_3.tag === /* Document */
+          0) {
+            matchResult_1 = 0;
+          } else {
+            matchResult_1 = 1;
+          }
+        } else {
+          matchResult_1 = 1;
+        }
+        switch (matchResult_1) {
+          case 0: {
+            beforeDocument = true;
+            break;
+          }
+          default:
+            beforeDocument = false;
+        }
+        const behindExtraEndMarker = previous != null && previous.tag === /* ExtraEndMarker */
+        2;
+        const behindEndMarker = previous != null && (previous.tag === /* Document */
+        0 && (document$_2 = previous.fields[0], document$_2.EndMarker != null));
+        let beforeExtraEndMarker;
+        const matchValue_4 = item(i_1, following);
+        let matchResult_2 = void 0;
+        if (matchValue_4 != null) {
+          if (matchValue_4.tag === /* ExtraEndMarker */
+          2) {
+            matchResult_2 = 0;
+          } else {
+            matchResult_2 = 1;
+          }
+        } else {
+          matchResult_2 = 1;
+        }
+        switch (matchResult_2) {
+          case 0: {
+            beforeExtraEndMarker = previous == null;
+            break;
+          }
+          default:
+            beforeExtraEndMarker = false;
+        }
+        if (beforeDocument) {
+          void errors.push(at + ": trivia in front of a document belong to that document (R3)");
+        } else if (behindEndMarker) {
+          void errors.push(at + ": trivia behind the `...` of a document belong to its AfterEndMarker (R3)");
+        } else if (hasDocument && !behindExtraEndMarker && !beforeExtraEndMarker) {
+          void errors.push(at + ": trivia stand in the stream only behind an extra end marker or at the start of the stream in front of one, and otherwise they belong to a document (R3)");
+        }
+        break;
+      }
+      default: {
+        const document$_1 = matchValue_1.fields[0];
+        Validate_walkDocument(errors, at + ".", (matchValue_2 = item(i_1, following), matchValue_2 != null ? matchValue_2.tag === /* Document */
+        0 ? (next_1 = matchValue_2.fields[0], next_1) : void 0 : void 0), document$_1);
+        previous = item(i_1, parts);
+      }
+    }
+  }
+  return ofSeq(errors);
+}
+
+export { NodePath_PathInfo, NodePath_PathInfo_$reflection, NodePath_child, NodePath_fullPathDepth, NodePath_materialize, NodePath_rootPath, NodePath_slotOf, NodePath_tailSegments, Validate_allChars, Validate_blankLineFollowsRoot, Validate_blockChomping, Validate_commentFollowsRoot, Validate_document, Validate_isAnchorChar, Validate_isAnchorName, Validate_isBlockText, Validate_isCommentText, Validate_isDirectiveWord, Validate_isNbChar, Validate_isNsChar, Validate_linesBehindRoot, Validate_startsWithBlankLine, Validate_storedKeepApplies, Validate_stream };