@nfdi4plants/arctrl 3.2.2 → 3.3.0

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

@@ -0,0 +1,725 @@
+import { Union, FSharpRef, toString, Record } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { union_type, record_type, class_type, string_type, int32_type, array_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
+import { join, isNullOrEmpty, getCharAtIndex, substring, replicate } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { isMatch, create } from '../../../node_modules/@fable-org/fable-library-ts/RegExp.js';
+import { op_UnaryNegation_Int32 } from '../../../node_modules/@fable-org/fable-library-ts/Int32.js';
+import { YamlTagModule_identifier, YamlTagModule_coreNamespace } from './Tag.fs.js';
+import { YamlScalar, ScalarStyle } from './Model.fs.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { equals, comparePrimitives, int32ToString, physicalHash, defaultOf, getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { toInt64_unchecked, fromInt32, op_Division, compare, op_Multiply, op_Addition, op_Subtraction, toInt32_unchecked } from '../../../node_modules/@fable-org/fable-library-ts/BigInt.js';
+import { tryParse } from '../../../node_modules/@fable-org/fable-library-ts/Double.js';
+import { FSharpResult$2_Error$, FSharpResult$2_Ok } from '../../../node_modules/@fable-org/fable-library-ts/Result.js';
+import { item, setItem } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { StringBuilder_$ctor, StringBuilder__Append_Z721C83C5, StringBuilder_$ctor_Z524259A4, StringBuilder__Append_244C7CD6 } from '../../../node_modules/@fable-org/fable-library-ts/System.Text.js';
+import { tryGetValue, getItemFromDict, addToSet } from '../../../node_modules/@fable-org/fable-library-ts/MapUtil.js';
+
+function CoreKind_Null() {
+  return CoreKind.Null;
+}
+function CoreKind_Bool() {
+  return CoreKind.Bool;
+}
+function CoreKind_Integer() {
+  return CoreKind.Integer;
+}
+function CoreKind_Float() {
+  return CoreKind.Float;
+}
+function CoreKind_Str() {
+  return CoreKind.Str;
+}
+class CoreKind extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Null", "Bool", "Integer", "Float", "Str"];
+  }
+  static {
+    this.Null = new CoreKind(0, []);
+  }
+  static {
+    this.Bool = new CoreKind(1, []);
+  }
+  static {
+    this.Integer = new CoreKind(2, []);
+  }
+  static {
+    this.Float = new CoreKind(3, []);
+  }
+  static {
+    this.Str = new CoreKind(4, []);
+  }
+}
+function CoreKind_$reflection() {
+  return union_type("YAMLicious.CoreKind", [], CoreKind, () => [[], [], [], [], []]);
+}
+function IntegerToFloatError_NotAnInteger() {
+  return IntegerToFloatError.NotAnInteger;
+}
+function IntegerToFloatError_BeyondFloatRange() {
+  return IntegerToFloatError.BeyondFloatRange;
+}
+class IntegerToFloatError extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["NotAnInteger", "BeyondFloatRange"];
+  }
+  static {
+    this.NotAnInteger = new IntegerToFloatError(0, []);
+  }
+  static {
+    this.BeyondFloatRange = new IntegerToFloatError(1, []);
+  }
+}
+function IntegerToFloatError_$reflection() {
+  return union_type("YAMLicious.IntegerToFloatError", [], IntegerToFloatError, () => [[], []]);
+}
+const CoreSchema_nullAlternative = "null|Null|NULL|~";
+const CoreSchema_boolAlternative = "true|True|TRUE|false|False|FALSE";
+const CoreSchema_decimalAlternative = "[-+]?[0-9]+";
+const CoreSchema_octalAlternative = "0o[0-7]+";
+const CoreSchema_hexadecimalAlternative = "0x[0-9a-fA-F]+";
+const CoreSchema_numberAlternative = "[-+]?(?:\\.[0-9]+|[0-9]+(?:\\.[0-9]*)?)(?:[eE][-+]?[0-9]+)?";
+const CoreSchema_infinityAlternative = "[-+]?\\.(?:inf|Inf|INF)";
+const CoreSchema_nanAlternative = "\\.(?:nan|NaN|NAN)";
+function CoreSchema_anchored(alternative) {
+  return "^(?:" + alternative + ")$";
+}
+const CoreSchema_nonStringPattern = CoreSchema_anchored(join("|", [CoreSchema_nullAlternative, CoreSchema_boolAlternative, CoreSchema_decimalAlternative, CoreSchema_octalAlternative, CoreSchema_hexadecimalAlternative, CoreSchema_numberAlternative, CoreSchema_infinityAlternative, CoreSchema_nanAlternative]));
+const CoreSchema_nullPattern = CoreSchema_anchored(CoreSchema_nullAlternative);
+const CoreSchema_boolPattern = CoreSchema_anchored(CoreSchema_boolAlternative);
+const CoreSchema_decimalPattern = CoreSchema_anchored(CoreSchema_decimalAlternative);
+const CoreSchema_octalPattern = CoreSchema_anchored(CoreSchema_octalAlternative);
+const CoreSchema_hexadecimalPattern = CoreSchema_anchored(CoreSchema_hexadecimalAlternative);
+const CoreSchema_numberPattern = CoreSchema_anchored(CoreSchema_numberAlternative);
+const CoreSchema_infinityPattern = CoreSchema_anchored(CoreSchema_infinityAlternative);
+const CoreSchema_nanPattern = CoreSchema_anchored(CoreSchema_nanAlternative);
+function CoreSchema_matches(pattern, text) {
+  if (!(text.indexOf("\n") >= 0)) {
+    return isMatch(create(pattern), text);
+  } else {
+    return false;
+  }
+}
+function CoreSchema_integerRadix(text) {
+  if (CoreSchema_matches(CoreSchema_decimalPattern, text)) {
+    return 10;
+  } else if (CoreSchema_matches(CoreSchema_octalPattern, text)) {
+    return 8;
+  } else if (CoreSchema_matches(CoreSchema_hexadecimalPattern, text)) {
+    return 16;
+  } else {
+    return 0;
+  }
+}
+function CoreSchema_digitValue(c) {
+  if (c <= "9") {
+    return ~~c.charCodeAt(0) - ~~"0".charCodeAt(0) | 0;
+  } else if (c >= "a") {
+    return ~~c.charCodeAt(0) - ~~"a".charCodeAt(0) + 10 | 0;
+  } else {
+    return ~~c.charCodeAt(0) - ~~"A".charCodeAt(0) + 10 | 0;
+  }
+}
+function CoreSchema_resolvesToNull(text) {
+  if (isNullOrEmpty(text)) {
+    return true;
+  } else {
+    return CoreSchema_matches(CoreSchema_nullPattern, text);
+  }
+}
+function CoreSchema_resolvesToNonString(text) {
+  if (isNullOrEmpty(text)) {
+    return true;
+  } else {
+    return CoreSchema_matches(CoreSchema_nonStringPattern, text);
+  }
+}
+function CoreSchema_resolveKind(text) {
+  if (CoreSchema_resolvesToNull(text)) {
+    return CoreKind.Null;
+  } else if (CoreSchema_matches(CoreSchema_boolPattern, text)) {
+    return CoreKind.Bool;
+  } else if (CoreSchema_integerRadix(text) !== 0) {
+    return CoreKind.Integer;
+  } else if ((CoreSchema_matches(CoreSchema_numberPattern, text) ? true : CoreSchema_matches(CoreSchema_infinityPattern, text)) ? true : CoreSchema_matches(CoreSchema_nanPattern, text)) {
+    return CoreKind.Float;
+  } else {
+    return CoreKind.Str;
+  }
+}
+function CoreSchema_resolvesAs(suffix, tag, scalar) {
+  if (tag == null) {
+    if (scalar.Style.tag === /* Plain */
+    0) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return YamlTagModule_identifier(tag) === YamlTagModule_coreNamespace + suffix;
+  }
+}
+function CoreSchema_isNull(tag, scalar) {
+  if (CoreSchema_resolvesAs("null", tag, scalar)) {
+    return CoreSchema_resolvesToNull(scalar.Value);
+  } else {
+    return false;
+  }
+}
+function CoreSchema_tryParseBool(tag, scalar) {
+  if (CoreSchema_resolvesAs("bool", tag, scalar)) {
+    const matchValue = scalar.Value;
+    switch (matchValue) {
+      case "true":
+      case "True":
+      case "TRUE":
+        return true;
+      case "false":
+      case "False":
+      case "FALSE":
+        return false;
+      default:
+        return void 0;
+    }
+  } else {
+    return void 0;
+  }
+}
+function CoreSchema_isString(tag, scalar) {
+  if (tag == null) {
+    if (scalar.Style.tag === /* Plain */
+    0) {
+      const text = scalar.Value;
+      if (text.length === 0) {
+        return false;
+      } else if ("+-.0123456789".indexOf(getCharAtIndex(text, 0)) >= 0) {
+        return equals(CoreSchema_resolveKind(text), CoreKind.Str);
+      } else if ("~nN".indexOf(getCharAtIndex(text, 0)) >= 0) {
+        return !CoreSchema_resolvesToNull(text);
+      } else if ("tTfF".indexOf(getCharAtIndex(text, 0)) >= 0) {
+        return CoreSchema_tryParseBool(void 0, scalar) == null;
+      } else {
+        return true;
+      }
+    } else {
+      return true;
+    }
+  } else if (tag.tag === /* NonSpecific */
+  0) {
+    return true;
+  } else {
+    const explicit = tag;
+    return YamlTagModule_identifier(explicit) === YamlTagModule_coreNamespace + "str";
+  }
+}
+function CoreSchema_tryParseInt64(tag, scalar) {
+  const text = scalar.Value;
+  const sum = (start, radix, negative) => {
+    const radix64 = toInt64_unchecked(fromInt32(radix));
+    const lowestBeforeStep = toInt64_unchecked(op_Division(-9223372036854775808n, radix64));
+    const highestBeforeStep = toInt64_unchecked(op_Division(9223372036854775807n, radix64));
+    let total = 0n;
+    let index = start;
+    let fits = true;
+    while (fits && index < text.length) {
+      const digit = toInt64_unchecked(fromInt32(CoreSchema_digitValue(getCharAtIndex(text, index))));
+      if (negative) {
+        if (compare(total, lowestBeforeStep) < 0 ? true : compare(toInt64_unchecked(op_Multiply(total, radix64)), toInt64_unchecked(op_Addition(-9223372036854775808n, digit))) < 0) {
+          fits = false;
+        } else {
+          total = toInt64_unchecked(op_Subtraction(toInt64_unchecked(op_Multiply(total, radix64)), digit));
+        }
+      } else if (compare(total, highestBeforeStep) > 0 ? true : compare(toInt64_unchecked(op_Multiply(total, radix64)), toInt64_unchecked(op_Subtraction(9223372036854775807n, digit))) > 0) {
+        fits = false;
+      } else {
+        total = toInt64_unchecked(op_Addition(toInt64_unchecked(op_Multiply(total, radix64)), digit));
+      }
+      index = index + 1 | 0;
+    }
+    if (fits) {
+      return total;
+    } else {
+      return void 0;
+    }
+  };
+  if (!CoreSchema_resolvesAs("int", tag, scalar)) {
+    return void 0;
+  } else if (CoreSchema_matches(CoreSchema_decimalPattern, text)) {
+    return sum((getCharAtIndex(text, 0) === "-" ? true : getCharAtIndex(text, 0) === "+") ? 1 : 0, 10, getCharAtIndex(text, 0) === "-");
+  } else if (CoreSchema_matches(CoreSchema_octalPattern, text)) {
+    return sum(2, 8, false);
+  } else if (CoreSchema_matches(CoreSchema_hexadecimalPattern, text)) {
+    return sum(2, 16, false);
+  } else {
+    return void 0;
+  }
+}
+function CoreSchema_tryParseInt(tag, scalar) {
+  let number = void 0;
+  let option_3;
+  const option_1 = CoreSchema_tryParseInt64(tag, scalar);
+  option_3 = option_1 != null ? (number = option_1, compare(number, toInt64_unchecked(fromInt32(-2147483648))) >= 0 && compare(number, toInt64_unchecked(fromInt32(2147483647))) <= 0) ? option_1 : void 0 : void 0;
+  if (option_3 != null) {
+    return ~~toInt32_unchecked(option_3);
+  } else {
+    return void 0;
+  }
+}
+function CoreSchema_tryParseFloat(tag, scalar) {
+  const text = scalar.Value;
+  if (!CoreSchema_resolvesAs("float", tag, scalar)) {
+    return void 0;
+  } else if (CoreSchema_matches(CoreSchema_infinityPattern, text)) {
+    return getCharAtIndex(text, 0) === "-" ? -Infinity : Infinity;
+  } else if (CoreSchema_matches(CoreSchema_nanPattern, text)) {
+    return NaN;
+  } else if (CoreSchema_matches(CoreSchema_numberPattern, text)) {
+    let matchValue;
+    const cell = new FSharpRef(0);
+    matchValue = [tryParse(text, 231, cell), cell.contents];
+    if (matchValue[0]) {
+      return matchValue[1];
+    } else {
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+}
+function CoreSchema_integerToFloat(text) {
+  const radix = CoreSchema_integerRadix(text) | 0;
+  if (radix === 0) {
+    return FSharpResult$2_Error$(IntegerToFloatError.NotAnInteger);
+  } else {
+    const limbs = new Int32Array(65);
+    let used = 0;
+    let fits = true;
+    let index = radix === 10 ? (getCharAtIndex(text, 0) === "-" ? true : getCharAtIndex(text, 0) === "+") ? 1 : 0 : 2;
+    while (fits && index < text.length) {
+      let carry = CoreSchema_digitValue(getCharAtIndex(text, index));
+      for (let limb = 0; limb <= used - 1; limb++) {
+        const product = item(limb, limbs) * radix + carry | 0;
+        setItem(limbs, limb, product & 65535 | 0);
+        carry = product >> 16 | 0;
+      }
+      if (carry > 0) {
+        if (used === 65) {
+          fits = false;
+        } else {
+          setItem(limbs, used, carry | 0);
+          used = used + 1 | 0;
+        }
+      }
+      index = index + 1 | 0;
+    }
+    if (!fits) {
+      return FSharpResult$2_Error$(IntegerToFloatError.BeyondFloatRange);
+    } else {
+      const bitAt = (position) => item(position >> 4, limbs) >> (position & 15) & 1 | 0;
+      let topLimbBits = 0;
+      if (used > 0) {
+        let top = item(used - 1, limbs);
+        while (top > 0) {
+          topLimbBits = topLimbBits + 1 | 0;
+          top = top >> 1 | 0;
+        }
+      }
+      const bitLength = (used === 0 ? 0 : (used - 1) * 16 + topLimbBits) | 0;
+      const dropped = bitLength - (bitLength < 53 ? bitLength : 53) | 0;
+      let significand = 0;
+      for (let position_1 = bitLength - 1; position_1 >= dropped; position_1--) {
+        significand = significand * 2 + bitAt(position_1);
+      }
+      if (dropped > 0 && bitAt(dropped - 1) === 1) {
+        let laterBitSet = false;
+        let position_2 = dropped - 2;
+        while (!laterBitSet && position_2 >= 0) {
+          laterBitSet = bitAt(position_2) === 1;
+          position_2 = position_2 - 1 | 0;
+        }
+        if (laterBitSet ? true : bitAt(dropped) === 1) {
+          significand = significand + 1;
+        }
+      }
+      if (dropped > 971 ? true : dropped === 971 && significand === 9007199254740992) {
+        return FSharpResult$2_Error$(IntegerToFloatError.BeyondFloatRange);
+      } else {
+        let magnitude = significand;
+        for (let forLoopVar = 1; forLoopVar <= dropped; forLoopVar++) {
+          magnitude = magnitude * 2;
+        }
+        return FSharpResult$2_Ok(radix === 10 && getCharAtIndex(text, 0) === "-" && magnitude > 0 ? -magnitude : magnitude);
+      }
+    }
+  }
+}
+function CoreSchema_withoutLeadingZeros(digits) {
+  let start = 0;
+  while (start < digits.length - 1 && getCharAtIndex(digits, start) === "0") {
+    start = start + 1 | 0;
+  }
+  return substring(digits, start);
+}
+function CoreSchema_compareMagnitudes(a, b) {
+  if (a.length !== b.length) {
+    return comparePrimitives(a.length, b.length) | 0;
+  } else {
+    let i = 0;
+    while (i < a.length && getCharAtIndex(a, i) === getCharAtIndex(b, i)) {
+      i = i + 1 | 0;
+    }
+    if (i === a.length) {
+      return 0;
+    } else if (getCharAtIndex(a, i) < getCharAtIndex(b, i)) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+}
+function CoreSchema_fromLastDigit(digits) {
+  const sb = StringBuilder_$ctor();
+  for (let i = digits.length - 1; i >= 0; i--) {
+    StringBuilder__Append_Z721C83C5(sb, int32ToString(item(i, digits)));
+  }
+  return CoreSchema_withoutLeadingZeros(toString(sb));
+}
+function CoreSchema_addMagnitudes(a, b) {
+  const digits = [];
+  let i = a.length - 1;
+  let j = b.length - 1;
+  let carry = 0;
+  while ((i >= 0 ? true : j >= 0) ? true : carry > 0) {
+    const sum = carry + (i >= 0 ? CoreSchema_digitValue(getCharAtIndex(a, i)) : 0) + (j >= 0 ? CoreSchema_digitValue(getCharAtIndex(b, j)) : 0) | 0;
+    void digits.push(sum % 10);
+    carry = ~~(sum / 10) | 0;
+    i = i - 1 | 0;
+    j = j - 1 | 0;
+  }
+  return CoreSchema_fromLastDigit(digits);
+}
+function CoreSchema_subtractMagnitudes(larger, smaller) {
+  const digits = [];
+  let i = larger.length - 1;
+  let j = smaller.length - 1;
+  let borrow = 0;
+  while (i >= 0) {
+    let difference = CoreSchema_digitValue(getCharAtIndex(larger, i)) - borrow - (j >= 0 ? CoreSchema_digitValue(getCharAtIndex(smaller, j)) : 0);
+    if (difference < 0) {
+      difference = difference + 10 | 0;
+      borrow = 1;
+    } else {
+      borrow = 0;
+    }
+    void digits.push(difference);
+    i = i - 1 | 0;
+    j = j - 1 | 0;
+  }
+  return CoreSchema_fromLastDigit(digits);
+}
+function CoreSchema_addToDecimal(canonical, offset) {
+  const negativeA = canonical.startsWith("-");
+  const magnitudeA = negativeA ? substring(canonical, 1) : canonical;
+  const negativeB = offset < 0;
+  const magnitudeB = int32ToString(negativeB ? op_UnaryNegation_Int32(offset) : offset);
+  let patternInput;
+  if (negativeA === negativeB) {
+    patternInput = [negativeA, CoreSchema_addMagnitudes(magnitudeA, magnitudeB)];
+  } else {
+    const matchValue = CoreSchema_compareMagnitudes(magnitudeA, magnitudeB) | 0;
+    patternInput = matchValue === 0 ? [false, "0"] : matchValue === 1 ? [negativeA, CoreSchema_subtractMagnitudes(magnitudeA, magnitudeB)] : [negativeB, CoreSchema_subtractMagnitudes(magnitudeB, magnitudeA)];
+  }
+  const magnitude = patternInput[1];
+  if (patternInput[0] && magnitude !== "0") {
+    return "-" + magnitude;
+  } else {
+    return magnitude;
+  }
+}
+function CoreSchema_powerOfTwoDigits(text, radix) {
+  if (radix === 16) {
+    return CoreSchema_withoutLeadingZeros(substring(text, 2).toLowerCase());
+  } else {
+    const reversed = [];
+    let bits = 0;
+    let count = 0;
+    for (let index = text.length - 1; index >= 2; index--) {
+      bits = bits | CoreSchema_digitValue(getCharAtIndex(text, index)) << count | 0;
+      count = count + 3 | 0;
+      while (count >= 4) {
+        void reversed.push(getCharAtIndex("0123456789abcdef", bits & 15));
+        bits = bits >> 4 | 0;
+        count = count - 4 | 0;
+      }
+    }
+    if (count > 0) {
+      void reversed.push(getCharAtIndex("0123456789abcdef", bits));
+    }
+    const sb = StringBuilder_$ctor_Z524259A4(reversed.length);
+    for (let i = reversed.length - 1; i >= 0; i--) {
+      StringBuilder__Append_244C7CD6(sb, item(i, reversed));
+    }
+    return CoreSchema_withoutLeadingZeros(toString(sb));
+  }
+}
+function CoreSchema_decimalOfHex(hex) {
+  const limbs = [];
+  let index = 0;
+  let width = hex.length % 3 === 0 ? 3 : hex.length % 3;
+  while (index < hex.length) {
+    let carry = 0;
+    for (let k = index; k <= index + width - 1; k++) {
+      carry = carry * 16 + CoreSchema_digitValue(getCharAtIndex(hex, k)) | 0;
+    }
+    const factor = 1 << 4 * width | 0;
+    for (let limb = 0; limb <= limbs.length - 1; limb++) {
+      const product = item(limb, limbs) * factor + carry | 0;
+      setItem(limbs, limb, product % 1e4);
+      carry = ~~(product / 1e4) | 0;
+    }
+    while (carry > 0) {
+      void limbs.push(carry % 1e4);
+      carry = ~~(carry / 1e4) | 0;
+    }
+    index = index + width | 0;
+    width = 3;
+  }
+  if (limbs.length === 0) {
+    return "0";
+  } else {
+    const sb = StringBuilder_$ctor();
+    StringBuilder__Append_Z721C83C5(sb, int32ToString(item(limbs.length - 1, limbs)));
+    for (let limb_1 = limbs.length - 2; limb_1 >= 0; limb_1--) {
+      const text = int32ToString(item(limb_1, limbs));
+      StringBuilder__Append_Z721C83C5(StringBuilder__Append_Z721C83C5(sb, replicate(4 - text.length, "0")), text);
+    }
+    return toString(sb);
+  }
+}
+function CoreSchema_canonicalInteger(text) {
+  const matchValue = CoreSchema_integerRadix(text) | 0;
+  switch (matchValue) {
+    case 0:
+      return void 0;
+    case 10: {
+      const negative = getCharAtIndex(text, 0) === "-";
+      const magnitude = CoreSchema_withoutLeadingZeros(substring(text, (getCharAtIndex(text, 0) === "-" ? true : getCharAtIndex(text, 0) === "+") ? 1 : 0));
+      return negative && magnitude !== "0" ? "-" + magnitude : magnitude;
+    }
+    default:
+      return CoreSchema_decimalOfHex(CoreSchema_powerOfTwoDigits(text, matchValue));
+  }
+}
+const CoreSchema_smallHexDigits = 32;
+const CoreSchema_smallDecimalDigits = 38;
+const CoreSchema_decimalDigitsPerHexDigit = 1.2041199826559248;
+function CoreSchema_residues(digits, radix) {
+  let first = 0;
+  let second = 0;
+  for (let index = 0; index <= digits.length - 1; index++) {
+    const digit = CoreSchema_digitValue(getCharAtIndex(digits, index)) | 0;
+    first = (first * radix + digit) % 8388593 | 0;
+    second = (second * radix + digit) % 8388587 | 0;
+  }
+  return int32ToString(first) + ":" + int32ToString(second);
+}
+class CoreSchema_IntegerClass extends Record {
+  constructor(Names, DecimalLengths, Unconverted) {
+    super();
+    this.Names = Names;
+    this.DecimalLengths = DecimalLengths;
+    this.Unconverted = Unconverted;
+  }
+  Equals(other) {
+    return this === other;
+  }
+  GetHashCode() {
+    return physicalHash(this);
+  }
+}
+function CoreSchema_IntegerClass_$reflection() {
+  return record_type("YAMLicious.CoreSchema.IntegerClass", [], CoreSchema_IntegerClass, () => [["Names", class_type("System.Collections.Generic.Dictionary`2", [string_type, string_type])], ["DecimalLengths", class_type("System.Collections.Generic.HashSet`1", [int32_type])], ["Unconverted", class_type("System.Collections.Generic.Dictionary`2", [int32_type, array_type(string_type)])]]);
+}
+class CoreSchema_IntegerNames {
+  constructor() {
+    this.classes = /* @__PURE__ */ new Map([]);
+  }
+}
+function CoreSchema_IntegerNames_$reflection() {
+  return class_type("YAMLicious.CoreSchema.IntegerNames", void 0, CoreSchema_IntegerNames);
+}
+function CoreSchema_IntegerNames_$ctor() {
+  return new CoreSchema_IntegerNames();
+}
+function CoreSchema_IntegerNames__Name_Z721C83C5(_, text) {
+  const matchValue = CoreSchema_integerRadix(text) | 0;
+  switch (matchValue) {
+    case 0:
+      return void 0;
+    case 10: {
+      const negative = getCharAtIndex(text, 0) === "-";
+      const magnitude = CoreSchema_withoutLeadingZeros(substring(text, (getCharAtIndex(text, 0) === "-" ? true : getCharAtIndex(text, 0) === "+") ? 1 : 0));
+      if (negative && magnitude !== "0") {
+        return "-" + magnitude;
+      } else if (magnitude.length <= CoreSchema_smallDecimalDigits) {
+        return magnitude;
+      } else {
+        return CoreSchema_IntegerNames__nameDecimal_Z721C83C5(_, magnitude);
+      }
+    }
+    default: {
+      const hex = CoreSchema_powerOfTwoDigits(text, matchValue);
+      if (hex.length <= CoreSchema_smallHexDigits) {
+        return CoreSchema_decimalOfHex(hex);
+      } else {
+        return CoreSchema_IntegerNames__nameHex_Z721C83C5(_, hex);
+      }
+    }
+  }
+}
+function CoreSchema_IntegerNames__classOf_Z721C83C5(this$, key) {
+  let matchValue;
+  const cell = new FSharpRef(defaultOf());
+  matchValue = [tryGetValue(this$.classes, key, cell), cell.contents];
+  if (matchValue[0]) {
+    return matchValue[1];
+  } else {
+    const created = new CoreSchema_IntegerClass(/* @__PURE__ */ new Map([]), /* @__PURE__ */ new Set([]), /* @__PURE__ */ new Map([]));
+    this$.classes.set(key, created);
+    return created;
+  }
+}
+function CoreSchema_IntegerNames__nameDecimal_Z721C83C5(this$, digits) {
+  const entry = CoreSchema_IntegerNames__classOf_Z721C83C5(this$, CoreSchema_residues(digits, 10));
+  const length = digits.length | 0;
+  const low = ~~((length - 1) / CoreSchema_decimalDigitsPerHexDigit) - 1 | 0;
+  const high = ~~(length / CoreSchema_decimalDigitsPerHexDigit) + 2 | 0;
+  for (let hexLength = low; hexLength <= high; hexLength++) {
+    let matchValue;
+    const cell = new FSharpRef(defaultOf());
+    matchValue = [tryGetValue(entry.Unconverted, hexLength, cell), cell.contents];
+    if (matchValue[0]) {
+      let enumerator = getEnumerator(matchValue[1]);
+      try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+          const hex = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          entry.Names.set("d" + CoreSchema_decimalOfHex(hex), getItemFromDict(entry.Names, "x" + hex));
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+      entry.Unconverted.delete(hexLength);
+    }
+  }
+  addToSet(length, entry.DecimalLengths);
+  let matchValue_1;
+  const cell_1 = new FSharpRef(defaultOf());
+  matchValue_1 = [tryGetValue(entry.Names, "d" + digits, cell_1), cell_1.contents];
+  if (matchValue_1[0]) {
+    return matchValue_1[1];
+  } else {
+    entry.Names.set("d" + digits, digits);
+    return digits;
+  }
+}
+function CoreSchema_IntegerNames__nameHex_Z721C83C5(this$, hex) {
+  const entry = CoreSchema_IntegerNames__classOf_Z721C83C5(this$, CoreSchema_residues(hex, 16));
+  let matchValue;
+  const cell = new FSharpRef(defaultOf());
+  matchValue = [tryGetValue(entry.Names, "x" + hex, cell), cell.contents];
+  if (matchValue[0]) {
+    return matchValue[1];
+  } else {
+    const length = hex.length | 0;
+    const low = ~~((length - 1) * CoreSchema_decimalDigitsPerHexDigit) - 1 | 0;
+    const high = ~~(length * CoreSchema_decimalDigitsPerHexDigit) + 2 | 0;
+    let similar = false;
+    for (let decimalLength = low; decimalLength <= high; decimalLength++) {
+      if (entry.DecimalLengths.has(decimalLength)) {
+        similar = true;
+      }
+    }
+    let name_2;
+    if (similar) {
+      const converted = "d" + CoreSchema_decimalOfHex(hex);
+      let matchValue_1;
+      const cell_1 = new FSharpRef(defaultOf());
+      matchValue_1 = [tryGetValue(entry.Names, converted, cell_1), cell_1.contents];
+      if (matchValue_1[0]) {
+        name_2 = matchValue_1[1];
+      } else {
+        entry.Names.set(converted, "x" + hex);
+        name_2 = "x" + hex;
+      }
+    } else {
+      let matchValue_2;
+      const cell_2 = new FSharpRef(defaultOf());
+      matchValue_2 = [tryGetValue(entry.Unconverted, length, cell_2), cell_2.contents];
+      if (matchValue_2[0]) {
+        void matchValue_2[1].push(hex);
+      } else {
+        entry.Unconverted.set(length, [hex]);
+      }
+      name_2 = "x" + hex;
+    }
+    entry.Names.set("x" + hex, name_2);
+    return name_2;
+  }
+}
+function CoreSchema_canonicalFloat(text) {
+  if (CoreSchema_matches(CoreSchema_infinityPattern, text)) {
+    return getCharAtIndex(text, 0) === "-" ? "-inf" : "+inf";
+  } else if (CoreSchema_matches(CoreSchema_nanPattern, text)) {
+    return "nan";
+  } else if (CoreSchema_matches(CoreSchema_numberPattern, text)) {
+    const negative = getCharAtIndex(text, 0) === "-";
+    const start = ((getCharAtIndex(text, 0) === "-" ? true : getCharAtIndex(text, 0) === "+") ? 1 : 0) | 0;
+    let exponentAt = start;
+    while (exponentAt < text.length && getCharAtIndex(text, exponentAt) !== "e" && getCharAtIndex(text, exponentAt) !== "E") {
+      exponentAt = exponentAt + 1 | 0;
+    }
+    const mantissa = substring(text, start, exponentAt - start);
+    const point = mantissa.indexOf(".") | 0;
+    const integerDigits = point < 0 ? mantissa : substring(mantissa, 0, point);
+    const fractionDigits = point < 0 ? "" : substring(mantissa, point + 1);
+    const digits = integerDigits + fractionDigits;
+    let first = 0;
+    while (first < digits.length && getCharAtIndex(digits, first) === "0") {
+      first = first + 1 | 0;
+    }
+    if (first === digits.length) {
+      return "0";
+    } else {
+      let last = digits.length;
+      while (getCharAtIndex(digits, last - 1) === "0") {
+        last = last - 1 | 0;
+      }
+      const exponent = exponentAt === text.length ? "0" : value(CoreSchema_canonicalInteger(substring(text, exponentAt + 1)));
+      const shift = digits.length - last - fractionDigits.length | 0;
+      return (negative ? "-" : "+") + substring(digits, first, last - first) + "e" + CoreSchema_addToDecimal(exponent, shift);
+    }
+  } else {
+    return void 0;
+  }
+}
+function CoreSchema_floatText(text) {
+  if (CoreSchema_matches(CoreSchema_decimalPattern, text)) {
+    return text + ".0";
+  } else {
+    return text;
+  }
+}
+function CoreSchema_stringContent(text) {
+  return new YamlScalar(text, CoreSchema_resolvesToNonString(text) ? ScalarStyle.DoubleQuoted : ScalarStyle.Plain, void 0, void 0);
+}
+
+export { CoreKind, CoreKind_$reflection, CoreKind_Bool, CoreKind_Float, CoreKind_Integer, CoreKind_Null, CoreKind_Str, CoreSchema_IntegerClass, CoreSchema_IntegerClass_$reflection, CoreSchema_IntegerNames, CoreSchema_IntegerNames_$ctor, CoreSchema_IntegerNames_$reflection, CoreSchema_IntegerNames__Name_Z721C83C5, CoreSchema_IntegerNames__classOf_Z721C83C5, CoreSchema_IntegerNames__nameDecimal_Z721C83C5, CoreSchema_IntegerNames__nameHex_Z721C83C5, CoreSchema_canonicalFloat, CoreSchema_canonicalInteger, CoreSchema_floatText, CoreSchema_integerToFloat, CoreSchema_isNull, CoreSchema_isString, CoreSchema_resolveKind, CoreSchema_resolvesToNonString, CoreSchema_resolvesToNull, CoreSchema_stringContent, CoreSchema_tryParseBool, CoreSchema_tryParseFloat, CoreSchema_tryParseInt, CoreSchema_tryParseInt64, IntegerToFloatError, IntegerToFloatError_$reflection, IntegerToFloatError_BeyondFloatRange, IntegerToFloatError_NotAnInteger };