@continuous-excellence/coupling-cli 0.0.0

package/kotlin/mordant-mordant/com/github/ajalt/mordant/table/Table.mjs

@@ -0,0 +1,1443 @@
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+  toString1pkumu07cwy4m as toString,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  protoOf180f3jzyo7rfj as protoOf,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { toString30pk9tzaqopn as toString_0 } from '../../../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import {
+  getOrNull1go7ef9ldk0df as getOrNull,
+  withIndex37cl61h9v5txo as withIndex,
+  sortedWith2csnbbb21k0lg as sortedWith,
+  zipfdxxupzuj2p9 as zip,
+  sum1ib1hqt64m6qf as sum,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { compareTo3ankvs086tmwq as compareTo } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/compareTo.mjs';
+import { WidthRangevnx4894h4q60 as WidthRange } from '../rendering/WidthRange.mjs';
+import {
+  coerceAtLeast2bkz8m9ik7hep as coerceAtLeast,
+  coerceIn10f36k81le1mm as coerceIn,
+  coerceAtMost322komnqp70ag as coerceAtMost,
+  until1jbpn0z3f8lbg as until,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/ranges/_Ranges.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+import {
+  mapCapacity1h45rc3eh9p2l as mapCapacity,
+  checkCountOverflow1ro2fe1r4xvgf as checkCountOverflow,
+  listOfvhqybd2zx248 as listOf,
+  checkIndexOverflow3frtmheghr0th as checkIndexOverflow,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import { numberToInt1ygmcfwhs2fkq as numberToInt } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import { FunctionAdapter3lcrrz3moet5b as FunctionAdapter } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/FunctionAdapter.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { Comparator2b3maoeh98xtg as Comparator } from '../../../../../../kotlin-kotlin-stdlib/kotlin/ComparatorJs.mjs';
+import { compareValues1n2ayl87ihzfk as compareValues } from '../../../../../../kotlin-kotlin-stdlib/kotlin/comparisons/Comparisons.mjs';
+import { Collection1k04j3hzsbod0 as Collection } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs';
+import {
+  get_indices3txodfl5wuu5j as get_indices,
+  get_lastIndex1yw0x4k50k51w as get_lastIndex,
+  emptyList1g2z5xcrvp2zy as emptyList,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import {
+  render$default1ajjvm90qz861 as render$default,
+  Widget367sjqcdf3bp7 as Widget,
+} from '../rendering/Widget.mjs';
+import { Companion_instancejds5ql83jr4n as Companion_instance } from '../rendering/Span.mjs';
+import { repeat2w4c6j8zoq09o as repeat } from '../../../../../../kotlin-kotlin-stdlib/kotlin/text/stringsCode.mjs';
+import {
+  get_SINGLE_SPACEkhfztdcb18zi as get_SINGLE_SPACE,
+  get_EMPTY_LINESw02we56bmip6 as get_EMPTY_LINES,
+} from '../internal/Constants.mjs';
+import {
+  setSize3ssegge31vyl8 as setSize,
+  Line2gahqv4ywxewt as Line,
+  Lines1zphsr74zhzwc as Lines,
+} from '../rendering/Lines.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var EmptyClass;
+function Empty() {
+  if (EmptyClass === VOID) {
+    class $ extends Cell() {
+      constructor() {
+        Empty_instance = null;
+        super();
+        Empty_instance = this;
+      }
+      i6b() {
+        return 1;
+      }
+      j6b() {
+        return false;
+      }
+      k6b() {
+        return false;
+      }
+      l6b() {
+        return false;
+      }
+      m6b() {
+        return false;
+      }
+      toString() {
+        return 'Empty';
+      }
+      hashCode() {
+        return 264596584;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Empty()))
+          return false;
+        other instanceof Empty() || THROW_CCE();
+        return true;
+      }
+    }
+    initMetadataForObject($, 'Empty');
+    EmptyClass = $;
+  }
+  return EmptyClass;
+}
+var Empty_instance;
+function Empty_getInstance() {
+  if (Empty_instance === VOID)
+    new (Empty())();
+  return Empty_instance;
+}
+var SpanRefClass;
+function SpanRef() {
+  if (SpanRefClass === VOID) {
+    class $ extends Cell() {
+      constructor(cell, borderLeft, borderTop, borderRight, borderBottom) {
+        super();
+        this.n6b_1 = cell;
+        this.o6b_1 = borderLeft;
+        this.p6b_1 = borderTop;
+        this.q6b_1 = borderRight;
+        this.r6b_1 = borderBottom;
+      }
+      j6b() {
+        return this.o6b_1;
+      }
+      k6b() {
+        return this.p6b_1;
+      }
+      l6b() {
+        return this.q6b_1;
+      }
+      m6b() {
+        return this.r6b_1;
+      }
+      i6b() {
+        return this.n6b_1.t6b_1;
+      }
+      d6c() {
+        return this.n6b_1.u6b_1;
+      }
+      toString() {
+        return 'SpanRef(cell=' + this.n6b_1.toString() + ', borderLeft=' + this.o6b_1 + ', borderTop=' + this.p6b_1 + ', borderRight=' + this.q6b_1 + ', borderBottom=' + this.r6b_1 + ')';
+      }
+      hashCode() {
+        var result = this.n6b_1.hashCode();
+        result = imul(result, 31) + (this.o6b_1 == null ? 0 : getBooleanHashCode(this.o6b_1)) | 0;
+        result = imul(result, 31) + (this.p6b_1 == null ? 0 : getBooleanHashCode(this.p6b_1)) | 0;
+        result = imul(result, 31) + (this.q6b_1 == null ? 0 : getBooleanHashCode(this.q6b_1)) | 0;
+        result = imul(result, 31) + (this.r6b_1 == null ? 0 : getBooleanHashCode(this.r6b_1)) | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof SpanRef()))
+          return false;
+        var tmp0_other_with_cast = other instanceof SpanRef() ? other : THROW_CCE();
+        if (!this.n6b_1.equals(tmp0_other_with_cast.n6b_1))
+          return false;
+        if (!(this.o6b_1 == tmp0_other_with_cast.o6b_1))
+          return false;
+        if (!(this.p6b_1 == tmp0_other_with_cast.p6b_1))
+          return false;
+        if (!(this.q6b_1 == tmp0_other_with_cast.q6b_1))
+          return false;
+        if (!(this.r6b_1 == tmp0_other_with_cast.r6b_1))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'SpanRef');
+    SpanRefClass = $;
+  }
+  return SpanRefClass;
+}
+var ContentClass;
+function Content() {
+  if (ContentClass === VOID) {
+    class $ extends Cell() {
+      constructor(content, rowSpan, columnSpan, borderLeft, borderTop, borderRight, borderBottom, style, textAlign, verticalAlign, paddingWidth) {
+        super();
+        this.s6b_1 = content;
+        this.t6b_1 = rowSpan;
+        this.u6b_1 = columnSpan;
+        this.v6b_1 = borderLeft;
+        this.w6b_1 = borderTop;
+        this.x6b_1 = borderRight;
+        this.y6b_1 = borderBottom;
+        this.z6b_1 = style;
+        this.a6c_1 = textAlign;
+        this.b6c_1 = verticalAlign;
+        this.c6c_1 = paddingWidth;
+        // Inline function 'kotlin.require' call
+        if (!(this.t6b_1 > 0)) {
+          var message = 'rowSpan must be greater than 0';
+          throw IllegalArgumentException().r2(toString(message));
+        }
+        // Inline function 'kotlin.require' call
+        if (!(this.u6b_1 > 0)) {
+          var message_0 = 'columnSpan must be greater than 0';
+          throw IllegalArgumentException().r2(toString(message_0));
+        }
+      }
+      i6b() {
+        return this.t6b_1;
+      }
+      j6b() {
+        return this.v6b_1;
+      }
+      k6b() {
+        return this.w6b_1;
+      }
+      l6b() {
+        return this.x6b_1;
+      }
+      m6b() {
+        return this.y6b_1;
+      }
+      toString() {
+        return 'Content(content=' + toString(this.s6b_1) + ', rowSpan=' + this.t6b_1 + ', columnSpan=' + this.u6b_1 + ', borderLeft=' + this.v6b_1 + ', borderTop=' + this.w6b_1 + ', borderRight=' + this.x6b_1 + ', borderBottom=' + this.y6b_1 + ', style=' + toString_0(this.z6b_1) + ', textAlign=' + this.a6c_1.toString() + ', verticalAlign=' + this.b6c_1.toString() + ', paddingWidth=' + this.c6c_1 + ')';
+      }
+      hashCode() {
+        var result = hashCode(this.s6b_1);
+        result = imul(result, 31) + this.t6b_1 | 0;
+        result = imul(result, 31) + this.u6b_1 | 0;
+        result = imul(result, 31) + (this.v6b_1 == null ? 0 : getBooleanHashCode(this.v6b_1)) | 0;
+        result = imul(result, 31) + (this.w6b_1 == null ? 0 : getBooleanHashCode(this.w6b_1)) | 0;
+        result = imul(result, 31) + (this.x6b_1 == null ? 0 : getBooleanHashCode(this.x6b_1)) | 0;
+        result = imul(result, 31) + (this.y6b_1 == null ? 0 : getBooleanHashCode(this.y6b_1)) | 0;
+        result = imul(result, 31) + (this.z6b_1 == null ? 0 : hashCode(this.z6b_1)) | 0;
+        result = imul(result, 31) + this.a6c_1.hashCode() | 0;
+        result = imul(result, 31) + this.b6c_1.hashCode() | 0;
+        result = imul(result, 31) + this.c6c_1 | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Content()))
+          return false;
+        var tmp0_other_with_cast = other instanceof Content() ? other : THROW_CCE();
+        if (!equals(this.s6b_1, tmp0_other_with_cast.s6b_1))
+          return false;
+        if (!(this.t6b_1 === tmp0_other_with_cast.t6b_1))
+          return false;
+        if (!(this.u6b_1 === tmp0_other_with_cast.u6b_1))
+          return false;
+        if (!(this.v6b_1 == tmp0_other_with_cast.v6b_1))
+          return false;
+        if (!(this.w6b_1 == tmp0_other_with_cast.w6b_1))
+          return false;
+        if (!(this.x6b_1 == tmp0_other_with_cast.x6b_1))
+          return false;
+        if (!(this.y6b_1 == tmp0_other_with_cast.y6b_1))
+          return false;
+        if (!equals(this.z6b_1, tmp0_other_with_cast.z6b_1))
+          return false;
+        if (!this.a6c_1.equals(tmp0_other_with_cast.a6c_1))
+          return false;
+        if (!this.b6c_1.equals(tmp0_other_with_cast.b6c_1))
+          return false;
+        if (!(this.c6c_1 === tmp0_other_with_cast.c6c_1))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'Content');
+    ContentClass = $;
+  }
+  return ContentClass;
+}
+var CellClass;
+function Cell() {
+  if (CellClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'Cell');
+    CellClass = $;
+  }
+  return CellClass;
+}
+function measureColumn($this, x, t, width) {
+  var tmp56_safe_receiver = $this.m6c_1.u2(x).f6c_1;
+  if (tmp56_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    var tmp;
+    if (!$this.o6c_1) {
+      tmp = 0;
+    } else {
+      var tmp0 = $this.h6c_1;
+      var tmp$ret$0;
+      $l$block: {
+        // Inline function 'kotlin.collections.maxOfOrNull' call
+        var iterator = tmp0.q1();
+        if (!iterator.r1()) {
+          tmp$ret$0 = null;
+          break $l$block;
+        }
+        var row = iterator.s1();
+        var tmp_0 = getOrNull(row, x);
+        var tmp57_safe_receiver = tmp_0 instanceof Content() ? tmp_0 : null;
+        var tmp0_elvis_lhs = tmp57_safe_receiver == null ? null : tmp57_safe_receiver.c6c_1;
+        var maxValue = tmp0_elvis_lhs == null ? 0 : tmp0_elvis_lhs;
+        while (iterator.r1()) {
+          var row_0 = iterator.s1();
+          var tmp_1 = getOrNull(row_0, x);
+          var tmp57_safe_receiver_0 = tmp_1 instanceof Content() ? tmp_1 : null;
+          var tmp0_elvis_lhs_0 = tmp57_safe_receiver_0 == null ? null : tmp57_safe_receiver_0.c6c_1;
+          var v = tmp0_elvis_lhs_0 == null ? 0 : tmp0_elvis_lhs_0;
+          if (compareTo(maxValue, v) < 0) {
+            maxValue = v;
+          }
+        }
+        tmp$ret$0 = maxValue;
+      }
+      var tmp0_elvis_lhs_1 = tmp$ret$0;
+      tmp = tmp0_elvis_lhs_1 == null ? 0 : tmp0_elvis_lhs_1;
+    }
+    var paddingWidth = tmp;
+    return new (WidthRange())(tmp56_safe_receiver + paddingWidth | 0, tmp56_safe_receiver + paddingWidth | 0);
+  }
+  // Inline function 'com.github.ajalt.mordant.rendering.maxWidthRange' call
+  var max = 0;
+  var min = 0;
+  var _iterator__ex2g4s = $this.h6c_1.q1();
+  $l$loop: while (_iterator__ex2g4s.r1()) {
+    var it = _iterator__ex2g4s.s1();
+    var cell = getOrNull(it, x);
+    var tmp_2;
+    if (cell == null) {
+      tmp_2 = null;
+    } else {
+      if (cell instanceof Empty()) {
+        tmp_2 = new (WidthRange())(0, 0);
+      } else {
+        if (cell instanceof Content()) {
+          tmp_2 = cell.s6b_1.j6a(t, width).b6b(cell.u6b_1);
+        } else {
+          if (cell instanceof SpanRef()) {
+            tmp_2 = cell.n6b_1.s6b_1.j6a(t, width).b6b(cell.d6c());
+          } else {
+            noWhenBranchMatchedException();
+          }
+        }
+      }
+    }
+    var tmp0_elvis_lhs_2 = tmp_2;
+    var tmp_3;
+    if (tmp0_elvis_lhs_2 == null) {
+      continue $l$loop;
+    } else {
+      tmp_3 = tmp0_elvis_lhs_2;
+    }
+    var range = tmp_3;
+    var tmp0_0 = max;
+    // Inline function 'kotlin.comparisons.maxOf' call
+    var b = range.y6a_1;
+    max = Math.max(tmp0_0, b);
+    var tmp0_1 = min;
+    // Inline function 'kotlin.comparisons.maxOf' call
+    var b_0 = range.x6a_1;
+    min = Math.max(tmp0_1, b_0);
+  }
+  var range_0 = new (WidthRange())(min + 0 | 0, max + 0 | 0);
+  if (!($this.m6c_1.u2(x).g6c_1 == null)) {
+    return new (WidthRange())(range_0.x6a_1, coerceAtLeast(width, range_0.y6a_1));
+  }
+  return range_0;
+}
+function calculateColumnWidths($this, t, terminalWidth) {
+  var availableWidth = terminalWidth - $this.t6c_1 | 0;
+  if (availableWidth <= 0) {
+    // Inline function 'kotlin.collections.List' call
+    // Inline function 'kotlin.collections.MutableList' call
+    var size = $this.q6c_1;
+    var list = ArrayList().w2(size);
+    // Inline function 'kotlin.repeat' call
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        list.t2(0);
+      }
+       while (inductionVariable < size);
+    return list;
+  }
+  // Inline function 'kotlin.collections.List' call
+  // Inline function 'kotlin.collections.MutableList' call
+  var size_0 = $this.q6c_1;
+  var list_0 = ArrayList().w2(size_0);
+  // Inline function 'kotlin.repeat' call
+  var inductionVariable_0 = 0;
+  if (inductionVariable_0 < size_0)
+    do {
+      var index_0 = inductionVariable_0;
+      inductionVariable_0 = inductionVariable_0 + 1 | 0;
+      var tmp$ret$5 = measureColumn($this, index_0, t, availableWidth);
+      list_0.t2(tmp$ret$5);
+    }
+     while (inductionVariable_0 < size_0);
+  var measurements = list_0;
+  // Inline function 'kotlin.collections.mutableListOf' call
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList().n2();
+  var _iterator__ex2g4s = measurements.q1();
+  while (_iterator__ex2g4s.r1()) {
+    var item = _iterator__ex2g4s.s1();
+    var tmp$ret$11 = item.y6a_1;
+    destination.t2(tmp$ret$11);
+  }
+  var widths = destination;
+  // Inline function 'kotlin.collections.groupBy' call
+  var tmp0 = withIndex($this.m6c_1);
+  // Inline function 'kotlin.collections.groupByTo' call
+  var destination_0 = LinkedHashMap().qc();
+  var _iterator__ex2g4s_0 = tmp0.q1();
+  while (_iterator__ex2g4s_0.r1()) {
+    var element = _iterator__ex2g4s_0.s1();
+    var key = element.ul_1.e6c_1;
+    // Inline function 'kotlin.collections.getOrPut' call
+    var value = destination_0.o4(key);
+    var tmp;
+    if (value == null) {
+      var answer = ArrayList().n2();
+      destination_0.v4(key, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    var list_1 = tmp;
+    list_1.t2(element);
+  }
+  // Inline function 'kotlin.collections.mapValues' call
+  // Inline function 'kotlin.collections.mapValuesTo' call
+  var destination_1 = LinkedHashMap().rc(mapCapacity(destination_0.v2()));
+  // Inline function 'kotlin.collections.associateByTo' call
+  var _iterator__ex2g4s_1 = destination_0.e3().q1();
+  while (_iterator__ex2g4s_1.r1()) {
+    var element_0 = _iterator__ex2g4s_1.s1();
+    var tmp_0 = element_0.f3();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = element_0.g3();
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_2 = ArrayList().w2(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s_2 = this_0.q1();
+    while (_iterator__ex2g4s_2.r1()) {
+      var item_0 = _iterator__ex2g4s_2.s1();
+      var tmp$ret$19 = item_0.tl_1;
+      destination_2.t2(tmp$ret$19);
+    }
+    destination_1.v4(tmp_0, destination_2);
+  }
+  var shrinkPriorities = destination_1;
+  // Inline function 'kotlin.collections.mapValues' call
+  // Inline function 'kotlin.collections.mapValuesTo' call
+  var destination_3 = LinkedHashMap().rc(mapCapacity(shrinkPriorities.v2()));
+  // Inline function 'kotlin.collections.associateByTo' call
+  var _iterator__ex2g4s_3 = shrinkPriorities.e3().q1();
+  while (_iterator__ex2g4s_3.r1()) {
+    var element_1 = _iterator__ex2g4s_3.s1();
+    var tmp_1 = element_1.f3();
+    // Inline function 'kotlin.collections.sumOf' call
+    var sum = 0;
+    var _iterator__ex2g4s_4 = element_1.g3().q1();
+    while (_iterator__ex2g4s_4.r1()) {
+      var element_2 = _iterator__ex2g4s_4.s1();
+      var tmp_2 = sum;
+      sum = tmp_2 + measurements.u2(element_2).x6a_1 | 0;
+    }
+    var tmp_3 = sum;
+    // Inline function 'kotlin.collections.sumOf' call
+    var sum_0 = 0;
+    var _iterator__ex2g4s_5 = element_1.g3().q1();
+    while (_iterator__ex2g4s_5.r1()) {
+      var element_3 = _iterator__ex2g4s_5.s1();
+      var tmp_4 = sum_0;
+      sum_0 = tmp_4 + measurements.u2(element_3).y6a_1 | 0;
+    }
+    var tmp$ret$30 = sum_0;
+    var tmp$ret$31 = new (WidthRange())(tmp_3, tmp$ret$30);
+    destination_3.v4(tmp_1, tmp$ret$31);
+  }
+  var priorityMeasurements = destination_3;
+  var remainingWidth = availableWidth;
+  // Inline function 'kotlin.collections.mutableMapOf' call
+  var allocatedWidths = LinkedHashMap().qc();
+  // Inline function 'kotlin.collections.sortedByDescending' call
+  var this_1 = priorityMeasurements.e3();
+  // Inline function 'kotlin.comparisons.compareByDescending' call
+  var tmp_5 = TableImpl$calculateColumnWidths$lambda;
+  var tmp$ret$36 = new (sam$kotlin_Comparator$0())(tmp_5);
+  // Inline function 'kotlin.collections.forEach' call
+  var _iterator__ex2g4s_6 = sortedWith(this_1, tmp$ret$36).q1();
+  while (_iterator__ex2g4s_6.r1()) {
+    var element_4 = _iterator__ex2g4s_6.s1();
+    // Inline function 'kotlin.collections.component1' call
+    var p = element_4.f3();
+    // Inline function 'kotlin.collections.component2' call
+    var m = element_4.g3();
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_0 = priorityMeasurements.e3();
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination_4 = ArrayList().n2();
+    var _iterator__ex2g4s_7 = tmp0_0.q1();
+    while (_iterator__ex2g4s_7.r1()) {
+      var element_5 = _iterator__ex2g4s_7.s1();
+      if (element_5.f3() < p) {
+        destination_4.t2(element_5);
+      }
+    }
+    // Inline function 'kotlin.collections.sumOf' call
+    var sum_1 = 0;
+    var _iterator__ex2g4s_8 = destination_4.q1();
+    while (_iterator__ex2g4s_8.r1()) {
+      var element_6 = _iterator__ex2g4s_8.s1();
+      var tmp_6 = sum_1;
+      sum_1 = tmp_6 + element_6.g3().x6a_1 | 0;
+    }
+    var lowerMin = sum_1;
+    var allocated = coerceAtMost(coerceIn(remainingWidth - lowerMin | 0, m.x6a_1, m.y6a_1), remainingWidth);
+    remainingWidth = remainingWidth - allocated | 0;
+    // Inline function 'kotlin.collections.set' call
+    allocatedWidths.v4(p, allocated);
+  }
+  // Inline function 'kotlin.collections.sortedByDescending' call
+  var this_2 = allocatedWidths.e3();
+  // Inline function 'kotlin.comparisons.compareByDescending' call
+  var tmp_7 = TableImpl$calculateColumnWidths$lambda_0;
+  var tmp$ret$48 = new (sam$kotlin_Comparator$0())(tmp_7);
+  var _iterator__ex2g4s_9 = sortedWith(this_2, tmp$ret$48).q1();
+  while (_iterator__ex2g4s_9.r1()) {
+    var _destruct__k2r9zo = _iterator__ex2g4s_9.s1();
+    // Inline function 'kotlin.collections.component1' call
+    var p_0 = _destruct__k2r9zo.f3();
+    // Inline function 'kotlin.collections.component2' call
+    var w = _destruct__k2r9zo.g3();
+    var indexes = ensureNotNull(shrinkPriorities.o4(p_0));
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_5 = ArrayList().w2(collectionSizeOrDefault(indexes, 10));
+    var _iterator__ex2g4s_10 = indexes.q1();
+    while (_iterator__ex2g4s_10.r1()) {
+      var item_1 = _iterator__ex2g4s_10.s1();
+      var tmp0_elvis_lhs = $this.m6c_1.u2(item_1).g6c_1;
+      var tmp$ret$52 = tmp0_elvis_lhs == null ? measurements.u2(item_1).y6a_1 : tmp0_elvis_lhs;
+      destination_5.t2(tmp$ret$52);
+    }
+    var weights = destination_5;
+    var distributedWidths = distributeWidths($this, weights, w);
+    var _iterator__ex2g4s_11 = zip(indexes, distributedWidths).q1();
+    while (_iterator__ex2g4s_11.r1()) {
+      var _destruct__k2r9zo_0 = _iterator__ex2g4s_11.s1();
+      var i = _destruct__k2r9zo_0.vl();
+      var ww = _destruct__k2r9zo_0.wl();
+      widths.s4(i, ww);
+    }
+  }
+  return widths;
+}
+function distributeWidths($this, weights, totalWidth) {
+  if (totalWidth === 0) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList().w2(collectionSizeOrDefault(weights, 10));
+    var _iterator__ex2g4s = weights.q1();
+    while (_iterator__ex2g4s.r1()) {
+      var item = _iterator__ex2g4s.s1();
+      destination.t2(0);
+    }
+    return destination;
+  }
+  // Inline function 'kotlin.collections.sumOf' call
+  var sum_0 = 0;
+  var _iterator__ex2g4s_0 = weights.q1();
+  while (_iterator__ex2g4s_0.r1()) {
+    var element = _iterator__ex2g4s_0.s1();
+    var tmp = sum_0;
+    sum_0 = tmp + element;
+  }
+  var totalWeight = sum_0;
+  // Inline function 'kotlin.collections.mutableListOf' call
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination_0 = ArrayList().n2();
+  var _iterator__ex2g4s_1 = weights.q1();
+  while (_iterator__ex2g4s_1.r1()) {
+    var item_0 = _iterator__ex2g4s_1.s1();
+    var tmp$ret$6 = numberToInt(item_0 / totalWeight * totalWidth);
+    destination_0.t2(tmp$ret$6);
+  }
+  var widths = destination_0;
+  // Inline function 'kotlin.repeat' call
+  var times = totalWidth - sum(widths) | 0;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      widths.s4(index, widths.u2(index) + 1 | 0);
+    }
+     while (inductionVariable < times);
+  return widths;
+}
+function getCell($this, x, y) {
+  var tmp58_safe_receiver = getOrNull($this.h6c_1, y);
+  return tmp58_safe_receiver == null ? null : getOrNull(tmp58_safe_receiver, x);
+}
+var sam$kotlin_Comparator$0Class;
+function sam$kotlin_Comparator$0() {
+  if (sam$kotlin_Comparator$0Class === VOID) {
+    class $ {
+      constructor(function_0) {
+        this.u6c_1 = function_0;
+      }
+      zi(a, b) {
+        return this.u6c_1(a, b);
+      }
+      compare(a, b) {
+        return this.zi(a, b);
+      }
+      h5() {
+        return this.u6c_1;
+      }
+      equals(other) {
+        var tmp;
+        if (!(other == null) ? isInterface(other, Comparator()) : false) {
+          var tmp_0;
+          if (!(other == null) ? isInterface(other, FunctionAdapter()) : false) {
+            tmp_0 = equals(this.h5(), other.h5());
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.h5());
+      }
+    }
+    initMetadataForClass($, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator(), FunctionAdapter()]);
+    sam$kotlin_Comparator$0Class = $;
+  }
+  return sam$kotlin_Comparator$0Class;
+}
+function TableImpl$calculateColumnWidths$lambda(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  var tmp = b.f3();
+  var tmp$ret$1 = a.f3();
+  return compareValues(tmp, tmp$ret$1);
+}
+function TableImpl$calculateColumnWidths$lambda_0(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  var tmp = b.f3();
+  var tmp$ret$1 = a.f3();
+  return compareValues(tmp, tmp$ret$1);
+}
+var TableImplClass;
+function TableImpl() {
+  if (TableImplClass === VOID) {
+    class $ extends Table() {
+      constructor(rows, borderType, borderStyle, headerRowCount, footerRowCount, columnWidths, tableBorders, addPaddingWidthToFixedWidth) {
+        super();
+        this.h6c_1 = rows;
+        this.i6c_1 = borderType;
+        this.j6c_1 = borderStyle;
+        this.k6c_1 = headerRowCount;
+        this.l6c_1 = footerRowCount;
+        this.m6c_1 = columnWidths;
+        this.n6c_1 = tableBorders;
+        this.o6c_1 = addPaddingWidthToFixedWidth;
+        // Inline function 'kotlin.collections.isNotEmpty' call
+        // Inline function 'kotlin.require' call
+        if (!!this.h6c_1.o1()) {
+          var message = 'Table cannot be empty';
+          throw IllegalArgumentException().r2(toString(message));
+        }
+        var tmp = this;
+        var tmp0 = this.m6c_1;
+        var tmp$ret$3;
+        $l$block_0: {
+          // Inline function 'kotlin.collections.any' call
+          var tmp_0;
+          if (isInterface(tmp0, Collection())) {
+            tmp_0 = tmp0.o1();
+          } else {
+            tmp_0 = false;
+          }
+          if (tmp_0) {
+            tmp$ret$3 = false;
+            break $l$block_0;
+          }
+          var _iterator__ex2g4s = tmp0.q1();
+          while (_iterator__ex2g4s.r1()) {
+            var element = _iterator__ex2g4s.s1();
+            if (!(element.g6c_1 == null)) {
+              tmp$ret$3 = true;
+              break $l$block_0;
+            }
+          }
+          tmp$ret$3 = false;
+        }
+        tmp.p6c_1 = tmp$ret$3;
+        this.q6c_1 = this.m6c_1.v2();
+        var tmp_1 = this;
+        // Inline function 'kotlin.collections.List' call
+        // Inline function 'kotlin.collections.MutableList' call
+        var size = this.h6c_1.v2() + 1 | 0;
+        var list = ArrayList().w2(size);
+        // Inline function 'kotlin.repeat' call
+        var inductionVariable = 0;
+        if (inductionVariable < size)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var tmp_2;
+            if (index === 0 && !(this.n6c_1 == null)) {
+              tmp_2 = this.n6c_1.f6b_1;
+            } else if (index === this.h6c_1.v2() && !(this.n6c_1 == null)) {
+              tmp_2 = this.n6c_1.h6b_1;
+            } else {
+              var tmp0_0 = until(0, this.q6c_1);
+              var tmp$ret$5;
+              $l$block_2: {
+                // Inline function 'kotlin.collections.any' call
+                var tmp_3;
+                if (isInterface(tmp0_0, Collection())) {
+                  tmp_3 = tmp0_0.o1();
+                } else {
+                  tmp_3 = false;
+                }
+                if (tmp_3) {
+                  tmp$ret$5 = false;
+                  break $l$block_2;
+                }
+                var inductionVariable_0 = tmp0_0.j3_1;
+                var last = tmp0_0.k3_1;
+                if (inductionVariable_0 <= last)
+                  do {
+                    var element_0 = inductionVariable_0;
+                    inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                    var x = element_0;
+                    if (get_t(getCell(this, x, index)) || get_b(getCell(this, x, index - 1 | 0))) {
+                      tmp$ret$5 = true;
+                      break $l$block_2;
+                    }
+                  }
+                   while (!(element_0 === last));
+                tmp$ret$5 = false;
+              }
+              tmp_2 = tmp$ret$5;
+            }
+            var tmp$ret$7 = tmp_2;
+            list.t2(tmp$ret$7);
+          }
+           while (inductionVariable < size);
+        tmp_1.r6c_1 = list;
+        var tmp_4 = this;
+        // Inline function 'kotlin.collections.List' call
+        // Inline function 'kotlin.collections.MutableList' call
+        var size_0 = this.q6c_1 + 1 | 0;
+        var list_0 = ArrayList().w2(size_0);
+        // Inline function 'kotlin.repeat' call
+        var inductionVariable_1 = 0;
+        if (inductionVariable_1 < size_0)
+          do {
+            var index_0 = inductionVariable_1;
+            inductionVariable_1 = inductionVariable_1 + 1 | 0;
+            var tmp_5;
+            if (index_0 === 0 && !(this.n6c_1 == null)) {
+              tmp_5 = this.n6c_1.e6b_1;
+            } else if (index_0 === this.q6c_1 && !(this.n6c_1 == null)) {
+              tmp_5 = this.n6c_1.g6b_1;
+            } else {
+              var tmp0_1 = get_indices(this.h6c_1);
+              var tmp$ret$12;
+              $l$block_4: {
+                // Inline function 'kotlin.collections.any' call
+                var tmp_6;
+                if (isInterface(tmp0_1, Collection())) {
+                  tmp_6 = tmp0_1.o1();
+                } else {
+                  tmp_6 = false;
+                }
+                if (tmp_6) {
+                  tmp$ret$12 = false;
+                  break $l$block_4;
+                }
+                var inductionVariable_2 = tmp0_1.j3_1;
+                var last_0 = tmp0_1.k3_1;
+                if (inductionVariable_2 <= last_0)
+                  do {
+                    var element_1 = inductionVariable_2;
+                    inductionVariable_2 = inductionVariable_2 + 1 | 0;
+                    var y = element_1;
+                    if (get_l(getCell(this, index_0, y)) || get_r(getCell(this, index_0 - 1 | 0, y))) {
+                      tmp$ret$12 = true;
+                      break $l$block_4;
+                    }
+                  }
+                   while (!(element_1 === last_0));
+                tmp$ret$12 = false;
+              }
+              tmp_5 = tmp$ret$12;
+            }
+            var tmp$ret$14 = tmp_5;
+            list_0.t2(tmp$ret$14);
+          }
+           while (inductionVariable_1 < size_0);
+        tmp_4.s6c_1 = list_0;
+        var tmp_7 = this;
+        var tmp0_2 = this.s6c_1;
+        var tmp$ret$19;
+        $l$block_5: {
+          // Inline function 'kotlin.collections.count' call
+          var tmp_8;
+          if (isInterface(tmp0_2, Collection())) {
+            tmp_8 = tmp0_2.o1();
+          } else {
+            tmp_8 = false;
+          }
+          if (tmp_8) {
+            tmp$ret$19 = 0;
+            break $l$block_5;
+          }
+          var count = 0;
+          var _iterator__ex2g4s_0 = tmp0_2.q1();
+          while (_iterator__ex2g4s_0.r1()) {
+            var element_2 = _iterator__ex2g4s_0.s1();
+            if (element_2) {
+              count = count + 1 | 0;
+              checkCountOverflow(count);
+            }
+          }
+          tmp$ret$19 = count;
+        }
+        tmp_7.t6c_1 = tmp$ret$19;
+      }
+      j6a(t, width) {
+        if (this.p6c_1)
+          return new (WidthRange())(width, width);
+        var remainingWidth = width - this.t6c_1 | 0;
+        // Inline function 'kotlin.collections.List' call
+        // Inline function 'kotlin.collections.MutableList' call
+        var size = this.q6c_1;
+        var list = ArrayList().w2(size);
+        // Inline function 'kotlin.repeat' call
+        var inductionVariable = 0;
+        if (inductionVariable < size)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var tmp$ret$0 = measureColumn(this, index, t, remainingWidth);
+            list.t2(tmp$ret$0);
+          }
+           while (inductionVariable < size);
+        var ranges = list;
+        // Inline function 'kotlin.collections.sumOf' call
+        var sum = 0;
+        var _iterator__ex2g4s = ranges.q1();
+        while (_iterator__ex2g4s.r1()) {
+          var element = _iterator__ex2g4s.s1();
+          var tmp = sum;
+          sum = tmp + element.x6a_1 | 0;
+        }
+        var tmp_0 = sum + this.t6c_1 | 0;
+        // Inline function 'kotlin.collections.sumOf' call
+        var sum_0 = 0;
+        var _iterator__ex2g4s_0 = ranges.q1();
+        while (_iterator__ex2g4s_0.r1()) {
+          var element_0 = _iterator__ex2g4s_0.s1();
+          var tmp_1 = sum_0;
+          sum_0 = tmp_1 + element_0.y6a_1 | 0;
+        }
+        var tmp$ret$8 = sum_0;
+        return new (WidthRange())(tmp_0, tmp$ret$8 + this.t6c_1 | 0);
+      }
+      k6a(t, width) {
+        return (new (TableRenderer())(this.h6c_1, this.i6c_1, this.j6c_1, this.k6c_1, this.l6c_1, this.q6c_1, calculateColumnWidths(this, t, width), this.s6c_1, this.r6c_1, this.n6c_1, t)).j6d();
+      }
+    }
+    initMetadataForClass($, 'TableImpl');
+    TableImplClass = $;
+  }
+  return TableImplClass;
+}
+var TableClass;
+function Table() {
+  if (TableClass === VOID) {
+    class $ {}
+    protoOf($).l6a = render$default;
+    initMetadataForClass($, 'Table', VOID, VOID, [Widget()]);
+    TableClass = $;
+  }
+  return TableClass;
+}
+function get_t(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.k6b()) === true;
+}
+function get_b(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.m6b()) === true;
+}
+function get_l(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.j6b()) === true;
+}
+function get_r(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.l6b()) === true;
+}
+function _get_rowCount__xlqfpy($this) {
+  return $this.v6c_1.v2();
+}
+function drawBottomBorder($this) {
+  if (!$this.d6d_1.u2(_get_rowCount__xlqfpy($this)))
+    return Unit_instance;
+  var line = $this.i6d_1.u2(get_lastIndex($this.i6d_1));
+  var inductionVariable = 0;
+  var last = $this.b6d_1.v2() - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var x = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      if ($this.c6d_1.u2(x)) {
+        var tmp61_safe_receiver = getTopLeftCorner($this, x, _get_rowCount__xlqfpy($this));
+        if (tmp61_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          line.t2(tmp61_safe_receiver);
+        }
+      }
+      drawTopBorderForCell($this, get_lastIndex($this.i6d_1), x, _get_rowCount__xlqfpy($this), $this.b6d_1.u2(x), false);
+    }
+     while (inductionVariable <= last);
+  if ($this.c6d_1.u2($this.a6d_1)) {
+    var tmp62_safe_receiver = getTopLeftCorner($this, $this.a6d_1, _get_rowCount__xlqfpy($this));
+    if (tmp62_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      line.t2(tmp62_safe_receiver);
+    }
+  }
+}
+function drawCellContent($this, tableLineY, cell, x, y) {
+  var lines = renderCell($this, cell, x, y);
+  var iterator = lines.q1();
+  var index = 0;
+  while (iterator.r1()) {
+    var i = index;
+    index = index + 1 | 0;
+    var line = iterator.s1();
+    $this.i6d_1.u2(tableLineY + i | 0).x2(line);
+  }
+}
+function drawTopBorderForCell($this, tableLineY, x, y, colWidth, borderTop) {
+  if (!$this.d6d_1.u2(y))
+    return 0;
+  if (colWidth === 0 || borderTop == null) {
+    return 1;
+  }
+  var tmp;
+  if (borderTop || (y === 0 && get_t_0($this.e6d_1)) || (y === _get_rowCount__xlqfpy($this) && get_b_0($this.e6d_1)) || get_b(cellAt($this, x, y - 1 | 0))) {
+    tmp = sectionOfRow$default($this, y).v67_1;
+  } else {
+    tmp = ' ';
+  }
+  var char = tmp;
+  $this.i6d_1.u2(tableLineY).t2(Companion_instance.p66(repeat(char, colWidth), $this.x6c_1));
+  return 1;
+}
+function drawLeftBorderForColumn($this, x) {
+  if (!$this.c6d_1.u2(x))
+    return Unit_instance;
+  var tableLineY = 0;
+  var iterator = $this.v6c_1.q1();
+  var index = 0;
+  while (iterator.r1()) {
+    var y = index;
+    index = index + 1 | 0;
+    var row = iterator.s1();
+    var rowHeight = $this.h6d_1.u2(y);
+    var tmp0_elvis_lhs = getOrNull(row, x);
+    var cell = tmp0_elvis_lhs == null ? Empty_getInstance() : tmp0_elvis_lhs;
+    if ($this.d6d_1.u2(y)) {
+      var tmp63_safe_receiver = getTopLeftCorner($this, x, y);
+      if (tmp63_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        $this.i6d_1.u2(tableLineY).t2(tmp63_safe_receiver);
+      }
+    }
+    var borderLeft = cell.j6b();
+    var topBorderHeight = $this.d6d_1.u2(y) ? 1 : 0;
+    if (!(borderLeft == null)) {
+      var tmp;
+      if (x === 0 && get_l_0($this.e6d_1) || (x === $this.a6d_1 && get_r_0($this.e6d_1)) || borderLeft || get_r(cellAt($this, x - 1 | 0, y))) {
+        tmp = Companion_instance.p66(sectionOfRow($this, y, false).w67_1, $this.x6c_1);
+      } else {
+        tmp = get_SINGLE_SPACE();
+      }
+      var border = tmp;
+      var inductionVariable = 0;
+      if (inductionVariable < rowHeight)
+        do {
+          var i = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          $this.i6d_1.u2((tableLineY + i | 0) + topBorderHeight | 0).t2(border);
+        }
+         while (inductionVariable < rowHeight);
+    }
+    tableLineY = tableLineY + (rowHeight + topBorderHeight | 0) | 0;
+  }
+}
+function renderCell($this, cell, x, y) {
+  var tmp;
+  if (cell instanceof SpanRef()) {
+    tmp = emptyList();
+  } else {
+    if (cell instanceof Empty()) {
+      var space = listOf(Companion_instance.e66($this.b6d_1.u2(x)));
+      // Inline function 'kotlin.collections.List' call
+      // Inline function 'kotlin.collections.MutableList' call
+      var size = $this.h6d_1.u2(y);
+      var list = ArrayList().w2(size);
+      // Inline function 'kotlin.repeat' call
+      var inductionVariable = 0;
+      if (inductionVariable < size)
+        do {
+          var index = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          list.t2(space);
+        }
+         while (inductionVariable < size);
+      tmp = list;
+    } else {
+      if (cell instanceof Content()) {
+        // Inline function 'kotlin.collections.sumOf' call
+        var sum = 0;
+        var progression = until(x, x + cell.u6b_1 | 0);
+        var inductionVariable_0 = progression.j3_1;
+        var last = progression.k3_1;
+        if (inductionVariable_0 <= last)
+          do {
+            var element = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            var tmp_0 = sum;
+            var it = element;
+            sum = tmp_0 + $this.b6d_1.u2(it) | 0;
+          }
+           while (!(element === last));
+        var tmp_1 = sum;
+        var tmp0 = until(x + 1 | 0, x + cell.u6b_1 | 0);
+        var tmp$ret$7;
+        $l$block: {
+          // Inline function 'kotlin.collections.count' call
+          var tmp_2;
+          if (isInterface(tmp0, Collection())) {
+            tmp_2 = tmp0.o1();
+          } else {
+            tmp_2 = false;
+          }
+          if (tmp_2) {
+            tmp$ret$7 = 0;
+            break $l$block;
+          }
+          var count = 0;
+          var inductionVariable_1 = tmp0.j3_1;
+          var last_0 = tmp0.k3_1;
+          if (inductionVariable_1 <= last_0)
+            do {
+              var element_0 = inductionVariable_1;
+              inductionVariable_1 = inductionVariable_1 + 1 | 0;
+              var it_0 = element_0;
+              if ($this.c6d_1.u2(it_0 + 1 | 0)) {
+                count = count + 1 | 0;
+                checkCountOverflow(count);
+              }
+            }
+             while (!(element_0 === last_0));
+          tmp$ret$7 = count;
+        }
+        var cellWidth = coerceAtLeast(tmp_1 + tmp$ret$7 | 0, 0);
+        // Inline function 'kotlin.collections.sumOf' call
+        var sum_0 = 0;
+        var progression_0 = until(y, y + cell.t6b_1 | 0);
+        var inductionVariable_2 = progression_0.j3_1;
+        var last_1 = progression_0.k3_1;
+        if (inductionVariable_2 <= last_1)
+          do {
+            var element_1 = inductionVariable_2;
+            inductionVariable_2 = inductionVariable_2 + 1 | 0;
+            var tmp_3 = sum_0;
+            var it_1 = element_1;
+            sum_0 = tmp_3 + $this.h6d_1.u2(it_1) | 0;
+          }
+           while (!(element_1 === last_1));
+        var tmp_4 = sum_0;
+        var tmp0_0 = until(y + 1 | 0, y + cell.t6b_1 | 0);
+        var tmp$ret$11;
+        $l$block_0: {
+          // Inline function 'kotlin.collections.count' call
+          var tmp_5;
+          if (isInterface(tmp0_0, Collection())) {
+            tmp_5 = tmp0_0.o1();
+          } else {
+            tmp_5 = false;
+          }
+          if (tmp_5) {
+            tmp$ret$11 = 0;
+            break $l$block_0;
+          }
+          var count_0 = 0;
+          var inductionVariable_3 = tmp0_0.j3_1;
+          var last_2 = tmp0_0.k3_1;
+          if (inductionVariable_3 <= last_2)
+            do {
+              var element_2 = inductionVariable_3;
+              inductionVariable_3 = inductionVariable_3 + 1 | 0;
+              var it_2 = element_2;
+              if ($this.d6d_1.u2(it_2 + 1 | 0)) {
+                count_0 = count_0 + 1 | 0;
+                checkCountOverflow(count_0);
+              }
+            }
+             while (!(element_2 === last_2));
+          tmp$ret$11 = count_0;
+        }
+        var cellHeight = tmp_4 + tmp$ret$11 | 0;
+        tmp = setSize(cell.s6b_1.k6a($this.f6d_1, cellWidth).l68(cell.z6b_1), cellWidth, cellHeight, cell.b6c_1, cell.a6c_1).w65_1;
+      } else {
+        noWhenBranchMatchedException();
+      }
+    }
+  }
+  return tmp;
+}
+function cellAt($this, x, y) {
+  var tmp65_safe_receiver = getOrNull($this.v6c_1, y);
+  return tmp65_safe_receiver == null ? null : getOrNull(tmp65_safe_receiver, x);
+}
+function getTopLeftCorner($this, x, y) {
+  var tl = cellAt($this, x - 1 | 0, y - 1 | 0);
+  var tr = cellAt($this, x, y - 1 | 0);
+  var bl = cellAt($this, x - 1 | 0, y);
+  var br = cellAt($this, x, y);
+  var tmp;
+  var tmp_0;
+  var tmp_1;
+  var tmp_2;
+  var tmp_3;
+  var tmp_4;
+  var tmp_5;
+  var tmp_6;
+  if (!(tl == null) || !(tr == null) || !(bl == null) || !(br == null)) {
+    tmp_6 = (tl == null ? null : tl.l6b()) == null;
+  } else {
+    tmp_6 = false;
+  }
+  if (tmp_6) {
+    tmp_5 = (tr == null ? null : tr.j6b()) == null;
+  } else {
+    tmp_5 = false;
+  }
+  if (tmp_5) {
+    tmp_4 = (tr == null ? null : tr.m6b()) == null;
+  } else {
+    tmp_4 = false;
+  }
+  if (tmp_4) {
+    tmp_3 = (br == null ? null : br.k6b()) == null;
+  } else {
+    tmp_3 = false;
+  }
+  if (tmp_3) {
+    tmp_2 = (bl == null ? null : bl.l6b()) == null;
+  } else {
+    tmp_2 = false;
+  }
+  if (tmp_2) {
+    tmp_1 = (br == null ? null : br.j6b()) == null;
+  } else {
+    tmp_1 = false;
+  }
+  if (tmp_1) {
+    tmp_0 = (tl == null ? null : tl.m6b()) == null;
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = (bl == null ? null : bl.k6b()) == null;
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    return null;
+  }
+  return sectionOfRow$default($this, y).j68(get_r(tl) || get_l(tr) || (y > 0 && (x === 0 && get_l_0($this.e6d_1) || (x === $this.a6d_1 && get_r_0($this.e6d_1)))), get_b(tr) || get_t(br) || (x < $this.a6d_1 && (y === 0 && get_t_0($this.e6d_1) || (y === _get_rowCount__xlqfpy($this) && get_b_0($this.e6d_1)))), get_r(bl) || get_l(br) || (y < _get_rowCount__xlqfpy($this) && (x === 0 && get_l_0($this.e6d_1) || (x === $this.a6d_1 && get_r_0($this.e6d_1)))), get_b(tl) || get_t(bl) || (x > 0 && (y === 0 && get_t_0($this.e6d_1) || (y === _get_rowCount__xlqfpy($this) && get_b_0($this.e6d_1)))), $this.x6c_1);
+}
+function sectionOfRow($this, y, allowBottom) {
+  return y < $this.y6c_1 ? $this.w6c_1.d68_1 : allowBottom && $this.y6c_1 > 0 && y === $this.y6c_1 ? $this.w6c_1.e68_1 : allowBottom && $this.z6c_1 > 0 && y === (_get_rowCount__xlqfpy($this) - $this.z6c_1 | 0) ? $this.w6c_1.g68_1 : $this.z6c_1 === 0 || y < (_get_rowCount__xlqfpy($this) - $this.z6c_1 | 0) ? $this.w6c_1.f68_1 : $this.w6c_1.h68_1;
+}
+function sectionOfRow$default($this, y, allowBottom, $super) {
+  allowBottom = allowBottom === VOID ? true : allowBottom;
+  return sectionOfRow($this, y, allowBottom);
+}
+var TableRendererClass;
+function TableRenderer() {
+  if (TableRendererClass === VOID) {
+    class $ {
+      constructor(rows, borderType, borderStyle, headerRowCount, footerRowCount, columnCount, columnWidths, columnBorders, rowBorders, tableBorders, t) {
+        this.v6c_1 = rows;
+        this.w6c_1 = borderType;
+        this.x6c_1 = borderStyle;
+        this.y6c_1 = headerRowCount;
+        this.z6c_1 = footerRowCount;
+        this.a6d_1 = columnCount;
+        this.b6d_1 = columnWidths;
+        this.c6d_1 = columnBorders;
+        this.d6d_1 = rowBorders;
+        this.e6d_1 = tableBorders;
+        this.f6d_1 = t;
+        var tmp = this;
+        // Inline function 'kotlin.collections.map' call
+        var this_0 = this.v6c_1;
+        // 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();
+          // Inline function 'kotlin.collections.mapIndexed' call
+          // Inline function 'kotlin.collections.mapIndexedTo' call
+          var destination_0 = ArrayList().w2(collectionSizeOrDefault(item, 10));
+          var index = 0;
+          var _iterator__ex2g4s_0 = item.q1();
+          while (_iterator__ex2g4s_0.r1()) {
+            var item_0 = _iterator__ex2g4s_0.s1();
+            var _unary__edvuaz = index;
+            index = _unary__edvuaz + 1 | 0;
+            var x = checkIndexOverflow(_unary__edvuaz);
+            var tmp_0;
+            if (item_0 instanceof Content()) {
+              // Inline function 'kotlin.collections.sumOf' call
+              var sum_0 = 0;
+              var progression = until(x, x + item_0.u6b_1 | 0);
+              var inductionVariable = progression.j3_1;
+              var last = progression.k3_1;
+              if (inductionVariable <= last)
+                do {
+                  var element = inductionVariable;
+                  inductionVariable = inductionVariable + 1 | 0;
+                  var tmp_1 = sum_0;
+                  var it = element;
+                  sum_0 = tmp_1 + this.b6d_1.u2(it) | 0;
+                }
+                 while (!(element === last));
+              var w = sum_0;
+              tmp_0 = w === 0 ? get_EMPTY_LINES() : item_0.s6b_1.k6a(this.f6d_1, w).l68(item_0.z6b_1);
+            } else {
+              tmp_0 = get_EMPTY_LINES();
+            }
+            var tmp$ret$2 = tmp_0;
+            destination_0.t2(tmp$ret$2);
+          }
+          destination.t2(destination_0);
+        }
+        tmp.g6d_1 = destination;
+        var tmp_2 = this;
+        // Inline function 'kotlin.collections.mapIndexed' call
+        var this_1 = this.g6d_1;
+        // Inline function 'kotlin.collections.mapIndexedTo' call
+        var destination_1 = ArrayList().w2(collectionSizeOrDefault(this_1, 10));
+        var index_0 = 0;
+        var _iterator__ex2g4s_1 = this_1.q1();
+        while (_iterator__ex2g4s_1.r1()) {
+          var item_1 = _iterator__ex2g4s_1.s1();
+          var _unary__edvuaz_0 = index_0;
+          index_0 = _unary__edvuaz_0 + 1 | 0;
+          var y = checkIndexOverflow(_unary__edvuaz_0);
+          var tmp0 = withIndex(item_1);
+          var tmp$ret$8;
+          $l$block: {
+            // Inline function 'kotlin.collections.maxOfOrNull' call
+            var iterator = tmp0.q1();
+            if (!iterator.r1()) {
+              tmp$ret$8 = null;
+              break $l$block;
+            }
+            var destruct = iterator.s1();
+            var x_0 = destruct.vl();
+            var it_0 = destruct.wl();
+            var tmp_3 = it_0.k68();
+            var tmp59_safe_receiver = cellAt(this, x_0, y);
+            var tmp0_elvis_lhs = tmp59_safe_receiver == null ? null : tmp59_safe_receiver.i6b();
+            var maxValue = tmp_3 / (tmp0_elvis_lhs == null ? 1 : tmp0_elvis_lhs) | 0;
+            while (iterator.r1()) {
+              var destruct_0 = iterator.s1();
+              var x_1 = destruct_0.vl();
+              var it_1 = destruct_0.wl();
+              var tmp_4 = it_1.k68();
+              var tmp59_safe_receiver_0 = cellAt(this, x_1, y);
+              var tmp0_elvis_lhs_0 = tmp59_safe_receiver_0 == null ? null : tmp59_safe_receiver_0.i6b();
+              var v = tmp_4 / (tmp0_elvis_lhs_0 == null ? 1 : tmp0_elvis_lhs_0) | 0;
+              if (compareTo(maxValue, v) < 0) {
+                maxValue = v;
+              }
+            }
+            tmp$ret$8 = maxValue;
+          }
+          var tmp60_safe_receiver = tmp$ret$8;
+          var tmp0_elvis_lhs_1 = tmp60_safe_receiver == null ? null : coerceAtLeast(tmp60_safe_receiver, 1);
+          var tmp$ret$11 = tmp0_elvis_lhs_1 == null ? 1 : tmp0_elvis_lhs_1;
+          destination_1.t2(tmp$ret$11);
+        }
+        tmp_2.h6d_1 = destination_1;
+        var tmp_5 = this;
+        var tmp_6 = sum(this.h6d_1);
+        var tmp0_0 = this.d6d_1;
+        var tmp$ret$14;
+        $l$block_0: {
+          // Inline function 'kotlin.collections.count' call
+          var tmp_7;
+          if (isInterface(tmp0_0, Collection())) {
+            tmp_7 = tmp0_0.o1();
+          } else {
+            tmp_7 = false;
+          }
+          if (tmp_7) {
+            tmp$ret$14 = 0;
+            break $l$block_0;
+          }
+          var count = 0;
+          var _iterator__ex2g4s_2 = tmp0_0.q1();
+          while (_iterator__ex2g4s_2.r1()) {
+            var element_0 = _iterator__ex2g4s_2.s1();
+            if (element_0) {
+              count = count + 1 | 0;
+              checkCountOverflow(count);
+            }
+          }
+          tmp$ret$14 = count;
+        }
+        // Inline function 'kotlin.collections.MutableList' call
+        var size = tmp_6 + tmp$ret$14 | 0;
+        var list = ArrayList().w2(size);
+        // Inline function 'kotlin.repeat' call
+        var inductionVariable_0 = 0;
+        if (inductionVariable_0 < size)
+          do {
+            var index_1 = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            // Inline function 'kotlin.collections.mutableListOf' call
+            var tmp$ret$17 = ArrayList().n2();
+            list.t2(tmp$ret$17);
+          }
+           while (inductionVariable_0 < size);
+        tmp_5.i6d_1 = list;
+      }
+      j6d() {
+        var inductionVariable = 0;
+        var last = this.b6d_1.v2() - 1 | 0;
+        if (inductionVariable <= last)
+          do {
+            var x = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            drawLeftBorderForColumn(this, x);
+            var colWidth = this.b6d_1.u2(x);
+            var tableLineY = 0;
+            var iterator = this.v6c_1.q1();
+            var index = 0;
+            while (iterator.r1()) {
+              var y = index;
+              index = index + 1 | 0;
+              var row = iterator.s1();
+              var rowHeight = this.h6d_1.u2(y);
+              var tmp0_elvis_lhs = getOrNull(row, x);
+              var cell = tmp0_elvis_lhs == null ? Empty_getInstance() : tmp0_elvis_lhs;
+              tableLineY = tableLineY + drawTopBorderForCell(this, tableLineY, x, y, colWidth, cell.k6b()) | 0;
+              drawCellContent(this, tableLineY, cell, x, y);
+              tableLineY = tableLineY + rowHeight | 0;
+            }
+          }
+           while (inductionVariable <= last);
+        drawLeftBorderForColumn(this, this.a6d_1);
+        drawBottomBorder(this);
+        // Inline function 'kotlin.collections.map' call
+        var this_0 = this.i6d_1;
+        // 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 = Line().q66(item);
+          destination.t2(tmp$ret$0);
+        }
+        return new (Lines())(destination);
+      }
+    }
+    initMetadataForClass($, 'TableRenderer');
+    TableRendererClass = $;
+  }
+  return TableRendererClass;
+}
+function get_t_0(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.f6b_1) === true;
+}
+function get_b_0(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.h6b_1) === true;
+}
+function get_l_0(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.e6b_1) === true;
+}
+function get_r_0(_this__u8e3s4) {
+  return (_this__u8e3s4 == null ? null : _this__u8e3s4.g6b_1) === true;
+}
+//region block: exports
+export {
+  Content as Contents7lf7mns75yn,
+  SpanRef as SpanRefttmqw37fbm3u,
+  TableImpl as TableImplefaqr1hpwzuo,
+  Empty_getInstance as Empty_getInstance2p29xo38tq83t,
+};
+//endregion
+
+//# sourceMappingURL=Table.mjs.map