@nfdi4plants/arctrl 3.2.3 → 3.3.1

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

@@ -0,0 +1,453 @@
+import { YamlNode, NodeProperties, Collection$1, YamlNodeKind_Scalar, YamlScalar, ScalarStyle, YamlNodeKind_Alias, YamlNodeKind_Mapping, CollectionStyle, YamlNodeKind_Sequence, SequenceItem, Separation, Separation_NewLine, LineBreak, MappingEntry, PropertyPlacement, PropertyName, YamlDocument } from './Model.fs.js';
+import { empty, isEmpty, map, append, singleton, cons, exists } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { Exception, equals } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { getCharAtIndex } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { CoreSchema_resolvesToNonString, CoreSchema_stringContent } from './CoreSchema.fs.js';
+import { Layout_fits } from './Layout.fs.js';
+import { nodesEqualIgnoringSpans, showNode, documentsEqualIgnoringSpans, showDocument, streamsEqualIgnoringSpans, showStream } from './Compare.fs.js';
+
+function YamlNodeModule_create(kind) {
+  return new YamlNode(kind, new NodeProperties(void 0, void 0), empty(), void 0, void 0);
+}
+function YamlNodeModule_collection(style, items) {
+  return new Collection$1(style, void 0, items, empty());
+}
+function YamlNodeModule_scalar(style, value) {
+  return YamlNodeModule_create(YamlNodeKind_Scalar(new YamlScalar(value, style, void 0, void 0)));
+}
+function YamlNodeModule_plain(value) {
+  return YamlNodeModule_scalar(ScalarStyle.Plain, value);
+}
+const YamlNodeModule_empty = YamlNodeModule_plain("");
+function YamlNodeModule_isAnchorChar(c) {
+  const code = ~~c.charCodeAt(0) | 0;
+  if (((((code >= 33 && code <= 126 ? true : code === 133) ? true : code >= 160 && code <= 55295) ? true : code >= 57344 && code <= 65533 && code !== 65279) ? true : code >= 65536 && code <= 1114111) && c !== "," && c !== "[" && c !== "]" && c !== "{") {
+    return c !== "}";
+  } else {
+    return false;
+  }
+}
+function YamlNodeModule_isHighSurrogate(c) {
+  if (~~c.charCodeAt(0) >= 55296) {
+    return ~~c.charCodeAt(0) <= 56319;
+  } else {
+    return false;
+  }
+}
+function YamlNodeModule_isLowSurrogate(c) {
+  if (~~c.charCodeAt(0) >= 56320) {
+    return ~~c.charCodeAt(0) <= 57343;
+  } else {
+    return false;
+  }
+}
+function YamlNodeModule_checkName(what, name) {
+  if (name.length === 0) {
+    throw new Exception("The " + what + " name must not be empty.");
+  }
+  let valid = true;
+  let i = 0;
+  while (valid && i < name.length) {
+    if (YamlNodeModule_isHighSurrogate(getCharAtIndex(name, i)) && i + 1 < name.length && YamlNodeModule_isLowSurrogate(getCharAtIndex(name, i + 1))) {
+      i = i + 2 | 0;
+    } else if (YamlNodeModule_isAnchorChar(getCharAtIndex(name, i))) {
+      i = i + 1 | 0;
+    } else {
+      valid = false;
+    }
+  }
+  if (!valid) {
+    throw new Exception("The " + what + " name " + name + " holds a character that a name cannot hold.");
+  }
+}
+function YamlNodeModule_alias(name) {
+  YamlNodeModule_checkName("alias", name);
+  return YamlNodeModule_create(YamlNodeKind_Alias(name));
+}
+function YamlNodeModule_mapping(entries) {
+  return YamlNodeModule_create(YamlNodeKind_Mapping(YamlNodeModule_collection(isEmpty(entries) ? CollectionStyle.Flow : CollectionStyle.Block, entries)));
+}
+function YamlNodeModule_flowMapping(entries) {
+  return YamlNodeModule_create(YamlNodeKind_Mapping(YamlNodeModule_collection(CollectionStyle.Flow, entries)));
+}
+function YamlNodeModule_sequence(items) {
+  return YamlNodeModule_create(YamlNodeKind_Sequence(YamlNodeModule_collection(isEmpty(items) ? CollectionStyle.Flow : CollectionStyle.Block, map((item) => {
+    if (item.Dash == null) {
+      return new SequenceItem(item.Before, Separation.Inline, item.Node, item.Span);
+    } else {
+      return item;
+    }
+  }, items))));
+}
+function YamlNodeModule_flowSequence(items) {
+  return YamlNodeModule_create(YamlNodeKind_Sequence(YamlNodeModule_collection(CollectionStyle.Flow, map((item) => new SequenceItem(item.Before, void 0, item.Node, item.Span), items))));
+}
+function YamlNodeModule_isBlockCollectionWithItems(node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Mapping */
+    1: {
+      const content = matchValue.fields[0];
+      if (equals(content.Style, CollectionStyle.Block)) {
+        return !isEmpty(content.Items);
+      } else {
+        return false;
+      }
+    }
+    case /* Sequence */
+    2: {
+      const content_1 = matchValue.fields[0];
+      if (equals(content_1.Style, CollectionStyle.Block)) {
+        return !isEmpty(content_1.Items);
+      } else {
+        return false;
+      }
+    }
+    default:
+      return false;
+  }
+}
+const YamlNodeModule_plainLineBreak = Separation_NewLine(new LineBreak(void 0, empty()));
+function YamlNodeModule_entry(key, value) {
+  return new MappingEntry(empty(), void 0, key, empty(), YamlNodeModule_isBlockCollectionWithItems(value) && value.Properties.Tag == null && value.Properties.Anchor == null ? YamlNodeModule_plainLineBreak : Separation.Inline, value, void 0);
+}
+function YamlNodeModule_item(node) {
+  return new SequenceItem(empty(), Separation.Inline, node, void 0);
+}
+function YamlNodeModule_describe(node) {
+  const matchValue = node.Kind;
+  switch (matchValue.tag) {
+    case /* Mapping */
+    1:
+      return "a mapping";
+    case /* Sequence */
+    2:
+      return "a sequence";
+    case /* Alias */
+    3:
+      return "an alias";
+    default:
+      return "a scalar";
+  }
+}
+function YamlNodeModule_addPlacement(property, node) {
+  const onLaterLine = YamlNodeModule_isBlockCollectionWithItems(node);
+  const layout = node.PropertyLayout;
+  if (property.tag === /* Anchor */
+  1) {
+    const added_1 = new PropertyPlacement(PropertyName.Anchor, onLaterLine ? YamlNodeModule_plainLineBreak : Separation.Inline, void 0);
+    return append(map((placement) => {
+      const matchValue = placement.After;
+      let matchResult = void 0;
+      if (matchValue.tag === /* NewLine */
+      1) {
+        if (matchValue.fields[0].Comment == null) {
+          if (isEmpty(matchValue.fields[0].Following)) {
+            if (onLaterLine) {
+              matchResult = 0;
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      switch (matchResult) {
+        case 0:
+          return new PropertyPlacement(placement.Property, Separation.Inline, placement.Span);
+        default:
+          return placement;
+      }
+    }, layout), singleton(added_1));
+  } else {
+    return cons(new PropertyPlacement(PropertyName.Tag, onLaterLine && isEmpty(layout) ? YamlNodeModule_plainLineBreak : Separation.Inline, void 0), layout);
+  }
+}
+function YamlNodeModule_withTag(tag, node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Alias */
+  3) {
+    throw new Exception("The alias *" + matchValue.fields[0] + " cannot have a tag.");
+  } else if (node.Properties.Tag != null) {
+    throw new Exception("A node cannot have two tags.");
+  } else {
+    return new YamlNode(node.Kind, new NodeProperties(tag, node.Properties.Anchor), YamlNodeModule_addPlacement(PropertyName.Tag, node), node.TrailingComment, node.Span);
+  }
+}
+function YamlNodeModule_withAnchor(name, node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Alias */
+  3) {
+    throw new Exception("The alias *" + matchValue.fields[0] + " cannot have an anchor.");
+  } else if (node.Properties.Anchor != null) {
+    throw new Exception("A node cannot have two anchors.");
+  } else {
+    YamlNodeModule_checkName("anchor", name);
+    return new YamlNode(node.Kind, new NodeProperties(node.Properties.Tag, name), YamlNodeModule_addPlacement(PropertyName.Anchor, node), node.TrailingComment, node.Span);
+  }
+}
+function YamlNodeModule_isBlockScalar(content) {
+  if (content.Style.tag === /* Block */
+  3) {
+    return true;
+  } else {
+    return false;
+  }
+}
+function YamlNodeModule_isEmptyPlain(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Scalar */
+  0) {
+    const content = matchValue.fields[0];
+    if (content.Value.length === 0) {
+      return equals(content.Style, ScalarStyle.Plain);
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+function YamlNodeModule_isMissingValue(node) {
+  if (YamlNodeModule_isEmptyPlain(node) && node.Properties.Tag == null) {
+    return node.Properties.Anchor == null;
+  } else {
+    return false;
+  }
+}
+function YamlNodeModule_isPropertyOnly(node) {
+  if (YamlNodeModule_isEmptyPlain(node)) {
+    if (node.Properties.Tag != null) {
+      return true;
+    } else {
+      return node.Properties.Anchor != null;
+    }
+  } else {
+    return false;
+  }
+}
+function YamlNodeModule_withTrailingComment(comment, node) {
+  const matchValue = node.Kind;
+  let matchResult = void 0, content_3 = void 0, content_4 = void 0, content_5 = void 0;
+  switch (matchValue.tag) {
+    case /* Mapping */
+    1: {
+      if (equals(matchValue.fields[0].Style, CollectionStyle.Block)) {
+        matchResult = 0;
+        content_3 = matchValue.fields[0];
+      } else if (YamlNodeModule_isMissingValue(node)) {
+        matchResult = 3;
+      } else {
+        matchResult = 4;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      if (equals(matchValue.fields[0].Style, CollectionStyle.Block)) {
+        matchResult = 1;
+        content_4 = matchValue.fields[0];
+      } else if (YamlNodeModule_isMissingValue(node)) {
+        matchResult = 3;
+      } else {
+        matchResult = 4;
+      }
+      break;
+    }
+    case /* Scalar */
+    0: {
+      if (YamlNodeModule_isBlockScalar(matchValue.fields[0])) {
+        matchResult = 2;
+        content_5 = matchValue.fields[0];
+      } else if (YamlNodeModule_isMissingValue(node)) {
+        matchResult = 3;
+      } else {
+        matchResult = 4;
+      }
+      break;
+    }
+    default:
+      if (YamlNodeModule_isMissingValue(node)) {
+        matchResult = 3;
+      } else {
+        matchResult = 4;
+      }
+  }
+  switch (matchResult) {
+    case 0:
+      throw new Exception("A block mapping has no closing token for a trailing comment. Put the comment on an entry or the end of the collection.");
+    case 1:
+      throw new Exception("A block sequence has no closing token for a trailing comment. Put the comment on an item or the end of the collection.");
+    case 2:
+      throw new Exception("A block scalar has no place for a trailing comment. Use its header comment.");
+    case 3:
+      throw new Exception("A missing value has no trailing comment. Put the comment on the separation behind the indicator.");
+    default:
+      return new YamlNode(node.Kind, node.Properties, node.PropertyLayout, comment, node.Span);
+  }
+}
+function YamlNodeModule_withHeaderComment(comment, node) {
+  const matchValue = node.Kind;
+  let matchResult = void 0, content_1 = void 0;
+  if (matchValue.tag === /* Scalar */
+  0) {
+    if (YamlNodeModule_isBlockScalar(matchValue.fields[0])) {
+      matchResult = 0;
+      content_1 = matchValue.fields[0];
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return new YamlNode(YamlNodeKind_Scalar(new YamlScalar(content_1.Value, content_1.Style, comment, content_1.Layout)), node.Properties, node.PropertyLayout, node.TrailingComment, node.Span);
+    default:
+      throw new Exception("Only a block scalar has a header comment, not " + YamlNodeModule_describe(node) + ".");
+  }
+}
+function YamlNodeModule_withScalarValue(value, node) {
+  let matchValue_1 = void 0, kept = void 0, kept_1 = void 0;
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Scalar */
+  0) {
+    const content = matchValue.fields[0];
+    if (content.Value === value) {
+      return node;
+    } else {
+      const restyled = equals(content.Style, ScalarStyle.Plain) && node.Properties.Tag == null && !CoreSchema_resolvesToNonString(content.Value) && CoreSchema_resolvesToNonString(value);
+      const style = restyled ? CoreSchema_stringContent(value).Style : content.Style;
+      return new YamlNode(YamlNodeKind_Scalar(new YamlScalar(value, style, content.HeaderComment, (matchValue_1 = content.Layout, matchValue_1 != null ? (kept = matchValue_1, !restyled && Layout_fits(kept, value, style)) ? (kept_1 = matchValue_1, kept_1) : void 0 : void 0))), node.Properties, node.PropertyLayout, node.TrailingComment, void 0);
+    }
+  } else {
+    throw new Exception("Only a scalar has a text, not " + YamlNodeModule_describe(node) + ".");
+  }
+}
+function YamlNodeModule_withOpeningComment(comment, node) {
+  const matchValue = node.Kind;
+  let matchResult = void 0, content_2 = void 0, content_3 = void 0;
+  switch (matchValue.tag) {
+    case /* Mapping */
+    1: {
+      if (equals(matchValue.fields[0].Style, CollectionStyle.Flow)) {
+        matchResult = 0;
+        content_2 = matchValue.fields[0];
+      } else {
+        matchResult = 2;
+      }
+      break;
+    }
+    case /* Sequence */
+    2: {
+      if (equals(matchValue.fields[0].Style, CollectionStyle.Flow)) {
+        matchResult = 1;
+        content_3 = matchValue.fields[0];
+      } else {
+        matchResult = 2;
+      }
+      break;
+    }
+    default:
+      matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return new YamlNode(YamlNodeKind_Mapping(new Collection$1(content_2.Style, comment, content_2.Items, content_2.End)), node.Properties, node.PropertyLayout, node.TrailingComment, node.Span);
+    case 1:
+      return new YamlNode(YamlNodeKind_Sequence(new Collection$1(content_3.Style, comment, content_3.Items, content_3.End)), node.Properties, node.PropertyLayout, node.TrailingComment, node.Span);
+    default:
+      throw new Exception("Only a flow collection has an opening comment, not " + YamlNodeModule_describe(node) + ".");
+  }
+}
+function YamlNodeModule_withPropertyComment(property, comment, node) {
+  if (!exists((placement) => equals(placement.Property, property), node.PropertyLayout)) {
+    throw new Exception("The node does not have the property that the comment belongs to.");
+  } else {
+    return new YamlNode(node.Kind, node.Properties, map((placement_1) => {
+      let matchValue = void 0;
+      if (!equals(placement_1.Property, property)) {
+        return placement_1;
+      } else {
+        return new PropertyPlacement(placement_1.Property, Separation_NewLine(new LineBreak(comment, (matchValue = placement_1.After, matchValue.tag === /* Inline */
+        0 ? empty() : matchValue.fields[0].Following))), placement_1.Span);
+      }
+    }, node.PropertyLayout), node.TrailingComment, node.Span);
+  }
+}
+function YamlNodeModule_tryScalar(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Scalar */
+  0) {
+    return matchValue.fields[0];
+  } else {
+    return void 0;
+  }
+}
+function YamlNodeModule_tryMapping(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Mapping */
+  1) {
+    return matchValue.fields[0];
+  } else {
+    return void 0;
+  }
+}
+function YamlNodeModule_trySequence(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Sequence */
+  2) {
+    return matchValue.fields[0];
+  } else {
+    return void 0;
+  }
+}
+function YamlNodeModule_entries(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Mapping */
+  1) {
+    return matchValue.fields[0].Items;
+  } else {
+    throw new Exception("The node is " + YamlNodeModule_describe(node) + ", not a mapping.");
+  }
+}
+function YamlNodeModule_items(node) {
+  const matchValue = node.Kind;
+  if (matchValue.tag === /* Sequence */
+  2) {
+    return matchValue.fields[0].Items;
+  } else {
+    throw new Exception("The node is " + YamlNodeModule_describe(node) + ", not a sequence.");
+  }
+}
+function YamlNodeModule_properties(node) {
+  return node.Properties;
+}
+function YamlNodeModule_equalIgnoringSpans(left, right) {
+  return nodesEqualIgnoringSpans(left, right);
+}
+function YamlNodeModule_show(node) {
+  return showNode(node);
+}
+function YamlDocumentModule_create(root) {
+  return new YamlDocument(empty(), void 0, empty(), root, empty(), void 0, empty(), void 0);
+}
+function YamlDocumentModule_equalIgnoringSpans(left, right) {
+  return documentsEqualIgnoringSpans(left, right);
+}
+function YamlDocumentModule_show(document$) {
+  return showDocument(document$);
+}
+function YamlStreamModule_equalIgnoringSpans(left, right) {
+  return streamsEqualIgnoringSpans(left, right);
+}
+function YamlStreamModule_show(stream) {
+  return showStream(stream);
+}
+
+export { YamlDocumentModule_create, YamlDocumentModule_equalIgnoringSpans, YamlDocumentModule_show, YamlNodeModule_alias, YamlNodeModule_empty, YamlNodeModule_entries, YamlNodeModule_entry, YamlNodeModule_equalIgnoringSpans, YamlNodeModule_flowMapping, YamlNodeModule_flowSequence, YamlNodeModule_isMissingValue, YamlNodeModule_isPropertyOnly, YamlNodeModule_item, YamlNodeModule_items, YamlNodeModule_mapping, YamlNodeModule_plain, YamlNodeModule_properties, YamlNodeModule_scalar, YamlNodeModule_sequence, YamlNodeModule_show, YamlNodeModule_tryMapping, YamlNodeModule_tryScalar, YamlNodeModule_trySequence, YamlNodeModule_withAnchor, YamlNodeModule_withHeaderComment, YamlNodeModule_withOpeningComment, YamlNodeModule_withPropertyComment, YamlNodeModule_withScalarValue, YamlNodeModule_withTag, YamlNodeModule_withTrailingComment, YamlStreamModule_equalIgnoringSpans, YamlStreamModule_show };