@continuous-excellence/coupling-cli 0.0.0

package/kotlin/kotlin-kotlin-stdlib/kotlin/text/Strings.mjs

@@ -0,0 +1,872 @@
+import {
+  _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
+  toString3dhdjl9yf50de as toString,
+} from '../Char.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { isCharSequence1ju9jr1w86plq as isCharSequence } from '../js/typeCheckUtils.mjs';
+import { toString1pkumu07cwy4m as toString_0 } from '../js/coreRuntime.mjs';
+import {
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+} from '../js/charSequenceJs.mjs';
+import {
+  startsWith5hna0vjiqaqm as startsWith,
+  endsWith3cq61xxngobwh as endsWith,
+  startsWith26w8qjqapeeq6 as startsWith_0,
+  regionMatches30ph926sbb53j as regionMatches,
+} from './stringsCode.mjs';
+import {
+  asIterable1fxmj7vyh9cyo as asIterable,
+  toListx6x8nvfmvvht as toList,
+} from '../sequences/_Sequences.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../collections/ArrayListJs.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../collections/Iterables.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import { equals2ukvbdmtrnsss as equals } from './Char.mjs';
+import {
+  isWhitespace25occ8z1ed1s9 as isWhitespace,
+  isHighSurrogate11jfjw70ar0zf as isHighSurrogate,
+  isLowSurrogateujxcv7hjn4ma as isLowSurrogate,
+} from './charJs.mjs';
+import { substringiqarkczpya5m as substring } from './stringJs.mjs';
+import { charArrayOf27f4r3dozbrk1 as charArrayOf } from '../js/arrays.mjs';
+import {
+  single2hobxym0rz0fw as single,
+  contains39avmiojcughs as contains,
+} from '../collections/_Arrays.mjs';
+import {
+  coerceAtLeast2bkz8m9ik7hep as coerceAtLeast,
+  coerceAtMost322komnqp70ag as coerceAtMost,
+  downTo39qhfeycepm1j as downTo,
+  until1jbpn0z3f8lbg as until,
+  coerceIn10f36k81le1mm as coerceIn,
+} from '../ranges/_Ranges.mjs';
+import {
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  NoSuchElementException679xzhnp5bpj as NoSuchElementException,
+} from '../exceptions.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from './StringBuilderJs.mjs';
+import { listOfvhqybd2zx248 as listOf } from '../collections/collectionJs.mjs';
+import { asList2ho2pewtsfvv as asList } from '../collections/_ArraysJs.mjs';
+import { numberRangeToNumber25vse2rgp6rs8 as numberRangeToNumber } from '../js/rangeTo.mjs';
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { IntRange1cx8zvxgibbj2 as IntRange } from '../ranges/PrimitiveRanges.mjs';
+import { Sequence1quqbxersk0bb as Sequence } from '../sequences/Sequence.mjs';
+import { single3ds7xj9roxi5z as single_0 } from '../collections/_Collections.mjs';
+import { to2cs3ny02qtbcb as to } from '../Tuples.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function padStart(_this__u8e3s4, length, padChar) {
+  padChar = padChar === VOID ? _Char___init__impl__6a9atx(32) : padChar;
+  return toString_0(padStart_0(isCharSequence(_this__u8e3s4) ? _this__u8e3s4 : THROW_CCE(), length, padChar));
+}
+function startsWith_1(_this__u8e3s4, prefix, startIndex, ignoreCase) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  var tmp_0;
+  if (!ignoreCase) {
+    tmp_0 = typeof _this__u8e3s4 === 'string';
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = typeof prefix === 'string';
+  } else {
+    tmp = false;
+  }
+  if (tmp)
+    return startsWith(_this__u8e3s4, prefix, startIndex);
+  else {
+    return regionMatchesImpl(_this__u8e3s4, startIndex, prefix, 0, charSequenceLength(prefix), ignoreCase);
+  }
+}
+function split(_this__u8e3s4, delimiters, ignoreCase, limit) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  limit = limit === VOID ? 0 : limit;
+  if (delimiters.length === 1) {
+    return split_1(_this__u8e3s4, toString(delimiters[0]), ignoreCase, limit);
+  }
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = asIterable(rangesDelimitedBy(_this__u8e3s4, delimiters, VOID, ignoreCase, limit));
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList().w2(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.q1();
+  while (_iterator__ex2g4s.r1()) {
+    var item = _iterator__ex2g4s.s1();
+    var tmp$ret$0 = substring_1(_this__u8e3s4, item);
+    destination.t2(tmp$ret$0);
+  }
+  return destination;
+}
+function startsWith_2(_this__u8e3s4, char, ignoreCase) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  return charSequenceLength(_this__u8e3s4) > 0 && equals(charSequenceGet(_this__u8e3s4, 0), char, ignoreCase);
+}
+function get_lastIndex(_this__u8e3s4) {
+  return charSequenceLength(_this__u8e3s4) - 1 | 0;
+}
+function isBlank(_this__u8e3s4) {
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.text.all' call
+    var inductionVariable = 0;
+    while (inductionVariable < charSequenceLength(_this__u8e3s4)) {
+      var element = charSequenceGet(_this__u8e3s4, inductionVariable);
+      inductionVariable = inductionVariable + 1 | 0;
+      if (!isWhitespace(element)) {
+        tmp$ret$1 = false;
+        break $l$block;
+      }
+    }
+    tmp$ret$1 = true;
+  }
+  return tmp$ret$1;
+}
+function split_0(_this__u8e3s4, delimiters, ignoreCase, limit) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  limit = limit === VOID ? 0 : limit;
+  if (delimiters.length === 1) {
+    var delimiter = delimiters[0];
+    // Inline function 'kotlin.text.isEmpty' call
+    if (!(charSequenceLength(delimiter) === 0)) {
+      return split_1(_this__u8e3s4, delimiter, ignoreCase, limit);
+    }
+  }
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = asIterable(rangesDelimitedBy_0(_this__u8e3s4, delimiters, VOID, ignoreCase, limit));
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList().w2(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.q1();
+  while (_iterator__ex2g4s.r1()) {
+    var item = _iterator__ex2g4s.s1();
+    var tmp$ret$1 = substring_1(_this__u8e3s4, item);
+    destination.t2(tmp$ret$1);
+  }
+  return destination;
+}
+function substringBefore(_this__u8e3s4, delimiter, missingDelimiterValue) {
+  missingDelimiterValue = missingDelimiterValue === VOID ? _this__u8e3s4 : missingDelimiterValue;
+  var index = indexOf_0(_this__u8e3s4, delimiter);
+  return index === -1 ? missingDelimiterValue : substring(_this__u8e3s4, 0, index);
+}
+function contains_0(_this__u8e3s4, other, ignoreCase) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  if (typeof other === 'string') {
+    tmp = indexOf_0(_this__u8e3s4, other, VOID, ignoreCase) >= 0;
+  } else {
+    tmp = indexOf_1(_this__u8e3s4, other, 0, charSequenceLength(_this__u8e3s4), ignoreCase) >= 0;
+  }
+  return tmp;
+}
+function trim(_this__u8e3s4) {
+  // Inline function 'kotlin.text.trim' call
+  var startIndex = 0;
+  var endIndex = charSequenceLength(_this__u8e3s4) - 1 | 0;
+  var startFound = false;
+  $l$loop: while (startIndex <= endIndex) {
+    var index = !startFound ? startIndex : endIndex;
+    var p0 = charSequenceGet(_this__u8e3s4, index);
+    var match = isWhitespace(p0);
+    if (!startFound) {
+      if (!match)
+        startFound = true;
+      else
+        startIndex = startIndex + 1 | 0;
+    } else {
+      if (!match)
+        break $l$loop;
+      else
+        endIndex = endIndex - 1 | 0;
+    }
+  }
+  return charSequenceSubSequence(_this__u8e3s4, startIndex, endIndex + 1 | 0);
+}
+function removeSuffix(_this__u8e3s4, suffix) {
+  if (endsWith_0(_this__u8e3s4, suffix)) {
+    return substring(_this__u8e3s4, 0, _this__u8e3s4.length - charSequenceLength(suffix) | 0);
+  }
+  return _this__u8e3s4;
+}
+function endsWith_0(_this__u8e3s4, suffix, ignoreCase) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  var tmp_0;
+  if (!ignoreCase) {
+    tmp_0 = typeof _this__u8e3s4 === 'string';
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = typeof suffix === 'string';
+  } else {
+    tmp = false;
+  }
+  if (tmp)
+    return endsWith(_this__u8e3s4, suffix);
+  else {
+    return regionMatchesImpl(_this__u8e3s4, charSequenceLength(_this__u8e3s4) - charSequenceLength(suffix) | 0, suffix, 0, charSequenceLength(suffix), ignoreCase);
+  }
+}
+function contains_1(_this__u8e3s4, char, ignoreCase) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  return indexOf(_this__u8e3s4, char, VOID, ignoreCase) >= 0;
+}
+function indexOf(_this__u8e3s4, char, startIndex, ignoreCase) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  var tmp_0;
+  if (ignoreCase) {
+    tmp_0 = true;
+  } else {
+    tmp_0 = !(typeof _this__u8e3s4 === 'string');
+  }
+  if (tmp_0) {
+    // Inline function 'kotlin.charArrayOf' call
+    var tmp$ret$0 = charArrayOf([char]);
+    tmp = indexOfAny(_this__u8e3s4, tmp$ret$0, startIndex, ignoreCase);
+  } else {
+    // Inline function 'kotlin.text.nativeIndexOf' call
+    // Inline function 'kotlin.text.nativeIndexOf' call
+    var str = toString(char);
+    // Inline function 'kotlin.js.asDynamic' call
+    tmp = _this__u8e3s4.indexOf(str, startIndex);
+  }
+  return tmp;
+}
+function substring_0(_this__u8e3s4, range) {
+  return substring(_this__u8e3s4, range.l2(), range.m2() + 1 | 0);
+}
+function startsWith_3(_this__u8e3s4, prefix, ignoreCase) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  var tmp_0;
+  if (!ignoreCase) {
+    tmp_0 = typeof _this__u8e3s4 === 'string';
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = typeof prefix === 'string';
+  } else {
+    tmp = false;
+  }
+  if (tmp)
+    return startsWith_0(_this__u8e3s4, prefix);
+  else {
+    return regionMatchesImpl(_this__u8e3s4, 0, prefix, 0, charSequenceLength(prefix), ignoreCase);
+  }
+}
+function lineSequence(_this__u8e3s4) {
+  // Inline function 'kotlin.sequences.Sequence' call
+  return new (lineSequence$$inlined$Sequence$1())(_this__u8e3s4);
+}
+function indexOfAny(_this__u8e3s4, chars, startIndex, ignoreCase) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  if (!ignoreCase && chars.length === 1) {
+    tmp = typeof _this__u8e3s4 === 'string';
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    var char = single(chars);
+    // Inline function 'kotlin.text.nativeIndexOf' call
+    // Inline function 'kotlin.text.nativeIndexOf' call
+    var str = toString(char);
+    // Inline function 'kotlin.js.asDynamic' call
+    return _this__u8e3s4.indexOf(str, startIndex);
+  }
+  var inductionVariable = coerceAtLeast(startIndex, 0);
+  var last = get_lastIndex(_this__u8e3s4);
+  if (inductionVariable <= last)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var charAtIndex = charSequenceGet(_this__u8e3s4, index);
+      var tmp$ret$4;
+      $l$block: {
+        // Inline function 'kotlin.collections.any' call
+        var inductionVariable_0 = 0;
+        var last_0 = chars.length;
+        while (inductionVariable_0 < last_0) {
+          var element = chars[inductionVariable_0];
+          inductionVariable_0 = inductionVariable_0 + 1 | 0;
+          if (equals(element, charAtIndex, ignoreCase)) {
+            tmp$ret$4 = true;
+            break $l$block;
+          }
+        }
+        tmp$ret$4 = false;
+      }
+      if (tmp$ret$4)
+        return index;
+    }
+     while (!(index === last));
+  return -1;
+}
+function indexOf_0(_this__u8e3s4, string, startIndex, ignoreCase) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  var tmp_0;
+  if (ignoreCase) {
+    tmp_0 = true;
+  } else {
+    tmp_0 = !(typeof _this__u8e3s4 === 'string');
+  }
+  if (tmp_0) {
+    tmp = indexOf_1(_this__u8e3s4, string, startIndex, charSequenceLength(_this__u8e3s4), ignoreCase);
+  } else {
+    // Inline function 'kotlin.text.nativeIndexOf' call
+    // Inline function 'kotlin.js.asDynamic' call
+    tmp = _this__u8e3s4.indexOf(string, startIndex);
+  }
+  return tmp;
+}
+function toBooleanStrictOrNull(_this__u8e3s4) {
+  switch (_this__u8e3s4) {
+    case 'true':
+      return true;
+    case 'false':
+      return false;
+    default:
+      return null;
+  }
+}
+function substringBefore_0(_this__u8e3s4, delimiter, missingDelimiterValue) {
+  missingDelimiterValue = missingDelimiterValue === VOID ? _this__u8e3s4 : missingDelimiterValue;
+  var index = indexOf(_this__u8e3s4, delimiter);
+  return index === -1 ? missingDelimiterValue : substring(_this__u8e3s4, 0, index);
+}
+function substringAfter(_this__u8e3s4, delimiter, missingDelimiterValue) {
+  missingDelimiterValue = missingDelimiterValue === VOID ? _this__u8e3s4 : missingDelimiterValue;
+  var index = indexOf(_this__u8e3s4, delimiter);
+  return index === -1 ? missingDelimiterValue : substring(_this__u8e3s4, index + 1 | 0, _this__u8e3s4.length);
+}
+function lastIndexOf(_this__u8e3s4, string, startIndex, ignoreCase) {
+  startIndex = startIndex === VOID ? get_lastIndex(_this__u8e3s4) : startIndex;
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp;
+  var tmp_0;
+  if (ignoreCase) {
+    tmp_0 = true;
+  } else {
+    tmp_0 = !(typeof _this__u8e3s4 === 'string');
+  }
+  if (tmp_0) {
+    tmp = indexOf_1(_this__u8e3s4, string, startIndex, 0, ignoreCase, true);
+  } else {
+    // Inline function 'kotlin.text.nativeLastIndexOf' call
+    // Inline function 'kotlin.js.asDynamic' call
+    tmp = _this__u8e3s4.lastIndexOf(string, startIndex);
+  }
+  return tmp;
+}
+function commonPrefixWith(_this__u8e3s4, other, ignoreCase) {
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  var tmp0 = charSequenceLength(_this__u8e3s4);
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = charSequenceLength(other);
+  var shortestLength = Math.min(tmp0, b);
+  var i = 0;
+  while (i < shortestLength && equals(charSequenceGet(_this__u8e3s4, i), charSequenceGet(other, i), ignoreCase)) {
+    i = i + 1 | 0;
+  }
+  if (hasSurrogatePairAt(_this__u8e3s4, i - 1 | 0) || hasSurrogatePairAt(other, i - 1 | 0)) {
+    i = i - 1 | 0;
+  }
+  return toString_0(charSequenceSubSequence(_this__u8e3s4, 0, i));
+}
+function lines(_this__u8e3s4) {
+  return toList(lineSequence(_this__u8e3s4));
+}
+function padStart_0(_this__u8e3s4, length, padChar) {
+  padChar = padChar === VOID ? _Char___init__impl__6a9atx(32) : padChar;
+  if (length < 0)
+    throw IllegalArgumentException().r2('Desired length ' + length + ' is less than zero.');
+  if (length <= charSequenceLength(_this__u8e3s4))
+    return charSequenceSubSequence(_this__u8e3s4, 0, charSequenceLength(_this__u8e3s4));
+  var sb = StringBuilder().gc(length);
+  var inductionVariable = 1;
+  var last = length - charSequenceLength(_this__u8e3s4) | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      sb.p1(padChar);
+    }
+     while (!(i === last));
+  sb.s2(_this__u8e3s4);
+  return sb;
+}
+function regionMatchesImpl(_this__u8e3s4, thisOffset, other, otherOffset, length, ignoreCase) {
+  if (otherOffset < 0 || thisOffset < 0 || thisOffset > (charSequenceLength(_this__u8e3s4) - length | 0) || otherOffset > (charSequenceLength(other) - length | 0)) {
+    return false;
+  }
+  var inductionVariable = 0;
+  if (inductionVariable < length)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      if (!equals(charSequenceGet(_this__u8e3s4, thisOffset + index | 0), charSequenceGet(other, otherOffset + index | 0), ignoreCase))
+        return false;
+    }
+     while (inductionVariable < length);
+  return true;
+}
+function split_1(_this__u8e3s4, delimiter, ignoreCase, limit) {
+  requireNonNegativeLimit(limit);
+  var currentOffset = 0;
+  var nextIndex = indexOf_0(_this__u8e3s4, delimiter, currentOffset, ignoreCase);
+  if (nextIndex === -1 || limit === 1) {
+    return listOf(toString_0(_this__u8e3s4));
+  }
+  var isLimited = limit > 0;
+  var result = ArrayList().w2(isLimited ? coerceAtMost(limit, 10) : 10);
+  $l$loop: do {
+    var tmp2 = currentOffset;
+    // Inline function 'kotlin.text.substring' call
+    var endIndex = nextIndex;
+    var tmp$ret$0 = toString_0(charSequenceSubSequence(_this__u8e3s4, tmp2, endIndex));
+    result.t2(tmp$ret$0);
+    currentOffset = nextIndex + delimiter.length | 0;
+    if (isLimited && result.v2() === (limit - 1 | 0))
+      break $l$loop;
+    nextIndex = indexOf_0(_this__u8e3s4, delimiter, currentOffset, ignoreCase);
+  }
+   while (!(nextIndex === -1));
+  var tmp2_0 = currentOffset;
+  // Inline function 'kotlin.text.substring' call
+  var endIndex_0 = charSequenceLength(_this__u8e3s4);
+  var tmp$ret$1 = toString_0(charSequenceSubSequence(_this__u8e3s4, tmp2_0, endIndex_0));
+  result.t2(tmp$ret$1);
+  return result;
+}
+function rangesDelimitedBy(_this__u8e3s4, delimiters, startIndex, ignoreCase, limit) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  limit = limit === VOID ? 0 : limit;
+  requireNonNegativeLimit(limit);
+  return new (DelimitedRangesSequence())(_this__u8e3s4, startIndex, limit, rangesDelimitedBy$lambda(delimiters, ignoreCase));
+}
+function substring_1(_this__u8e3s4, range) {
+  return toString_0(charSequenceSubSequence(_this__u8e3s4, range.l2(), range.m2() + 1 | 0));
+}
+function rangesDelimitedBy_0(_this__u8e3s4, delimiters, startIndex, ignoreCase, limit) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  ignoreCase = ignoreCase === VOID ? false : ignoreCase;
+  limit = limit === VOID ? 0 : limit;
+  requireNonNegativeLimit(limit);
+  var delimitersList = asList(delimiters);
+  return new (DelimitedRangesSequence())(_this__u8e3s4, startIndex, limit, rangesDelimitedBy$lambda_0(delimitersList, ignoreCase));
+}
+function indexOf_1(_this__u8e3s4, other, startIndex, endIndex, ignoreCase, last) {
+  last = last === VOID ? false : last;
+  var indices = !last ? numberRangeToNumber(coerceAtLeast(startIndex, 0), coerceAtMost(endIndex, charSequenceLength(_this__u8e3s4))) : downTo(coerceAtMost(startIndex, get_lastIndex(_this__u8e3s4)), coerceAtLeast(endIndex, 0));
+  var tmp;
+  if (typeof _this__u8e3s4 === 'string') {
+    tmp = typeof other === 'string';
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    var inductionVariable = indices.j3_1;
+    var last_0 = indices.k3_1;
+    var step = indices.l3_1;
+    if (step > 0 && inductionVariable <= last_0 || (step < 0 && last_0 <= inductionVariable))
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + step | 0;
+        if (regionMatches(other, 0, _this__u8e3s4, index, other.length, ignoreCase))
+          return index;
+      }
+       while (!(index === last_0));
+  } else {
+    var inductionVariable_0 = indices.j3_1;
+    var last_1 = indices.k3_1;
+    var step_0 = indices.l3_1;
+    if (step_0 > 0 && inductionVariable_0 <= last_1 || (step_0 < 0 && last_1 <= inductionVariable_0))
+      do {
+        var index_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + step_0 | 0;
+        if (regionMatchesImpl(other, 0, _this__u8e3s4, index_0, charSequenceLength(other), ignoreCase))
+          return index_0;
+      }
+       while (!(index_0 === last_1));
+  }
+  return -1;
+}
+var StateClass;
+function State() {
+  if (StateClass === VOID) {
+    class $ {
+      constructor() {
+        this.tq_1 = 0;
+        this.uq_1 = 1;
+        this.vq_1 = 2;
+      }
+    }
+    initMetadataForObject($, 'State');
+    StateClass = $;
+  }
+  return StateClass;
+}
+var State_instance;
+function State_getInstance() {
+  return State_instance;
+}
+var LinesIteratorClass;
+function LinesIterator() {
+  if (LinesIteratorClass === VOID) {
+    class $ {
+      constructor(string) {
+        this.wq_1 = string;
+        this.xq_1 = 0;
+        this.yq_1 = 0;
+        this.zq_1 = 0;
+        this.ar_1 = 0;
+      }
+      r1() {
+        if (!(this.xq_1 === 0)) {
+          return this.xq_1 === 1;
+        }
+        if (this.ar_1 < 0) {
+          this.xq_1 = 2;
+          return false;
+        }
+        var _delimiterLength = -1;
+        var _delimiterStartIndex = charSequenceLength(this.wq_1);
+        var inductionVariable = this.yq_1;
+        var last = charSequenceLength(this.wq_1);
+        if (inductionVariable < last)
+          $l$loop: do {
+            var idx = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var c = charSequenceGet(this.wq_1, idx);
+            if (c === _Char___init__impl__6a9atx(10) || c === _Char___init__impl__6a9atx(13)) {
+              _delimiterLength = c === _Char___init__impl__6a9atx(13) && (idx + 1 | 0) < charSequenceLength(this.wq_1) && charSequenceGet(this.wq_1, idx + 1 | 0) === _Char___init__impl__6a9atx(10) ? 2 : 1;
+              _delimiterStartIndex = idx;
+              break $l$loop;
+            }
+          }
+           while (inductionVariable < last);
+        this.xq_1 = 1;
+        this.ar_1 = _delimiterLength;
+        this.zq_1 = _delimiterStartIndex;
+        return true;
+      }
+      s1() {
+        if (!this.r1()) {
+          throw NoSuchElementException().w6();
+        }
+        this.xq_1 = 0;
+        var lastIndex = this.zq_1;
+        var firstIndex = this.yq_1;
+        this.yq_1 = this.zq_1 + this.ar_1 | 0;
+        // Inline function 'kotlin.text.substring' call
+        var this_0 = this.wq_1;
+        return toString_0(charSequenceSubSequence(this_0, firstIndex, lastIndex));
+      }
+    }
+    initMetadataForClass($, 'LinesIterator');
+    LinesIteratorClass = $;
+  }
+  return LinesIteratorClass;
+}
+function hasSurrogatePairAt(_this__u8e3s4, index) {
+  return (0 <= index ? index <= (charSequenceLength(_this__u8e3s4) - 2 | 0) : false) && isHighSurrogate(charSequenceGet(_this__u8e3s4, index)) && isLowSurrogate(charSequenceGet(_this__u8e3s4, index + 1 | 0));
+}
+function requireNonNegativeLimit(limit) {
+  // Inline function 'kotlin.require' call
+  if (!(limit >= 0)) {
+    var message = 'Limit must be non-negative, but was ' + limit;
+    throw IllegalArgumentException().r2(toString_0(message));
+  }
+  return Unit_instance;
+}
+function calcNext($this) {
+  if ($this.dr_1 < 0) {
+    $this.br_1 = 0;
+    $this.er_1 = null;
+  } else {
+    var tmp;
+    var tmp_0;
+    if ($this.gr_1.jr_1 > 0) {
+      $this.fr_1 = $this.fr_1 + 1 | 0;
+      tmp_0 = $this.fr_1 >= $this.gr_1.jr_1;
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = true;
+    } else {
+      tmp = $this.dr_1 > charSequenceLength($this.gr_1.hr_1);
+    }
+    if (tmp) {
+      $this.er_1 = numberRangeToNumber($this.cr_1, get_lastIndex($this.gr_1.hr_1));
+      $this.dr_1 = -1;
+    } else {
+      var match = $this.gr_1.kr_1($this.gr_1.hr_1, $this.dr_1);
+      if (match == null) {
+        $this.er_1 = numberRangeToNumber($this.cr_1, get_lastIndex($this.gr_1.hr_1));
+        $this.dr_1 = -1;
+      } else {
+        var index = match.vl();
+        var length = match.wl();
+        $this.er_1 = until($this.cr_1, index);
+        $this.cr_1 = index + length | 0;
+        $this.dr_1 = $this.cr_1 + (length === 0 ? 1 : 0) | 0;
+      }
+    }
+    $this.br_1 = 1;
+  }
+}
+var DelimitedRangesSequence$iterator$1Class;
+function DelimitedRangesSequence$iterator$1() {
+  if (DelimitedRangesSequence$iterator$1Class === VOID) {
+    class $ {
+      constructor(this$0) {
+        this.gr_1 = this$0;
+        this.br_1 = -1;
+        this.cr_1 = coerceIn(this$0.ir_1, 0, charSequenceLength(this$0.hr_1));
+        this.dr_1 = this.cr_1;
+        this.er_1 = null;
+        this.fr_1 = 0;
+      }
+      s1() {
+        if (this.br_1 === -1) {
+          calcNext(this);
+        }
+        if (this.br_1 === 0)
+          throw NoSuchElementException().w6();
+        var tmp = this.er_1;
+        var result = tmp instanceof IntRange() ? tmp : THROW_CCE();
+        this.er_1 = null;
+        this.br_1 = -1;
+        return result;
+      }
+      r1() {
+        if (this.br_1 === -1) {
+          calcNext(this);
+        }
+        return this.br_1 === 1;
+      }
+    }
+    initMetadataForClass($);
+    DelimitedRangesSequence$iterator$1Class = $;
+  }
+  return DelimitedRangesSequence$iterator$1Class;
+}
+var DelimitedRangesSequenceClass;
+function DelimitedRangesSequence() {
+  if (DelimitedRangesSequenceClass === VOID) {
+    class $ {
+      constructor(input, startIndex, limit, getNextMatch) {
+        this.hr_1 = input;
+        this.ir_1 = startIndex;
+        this.jr_1 = limit;
+        this.kr_1 = getNextMatch;
+      }
+      q1() {
+        return new (DelimitedRangesSequence$iterator$1())(this);
+      }
+    }
+    initMetadataForClass($, 'DelimitedRangesSequence', VOID, VOID, [Sequence()]);
+    DelimitedRangesSequenceClass = $;
+  }
+  return DelimitedRangesSequenceClass;
+}
+function findAnyOf(_this__u8e3s4, strings, startIndex, ignoreCase, last) {
+  if (!ignoreCase && strings.v2() === 1) {
+    var string = single_0(strings);
+    var index = !last ? indexOf_0(_this__u8e3s4, string, startIndex) : lastIndexOf(_this__u8e3s4, string, startIndex);
+    return index < 0 ? null : to(index, string);
+  }
+  var indices = !last ? numberRangeToNumber(coerceAtLeast(startIndex, 0), charSequenceLength(_this__u8e3s4)) : downTo(coerceAtMost(startIndex, get_lastIndex(_this__u8e3s4)), 0);
+  if (typeof _this__u8e3s4 === 'string') {
+    var inductionVariable = indices.j3_1;
+    var last_0 = indices.k3_1;
+    var step = indices.l3_1;
+    if (step > 0 && inductionVariable <= last_0 || (step < 0 && last_0 <= inductionVariable))
+      do {
+        var index_0 = inductionVariable;
+        inductionVariable = inductionVariable + step | 0;
+        var tmp$ret$1;
+        $l$block: {
+          // Inline function 'kotlin.collections.firstOrNull' call
+          var _iterator__ex2g4s = strings.q1();
+          while (_iterator__ex2g4s.r1()) {
+            var element = _iterator__ex2g4s.s1();
+            if (regionMatches(element, 0, _this__u8e3s4, index_0, element.length, ignoreCase)) {
+              tmp$ret$1 = element;
+              break $l$block;
+            }
+          }
+          tmp$ret$1 = null;
+        }
+        var matchingString = tmp$ret$1;
+        if (!(matchingString == null))
+          return to(index_0, matchingString);
+      }
+       while (!(index_0 === last_0));
+  } else {
+    var inductionVariable_0 = indices.j3_1;
+    var last_1 = indices.k3_1;
+    var step_0 = indices.l3_1;
+    if (step_0 > 0 && inductionVariable_0 <= last_1 || (step_0 < 0 && last_1 <= inductionVariable_0))
+      do {
+        var index_1 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + step_0 | 0;
+        var tmp$ret$3;
+        $l$block_0: {
+          // Inline function 'kotlin.collections.firstOrNull' call
+          var _iterator__ex2g4s_0 = strings.q1();
+          while (_iterator__ex2g4s_0.r1()) {
+            var element_0 = _iterator__ex2g4s_0.s1();
+            if (regionMatchesImpl(element_0, 0, _this__u8e3s4, index_1, element_0.length, ignoreCase)) {
+              tmp$ret$3 = element_0;
+              break $l$block_0;
+            }
+          }
+          tmp$ret$3 = null;
+        }
+        var matchingString_0 = tmp$ret$3;
+        if (!(matchingString_0 == null))
+          return to(index_1, matchingString_0);
+      }
+       while (!(index_1 === last_1));
+  }
+  return null;
+}
+function trimStart(_this__u8e3s4, chars) {
+  // Inline function 'kotlin.text.trimStart' call
+  var tmp0 = isCharSequence(_this__u8e3s4) ? _this__u8e3s4 : THROW_CCE();
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.text.trimStart' call
+    var inductionVariable = 0;
+    var last = charSequenceLength(tmp0) - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var it = charSequenceGet(tmp0, index);
+        if (!contains(chars, it)) {
+          tmp$ret$1 = charSequenceSubSequence(tmp0, index, charSequenceLength(tmp0));
+          break $l$block;
+        }
+      }
+       while (inductionVariable <= last);
+    tmp$ret$1 = '';
+  }
+  return toString_0(tmp$ret$1);
+}
+function trim_0(_this__u8e3s4, chars) {
+  // Inline function 'kotlin.text.trim' call
+  // Inline function 'kotlin.text.trim' call
+  var this_0 = isCharSequence(_this__u8e3s4) ? _this__u8e3s4 : THROW_CCE();
+  var startIndex = 0;
+  var endIndex = charSequenceLength(this_0) - 1 | 0;
+  var startFound = false;
+  $l$loop: while (startIndex <= endIndex) {
+    var index = !startFound ? startIndex : endIndex;
+    var it = charSequenceGet(this_0, index);
+    var match = contains(chars, it);
+    if (!startFound) {
+      if (!match)
+        startFound = true;
+      else
+        startIndex = startIndex + 1 | 0;
+    } else {
+      if (!match)
+        break $l$loop;
+      else
+        endIndex = endIndex - 1 | 0;
+    }
+  }
+  var tmp$ret$1 = charSequenceSubSequence(this_0, startIndex, endIndex + 1 | 0);
+  return toString_0(tmp$ret$1);
+}
+var lineSequence$$inlined$Sequence$1Class;
+function lineSequence$$inlined$Sequence$1() {
+  if (lineSequence$$inlined$Sequence$1Class === VOID) {
+    class $ {
+      constructor($this_lineSequence) {
+        this.lr_1 = $this_lineSequence;
+      }
+      q1() {
+        return new (LinesIterator())(this.lr_1);
+      }
+    }
+    initMetadataForClass($, VOID, VOID, VOID, [Sequence()]);
+    lineSequence$$inlined$Sequence$1Class = $;
+  }
+  return lineSequence$$inlined$Sequence$1Class;
+}
+function rangesDelimitedBy$lambda($delimiters, $ignoreCase) {
+  return ($this$DelimitedRangesSequence, currentIndex) => {
+    // Inline function 'kotlin.let' call
+    var it = indexOfAny($this$DelimitedRangesSequence, $delimiters, currentIndex, $ignoreCase);
+    return it < 0 ? null : to(it, 1);
+  };
+}
+function rangesDelimitedBy$lambda_0($delimitersList, $ignoreCase) {
+  return ($this$DelimitedRangesSequence, currentIndex) => {
+    var tmp0_safe_receiver = findAnyOf($this$DelimitedRangesSequence, $delimitersList, currentIndex, $ignoreCase, false);
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp = to(tmp0_safe_receiver.em_1, tmp0_safe_receiver.fm_1.length);
+    }
+    return tmp;
+  };
+}
+//region block: init
+State_instance = new (State())();
+//endregion
+//region block: exports
+export {
+  commonPrefixWith as commonPrefixWith1ni2eltc34azu,
+  contains_0 as contains3ue2qo8xhmpf1,
+  contains_1 as contains2el4s70rdq4ld,
+  endsWith_0 as endsWith1a79dp5rc3sfv,
+  indexOfAny as indexOfAny2ijjuuzpljsyd,
+  indexOf_0 as indexOfwa4w6635jewi,
+  indexOf as indexOf1xbs558u7wr52,
+  isBlank as isBlank1dvkhjjvox3p0,
+  get_lastIndex as get_lastIndexld83bqhfgcdd,
+  lastIndexOf as lastIndexOf2d52xhix5ymjr,
+  lineSequence as lineSequencefj20mplblw0p,
+  lines as lines3g90sq0zeq43v,
+  padStart as padStart36w1507hs626a,
+  regionMatchesImpl as regionMatchesImplsfmctm6zdxjp,
+  removeSuffix as removeSuffix3d61x5lsuvuho,
+  split as split3d3yeauc4rm2n,
+  split_0 as split2bvyvnrlcifjv,
+  startsWith_2 as startsWith1bgirhbedtv2y,
+  startsWith_3 as startsWith38d3sbg25w0lx,
+  startsWith_1 as startsWith641pyr7vf687,
+  substringAfter as substringAfter1hku067gwr5ve,
+  substringBefore as substringBeforekje8w2lxhyb6,
+  substringBefore_0 as substringBefore3n7kj60w69hju,
+  substring_0 as substring2pnd9wgs9hwtx,
+  toBooleanStrictOrNull as toBooleanStrictOrNull2j0md398tkvbj,
+  trimStart as trimStart1mkod6gyztuyy,
+  trim_0 as trim6jpmwojjgb3l,
+  trim as trim11nh7r46at6sx,
+};
+//endregion
+
+//# sourceMappingURL=Strings.mjs.map