@nfdi4plants/arctrl 3.2.3 → 3.3.0

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

@@ -0,0 +1,123 @@
+import { isPositiveInfinity, isNegativeInfinity } from '../../../node_modules/@fable-org/fable-library-ts/Double.js';
+import { compare } from '../../../node_modules/@fable-org/fable-library-ts/BigInt.js';
+import { doubleToInt64Bits } from '../../../node_modules/@fable-org/fable-library-ts/BitConverter.js';
+import { CoreSchema_floatText, CoreSchema_stringContent } from './CoreSchema.fs.js';
+import { int32ToString, int64ToString } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { YamlNodeModule_plain, YamlNodeModule_scalar, YamlNodeModule_sequence, YamlNodeModule_item, YamlNodeModule_mapping, YamlNodeModule_entry } from './Node.fs.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-ts/Date.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { toList, delay, map, collect, singleton } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { map as map$1, ofArray } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+
+function EncodeSupport_floatText(value) {
+  if (Number.isNaN(value)) {
+    return ".nan";
+  } else if (isPositiveInfinity(value)) {
+    return ".inf";
+  } else if (isNegativeInfinity(value)) {
+    return "-.inf";
+  } else if (value === 0 && compare(doubleToInt64Bits(value), 0n) < 0) {
+    return "-0.0";
+  } else {
+    return CoreSchema_floatText(value.toString());
+  }
+}
+function EncodeSupport_intText(value) {
+  return int32ToString(value);
+}
+function EncodeSupport_int64Text(value) {
+  return int64ToString(value);
+}
+const Encode_nullValue = YamlNodeModule_plain("null");
+function Encode_int(value) {
+  return YamlNodeModule_plain(EncodeSupport_intText(value));
+}
+function Encode_int64(value) {
+  return YamlNodeModule_plain(EncodeSupport_int64Text(value));
+}
+function Encode_float(value) {
+  return YamlNodeModule_plain(EncodeSupport_floatText(value));
+}
+function Encode_bool(value) {
+  return YamlNodeModule_plain(value ? "true" : "false");
+}
+function Encode_string(value) {
+  const content = CoreSchema_stringContent(value);
+  return YamlNodeModule_scalar(content.Style, content.Value);
+}
+function Encode_char(value) {
+  return Encode_string(value);
+}
+function Encode_datetime(value) {
+  return YamlNodeModule_plain(toString(value, "O", {}));
+}
+function Encode_datetimeOffset(value) {
+  return YamlNodeModule_plain(toString(value, "O", {}));
+}
+function Encode_option(encoder, value$1) {
+  if (value$1 == null) {
+    return Encode_nullValue;
+  } else {
+    return encoder(value(value$1));
+  }
+}
+function Encode_seq(encoder, items) {
+  return YamlNodeModule_sequence(toList(delay(() => map((item) => YamlNodeModule_item(encoder(item)), items))));
+}
+function Encode_list(encoder, items) {
+  return YamlNodeModule_sequence(map$1((item) => YamlNodeModule_item(encoder(item)), items));
+}
+function Encode_array(encoder, items) {
+  return YamlNodeModule_sequence(toList(delay(() => map((item) => YamlNodeModule_item(encoder(item)), items))));
+}
+function Encode_resizearray(encoder, items) {
+  return YamlNodeModule_sequence(toList(delay(() => map((item) => YamlNodeModule_item(encoder(item)), items))));
+}
+function Encode_values(toText, items) {
+  return YamlNodeModule_sequence(toList(delay(() => map((item) => YamlNodeModule_item(Encode_string(toText(item))), items))));
+}
+function Encode_tuple2(encoderA, encoderB, a, b) {
+  return YamlNodeModule_sequence(ofArray([YamlNodeModule_item(encoderA(a)), YamlNodeModule_item(encoderB(b))]));
+}
+function Encode_tuple3(encoderA, encoderB, encoderC, a, b, c) {
+  return YamlNodeModule_sequence(ofArray([YamlNodeModule_item(encoderA(a)), YamlNodeModule_item(encoderB(b)), YamlNodeModule_item(encoderC(c))]));
+}
+function Encode_tuple4(encoderA, encoderB, encoderC, encoderD, a, b, c, d) {
+  return YamlNodeModule_sequence(ofArray([YamlNodeModule_item(encoderA(a)), YamlNodeModule_item(encoderB(b)), YamlNodeModule_item(encoderC(c)), YamlNodeModule_item(encoderD(d))]));
+}
+function Encode_tuple5(encoderA, encoderB, encoderC, encoderD, encoderE, a, b, c, d, e) {
+  return YamlNodeModule_sequence(ofArray([YamlNodeModule_item(encoderA(a)), YamlNodeModule_item(encoderB(b)), YamlNodeModule_item(encoderC(c)), YamlNodeModule_item(encoderD(d)), YamlNodeModule_item(encoderE(e))]));
+}
+function Encode_tuple6(encoderA, encoderB, encoderC, encoderD, encoderE, encoderF, a, b, c, d, e, f) {
+  return YamlNodeModule_sequence(ofArray([YamlNodeModule_item(encoderA(a)), YamlNodeModule_item(encoderB(b)), YamlNodeModule_item(encoderC(c)), YamlNodeModule_item(encoderD(d)), YamlNodeModule_item(encoderE(e)), YamlNodeModule_item(encoderF(f))]));
+}
+function Encode_tuple7(encoderA, encoderB, encoderC, encoderD, encoderE, encoderF, encoderG, a, b, c, d, e, f, g) {
+  return YamlNodeModule_sequence(ofArray([YamlNodeModule_item(encoderA(a)), YamlNodeModule_item(encoderB(b)), YamlNodeModule_item(encoderC(c)), YamlNodeModule_item(encoderD(d)), YamlNodeModule_item(encoderE(e)), YamlNodeModule_item(encoderF(f)), YamlNodeModule_item(encoderG(g))]));
+}
+function Encode_tuple8(encoderA, encoderB, encoderC, encoderD, encoderE, encoderF, encoderG, encoderH, a, b, c, d, e, f, g, h) {
+  return YamlNodeModule_sequence(ofArray([YamlNodeModule_item(encoderA(a)), YamlNodeModule_item(encoderB(b)), YamlNodeModule_item(encoderC(c)), YamlNodeModule_item(encoderD(d)), YamlNodeModule_item(encoderE(e)), YamlNodeModule_item(encoderF(f)), YamlNodeModule_item(encoderG(g)), YamlNodeModule_item(encoderH(h))]));
+}
+function Encode_map(keyEncoder, valueEncoder, entries) {
+  return YamlNodeModule_mapping(toList(delay(() => collect((matchValue) => {
+    const activePatternResult = matchValue;
+    return singleton(YamlNodeModule_entry(keyEncoder(activePatternResult[0]), valueEncoder(activePatternResult[1])));
+  }, entries))));
+}
+function Encode_dict(keyEncoder, valueEncoder, entries) {
+  return YamlNodeModule_mapping(toList(delay(() => collect((matchValue) => {
+    const activePatternResult = matchValue;
+    return singleton(YamlNodeModule_entry(keyEncoder(activePatternResult[0]), valueEncoder(activePatternResult[1])));
+  }, entries))));
+}
+function Encode_object(fields) {
+  return YamlNodeModule_mapping(toList(delay(() => collect((matchValue) => singleton(YamlNodeModule_entry(Encode_string(matchValue[0]), matchValue[1])), fields))));
+}
+function Encode_optionalField(name, encoder, value$1) {
+  if (value$1 == null) {
+    return void 0;
+  } else {
+    return [name, encoder(value(value$1))];
+  }
+}
+
+export { EncodeSupport_floatText, EncodeSupport_int64Text, EncodeSupport_intText, Encode_array, Encode_bool, Encode_char, Encode_datetime, Encode_datetimeOffset, Encode_dict, Encode_float, Encode_int, Encode_int64, Encode_list, Encode_map, Encode_nullValue, Encode_object, Encode_option, Encode_optionalField, Encode_resizearray, Encode_seq, Encode_string, Encode_tuple2, Encode_tuple3, Encode_tuple4, Encode_tuple5, Encode_tuple6, Encode_tuple7, Encode_tuple8, Encode_values };

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

@@ -0,0 +1,282 @@
+import { Record } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { LayoutKind_$reflection } from './Model.fs.js';
+import { record_type, int32_type, option_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
+import { getCharAtIndex } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { isEmpty, FSharpList__get_Head, FSharpList__get_Tail } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { item } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+
+class LayoutPiece extends Record {
+  constructor(First, Limit, Behind) {
+    super();
+    this.First = First | 0;
+    this.Limit = Limit | 0;
+    this.Behind = Behind;
+  }
+}
+function LayoutPiece_$reflection() {
+  return record_type("YAMLicious.LayoutPiece", [], LayoutPiece, () => [["First", int32_type], ["Limit", int32_type], ["Behind", option_type(LayoutKind_$reflection())]]);
+}
+function Layout_isBlank(c) {
+  if (c === " ") {
+    return true;
+  } else {
+    return c === "	";
+  }
+}
+function Layout_splitsPair(value, index) {
+  if (index > 0 && index < value.length && ~~getCharAtIndex(value, index - 1).charCodeAt(0) >= 55296 && ~~getCharAtIndex(value, index - 1).charCodeAt(0) <= 56319 && ~~getCharAtIndex(value, index).charCodeAt(0) >= 56320) {
+    return ~~getCharAtIndex(value, index).charCodeAt(0) <= 57343;
+  } else {
+    return false;
+  }
+}
+function Layout_consumed(kind) {
+  if (kind.tag === /* EscapedBreak */
+  1) {
+    const lines_1 = kind.fields[0] | 0;
+    return lines_1 | 0;
+  } else if (kind.fields[0] === 0) {
+    return 1;
+  } else {
+    const lines = kind.fields[0] | 0;
+    return lines | 0;
+  }
+}
+function Layout_cut(layout, value, emptyLinesOk, escapedOk) {
+  const n = value.length | 0;
+  const pieces = [];
+  let start = 0;
+  let ok = true;
+  let rest = layout.Boundaries;
+  while (ok && !isEmpty(rest)) {
+    let matchValue = void 0, lines_1 = void 0, lines = void 0;
+    const boundary = FSharpList__get_Head(rest);
+    const take = Layout_consumed(boundary.Kind) | 0;
+    if (((!(matchValue = boundary.Kind, matchValue.tag === /* EscapedBreak */
+    1 ? (lines_1 = matchValue.fields[0] | 0, escapedOk && lines_1 >= 0) : matchValue.fields[0] === 0 ? true : (lines = matchValue.fields[0] | 0, emptyLinesOk && lines > 0)) ? true : boundary.At < start) ? true : boundary.At + take > n) ? true : Layout_splitsPair(value, boundary.At)) {
+      ok = false;
+    } else {
+      const matchValue_1 = boundary.Kind;
+      let matchResult = void 0;
+      if (matchValue_1.tag === /* Fold */
+      0) {
+        if (matchValue_1.fields[0] === 0) {
+          matchResult = 0;
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      switch (matchResult) {
+        case 0: {
+          if (getCharAtIndex(value, boundary.At) !== " ") {
+            ok = false;
+          }
+          break;
+        }
+        case 1: {
+          for (let i = boundary.At; i <= boundary.At + take - 1; i++) {
+            if (getCharAtIndex(value, i) !== "\n") {
+              ok = false;
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (ok) {
+      void pieces.push(new LayoutPiece(start, boundary.At, boundary.Kind));
+      start = boundary.At + take | 0;
+      rest = FSharpList__get_Tail(rest);
+    }
+  }
+  if (ok) {
+    void pieces.push(new LayoutPiece(start, n, void 0));
+    return pieces.slice();
+  } else {
+    return void 0;
+  }
+}
+function Layout_isEmptyPiece(piece) {
+  return piece.Limit <= piece.First;
+}
+function Layout_startsWithText(value, piece) {
+  if (!Layout_isEmptyPiece(piece) && !Layout_isBlank(getCharAtIndex(value, piece.First))) {
+    return getCharAtIndex(value, piece.First) !== "\n";
+  } else {
+    return false;
+  }
+}
+function Layout_endsWithText(value, piece) {
+  if (!Layout_isEmptyPiece(piece) && !Layout_isBlank(getCharAtIndex(value, piece.Limit - 1))) {
+    return getCharAtIndex(value, piece.Limit - 1) !== "\n";
+  } else {
+    return false;
+  }
+}
+function Layout_foldsOk(value, pieces, edgesMayBeEmpty) {
+  let ok = true;
+  for (let i = 0; i <= pieces.length - 2; i++) {
+    const left = item(i, pieces);
+    const right = item(i + 1, pieces);
+    if (!(Layout_endsWithText(value, left) ? true : edgesMayBeEmpty && i === 0 && Layout_isEmptyPiece(left))) {
+      ok = false;
+    }
+    if (!(Layout_startsWithText(value, right) ? true : edgesMayBeEmpty && i + 1 === pieces.length - 1 && Layout_isEmptyPiece(right))) {
+      ok = false;
+    }
+  }
+  return ok;
+}
+function Layout_isEscapedBreak(kind) {
+  let matchResult = void 0;
+  if (kind != null) {
+    if (kind.tag === /* EscapedBreak */
+    1) {
+      matchResult = 0;
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return true;
+    default:
+      return false;
+  }
+}
+function Layout_doubleOk(pieces) {
+  let ok = true;
+  for (let i = 1; i <= pieces.length - 2; i++) {
+    if (Layout_isEmptyPiece(item(i, pieces)) && !Layout_isEscapedBreak(item(i, pieces).Behind)) {
+      ok = false;
+    }
+  }
+  return ok;
+}
+function Layout_foldedOk(value, pieces) {
+  let ok = true;
+  let lineFirst = -1;
+  for (let i = 0; i <= pieces.length - 1; i++) {
+    const piece = item(i, pieces);
+    for (let k = piece.First; k <= piece.Limit - 1; k++) {
+      if (getCharAtIndex(value, k) === "\n") {
+        lineFirst = -1;
+      } else if (lineFirst < 0) {
+        lineFirst = k | 0;
+      }
+    }
+    if (piece.Behind == null) {
+    } else {
+      if (Layout_isEmptyPiece(piece) ? true : getCharAtIndex(value, piece.Limit - 1) === "\n") {
+        ok = false;
+      }
+      if (lineFirst < 0 ? true : Layout_isBlank(getCharAtIndex(value, lineFirst))) {
+        ok = false;
+      }
+      if (!Layout_startsWithText(value, item(i + 1, pieces))) {
+        ok = false;
+      }
+    }
+  }
+  return ok;
+}
+function Layout_tryPlan(layout, value, style) {
+  switch (style.tag) {
+    case /* SingleQuoted */
+    1: {
+      const matchValue_1 = Layout_cut(layout, value, false, false);
+      let matchResult = void 0, pieces_3 = void 0;
+      if (matchValue_1 != null) {
+        if (Layout_foldsOk(value, matchValue_1, true)) {
+          matchResult = 0;
+          pieces_3 = matchValue_1;
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      switch (matchResult) {
+        case 0:
+          return pieces_3;
+        default:
+          return void 0;
+      }
+    }
+    case /* DoubleQuoted */
+    2: {
+      const matchValue_2 = Layout_cut(layout, value, true, true);
+      let matchResult_1 = void 0, pieces_5 = void 0;
+      if (matchValue_2 != null) {
+        if (Layout_doubleOk(matchValue_2)) {
+          matchResult_1 = 0;
+          pieces_5 = matchValue_2;
+        } else {
+          matchResult_1 = 1;
+        }
+      } else {
+        matchResult_1 = 1;
+      }
+      switch (matchResult_1) {
+        case 0:
+          return pieces_5;
+        default:
+          return void 0;
+      }
+    }
+    case /* Block */
+    3:
+      if (style.fields[0].tag === /* Literal */
+      0) {
+        return void 0;
+      } else {
+        const matchValue_3 = Layout_cut(layout, value, false, false);
+        let matchResult_2 = void 0, pieces_7 = void 0;
+        if (matchValue_3 != null) {
+          if (Layout_foldedOk(value, matchValue_3)) {
+            matchResult_2 = 0;
+            pieces_7 = matchValue_3;
+          } else {
+            matchResult_2 = 1;
+          }
+        } else {
+          matchResult_2 = 1;
+        }
+        switch (matchResult_2) {
+          case 0:
+            return pieces_7;
+          default:
+            return void 0;
+        }
+      }
+    default: {
+      const matchValue = Layout_cut(layout, value, false, false);
+      let matchResult_3 = void 0, pieces_1 = void 0;
+      if (matchValue != null) {
+        if (Layout_foldsOk(value, matchValue, false)) {
+          matchResult_3 = 0;
+          pieces_1 = matchValue;
+        } else {
+          matchResult_3 = 1;
+        }
+      } else {
+        matchResult_3 = 1;
+      }
+      switch (matchResult_3) {
+        case 0:
+          return pieces_1;
+        default:
+          return void 0;
+      }
+    }
+  }
+}
+function Layout_fits(layout, value, style) {
+  return Layout_tryPlan(layout, value, style) != null;
+}
+
+export { LayoutPiece, LayoutPiece_$reflection, Layout_consumed, Layout_fits, Layout_tryPlan };

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

@@ -0,0 +1,203 @@
+import { Union, Record } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { union_type, record_type, int32_type, bool_type, string_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
+import { DirectiveKind_$reflection, YamlScalar_$reflection, YamlComment_$reflection } from './Model.fs.js';
+
+function GrammarContext_BlockIn() {
+  return GrammarContext.BlockIn;
+}
+function GrammarContext_BlockOut() {
+  return GrammarContext.BlockOut;
+}
+function GrammarContext_FlowIn() {
+  return GrammarContext.FlowIn;
+}
+function GrammarContext_FlowOut() {
+  return GrammarContext.FlowOut;
+}
+function GrammarContext_BlockKey() {
+  return GrammarContext.BlockKey;
+}
+function GrammarContext_FlowKey() {
+  return GrammarContext.FlowKey;
+}
+class GrammarContext extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["BlockIn", "BlockOut", "FlowIn", "FlowOut", "BlockKey", "FlowKey"];
+  }
+  static {
+    this.BlockIn = new GrammarContext(0, []);
+  }
+  static {
+    this.BlockOut = new GrammarContext(1, []);
+  }
+  static {
+    this.FlowIn = new GrammarContext(2, []);
+  }
+  static {
+    this.FlowOut = new GrammarContext(3, []);
+  }
+  static {
+    this.BlockKey = new GrammarContext(4, []);
+  }
+  static {
+    this.FlowKey = new GrammarContext(5, []);
+  }
+}
+function GrammarContext_$reflection() {
+  return union_type("YAMLicious.GrammarContext", [], GrammarContext, () => [[], [], [], [], [], []]);
+}
+class LexContext extends Record {
+  constructor(Grammar, ParentIndent, SimpleKey) {
+    super();
+    this.Grammar = Grammar;
+    this.ParentIndent = ParentIndent | 0;
+    this.SimpleKey = SimpleKey;
+  }
+}
+function LexContext_$reflection() {
+  return record_type("YAMLicious.LexContext", [], LexContext, () => [["Grammar", GrammarContext_$reflection()], ["ParentIndent", int32_type], ["SimpleKey", bool_type]]);
+}
+function TagToken_Verbatim(uri) {
+  return new TagToken(0, [uri]);
+}
+function TagToken_Shorthand(handle, suffix) {
+  return new TagToken(1, [handle, suffix]);
+}
+class TagToken extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Verbatim", "Shorthand"];
+  }
+}
+function TagToken_$reflection() {
+  return union_type("YAMLicious.TagToken", [], TagToken, () => [[["uri", string_type]], [["handle", string_type], ["suffix", string_type]]]);
+}
+function Lexeme_StreamStart() {
+  return Lexeme.StreamStart;
+}
+function Lexeme_StreamEnd() {
+  return Lexeme.StreamEnd;
+}
+function Lexeme_DocumentStart() {
+  return Lexeme.DocumentStart;
+}
+function Lexeme_DocumentEnd() {
+  return Lexeme.DocumentEnd;
+}
+function Lexeme_ByteOrderMark() {
+  return Lexeme.ByteOrderMark;
+}
+function Lexeme_Directive(Item) {
+  return new Lexeme(5, [Item]);
+}
+function Lexeme_LineStart(indent, tabbed) {
+  return new Lexeme(6, [indent, tabbed]);
+}
+function Lexeme_BlockEntry() {
+  return Lexeme.BlockEntry;
+}
+function Lexeme_ExplicitKey() {
+  return Lexeme.ExplicitKey;
+}
+function Lexeme_Value() {
+  return Lexeme.Value;
+}
+function Lexeme_FlowSequenceStart() {
+  return Lexeme.FlowSequenceStart;
+}
+function Lexeme_FlowSequenceEnd() {
+  return Lexeme.FlowSequenceEnd;
+}
+function Lexeme_FlowMappingStart() {
+  return Lexeme.FlowMappingStart;
+}
+function Lexeme_FlowMappingEnd() {
+  return Lexeme.FlowMappingEnd;
+}
+function Lexeme_FlowEntry() {
+  return Lexeme.FlowEntry;
+}
+function Lexeme_Anchor(anchorName) {
+  return new Lexeme(15, [anchorName]);
+}
+function Lexeme_Alias(aliasName) {
+  return new Lexeme(16, [aliasName]);
+}
+function Lexeme_Tag(Item) {
+  return new Lexeme(17, [Item]);
+}
+function Lexeme_Scalar(Item) {
+  return new Lexeme(18, [Item]);
+}
+function Lexeme_Comment$(comment, ownLine) {
+  return new Lexeme(19, [comment, ownLine]);
+}
+function Lexeme_BlankLine() {
+  return Lexeme.BlankLine;
+}
+class Lexeme extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["StreamStart", "StreamEnd", "DocumentStart", "DocumentEnd", "ByteOrderMark", "Directive", "LineStart", "BlockEntry", "ExplicitKey", "Value", "FlowSequenceStart", "FlowSequenceEnd", "FlowMappingStart", "FlowMappingEnd", "FlowEntry", "Anchor", "Alias", "Tag", "Scalar", "Comment", "BlankLine"];
+  }
+  static {
+    this.StreamStart = new Lexeme(0, []);
+  }
+  static {
+    this.StreamEnd = new Lexeme(1, []);
+  }
+  static {
+    this.DocumentStart = new Lexeme(2, []);
+  }
+  static {
+    this.DocumentEnd = new Lexeme(3, []);
+  }
+  static {
+    this.ByteOrderMark = new Lexeme(4, []);
+  }
+  static {
+    this.BlockEntry = new Lexeme(7, []);
+  }
+  static {
+    this.ExplicitKey = new Lexeme(8, []);
+  }
+  static {
+    this.Value = new Lexeme(9, []);
+  }
+  static {
+    this.FlowSequenceStart = new Lexeme(10, []);
+  }
+  static {
+    this.FlowSequenceEnd = new Lexeme(11, []);
+  }
+  static {
+    this.FlowMappingStart = new Lexeme(12, []);
+  }
+  static {
+    this.FlowMappingEnd = new Lexeme(13, []);
+  }
+  static {
+    this.FlowEntry = new Lexeme(14, []);
+  }
+  static {
+    this.BlankLine = new Lexeme(20, []);
+  }
+}
+function Lexeme_$reflection() {
+  return union_type("YAMLicious.Lexeme", [], Lexeme, () => [[], [], [], [], [], [["Item", DirectiveKind_$reflection()]], [["indent", int32_type], ["tabbed", bool_type]], [], [], [], [], [], [], [], [], [["anchorName", string_type]], [["aliasName", string_type]], [["Item", TagToken_$reflection()]], [["Item", YamlScalar_$reflection()]], [["comment", YamlComment_$reflection()], ["ownLine", bool_type]], []]);
+}
+
+export { GrammarContext, GrammarContext_$reflection, GrammarContext_BlockIn, GrammarContext_BlockKey, GrammarContext_BlockOut, GrammarContext_FlowIn, GrammarContext_FlowKey, GrammarContext_FlowOut, LexContext, LexContext_$reflection, Lexeme, Lexeme_$reflection, Lexeme_Alias, Lexeme_Anchor, Lexeme_BlankLine, Lexeme_BlockEntry, Lexeme_ByteOrderMark, Lexeme_Comment$, Lexeme_Directive, Lexeme_DocumentEnd, Lexeme_DocumentStart, Lexeme_ExplicitKey, Lexeme_FlowEntry, Lexeme_FlowMappingEnd, Lexeme_FlowMappingStart, Lexeme_FlowSequenceEnd, Lexeme_FlowSequenceStart, Lexeme_LineStart, Lexeme_Scalar, Lexeme_StreamEnd, Lexeme_StreamStart, Lexeme_Tag, Lexeme_Value, TagToken, TagToken_$reflection, TagToken_Shorthand, TagToken_Verbatim };