From 4a0ac9306481ac621f169c520f30cc1caca3567b Mon Sep 17 00:00:00 2001
From: rnentjes <info@nentjes.com>
Date: Mon, 11 Sep 2017 18:51:35 +0200
Subject: [PATCH] Testing dom diffing

---
 komp-todo.iml                                 | 1 +
 src/main/kotlin/nl/astraeus/komp/todo/Todo.kt | 7 +++++++
 web/js/kotlin/komp-todo.js                    | 7 ++++++-
 web/js/kotlin/komp-todo.js.map                | 2 +-
 web/js/kotlin/komp-todo.meta.js               | 2 +-
 5 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/komp-todo.iml b/komp-todo.iml
index d59e58e..4c95ce1 100644
--- a/komp-todo.iml
+++ b/komp-todo.iml
@@ -22,6 +22,7 @@
           <option name="pluginClasspaths">
             <array />
           </option>
+          <option name="verbose" value="true" />
           <option name="suppressWarnings" value="true" />
         </compilerArguments>
       </configuration>
diff --git a/src/main/kotlin/nl/astraeus/komp/todo/Todo.kt b/src/main/kotlin/nl/astraeus/komp/todo/Todo.kt
index c61509e..0c2aa1a 100644
--- a/src/main/kotlin/nl/astraeus/komp/todo/Todo.kt
+++ b/src/main/kotlin/nl/astraeus/komp/todo/Todo.kt
@@ -121,6 +121,13 @@ class TodoApp: Komponent() {
                 onKeyPressFunction = { e ->
                     if (e is KeyboardEvent && e.keyCode == 13) {
                         addTodo(e)
+
+                        val target = e.target
+
+                        if (target is HTMLInputElement) {
+                            target.value = ""
+                            target.defaultValue = ""
+                        }
                     }
                 }
             }
diff --git a/web/js/kotlin/komp-todo.js b/web/js/kotlin/komp-todo.js
index 6c78492..4802cda 100644
--- a/web/js/kotlin/komp-todo.js
+++ b/web/js/kotlin/komp-todo.js
@@ -184,6 +184,11 @@ this['komp-todo'] = function (_, Kotlin, $module$komp, $module$kotlinx_html_js)
     return function (e) {
       if (Kotlin.isType(e, KeyboardEvent) && e.keyCode === 13) {
         this$TodoApp.addTodo_9ojx7i$(e);
+        var target = e.target;
+        if (Kotlin.isType(target, HTMLInputElement)) {
+          target.value = '';
+          target.defaultValue = '';
+        }
       }
     };
   }
@@ -405,7 +410,7 @@ this['komp-todo'] = function (_, Kotlin, $module$komp, $module$kotlinx_html_js)
     var el2 = div_0(get_create(document), void 0, main$lambda_0);
     console.log('OLD', el1);
     console.log('NEW', el2);
-    komp.DomDiffer.replaceDiff_aifv3w$(el2, el1);
+    komp.DomDiffer.replaceDiff_26ucz2$(el2, el1);
     console.log('OLD', el1);
     console.log('NEW', el2);
   }
diff --git a/web/js/kotlin/komp-todo.js.map b/web/js/kotlin/komp-todo.js.map
index 0b46f8b..ebdd6d5 100644
--- a/web/js/kotlin/komp-todo.js.map
+++ b/web/js/kotlin/komp-todo.js.map
@@ -1 +1 @@
-{"version":3,"file":"komp-todo.js","sources":["nl/astraeus/komp/todo/Todo.kt","collections/Maps.kt"],"sourcesContent":["package nl.astraeus.komp.todo\n\nimport kotlinx.html.*\nimport kotlinx.html.dom.create\nimport kotlinx.html.js.*\nimport nl.astraeus.komp.Komponent\nimport nl.astraeus.komp.DomDiffer\nimport org.w3c.dom.HTMLElement\nimport org.w3c.dom.HTMLInputElement\nimport org.w3c.dom.events.Event\nimport org.w3c.dom.events.KeyboardEvent\nimport kotlin.browser.document\nimport kotlin.js.Date\n\n/**\n * https://github.com/tastejs/todomvc/\n */\n\nclass Todo(\n  val dataId: String,\n  var title: String,\n  var completed: Boolean = false,\n  var editing: Boolean = false\n)\n\nenum class Selection(val title: String) {\n    ALL(\"All\"),\n    ACTIVE(\"Active\"),\n    COMPLETED(\"Completed\")\n}\n\nclass TodoApp: Komponent() {\n    val todoList: MutableList<Todo> = ArrayList()\n    var selected: Selection = Selection.ALL\n\n    fun addTodo(e: Event) {\n        val target = e.target\n\n        if (target is HTMLInputElement) {\n            todoList.add(Todo(\"${Date().getTime()}\", target.value))\n\n            refresh()\n        }\n    }\n\n    fun editTodo(e: Event, todo: Todo) {\n        val target = e.target\n\n        if (target is HTMLInputElement) {\n            todo.title = target.value\n            todo.editing = false\n\n            refresh()\n        }\n\n    }\n\n    fun destroyTodo(todo: Todo) {\n        todoList.remove(todo)\n\n        refresh()\n    }\n\n    fun selectSelection(selection: Selection) {\n        selected = selection\n\n        refresh()\n    }\n\n    fun clearCompleted() {\n        for (todo in ArrayList(todoList)) {\n            if (todo.completed) {\n                todoList.remove(todo)\n            }\n        }\n\n        refresh()\n    }\n\n    fun todoClicked(todo: Todo) {\n        todo.completed = !todo.completed\n\n        refresh()\n    }\n\n    fun getItemsLeft(): Int {\n        var result = 0\n        for (todo in todoList) {\n            if (!todo.completed) {\n                result++\n            }\n        }\n        return result\n    }\n\n    fun setEditing(editTodo: Todo) {\n        for (todo in todoList) {\n            todo.editing = todo == editTodo\n        }\n\n        refresh()\n    }\n\n    override fun refresh() {\n        super.refresh()\n\n        val inputBox = document.getElementById(\"todo_input\")\n\n        if (inputBox is HTMLInputElement) {\n            inputBox.focus()\n        }\n    }\n\n    override fun render(consumer: TagConsumer<HTMLElement>) = consumer.section(classes = \"todoapp\") {\n        header(classes = \"header\") {\n            h1 { + \"todos\" }\n            input(classes = \"new-todo\") {\n                id = \"todo_input\"\n                placeholder = \"What needs to be done?\"\n                autoFocus = true\n                onKeyPressFunction = { e ->\n                    if (e is KeyboardEvent && e.keyCode == 13) {\n                        addTodo(e)\n                    }\n                }\n            }\n        }\n\n        section(classes = \"main\") {\n            input(classes = \"toggle-all\") {\n                type = InputType.checkBox\n            }\n            label {\n                for_ = \"toggle-all\"\n                + \"Mark all as complete\"\n            }\n            ul(classes = \"todo-list\") {\n                for (todo in todoList) {\n                    if (selected == Selection.ALL ||\n                        (todo.completed && selected == Selection.COMPLETED) ||\n                        (!todo.completed && selected == Selection.ACTIVE)) {\n                        li {\n                            if (todo.editing) {\n                                classes += \"editing\"\n                                input(classes = \"edit\") {\n                                    value = todo.title\n                                    onKeyPressFunction = { e ->\n                                        if (e is KeyboardEvent && e.keyCode == 13) {\n                                            editTodo(e, todo)\n                                        }\n                                    }\n                                }\n                            } else {\n                                if (todo.completed) {\n                                    classes += \"completed\"\n                                }\n                                attributes[\"data-id\"] = todo.dataId\n                                div(classes = \"view\") {\n                                    input(classes = \"toggle\") {\n                                        type = InputType.checkBox\n                                        checked = todo.completed\n                                        onClickFunction = {\n                                            todoClicked(todo)\n                                        }\n                                    }\n                                    label(classes = \"todo-content\") {\n                                        +todo.title\n\n                                        onDoubleClickFunction = {\n                                            setEditing(todo)\n                                        }\n                                    }\n                                    button(classes = \"destroy\") {\n                                        onClickFunction = {\n                                            destroyTodo(todo)\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        footer(classes = \"footer\") {\n            span(classes = \"todo-count\") {\n                strong { + \"${getItemsLeft()}\" }\n                + \" item left\"\n            }\n            ul(classes = \"filters\") {\n                for (selection in Selection.values())\n                li {\n                    a {\n                        if (selection == selected) { classes += \"selected\" }\n                        href = \"#\"\n                        + selection.title\n                        onClickFunction = {\n                            selectSelection(selection)\n                        }\n                    }\n                }\n            }\n            button(classes = \"clear-completed\") {\n                + \"Clear completed\"\n                onClickFunction = {\n                    clearCompleted()\n                }\n            }\n        }\n    }\n\n}\n\nfun main(args: Array<String>) {\n    Komponent.create(document.body!!, TodoApp(), true)\n\n    val el1 = document.create.div {\n        div {\n            div {\n                id = \"id1\"\n                span {\n                    +\"Test\"\n                }\n            }\n        }\n    }\n\n    val el2 = document.create.div {\n        div {\n            id = \"id1\"\n            span {\n                +\"Test\"\n            }\n            input {\n                name = \"bla\"\n            }\n        }\n    }\n\n    // println(\"equals ${DomDiffer.match(el1, el2)}\")\n\n    console.log(\"OLD\", el1)\n    console.log(\"NEW\", el2)\n\n    DomDiffer.replaceDiff(el2, el1)\n\n    console.log(\"OLD\", el1)\n    console.log(\"NEW\", el2)\n}\n\n","@file:kotlin.jvm.JvmMultifileClass\n@file:kotlin.jvm.JvmName(\"MapsKt\")\n\npackage kotlin.collections\n\nprivate object EmptyMap : Map<Any?, Nothing>, Serializable {\n    private const val serialVersionUID: Long = 8246714829545688274\n\n    override fun equals(other: Any?): Boolean = other is Map<*,*> && other.isEmpty()\n    override fun hashCode(): Int = 0\n    override fun toString(): String = \"{}\"\n\n    override val size: Int get() = 0\n    override fun isEmpty(): Boolean = true\n\n    override fun containsKey(key: Any?): Boolean = false\n    override fun containsValue(value: Nothing): Boolean = false\n    override fun get(key: Any?): Nothing? = null\n    override val entries: Set<Map.Entry<Any?, Nothing>> get() = EmptySet\n    override val keys: Set<Any?> get() = EmptySet\n    override val values: Collection<Nothing> get() = EmptyList\n\n    private fun readResolve(): Any = EmptyMap\n}\n\n/**\n * Returns an empty read-only map of specified type.\n *\n * The returned map is serializable (JVM).\n * @sample samples.collections.Maps.Instantiation.emptyReadOnlyMap\n */\npublic fun <K, V> emptyMap(): Map<K, V> = @Suppress(\"UNCHECKED_CAST\") (EmptyMap as Map<K, V>)\n\n/**\n * Returns a new read-only map with the specified contents, given as a list of pairs\n * where the first value is the key and the second is the value.\n *\n * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.\n *\n * Entries of the map are iterated in the order they were specified.\n *\n * The returned map is serializable (JVM).\n *\n * @sample samples.collections.Maps.Instantiation.mapFromPairs\n */\npublic fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V> = if (pairs.size > 0) pairs.toMap(LinkedHashMap(mapCapacity(pairs.size))) else emptyMap()\n\n/**\n * Returns an empty read-only map.\n *\n * The returned map is serializable (JVM).\n * @sample samples.collections.Maps.Instantiation.emptyReadOnlyMap\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> mapOf(): Map<K, V> = emptyMap()\n\n/* Not available on platform: JS */\n\n\n\n\n\n\n\n\n\n\n/**\n * Returns an empty new [MutableMap].\n *\n * The returned map preserves the entry iteration order.\n * @sample samples.collections.Maps.Instantiation.emptyMutableMap\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> mutableMapOf(): MutableMap<K, V> = LinkedHashMap()\n\n/**\n * Returns a new [MutableMap] with the specified contents, given as a list of pairs\n * where the first component is the key and the second is the value.\n *\n * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.\n *\n * Entries of the map are iterated in the order they were specified.\n *\n * @sample samples.collections.Maps.Instantiation.mutableMapFromPairs\n * @sample samples.collections.Maps.Instantiation.emptyMutableMap\n */\npublic fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>\n        = LinkedHashMap<K, V>(mapCapacity(pairs.size)).apply { putAll(pairs) }\n\n/**\n * Returns an empty new [HashMap].\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> hashMapOf(): HashMap<K, V> = HashMap<K, V>()\n\n/**\n * Returns a new [HashMap] with the specified contents, given as a list of pairs\n * where the first component is the key and the second is the value.\n *\n * @sample samples.collections.Maps.Instantiation.hashMapFromPairs\n */\npublic fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>\n        = HashMap<K, V>(mapCapacity(pairs.size)).apply { putAll(pairs) }\n\n/**\n * Returns an empty new [LinkedHashMap].\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> linkedMapOf(): LinkedHashMap<K, V> = LinkedHashMap<K, V>()\n\n/**\n * Returns a new [LinkedHashMap] with the specified contents, given as a list of pairs\n * where the first component is the key and the second is the value.\n *\n * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.\n *\n * Entries of the map are iterated in the order they were specified.\n *\n * @sample samples.collections.Maps.Instantiation.linkedMapFromPairs\n */\npublic fun <K, V> linkedMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>\n        = pairs.toMap(LinkedHashMap(mapCapacity(pairs.size)))\n\n/**\n * Calculate the initial capacity of a map, based on Guava's com.google.common.collect.Maps approach. This is equivalent\n * to the Collection constructor for HashSet, (c.size()/.75f) + 1, but provides further optimisations for very small or\n * very large sizes, allows support non-collection classes, and provides consistency for all map based class construction.\n */\n@PublishedApi\ninternal fun mapCapacity(expectedSize: Int): Int {\n    if (expectedSize < 3) {\n        return expectedSize + 1\n    }\n    if (expectedSize < INT_MAX_POWER_OF_TWO) {\n        return expectedSize + expectedSize / 3\n    }\n    return Int.MAX_VALUE // any large value\n}\n\nprivate const val INT_MAX_POWER_OF_TWO: Int = Int.MAX_VALUE / 2 + 1\n\n/** Returns `true` if this map is not empty. */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean = !isEmpty()\n\n/**\n * Returns the [Map] if its not `null`, or the empty [Map] otherwise.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map<K, V>?.orEmpty() : Map<K, V> = this ?: emptyMap()\n\n/**\n * Checks if the map contains the given key.\n *\n * This method allows to use the `x in map` syntax for checking whether an object is contained in the map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.contains(key: K) : Boolean = containsKey(key)\n\n/**\n * Returns the value corresponding to the given [key], or `null` if such a key is not present in the map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get(key: K): V?\n        = @Suppress(\"UNCHECKED_CAST\") (this as Map<K, V>).get(key)\n\n/**\n * Allows to use the index operator for storing values in a mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V): Unit {\n    put(key, value)\n}\n\n/**\n * Returns `true` if the map contains the specified [key].\n *\n * Allows to overcome type-safety restriction of `containsKey` that requires to pass a key of type `K`.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <@kotlin.internal.OnlyInputTypes K> Map<out K, *>.containsKey(key: K): Boolean\n        = @Suppress(\"UNCHECKED_CAST\") (this as Map<K, *>).containsKey(key)\n\n/**\n * Returns `true` if the map maps one or more keys to the specified [value].\n *\n * Allows to overcome type-safety restriction of `containsValue` that requires to pass a value of type `V`.\n */\n@Suppress(\"EXTENSION_SHADOWED_BY_MEMBER\") // false warning, extension takes precedence in some cases\n@kotlin.internal.InlineOnly\npublic inline fun <K, @kotlin.internal.OnlyInputTypes V> Map<K, V>.containsValue(value: V): Boolean = this.containsValue(value)\n\n\n/**\n * Removes the specified key and its corresponding value from this map.\n *\n * @return the previous value associated with the key, or `null` if the key was not present in the map.\n\n * Allows to overcome type-safety restriction of `remove` that requires to pass a key of type `K`.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <@kotlin.internal.OnlyInputTypes K, V> MutableMap<out K, V>.remove(key: K): V?\n        = @Suppress(\"UNCHECKED_CAST\") (this as MutableMap<K, V>).remove(key)\n\n/**\n * Returns the key component of the map entry.\n *\n * This method allows to use destructuring declarations when working with maps, for example:\n * ```\n * for ((key, value) in map) {\n *     // do something with the key and the value\n * }\n * ```\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> Map.Entry<K, V>.component1(): K = key\n\n/**\n * Returns the value component of the map entry.\n *\n * This method allows to use destructuring declarations when working with maps, for example:\n * ```\n * for ((key, value) in map) {\n *     // do something with the key and the value\n * }\n * ```\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> Map.Entry<K, V>.component2(): V = value\n\n/**\n * Converts entry to [Pair] with key being first component and value being second.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map.Entry<K, V>.toPair(): Pair<K, V> = Pair(key, value)\n\n/**\n * Returns the value for the given key, or the result of the [defaultValue] function if there was no entry for the given key.\n *\n * @sample samples.collections.Maps.Usage.getOrElse\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V = get(key) ?: defaultValue()\n\n\ninternal inline fun <K, V> Map<K, V>.getOrElseNullable(key: K, defaultValue: () -> V): V {\n    val value = get(key)\n    if (value == null && !containsKey(key)) {\n        return defaultValue()\n    } else {\n        @Suppress(\"UNCHECKED_CAST\")\n        return value as V\n    }\n}\n\n/**\n * Returns the value for the given [key] or throws an exception if there is no such key in the map.\n *\n * If the map was created by [withDefault], resorts to its `defaultValue` provider function\n * instead of throwing an exception.\n *\n * @throws NoSuchElementException when the map doesn't contain a value for the specified key and\n * no implicit default value was provided for that map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V> Map<K, V>.getValue(key: K): V = getOrImplicitDefault(key)\n\n/**\n * Returns the value for the given key. If the key is not found in the map, calls the [defaultValue] function,\n * puts its result into the map under the given key and returns it.\n *\n * @sample samples.collections.Maps.Usage.getOrPut\n */\npublic inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V {\n    val value = get(key)\n    return if (value == null) {\n        val answer = defaultValue()\n        put(key, answer)\n        answer\n    } else {\n        value\n    }\n}\n\n/**\n * Returns an [Iterator] over the entries in the [Map].\n *\n * @sample samples.collections.Maps.Usage.forOverEntries\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>> = entries.iterator()\n\n/* Not available on platform: JS */\n\n\n\n\n\n\n\n\n/**\n * Populates the given [destination] map with entries having the keys of this map and the values obtained\n * by applying the [transform] function to each entry in this [Map].\n */\npublic inline fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M {\n    return entries.associateByTo(destination, { it.key }, transform)\n}\n\n/**\n * Populates the given [destination] map with entries having the keys obtained\n * by applying the [transform] function to each entry in this [Map] and the values of this map.\n *\n * In case if any two entries are mapped to the equal keys, the value of the latter one will overwrite\n * the value associated with the former one.\n */\npublic inline fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M {\n    return entries.associateByTo(destination, transform, { it.value })\n}\n\n/**\n * Puts all the given [pairs] into this [MutableMap] with the first component in the pair being the key and the second the value.\n */\npublic fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>): Unit {\n    for ((key, value) in pairs) {\n        put(key, value)\n    }\n}\n\n/**\n * Puts all the elements of the given collection into this [MutableMap] with the first component in the pair being the key and the second the value.\n */\npublic fun <K, V> MutableMap<in K, in V>.putAll(pairs: Iterable<Pair<K,V>>): Unit {\n    for ((key, value) in pairs) {\n        put(key, value)\n    }\n}\n\n/**\n * Puts all the elements of the given sequence into this [MutableMap] with the first component in the pair being the key and the second the value.\n */\npublic fun <K, V> MutableMap<in K, in V>.putAll(pairs: Sequence<Pair<K,V>>): Unit {\n    for ((key, value) in pairs) {\n        put(key, value)\n    }\n}\n\n/**\n * Returns a new map with entries having the keys of this map and the values obtained by applying the [transform]\n * function to each entry in this [Map].\n *\n * The returned map preserves the entry iteration order of the original map.\n *\n * @sample samples.collections.Maps.Transforms.mapValues\n */\npublic inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R> {\n    return mapValuesTo(LinkedHashMap<K, R>(mapCapacity(size)), transform) // .optimizeReadOnlyMap()\n}\n\n/**\n * Returns a new Map with entries having the keys obtained by applying the [transform] function to each entry in this\n * [Map] and the values of this map.\n *\n * In case if any two entries are mapped to the equal keys, the value of the latter one will overwrite\n * the value associated with the former one.\n *\n * The returned map preserves the entry iteration order of the original map.\n *\n * @sample samples.collections.Maps.Transforms.mapKeys\n */\npublic inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V> {\n    return mapKeysTo(LinkedHashMap<R, V>(mapCapacity(size)), transform) // .optimizeReadOnlyMap()\n}\n\n/**\n * Returns a map containing all key-value pairs with keys matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V> {\n    val result = LinkedHashMap<K, V>()\n    for (entry in this) {\n        if (predicate(entry.key)) {\n            result.put(entry.key, entry.value)\n        }\n    }\n    return result\n}\n\n/**\n * Returns a map containing all key-value pairs with values matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V> {\n    val result = LinkedHashMap<K, V>()\n    for (entry in this) {\n        if (predicate(entry.value)) {\n            result.put(entry.key, entry.value)\n        }\n    }\n    return result\n}\n\n\n/**\n * Appends all entries matching the given [predicate] into the mutable map given as [destination] parameter.\n *\n * @return the destination map.\n */\npublic inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M {\n    for (element in this) {\n        if (predicate(element)) {\n            destination.put(element.key, element.value)\n        }\n    }\n    return destination\n}\n\n/**\n * Returns a new map containing all key-value pairs matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V> {\n    return filterTo(LinkedHashMap<K, V>(), predicate)\n}\n\n/**\n * Appends all entries not matching the given [predicate] into the given [destination].\n *\n * @return the destination map.\n */\npublic inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M {\n    for (element in this) {\n        if (!predicate(element)) {\n            destination.put(element.key, element.value)\n        }\n    }\n    return destination\n}\n\n/**\n * Returns a new map containing all key-value pairs not matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V> {\n    return filterNotTo(LinkedHashMap<K, V>(), predicate)\n}\n\n/**\n * Returns a new map containing all key-value pairs from the given collection of pairs.\n *\n * The returned map preserves the entry iteration order of the original collection.\n */\npublic fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V> {\n    if (this is Collection) {\n        return when (size) {\n            0 -> emptyMap()\n            1 -> mapOf(if (this is List) this[0] else iterator().next())\n            else -> toMap(LinkedHashMap<K, V>(mapCapacity(size)))\n        }\n    }\n    return toMap(LinkedHashMap<K, V>()).optimizeReadOnlyMap()\n}\n\n/**\n * Populates and returns the [destination] mutable map with key-value pairs from the given collection of pairs.\n */\npublic fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Returns a new map containing all key-value pairs from the given array of pairs.\n *\n * The returned map preserves the entry iteration order of the original array.\n */\npublic fun <K, V> Array<out Pair<K, V>>.toMap(): Map<K, V> = when(size) {\n    0 -> emptyMap()\n    1 -> mapOf(this[0])\n    else -> toMap(LinkedHashMap<K, V>(mapCapacity(size)))\n}\n\n/**\n *  Populates and returns the [destination] mutable map with key-value pairs from the given array of pairs.\n */\npublic fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Returns a new map containing all key-value pairs from the given sequence of pairs.\n *\n * The returned map preserves the entry iteration order of the original sequence.\n */\npublic fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V> = toMap(LinkedHashMap<K, V>()).optimizeReadOnlyMap()\n\n/**\n * Populates and returns the [destination] mutable map with key-value pairs from the given sequence of pairs.\n */\npublic fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Returns a new read-only map containing all key-value pairs from the original map.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V> Map<out K, V>.toMap(): Map<K, V> = when (size) {\n    0 -> emptyMap()\n    1 -> toSingletonMap()\n    else -> toMutableMap()\n}\n\n/**\n * Returns a new mutable map containing all key-value pairs from the original map.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V> = LinkedHashMap(this)\n\n/**\n * Populates and returns the [destination] mutable map with key-value pairs from the given map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Creates a new read-only map by replacing or adding an entry to this map from a given key-value [pair].\n *\n * The returned map preserves the entry iteration order of the original map.\n * The [pair] is iterated in the end if it has a unique key.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>\n        = if (this.isEmpty()) mapOf(pair) else LinkedHashMap(this).apply { put(pair.first, pair.second) }\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from a given collection of key-value [pairs].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those [pairs] with unique keys are iterated in the end in the order of [pairs] collection.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>\n        = if (this.isEmpty()) pairs.toMap() else LinkedHashMap(this).apply { putAll(pairs) }\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from a given array of key-value [pairs].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those [pairs] with unique keys are iterated in the end in the order of [pairs] array.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>\n        = if (this.isEmpty()) pairs.toMap() else LinkedHashMap(this).apply { putAll(pairs) }\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from a given sequence of key-value [pairs].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those [pairs] with unique keys are iterated in the end in the order of [pairs] sequence.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>\n        = LinkedHashMap(this).apply { putAll(pairs) }.optimizeReadOnlyMap()\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from another [map].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those entries of another [map] that are missing in this map are iterated in the end in the order of that [map].\n */\npublic operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>\n        = LinkedHashMap(this).apply { putAll(map) }\n\n\n/**\n * Appends or replaces the given [pair] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>) {\n    put(pair.first, pair.second)\n}\n\n/**\n * Appends or replaces all pairs from the given collection of [pairs] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>) {\n    putAll(pairs)\n}\n\n/**\n * Appends or replaces all pairs from the given array of [pairs] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>) {\n    putAll(pairs)\n}\n\n/**\n * Appends or replaces all pairs from the given sequence of [pairs] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>) {\n    putAll(pairs)\n}\n\n/**\n * Appends or replaces all entries from the given [map] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>) {\n    putAll(map)\n}\n\n/**\n * Returns a map containing all entries of the original map except the entry with the given [key].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(key) }.optimizeReadOnlyMap()\n\n/**\n * Returns a map containing all entries of the original map except those entries\n * the keys of which are contained in the given [keys] collection.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(keys: Iterable<K>): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(keys) }.optimizeReadOnlyMap()\n\n/**\n * Returns a map containing all entries of the original map except those entries\n * the keys of which are contained in the given [keys] array.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(keys: Array<out K>): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(keys) }.optimizeReadOnlyMap()\n\n/**\n * Returns a map containing all entries of the original map except those entries\n * the keys of which are contained in the given [keys] sequence.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(keys: Sequence<K>): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(keys) }.optimizeReadOnlyMap()\n\n/**\n * Removes the entry with the given [key] from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K) {\n    remove(key)\n}\n\n/**\n * Removes all entries the keys of which are contained in the given [keys] collection from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>) {\n    this.keys.removeAll(keys)\n}\n\n/**\n * Removes all entries the keys of which are contained in the given [keys] array from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>) {\n    this.keys.removeAll(keys)\n}\n\n/**\n * Removes all entries from the keys of which are contained in the given [keys] sequence from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>) {\n    this.keys.removeAll(keys)\n}\n\n\n// do not expose for now @PublishedApi\ninternal fun <K, V> Map<K, V>.optimizeReadOnlyMap() = when (size) {\n    0 -> emptyMap()\n    1 -> toSingletonMapOrSelf()\n    else -> this\n}\n\n/* Not available on platform: JS */\n\n\n\n\n/* Not available on platform: JS */\n\n\n\n"],"names":[],"mappings":"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"}
\ No newline at end of file
+{"version":3,"file":"komp-todo.js","sources":["nl/astraeus/komp/todo/Todo.kt","collections/Maps.kt"],"sourcesContent":["package nl.astraeus.komp.todo\n\nimport kotlinx.html.*\nimport kotlinx.html.dom.create\nimport kotlinx.html.js.*\nimport nl.astraeus.komp.Komponent\nimport nl.astraeus.komp.DomDiffer\nimport org.w3c.dom.HTMLElement\nimport org.w3c.dom.HTMLInputElement\nimport org.w3c.dom.events.Event\nimport org.w3c.dom.events.KeyboardEvent\nimport kotlin.browser.document\nimport kotlin.js.Date\n\n/**\n * https://github.com/tastejs/todomvc/\n */\n\nclass Todo(\n  val dataId: String,\n  var title: String,\n  var completed: Boolean = false,\n  var editing: Boolean = false\n)\n\nenum class Selection(val title: String) {\n    ALL(\"All\"),\n    ACTIVE(\"Active\"),\n    COMPLETED(\"Completed\")\n}\n\nclass TodoApp: Komponent() {\n    val todoList: MutableList<Todo> = ArrayList()\n    var selected: Selection = Selection.ALL\n\n    fun addTodo(e: Event) {\n        val target = e.target\n\n        if (target is HTMLInputElement) {\n            todoList.add(Todo(\"${Date().getTime()}\", target.value))\n\n            refresh()\n        }\n    }\n\n    fun editTodo(e: Event, todo: Todo) {\n        val target = e.target\n\n        if (target is HTMLInputElement) {\n            todo.title = target.value\n            todo.editing = false\n\n            refresh()\n        }\n\n    }\n\n    fun destroyTodo(todo: Todo) {\n        todoList.remove(todo)\n\n        refresh()\n    }\n\n    fun selectSelection(selection: Selection) {\n        selected = selection\n\n        refresh()\n    }\n\n    fun clearCompleted() {\n        for (todo in ArrayList(todoList)) {\n            if (todo.completed) {\n                todoList.remove(todo)\n            }\n        }\n\n        refresh()\n    }\n\n    fun todoClicked(todo: Todo) {\n        todo.completed = !todo.completed\n\n        refresh()\n    }\n\n    fun getItemsLeft(): Int {\n        var result = 0\n        for (todo in todoList) {\n            if (!todo.completed) {\n                result++\n            }\n        }\n        return result\n    }\n\n    fun setEditing(editTodo: Todo) {\n        for (todo in todoList) {\n            todo.editing = todo == editTodo\n        }\n\n        refresh()\n    }\n\n    override fun refresh() {\n        super.refresh()\n\n        val inputBox = document.getElementById(\"todo_input\")\n\n        if (inputBox is HTMLInputElement) {\n            inputBox.focus()\n        }\n    }\n\n    override fun render(consumer: TagConsumer<HTMLElement>) = consumer.section(classes = \"todoapp\") {\n        header(classes = \"header\") {\n            h1 { + \"todos\" }\n            input(classes = \"new-todo\") {\n                id = \"todo_input\"\n                placeholder = \"What needs to be done?\"\n                autoFocus = true\n                onKeyPressFunction = { e ->\n                    if (e is KeyboardEvent && e.keyCode == 13) {\n                        addTodo(e)\n\n                        val target = e.target\n\n                        if (target is HTMLInputElement) {\n                            target.value = \"\"\n                            target.defaultValue = \"\"\n                        }\n                    }\n                }\n            }\n        }\n\n        section(classes = \"main\") {\n            input(classes = \"toggle-all\") {\n                type = InputType.checkBox\n            }\n            label {\n                for_ = \"toggle-all\"\n                + \"Mark all as complete\"\n            }\n            ul(classes = \"todo-list\") {\n                for (todo in todoList) {\n                    if (selected == Selection.ALL ||\n                        (todo.completed && selected == Selection.COMPLETED) ||\n                        (!todo.completed && selected == Selection.ACTIVE)) {\n                        li {\n                            if (todo.editing) {\n                                classes += \"editing\"\n                                input(classes = \"edit\") {\n                                    value = todo.title\n                                    onKeyPressFunction = { e ->\n                                        if (e is KeyboardEvent && e.keyCode == 13) {\n                                            editTodo(e, todo)\n                                        }\n                                    }\n                                }\n                            } else {\n                                if (todo.completed) {\n                                    classes += \"completed\"\n                                }\n                                attributes[\"data-id\"] = todo.dataId\n                                div(classes = \"view\") {\n                                    input(classes = \"toggle\") {\n                                        type = InputType.checkBox\n                                        checked = todo.completed\n                                        onClickFunction = {\n                                            todoClicked(todo)\n                                        }\n                                    }\n                                    label(classes = \"todo-content\") {\n                                        +todo.title\n\n                                        onDoubleClickFunction = {\n                                            setEditing(todo)\n                                        }\n                                    }\n                                    button(classes = \"destroy\") {\n                                        onClickFunction = {\n                                            destroyTodo(todo)\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        footer(classes = \"footer\") {\n            span(classes = \"todo-count\") {\n                strong { + \"${getItemsLeft()}\" }\n                + \" item left\"\n            }\n            ul(classes = \"filters\") {\n                for (selection in Selection.values())\n                li {\n                    a {\n                        if (selection == selected) { classes += \"selected\" }\n                        href = \"#\"\n                        + selection.title\n                        onClickFunction = {\n                            selectSelection(selection)\n                        }\n                    }\n                }\n            }\n            button(classes = \"clear-completed\") {\n                + \"Clear completed\"\n                onClickFunction = {\n                    clearCompleted()\n                }\n            }\n        }\n    }\n\n}\n\nfun main(args: Array<String>) {\n    Komponent.create(document.body!!, TodoApp(), true)\n\n    val el1 = document.create.div {\n        div {\n            div {\n                id = \"id1\"\n                span {\n                    +\"Test\"\n                }\n            }\n        }\n    }\n\n    val el2 = document.create.div {\n        div {\n            id = \"id1\"\n            span {\n                +\"Test\"\n            }\n            input {\n                name = \"bla\"\n            }\n        }\n    }\n\n    // println(\"equals ${DomDiffer.match(el1, el2)}\")\n\n    console.log(\"OLD\", el1)\n    console.log(\"NEW\", el2)\n\n    DomDiffer.replaceDiff(el2, el1)\n\n    console.log(\"OLD\", el1)\n    console.log(\"NEW\", el2)\n}\n\n","@file:kotlin.jvm.JvmMultifileClass\n@file:kotlin.jvm.JvmName(\"MapsKt\")\n\npackage kotlin.collections\n\nprivate object EmptyMap : Map<Any?, Nothing>, Serializable {\n    private const val serialVersionUID: Long = 8246714829545688274\n\n    override fun equals(other: Any?): Boolean = other is Map<*,*> && other.isEmpty()\n    override fun hashCode(): Int = 0\n    override fun toString(): String = \"{}\"\n\n    override val size: Int get() = 0\n    override fun isEmpty(): Boolean = true\n\n    override fun containsKey(key: Any?): Boolean = false\n    override fun containsValue(value: Nothing): Boolean = false\n    override fun get(key: Any?): Nothing? = null\n    override val entries: Set<Map.Entry<Any?, Nothing>> get() = EmptySet\n    override val keys: Set<Any?> get() = EmptySet\n    override val values: Collection<Nothing> get() = EmptyList\n\n    private fun readResolve(): Any = EmptyMap\n}\n\n/**\n * Returns an empty read-only map of specified type.\n *\n * The returned map is serializable (JVM).\n * @sample samples.collections.Maps.Instantiation.emptyReadOnlyMap\n */\npublic fun <K, V> emptyMap(): Map<K, V> = @Suppress(\"UNCHECKED_CAST\") (EmptyMap as Map<K, V>)\n\n/**\n * Returns a new read-only map with the specified contents, given as a list of pairs\n * where the first value is the key and the second is the value.\n *\n * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.\n *\n * Entries of the map are iterated in the order they were specified.\n *\n * The returned map is serializable (JVM).\n *\n * @sample samples.collections.Maps.Instantiation.mapFromPairs\n */\npublic fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V> = if (pairs.size > 0) pairs.toMap(LinkedHashMap(mapCapacity(pairs.size))) else emptyMap()\n\n/**\n * Returns an empty read-only map.\n *\n * The returned map is serializable (JVM).\n * @sample samples.collections.Maps.Instantiation.emptyReadOnlyMap\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> mapOf(): Map<K, V> = emptyMap()\n\n/* Not available on platform: JS */\n\n\n\n\n\n\n\n\n\n\n/**\n * Returns an empty new [MutableMap].\n *\n * The returned map preserves the entry iteration order.\n * @sample samples.collections.Maps.Instantiation.emptyMutableMap\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> mutableMapOf(): MutableMap<K, V> = LinkedHashMap()\n\n/**\n * Returns a new [MutableMap] with the specified contents, given as a list of pairs\n * where the first component is the key and the second is the value.\n *\n * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.\n *\n * Entries of the map are iterated in the order they were specified.\n *\n * @sample samples.collections.Maps.Instantiation.mutableMapFromPairs\n * @sample samples.collections.Maps.Instantiation.emptyMutableMap\n */\npublic fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>\n        = LinkedHashMap<K, V>(mapCapacity(pairs.size)).apply { putAll(pairs) }\n\n/**\n * Returns an empty new [HashMap].\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> hashMapOf(): HashMap<K, V> = HashMap<K, V>()\n\n/**\n * Returns a new [HashMap] with the specified contents, given as a list of pairs\n * where the first component is the key and the second is the value.\n *\n * @sample samples.collections.Maps.Instantiation.hashMapFromPairs\n */\npublic fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>\n        = HashMap<K, V>(mapCapacity(pairs.size)).apply { putAll(pairs) }\n\n/**\n * Returns an empty new [LinkedHashMap].\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> linkedMapOf(): LinkedHashMap<K, V> = LinkedHashMap<K, V>()\n\n/**\n * Returns a new [LinkedHashMap] with the specified contents, given as a list of pairs\n * where the first component is the key and the second is the value.\n *\n * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.\n *\n * Entries of the map are iterated in the order they were specified.\n *\n * @sample samples.collections.Maps.Instantiation.linkedMapFromPairs\n */\npublic fun <K, V> linkedMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>\n        = pairs.toMap(LinkedHashMap(mapCapacity(pairs.size)))\n\n/**\n * Calculate the initial capacity of a map, based on Guava's com.google.common.collect.Maps approach. This is equivalent\n * to the Collection constructor for HashSet, (c.size()/.75f) + 1, but provides further optimisations for very small or\n * very large sizes, allows support non-collection classes, and provides consistency for all map based class construction.\n */\n@PublishedApi\ninternal fun mapCapacity(expectedSize: Int): Int {\n    if (expectedSize < 3) {\n        return expectedSize + 1\n    }\n    if (expectedSize < INT_MAX_POWER_OF_TWO) {\n        return expectedSize + expectedSize / 3\n    }\n    return Int.MAX_VALUE // any large value\n}\n\nprivate const val INT_MAX_POWER_OF_TWO: Int = Int.MAX_VALUE / 2 + 1\n\n/** Returns `true` if this map is not empty. */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean = !isEmpty()\n\n/**\n * Returns the [Map] if its not `null`, or the empty [Map] otherwise.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map<K, V>?.orEmpty() : Map<K, V> = this ?: emptyMap()\n\n/**\n * Checks if the map contains the given key.\n *\n * This method allows to use the `x in map` syntax for checking whether an object is contained in the map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.contains(key: K) : Boolean = containsKey(key)\n\n/**\n * Returns the value corresponding to the given [key], or `null` if such a key is not present in the map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get(key: K): V?\n        = @Suppress(\"UNCHECKED_CAST\") (this as Map<K, V>).get(key)\n\n/**\n * Allows to use the index operator for storing values in a mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V): Unit {\n    put(key, value)\n}\n\n/**\n * Returns `true` if the map contains the specified [key].\n *\n * Allows to overcome type-safety restriction of `containsKey` that requires to pass a key of type `K`.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <@kotlin.internal.OnlyInputTypes K> Map<out K, *>.containsKey(key: K): Boolean\n        = @Suppress(\"UNCHECKED_CAST\") (this as Map<K, *>).containsKey(key)\n\n/**\n * Returns `true` if the map maps one or more keys to the specified [value].\n *\n * Allows to overcome type-safety restriction of `containsValue` that requires to pass a value of type `V`.\n */\n@Suppress(\"EXTENSION_SHADOWED_BY_MEMBER\") // false warning, extension takes precedence in some cases\n@kotlin.internal.InlineOnly\npublic inline fun <K, @kotlin.internal.OnlyInputTypes V> Map<K, V>.containsValue(value: V): Boolean = this.containsValue(value)\n\n\n/**\n * Removes the specified key and its corresponding value from this map.\n *\n * @return the previous value associated with the key, or `null` if the key was not present in the map.\n\n * Allows to overcome type-safety restriction of `remove` that requires to pass a key of type `K`.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <@kotlin.internal.OnlyInputTypes K, V> MutableMap<out K, V>.remove(key: K): V?\n        = @Suppress(\"UNCHECKED_CAST\") (this as MutableMap<K, V>).remove(key)\n\n/**\n * Returns the key component of the map entry.\n *\n * This method allows to use destructuring declarations when working with maps, for example:\n * ```\n * for ((key, value) in map) {\n *     // do something with the key and the value\n * }\n * ```\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> Map.Entry<K, V>.component1(): K = key\n\n/**\n * Returns the value component of the map entry.\n *\n * This method allows to use destructuring declarations when working with maps, for example:\n * ```\n * for ((key, value) in map) {\n *     // do something with the key and the value\n * }\n * ```\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> Map.Entry<K, V>.component2(): V = value\n\n/**\n * Converts entry to [Pair] with key being first component and value being second.\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map.Entry<K, V>.toPair(): Pair<K, V> = Pair(key, value)\n\n/**\n * Returns the value for the given key, or the result of the [defaultValue] function if there was no entry for the given key.\n *\n * @sample samples.collections.Maps.Usage.getOrElse\n */\n@kotlin.internal.InlineOnly\npublic inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V = get(key) ?: defaultValue()\n\n\ninternal inline fun <K, V> Map<K, V>.getOrElseNullable(key: K, defaultValue: () -> V): V {\n    val value = get(key)\n    if (value == null && !containsKey(key)) {\n        return defaultValue()\n    } else {\n        @Suppress(\"UNCHECKED_CAST\")\n        return value as V\n    }\n}\n\n/**\n * Returns the value for the given [key] or throws an exception if there is no such key in the map.\n *\n * If the map was created by [withDefault], resorts to its `defaultValue` provider function\n * instead of throwing an exception.\n *\n * @throws NoSuchElementException when the map doesn't contain a value for the specified key and\n * no implicit default value was provided for that map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V> Map<K, V>.getValue(key: K): V = getOrImplicitDefault(key)\n\n/**\n * Returns the value for the given key. If the key is not found in the map, calls the [defaultValue] function,\n * puts its result into the map under the given key and returns it.\n *\n * @sample samples.collections.Maps.Usage.getOrPut\n */\npublic inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V {\n    val value = get(key)\n    return if (value == null) {\n        val answer = defaultValue()\n        put(key, answer)\n        answer\n    } else {\n        value\n    }\n}\n\n/**\n * Returns an [Iterator] over the entries in the [Map].\n *\n * @sample samples.collections.Maps.Usage.forOverEntries\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>> = entries.iterator()\n\n/* Not available on platform: JS */\n\n\n\n\n\n\n\n\n/**\n * Populates the given [destination] map with entries having the keys of this map and the values obtained\n * by applying the [transform] function to each entry in this [Map].\n */\npublic inline fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M {\n    return entries.associateByTo(destination, { it.key }, transform)\n}\n\n/**\n * Populates the given [destination] map with entries having the keys obtained\n * by applying the [transform] function to each entry in this [Map] and the values of this map.\n *\n * In case if any two entries are mapped to the equal keys, the value of the latter one will overwrite\n * the value associated with the former one.\n */\npublic inline fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M {\n    return entries.associateByTo(destination, transform, { it.value })\n}\n\n/**\n * Puts all the given [pairs] into this [MutableMap] with the first component in the pair being the key and the second the value.\n */\npublic fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>): Unit {\n    for ((key, value) in pairs) {\n        put(key, value)\n    }\n}\n\n/**\n * Puts all the elements of the given collection into this [MutableMap] with the first component in the pair being the key and the second the value.\n */\npublic fun <K, V> MutableMap<in K, in V>.putAll(pairs: Iterable<Pair<K,V>>): Unit {\n    for ((key, value) in pairs) {\n        put(key, value)\n    }\n}\n\n/**\n * Puts all the elements of the given sequence into this [MutableMap] with the first component in the pair being the key and the second the value.\n */\npublic fun <K, V> MutableMap<in K, in V>.putAll(pairs: Sequence<Pair<K,V>>): Unit {\n    for ((key, value) in pairs) {\n        put(key, value)\n    }\n}\n\n/**\n * Returns a new map with entries having the keys of this map and the values obtained by applying the [transform]\n * function to each entry in this [Map].\n *\n * The returned map preserves the entry iteration order of the original map.\n *\n * @sample samples.collections.Maps.Transforms.mapValues\n */\npublic inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R> {\n    return mapValuesTo(LinkedHashMap<K, R>(mapCapacity(size)), transform) // .optimizeReadOnlyMap()\n}\n\n/**\n * Returns a new Map with entries having the keys obtained by applying the [transform] function to each entry in this\n * [Map] and the values of this map.\n *\n * In case if any two entries are mapped to the equal keys, the value of the latter one will overwrite\n * the value associated with the former one.\n *\n * The returned map preserves the entry iteration order of the original map.\n *\n * @sample samples.collections.Maps.Transforms.mapKeys\n */\npublic inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V> {\n    return mapKeysTo(LinkedHashMap<R, V>(mapCapacity(size)), transform) // .optimizeReadOnlyMap()\n}\n\n/**\n * Returns a map containing all key-value pairs with keys matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V> {\n    val result = LinkedHashMap<K, V>()\n    for (entry in this) {\n        if (predicate(entry.key)) {\n            result.put(entry.key, entry.value)\n        }\n    }\n    return result\n}\n\n/**\n * Returns a map containing all key-value pairs with values matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V> {\n    val result = LinkedHashMap<K, V>()\n    for (entry in this) {\n        if (predicate(entry.value)) {\n            result.put(entry.key, entry.value)\n        }\n    }\n    return result\n}\n\n\n/**\n * Appends all entries matching the given [predicate] into the mutable map given as [destination] parameter.\n *\n * @return the destination map.\n */\npublic inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M {\n    for (element in this) {\n        if (predicate(element)) {\n            destination.put(element.key, element.value)\n        }\n    }\n    return destination\n}\n\n/**\n * Returns a new map containing all key-value pairs matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V> {\n    return filterTo(LinkedHashMap<K, V>(), predicate)\n}\n\n/**\n * Appends all entries not matching the given [predicate] into the given [destination].\n *\n * @return the destination map.\n */\npublic inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M {\n    for (element in this) {\n        if (!predicate(element)) {\n            destination.put(element.key, element.value)\n        }\n    }\n    return destination\n}\n\n/**\n * Returns a new map containing all key-value pairs not matching the given [predicate].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\npublic inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V> {\n    return filterNotTo(LinkedHashMap<K, V>(), predicate)\n}\n\n/**\n * Returns a new map containing all key-value pairs from the given collection of pairs.\n *\n * The returned map preserves the entry iteration order of the original collection.\n */\npublic fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V> {\n    if (this is Collection) {\n        return when (size) {\n            0 -> emptyMap()\n            1 -> mapOf(if (this is List) this[0] else iterator().next())\n            else -> toMap(LinkedHashMap<K, V>(mapCapacity(size)))\n        }\n    }\n    return toMap(LinkedHashMap<K, V>()).optimizeReadOnlyMap()\n}\n\n/**\n * Populates and returns the [destination] mutable map with key-value pairs from the given collection of pairs.\n */\npublic fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Returns a new map containing all key-value pairs from the given array of pairs.\n *\n * The returned map preserves the entry iteration order of the original array.\n */\npublic fun <K, V> Array<out Pair<K, V>>.toMap(): Map<K, V> = when(size) {\n    0 -> emptyMap()\n    1 -> mapOf(this[0])\n    else -> toMap(LinkedHashMap<K, V>(mapCapacity(size)))\n}\n\n/**\n *  Populates and returns the [destination] mutable map with key-value pairs from the given array of pairs.\n */\npublic fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Returns a new map containing all key-value pairs from the given sequence of pairs.\n *\n * The returned map preserves the entry iteration order of the original sequence.\n */\npublic fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V> = toMap(LinkedHashMap<K, V>()).optimizeReadOnlyMap()\n\n/**\n * Populates and returns the [destination] mutable map with key-value pairs from the given sequence of pairs.\n */\npublic fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Returns a new read-only map containing all key-value pairs from the original map.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V> Map<out K, V>.toMap(): Map<K, V> = when (size) {\n    0 -> emptyMap()\n    1 -> toSingletonMap()\n    else -> toMutableMap()\n}\n\n/**\n * Returns a new mutable map containing all key-value pairs from the original map.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V> = LinkedHashMap(this)\n\n/**\n * Populates and returns the [destination] mutable map with key-value pairs from the given map.\n */\n@SinceKotlin(\"1.1\")\npublic fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap(destination: M): M\n        = destination.apply { putAll(this@toMap) }\n\n/**\n * Creates a new read-only map by replacing or adding an entry to this map from a given key-value [pair].\n *\n * The returned map preserves the entry iteration order of the original map.\n * The [pair] is iterated in the end if it has a unique key.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>\n        = if (this.isEmpty()) mapOf(pair) else LinkedHashMap(this).apply { put(pair.first, pair.second) }\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from a given collection of key-value [pairs].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those [pairs] with unique keys are iterated in the end in the order of [pairs] collection.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>\n        = if (this.isEmpty()) pairs.toMap() else LinkedHashMap(this).apply { putAll(pairs) }\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from a given array of key-value [pairs].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those [pairs] with unique keys are iterated in the end in the order of [pairs] array.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>\n        = if (this.isEmpty()) pairs.toMap() else LinkedHashMap(this).apply { putAll(pairs) }\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from a given sequence of key-value [pairs].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those [pairs] with unique keys are iterated in the end in the order of [pairs] sequence.\n */\npublic operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>\n        = LinkedHashMap(this).apply { putAll(pairs) }.optimizeReadOnlyMap()\n\n/**\n * Creates a new read-only map by replacing or adding entries to this map from another [map].\n *\n * The returned map preserves the entry iteration order of the original map.\n * Those entries of another [map] that are missing in this map are iterated in the end in the order of that [map].\n */\npublic operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>\n        = LinkedHashMap(this).apply { putAll(map) }\n\n\n/**\n * Appends or replaces the given [pair] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>) {\n    put(pair.first, pair.second)\n}\n\n/**\n * Appends or replaces all pairs from the given collection of [pairs] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>) {\n    putAll(pairs)\n}\n\n/**\n * Appends or replaces all pairs from the given array of [pairs] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>) {\n    putAll(pairs)\n}\n\n/**\n * Appends or replaces all pairs from the given sequence of [pairs] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>) {\n    putAll(pairs)\n}\n\n/**\n * Appends or replaces all entries from the given [map] in this mutable map.\n */\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>) {\n    putAll(map)\n}\n\n/**\n * Returns a map containing all entries of the original map except the entry with the given [key].\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(key) }.optimizeReadOnlyMap()\n\n/**\n * Returns a map containing all entries of the original map except those entries\n * the keys of which are contained in the given [keys] collection.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(keys: Iterable<K>): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(keys) }.optimizeReadOnlyMap()\n\n/**\n * Returns a map containing all entries of the original map except those entries\n * the keys of which are contained in the given [keys] array.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(keys: Array<out K>): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(keys) }.optimizeReadOnlyMap()\n\n/**\n * Returns a map containing all entries of the original map except those entries\n * the keys of which are contained in the given [keys] sequence.\n *\n * The returned map preserves the entry iteration order of the original map.\n */\n@SinceKotlin(\"1.1\")\npublic operator fun <K, V> Map<out K, V>.minus(keys: Sequence<K>): Map<K, V>\n        = this.toMutableMap().apply { minusAssign(keys) }.optimizeReadOnlyMap()\n\n/**\n * Removes the entry with the given [key] from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K) {\n    remove(key)\n}\n\n/**\n * Removes all entries the keys of which are contained in the given [keys] collection from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>) {\n    this.keys.removeAll(keys)\n}\n\n/**\n * Removes all entries the keys of which are contained in the given [keys] array from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>) {\n    this.keys.removeAll(keys)\n}\n\n/**\n * Removes all entries from the keys of which are contained in the given [keys] sequence from this mutable map.\n */\n@SinceKotlin(\"1.1\")\n@kotlin.internal.InlineOnly\npublic inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>) {\n    this.keys.removeAll(keys)\n}\n\n\n// do not expose for now @PublishedApi\ninternal fun <K, V> Map<K, V>.optimizeReadOnlyMap() = when (size) {\n    0 -> emptyMap()\n    1 -> toSingletonMapOrSelf()\n    else -> this\n}\n\n/* Not available on platform: JS */\n\n\n\n\n/* Not available on platform: JS */\n\n\n\n"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/web/js/kotlin/komp-todo.meta.js b/web/js/kotlin/komp-todo.meta.js
index 24aad85..9493dee 100644
--- a/web/js/kotlin/komp-todo.meta.js
+++ b/web/js/kotlin/komp-todo.meta.js
@@ -1 +1 @@
-// Kotlin.kotlin_module_metadata(65537, "komp-todo", "H4sIAAAAAAAAAIVXW3PaRhQGSehyhGEtGxvjpEmJc48T4kzTaR86g11mYhdPU8ft5FUWaywsJLpafPkD+QF9yj9pnvrQhz73H7VnhRCgEeAZdFa737nuucg5qwI5K1crftb/G//l/9BzVh2KoF4G3HN9kHqhBSCRHCh6juRr8mc9wjRgHSTfA90OObPpMATlMugPLDLB4jNPJMEhCY4XsJFILdKbAWVun/rc9jLlP0P5YzTYvh9wm7uBn4l9ACsJVu4E/UzQDpQSkMJpyDNRb2AT5IB1Qb5+44CJRp4HrG/7Dl3gmRA9E4tM0c+hPCVavrlgC0T+APWJ+07AgiF3fRqmAjef/z7ARFmmObuwOmVO4dz1aLjExwiuXV6wwA+yfUwF+SY7yFtgoJgIdWMpAiCOcknq9X4fUnYL0tCdE8hKosR0MOls5oaBn23RN7CV6ALlgvfxmly/Rx0eLIr/W6il2QwHdQz7lC0K03cz+SOSEVR6hbcVWhtpJnxKRBassmBdB0VkUSogj/Gaxs5qZyy4DinLdPQtFkxKszxk3lK1j4AkClRm+12aHchXsDYlX7sO2OXiUFRBH19lyidxJxNRK1jb7rnrRPW9SGCWh+FVd6mHr6fyRWP03MPLj/rafFWpFPMEizsvxZ6AlYAxtzhl/pymJmKYyqpldpRTLi8AV6AQgbNKatzN3WB5t520m0zse3i5vDUBYCCY64euszzzxSxJhWWJq1FujThS3m6CBoVffvVdnjpI9zvKnYsFGmZmSu8qe6aIaZEyXMURQO1FtmelsRMuj9LMHQ1YgMHm7pw7+ha204aBzfFCzoZ8YZtvwr3MWplK7GV2PsScndWdaeJTrIWxJiOk2CdwyGZ7Iwp4ZvZA4ZqedRfNv5m2GfsxV3YqUorbHyySLQoqMqfQG4o8yxL7pw5/y1kfSDgWg04Axgca95TJvGz5wz4UuMs9CuoHUT2YI812G9Tmwenhby0wDn4+ft9unbZ+BOVUSJGb/i2oHZvbhx0xn9BuymkHtP0g8KiNrtOOy4UcTeCbgwEYPyEq8LFIQQ8jGxCvC5vabshnmh2Yx0Nun3k0OtHsTidSqojigjydM+eg0BIUSg5awA4Sm8wOfnOx4DaSoQu7olWxS/khp/2wTc85yIfIKe6L0fACxxH1O5SB+e70uN3yaD+yejyG09dmntrdg/FZeeTbJMpGmCwhpLwVx8UUnh94rnOJJip9W9yDzbroRZMx+9b6N5+d7aDqMlGqOTwt4LpAVFwLqkdUIUZMIaZmRGVSjHErMSXxvhVRiaxVhbYCwW9lnZDNGLUVadrGkzVyB5/r5C4+K+QrPN0g92LUTkQr5HGEfoqIGnmGO9vkeYzYq+Zqd2qbpFGTGtZekbyu6ZZiSQ2tcfeLnsMCru/pn/JVZW+0rTTUfdAlSyUaMmgnMe1JuoE/wJ+JbPUV/Z98Vd9D/L6kS6NXY/YVktePVRPXxf0dlFoS0sbSLR3dL+NqJVqtitWJMdr5+Kl0EsNxa3W8ZYw4cSnM+CtfLaHo8n7uqESqkYcqqSHdPFLJffGO+1/H+zJS82iD1Kdxyb5KHiCtHunkoTh/t4HIR7jawpg9iWO21biD+yXyIpawi1TB95fxez2SVCKvpjWiyesCJ6wvkkosymysfhFTSsL/x76HarqyNPzCDTFbl7XeWtxKalGnqZXj+tgV5bHbC/8HWmK8ePANAAA=");
+// Kotlin.kotlin_module_metadata(65537, "komp-todo", "H4sIAAAAAAAAAIVX3VLbRhS2JVmWj4y9CAxGkCZ1yC8hcUibTnvRGUM9E6iZZgjt5FbIi5GRJXe15ucF8gC9yps0V73oRa/7Ru1ZWZZtjZCZQWe1+53/s+fIOaMGOSNnlj9r/03+8n9oOaMBZVAvfe46Hkj9wACQSA4ULUfypvxZCzFNWAXJc0GzAs4sOgpAufQHQ4NMsfjME0lwSILjBazFUsv0ZkiZM6Aet9xU+c9R/gQNluf53OKO76ViH8JSjJW7/iAVtA2VGKRwGvBU1BtYB9lnPZCv39igo5HnPhtYnk0zPBOi52KRKvobqM8bgPiuNeSUBRmyd6A6Y5B8c8EywD9CYxo022f+iDseDRLhvpv/AcBUWaoTu7A8Y07h3HFplvUiMiG8eHnBfM9Pj0wiNTfpqdmAEooJUTeGIgDiKBcXbP/3EWW3II2cVPYdqMVKdBtL1WJO4HvpFn0LG7EuUC74AJPreH1qcz8r/m/BTLKVbNQxGmQn+fu5qhMlDCq9wmwFxlqSCZ8SkQWrLFhXQRG1lwjIE0zTxNniGfOvA8pSHX2L1yyhWR4xd6Hax0BiBSqzvB5ND+QrWJmRX7z22WV2KOqgTVKZ8EnkZCpqCTuCc+7YYVfIEpjmYXDVW+jh65l6KTJ67mLyw26YdVfnSswVLM5dJfYUjBiMtYVtwLujFYoYJqpqkR3VhMsZ4BoUQnDalZrMAMdf3KOn7SYV+x5eLm5NABgI5niBYy+ufDGBEmFZ4GpYW2OOhLfJtka5fZEhaG7g9K/SB44YJQn7VJwP1MoyMa1a7WBxMOZSMWQ+xpQ7d6TiO9hMGgYWx7ifjXhmN2/B/dQrMVO/i+x8hKU5rzvVxGdY8hNNpYBiO8AJnO6NuKdzIwYK1/SslzXm5rpj5MedshORUpzBMEu2uDehOYX+yHPSxf6pwd9y2tcTTj+/60PpA41ax3Qstr3RAArc4S4F9YO4JFgjrU4H1NbB6eFvbSgd/HL8vtM+bf8EyqmQIre8W1C7FrcOu2IMod2U0y4U933fpRa6TrsOF3KKAt8aDqH0M6J8D+8iaEFoA+I1YVPHwe+V2Z4G+vGIW2cuDU+KVrcbKlV+RachT+8YZ1BoCwoVGy1gB7FNehe/h5h/G8rQhF3hqtyj/JDTQdCh5xzkQ+QU+WI0uMCpQ70uZaC/Oz3utF06CK2eTNtk2vRTq3cwOauOfZtGuRTESwgob0dx0YXnB65jX6KJysASebBYD71oMWbdGv/m06sdVE0mSj2HpwVcF4iKa0G1kCqkFFGIqB5SmZQj3FJESbRvhFQiK3WhrUDwQ1ojZD1CbYSaNvFkhWzhc5Xcw2eNfIWna+R+hNoOaY08CdHPEGGS57izSXYixF49Z26Z66RpSk1jr0xem5qhGFKz2Lz3RcvhBW7saZ/ydWVvvK001X3QJEMlRWQonkS0L2kl/Af815GtsaT9k69re4jflzRp/Fqaf4X49WNdx3V5fxulVoS0iXRDQ/eruFoKV8tidVIa73z8VDmJ4Li1PNkqjTlxKcz4K1+voOjqfu6oQuqhhyoxka4fqeSBeMf9r6N9Gal+tEYas7h4XyUPkdaPNPJInL9bQ+RjXG1gzJ5GMdtobuF+hbyIJOwiVfD9ZfTeCCVVyKtZjWjyqsAJ68ukFonSm8tfxJSS8MfaD/gbInGzivghG2C1Lmq9ZtRKzLDTmNXofuyK67HbD/4HjWl22g0OAAA=");