tutuca 0.9.82 → 0.9.83

package/dist/tutuca-extra.ext.js

@@ -850,9 +850,6 @@ class DynVal extends RenderNameVal {
   eval(stack) {
     return stack.lookupDynamic(this.name);
   }
-  toPathItem() {
-    return null;
-  }
   toString() {
     return `*${this.name}`;
   }
@@ -1090,7 +1087,7 @@ class ConstAttrs extends Attributes {
   toMacroVars() {
     const r = {};
     for (const name in this.items)
-      r[name] = `'${this.items[name]}'`;
+      r[name] = new ConstVal(`${this.items[name]}`).toString();
     return r;
   }
   isConstant() {
@@ -1196,6 +1193,79 @@ class RequestHandler {
   }
 }
 
+// src/renderer.js
+import { isIndexed, isKeyed } from "immutable";
+
+// src/cache.js
+class NullDomCache {
+  get(_keys, _cacheKey) {}
+  set(_keys, _cacheKey, _v) {}
+  evict() {
+    return { hit: 0, miss: 0, badKey: 0 };
+  }
+}
+
+class WeakMapDomCache {
+  constructor() {
+    this.hit = this.miss = this.badKey = 0;
+    this.keysByLen = new Map;
+  }
+  _returnValue(r) {
+    if (r === undefined)
+      this.miss += 1;
+    else
+      this.hit += 1;
+    return r;
+  }
+  get(keys, cacheKey) {
+    const len = keys.length;
+    let cur = this.keysByLen.get(len);
+    if (!cur)
+      return this._returnValue(undefined);
+    for (let i = 0;i < len - 1; i++) {
+      cur = cur.get(keys[i]);
+      if (!cur)
+        return this._returnValue(undefined);
+    }
+    return this._returnValue(cur.get(keys[len - 1])?.[cacheKey]);
+  }
+  set(keys, cacheKey, v) {
+    const len = keys.length;
+    let cur = this.keysByLen.get(len);
+    if (!cur) {
+      cur = new WeakMap;
+      this.keysByLen.set(len, cur);
+    }
+    for (let i = 0;i < len - 1; i++) {
+      const key = keys[i];
+      let next = cur.get(key);
+      if (!next) {
+        if (typeof key !== "object") {
+          this.badKey += 1;
+          return;
+        }
+        next = new WeakMap;
+        cur.set(key, next);
+      }
+      cur = next;
+    }
+    const lastKey = keys[len - 1];
+    const leaf = cur.get(lastKey);
+    if (leaf)
+      leaf[cacheKey] = v;
+    else if (typeof lastKey === "object")
+      cur.set(lastKey, { [cacheKey]: v });
+    else
+      this.badKey += 1;
+  }
+  evict() {
+    const { hit, miss, badKey } = this;
+    this.hit = this.miss = this.badKey = 0;
+    this.keysByLen = new Map;
+    return { hit, miss, badKey };
+  }
+}
+
 // src/vdom.js
 var HTML_NS = "http://www.w3.org/1999/xhtml";
 var SVG_NS = "http://www.w3.org/2000/svg";
@@ -1223,6 +1293,7 @@ var NEVER_ASSIGN = new Set([
   "role",
   "popover"
 ]);
+var PROP_ATTR_NAME = { className: "class", htmlFor: "for" };
 function applyProperties(node, props) {
   const namespaced = isNamespaced(node);
   for (const name in props)
@@ -1241,15 +1312,22 @@ function setProp(node, name, value, namespaced) {
   }
   if (typeof value === "function")
     return;
-  if (!namespaced && !NEVER_ASSIGN.has(name) && name in node) {
+  const usesProp = !namespaced && !NEVER_ASSIGN.has(name) && name in node;
+  if (usesProp && value != null) {
     try {
-      node[name] = value == null ? "" : value;
+      node[name] = value;
       return;
     } catch {}
   }
-  if (value == null || value === false && name[4] !== "-")
-    node.removeAttribute(name);
-  else
+  if (value == null || value === false && name[4] !== "-") {
+    if (usesProp) {
+      try {
+        node[name] = "";
+      } catch {}
+      node.removeAttribute(PROP_ATTR_NAME[name] ?? name);
+    } else
+      node.removeAttribute(name);
+  } else
     node.setAttribute(name, value);
 }
 function applyValueLast(node, value) {
@@ -1430,22 +1508,12 @@ function morphNode(domNode, source, target, opts) {
     }
     if (type === 1 && source.isSameKind(target)) {
       const propsDiff = diffProps(source.attrs, target.attrs);
-      let pendingValue;
-      let pendingChecked;
-      let applyValue = false;
-      let applyChecked = false;
+      const hasValue = propsDiff != null && "value" in propsDiff;
+      const hasChecked = propsDiff != null && "checked" in propsDiff;
       if (propsDiff) {
-        if ("value" in propsDiff || "checked" in propsDiff) {
-          const { value, checked, ...rest } = propsDiff;
+        if (hasValue || hasChecked) {
+          const { value: _v, checked: _c, ...rest } = propsDiff;
           applyProperties(domNode, rest);
-          if ("value" in propsDiff) {
-            pendingValue = value;
-            applyValue = true;
-          }
-          if ("checked" in propsDiff) {
-            pendingChecked = checked;
-            applyChecked = true;
-          }
         } else
           applyProperties(domNode, propsDiff);
       }
@@ -1453,14 +1521,12 @@ function morphNode(domNode, source, target, opts) {
         const ns = effectiveNs(target, opts);
         morphChildren(domNode, source.childs, target.childs, childOpts(target, ns, opts));
       }
-      if (!applyValue && source.tag === "SELECT" && target.attrs.value !== undefined) {
-        pendingValue = target.attrs.value;
-        applyValue = true;
-      }
-      if (applyValue)
-        applyValueLast(domNode, pendingValue);
-      if (applyChecked)
-        setProp(domNode, "checked", pendingChecked, false);
+      if (hasValue)
+        applyValueLast(domNode, propsDiff.value);
+      else if (source.tag === "SELECT" && target.attrs.value !== undefined)
+        applyValueLast(domNode, target.attrs.value);
+      if (hasChecked)
+        setProp(domNode, "checked", propsDiff.checked, false);
       return domNode;
     }
     if (type === 11) {
@@ -1581,6 +1647,161 @@ function h(tagName, properties, children, namespace) {
   return new VNode(tag, props, normalizedChildren, key, namespace);
 }
 
+// src/renderer.js
+var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
+
+class Renderer {
+  constructor(comps) {
+    this.comps = comps;
+    this.cache = new WeakMapDomCache;
+    this.renderTag = h;
+  }
+  renderFragment(childs) {
+    return new VFragment(childs);
+  }
+  renderComment(text) {
+    return new VComment(text);
+  }
+  setNullCache() {
+    this.cache = new NullDomCache;
+  }
+  renderToDOM(stack, val) {
+    const rootNode = document.createElement("div");
+    const rOpts = { document };
+    render(h("DIV", null, [this.renderRoot(stack, val)]), rootNode, rOpts);
+    return rootNode.childNodes[0];
+  }
+  renderToString(stack, val, cleanAttrs = true) {
+    const dom = this.renderToDOM(stack, val);
+    if (cleanAttrs) {
+      const nodes = dom.querySelectorAll("[data-nid],[data-cid],[data-eid]");
+      for (const { dataset } of nodes)
+        for (const name of DATASET_ATTRS)
+          delete dataset[name];
+    }
+    return dom.innerHTML;
+  }
+  renderRoot(stack, val, viewName = null) {
+    const comp = this.comps.getCompFor(val);
+    if (comp === null)
+      return null;
+    return this._rValComp(stack, val, comp, comp.getView(viewName).anode, "ROOT", viewName);
+  }
+  renderIt(stack, node, key, viewName) {
+    const comp = this.comps.getCompFor(stack.it);
+    return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName) : null;
+  }
+  _rValComp(stack, val, comp, node, key, viewName) {
+    const cacheKey = `${viewName ?? stack.viewsId ?? ""}-${key}`;
+    const cachePath = [node, val];
+    stack._pushDynBindValuesToArray(cachePath, comp);
+    const cachedNode = this.cache.get(cachePath, cacheKey);
+    if (cachedNode)
+      return cachedNode;
+    const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
+    const meta = this._renderMetadata({
+      $: "Comp",
+      nid: node?.nodeId ?? null,
+      cid: comp.id,
+      vid: view.name
+    });
+    const dom = new VFragment([meta, this.renderView(view, stack)]);
+    this.cache.set(cachePath, cacheKey, dom);
+    return dom;
+  }
+  pushEachEntry(r, nid, attrName, key, dom) {
+    r.push(this._renderMetadata({ $: "Each", nid, [attrName]: key }), dom);
+  }
+  renderEach(stack, iterInfo, node, viewName) {
+    const { seq, filter, loopWith } = iterInfo.eval(stack);
+    const r = [];
+    const { iterData, start, end } = unpackLoopResult(loopWith.call(stack.it, seq), seq);
+    getSeqInfo(seq)(seq, (key, value, attrName) => {
+      if (filter.call(stack.it, key, value, iterData)) {
+        const dom = this.renderIt(stack.enter(value, { key }, true), node, key, viewName);
+        this.pushEachEntry(r, node.nodeId, attrName, key, dom);
+      }
+    }, start, end);
+    return r;
+  }
+  renderEachWhen(stack, iterInfo, view, nid) {
+    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
+    const r = [];
+    const it = stack.it;
+    const { iterData, start, end } = unpackLoopResult(loopWith.call(it, seq), seq);
+    getSeqInfo(seq)(seq, (key, value, attrName) => {
+      if (filter.call(it, key, value, iterData)) {
+        const cachePath = enricher ? [view, it, value] : [view, value];
+        const binds = { key, value };
+        const cacheKey = `${nid}-${key}`;
+        if (enricher)
+          enricher.call(it, binds, key, value, iterData);
+        const cachedNode = this.cache.get(cachePath, cacheKey);
+        if (cachedNode)
+          this.pushEachEntry(r, nid, attrName, key, cachedNode);
+        else {
+          const dom = this.renderView(view, stack.enter(value, binds, false));
+          this.pushEachEntry(r, nid, attrName, key, dom);
+          this.cache.set(cachePath, cacheKey, dom);
+        }
+      }
+    }, start, end);
+    return r;
+  }
+  renderView(view, stack) {
+    let n = stack.binds[1];
+    while (n !== null) {
+      const b = n[0];
+      if (b.isFrame) {
+        if (stack.it !== b.it)
+          break;
+        console.error("recursion detected", stack.it, b.it);
+        return new VComment("RECURSION AVOIDED");
+      }
+      n = n[1];
+    }
+    return view.render(stack, this);
+  }
+  _renderMetadata(info) {
+    return new VComment(`§${JSON.stringify(info)}§`);
+  }
+}
+var getSeqInfo = (seq) => isIndexed(seq) ? imIndexedIter : isKeyed(seq) ? imKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
+var normalizeRange = (start, end, size) => {
+  let s = start == null ? 0 : start < 0 ? size + start : start;
+  let e = end == null ? size : end < 0 ? size + end : end;
+  s = s < 0 ? 0 : s > size ? size : s;
+  e = e < 0 ? 0 : e > size ? size : e;
+  return [s, e < s ? s : e];
+};
+var filterAlwaysTrue = (_v, _k, _seq) => true;
+var nullLoopWith = (seq) => ({ iterData: { seq } });
+var unpackLoopResult = (result, seq) => {
+  const r = result ?? {};
+  return { iterData: r.iterData ?? { seq }, start: r.start, end: r.end };
+};
+var imIndexedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seq.size);
+  for (let i = s;i < e; i++)
+    visit(i, seq.get(i), "si");
+};
+var imKeyedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seq.size);
+  let i = 0;
+  for (const [k, v] of seq.toSeq().entries()) {
+    if (i >= e)
+      break;
+    if (i >= s)
+      visit(k, v, "sk");
+    i++;
+  }
+};
+var unkIter = () => {};
+var SEQ_INFO = Symbol.for("tutuca.seqInfo");
+
+// src/util/env.js
+var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
+
 // src/anode.js
 function resolveDynProducer(comp, name) {
   let producerComp, producerProvide;
@@ -1784,7 +2005,7 @@ class ANode extends BaseNode {
   }
 }
 function parseXOp(attrs, childs, opIdx, px) {
-  if (attrs.length === 0)
+  if (attrs.length <= opIdx)
     return maybeFragment(childs);
   const { name, value } = attrs[opIdx];
   const as = attrs.getNamedItem("as")?.value ?? null;
@@ -2105,8 +2326,6 @@ class IterInfo {
     return { seq, filter, loopWith, enricher };
   }
 }
-var filterAlwaysTrue = (_v, _k, _seq) => true;
-var nullLoopWith = (seq) => ({ iterData: { seq } });
 function xOp(consumed = [], { wrappable = false, wrapper = null } = {}) {
   return { consumed: new Set(consumed), wrappable, wrapper };
 }
@@ -2293,7 +2512,6 @@ class NodeEvent {
     return r;
   }
 }
-var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
 var fwdIfCtxPred = (pred) => (w) => (that, f, args, ctx) => pred(ctx) ? w(that, f, args, ctx) : that;
 var fwdIfKey = (keyName) => fwdIfCtxPred((ctx) => ctx.e.key === keyName);
 var fwdCtrl = fwdIfCtxPred(({ e }) => isMac && e.metaKey || e.ctrlKey);
@@ -2801,7 +3019,6 @@ class Transaction {
     return null;
   }
 }
-var isMac2 = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
 var toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
 function getValue(e) {
   return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
@@ -2855,7 +3072,7 @@ class InputEvent extends Transaction {
         return e.shiftKey;
       case "isCtrl":
       case "isCmd":
-        return isMac2 && e.metaKey || e.ctrlKey;
+        return isMac && e.metaKey || e.ctrlKey;
       case "key":
         return e.key;
       case "keyCode":
@@ -3335,18 +3552,82 @@ class ParseCtxClassSetCollector extends ParseContext {
     return false;
   }
 }
+function collectAppClassesInSet(app) {
+  const classes = new Set;
+  for (const Comp of app.comps.byId.values()) {
+    for (const key in Comp.views) {
+      const view = Comp.views[key];
+      for (const name of view.ctx.classes) {
+        classes.add(name);
+      }
+    }
+  }
+  return classes;
+}
 
-// extra/klist.js
-import { Map as IMap2, List as List2 } from "immutable";
-
-// src/oo.js
-import { Map as IMap, Set as ISet, List, OrderedMap, Record } from "immutable";
-var BAD_VALUE = Symbol("BadValue");
-var nullCoercer = (v) => v;
-
-class Field {
-  constructor(type, name, typeCheck, coercer, defaultValue = null) {
-    this.type = type;
+// index.js
+import {
+  Collection,
+  fromJS,
+  get,
+  getIn,
+  has,
+  hash,
+  hasIn,
+  is as is2,
+  isAssociative,
+  isCollection,
+  isImmutable,
+  isIndexed as isIndexed2,
+  isKeyed as isKeyed2,
+  isList,
+  isMap,
+  isMap as isMap2,
+  isOrdered,
+  isOrderedMap,
+  isOrderedMap as isOrderedMap2,
+  isOrderedSet,
+  isPlainObject,
+  isRecord,
+  isSeq,
+  isSet,
+  isStack,
+  isValueObject,
+  List as List2,
+  Map as Map2,
+  Map as Map3,
+  merge,
+  mergeDeep,
+  mergeDeepWith,
+  mergeWith,
+  OrderedMap as OrderedMap2,
+  OrderedMap as OrderedMap3,
+  OrderedSet,
+  PairSorting,
+  Range,
+  Record as Record2,
+  Repeat,
+  remove,
+  removeIn,
+  Seq,
+  Set as Set2,
+  Set as Set3,
+  Stack as Stack2,
+  set,
+  setIn,
+  update,
+  updateIn,
+  version
+} from "immutable";
+
+// src/oo.js
+import { Map as IMap, Set as ISet, List, OrderedMap, Record } from "immutable";
+var BAD_VALUE = Symbol("BadValue");
+var nullCoercer = (v) => v;
+
+class Field {
+  constructor(type, name, typeCheck, coercer, defaultValue = null) {
+    this.type = type;
     this.name = name;
     this.typeCheck = typeCheck;
     this.coercer = coercer;
@@ -3606,8 +3887,8 @@ class FieldSet extends Field {
   }
 }
 function mkCompField(field, scope, args) {
-  const Comp = scope.lookupComponent(field.type);
-  console.assert(Comp !== null, "component not found", { field });
+  const Comp = scope?.lookupComponent(field.type) ?? null;
+  console.assert(!scope || Comp !== null, "component not found", { field });
   return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
 }
 
@@ -3724,378 +4005,7 @@ function classFromData(name, { fields = {}, methods, statics }) {
 Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
 var component = (opts) => Component.fromSpec(opts);
 
-// src/renderer.js
-import { isIndexed, isKeyed } from "immutable";
-
-// src/cache.js
-class NullDomCache {
-  get(_keys, _cacheKey) {}
-  set(_keys, _cacheKey, _v) {}
-  evict() {
-    return { hit: 0, miss: 0, badKey: 0 };
-  }
-}
-
-class WeakMapDomCache {
-  constructor() {
-    this.hit = this.miss = this.badKey = 0;
-    this.keysByLen = new Map;
-  }
-  _returnValue(r) {
-    if (r === undefined)
-      this.miss += 1;
-    else
-      this.hit += 1;
-    return r;
-  }
-  get(keys, cacheKey) {
-    const len = keys.length;
-    let cur = this.keysByLen.get(len);
-    if (!cur)
-      return this._returnValue(undefined);
-    for (let i = 0;i < len - 1; i++) {
-      cur = cur.get(keys[i]);
-      if (!cur)
-        return this._returnValue(undefined);
-    }
-    return this._returnValue(cur.get(keys[len - 1])?.[cacheKey]);
-  }
-  set(keys, cacheKey, v) {
-    const len = keys.length;
-    let cur = this.keysByLen.get(len);
-    if (!cur) {
-      cur = new WeakMap;
-      this.keysByLen.set(len, cur);
-    }
-    for (let i = 0;i < len - 1; i++) {
-      const key = keys[i];
-      let next = cur.get(key);
-      if (!next) {
-        if (typeof key !== "object") {
-          this.badKey += 1;
-          return;
-        }
-        next = new WeakMap;
-        cur.set(key, next);
-      }
-      cur = next;
-    }
-    const lastKey = keys[len - 1];
-    const leaf = cur.get(lastKey);
-    if (leaf)
-      leaf[cacheKey] = v;
-    else if (typeof lastKey === "object")
-      cur.set(lastKey, { [cacheKey]: v });
-    else
-      this.badKey += 1;
-  }
-  evict() {
-    const { hit, miss, badKey } = this;
-    this.hit = this.miss = this.badKey = 0;
-    this.keysByLen = new Map;
-    return { hit, miss, badKey };
-  }
-}
-
-// src/renderer.js
-var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
-
-class Renderer {
-  constructor(comps) {
-    this.comps = comps;
-    this.cache = new WeakMapDomCache;
-    this.renderTag = h;
-  }
-  renderFragment(childs) {
-    return new VFragment(childs);
-  }
-  renderComment(text) {
-    return new VComment(text);
-  }
-  setNullCache() {
-    this.cache = new NullDomCache;
-  }
-  renderToDOM(stack, val) {
-    const rootNode = document.createElement("div");
-    const rOpts = { document };
-    render(h("DIV", null, [this.renderRoot(stack, val)]), rootNode, rOpts);
-    return rootNode.childNodes[0];
-  }
-  renderToString(stack, val, cleanAttrs = true) {
-    const dom = this.renderToDOM(stack, val);
-    if (cleanAttrs) {
-      const nodes = dom.querySelectorAll("[data-nid],[data-cid],[data-eid]");
-      for (const { dataset } of nodes)
-        for (const name of DATASET_ATTRS)
-          delete dataset[name];
-    }
-    return dom.innerHTML;
-  }
-  renderRoot(stack, val, viewName = null) {
-    const comp = this.comps.getCompFor(val);
-    if (comp === null)
-      return null;
-    return this._rValComp(stack, val, comp, comp.getView(viewName).anode, "ROOT", viewName);
-  }
-  renderIt(stack, node, key, viewName) {
-    const comp = this.comps.getCompFor(stack.it);
-    return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName) : null;
-  }
-  _rValComp(stack, val, comp, node, key, viewName) {
-    const cacheKey = `${viewName ?? stack.viewsId ?? ""}-${key}`;
-    const cachePath = [node, val];
-    stack._pushDynBindValuesToArray(cachePath, comp);
-    const cachedNode = this.cache.get(cachePath, cacheKey);
-    if (cachedNode)
-      return cachedNode;
-    const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
-    const meta = this._renderMetadata({
-      $: "Comp",
-      nid: node?.nodeId ?? null,
-      cid: comp.id,
-      vid: view.name
-    });
-    const dom = new VFragment([meta, this.renderView(view, stack)]);
-    this.cache.set(cachePath, cacheKey, dom);
-    return dom;
-  }
-  pushEachEntry(r, nid, attrName, key, dom) {
-    r.push(this._renderMetadata({ $: "Each", nid, [attrName]: key }), dom);
-  }
-  renderEach(stack, iterInfo, node, viewName) {
-    const { seq, filter, loopWith } = iterInfo.eval(stack);
-    const r = [];
-    const { iterData, start, end } = unpackLoopResult(loopWith.call(stack.it, seq), seq);
-    getSeqInfo(seq)(seq, (key, value, attrName) => {
-      if (filter.call(stack.it, key, value, iterData)) {
-        const dom = this.renderIt(stack.enter(value, { key }, true), node, key, viewName);
-        this.pushEachEntry(r, node.nodeId, attrName, key, dom);
-      }
-    }, start, end);
-    return r;
-  }
-  renderEachWhen(stack, iterInfo, view, nid) {
-    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
-    const r = [];
-    const it = stack.it;
-    const { iterData, start, end } = unpackLoopResult(loopWith.call(it, seq), seq);
-    getSeqInfo(seq)(seq, (key, value, attrName) => {
-      if (filter.call(it, key, value, iterData)) {
-        const cachePath = enricher ? [view, it, value] : [view, value];
-        const binds = { key, value };
-        const cacheKey = `${nid}-${key}`;
-        if (enricher)
-          enricher.call(it, binds, key, value, iterData);
-        const cachedNode = this.cache.get(cachePath, cacheKey);
-        if (cachedNode)
-          this.pushEachEntry(r, nid, attrName, key, cachedNode);
-        else {
-          const dom = this.renderView(view, stack.enter(value, binds, false));
-          this.pushEachEntry(r, nid, attrName, key, dom);
-          this.cache.set(cachePath, cacheKey, dom);
-        }
-      }
-    }, start, end);
-    return r;
-  }
-  renderView(view, stack) {
-    let n = stack.binds[1];
-    while (n !== null) {
-      const b = n[0];
-      if (b.isFrame) {
-        if (stack.it !== b.it)
-          break;
-        console.error("recursion detected", stack.it, b.it);
-        return new VComment("RECURSION AVOIDED");
-      }
-      n = n[1];
-    }
-    return view.render(stack, this);
-  }
-  _renderMetadata(info) {
-    return new VComment(`§${JSON.stringify(info)}§`);
-  }
-}
-var getSeqInfo = (seq) => isIndexed(seq) ? imIndexedIter : isKeyed(seq) ? imKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
-var normalizeRange = (start, end, size) => {
-  let s = start == null ? 0 : start < 0 ? size + start : start;
-  let e = end == null ? size : end < 0 ? size + end : end;
-  s = s < 0 ? 0 : s > size ? size : s;
-  e = e < 0 ? 0 : e > size ? size : e;
-  return [s, e < s ? s : e];
-};
-var unpackLoopResult = (result, seq) => {
-  const r = result ?? {};
-  return { iterData: r.iterData ?? { seq }, start: r.start, end: r.end };
-};
-var imIndexedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seq.size);
-  for (let i = s;i < e; i++)
-    visit(i, seq.get(i), "si");
-};
-var imKeyedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seq.size);
-  let i = 0;
-  for (const [k, v] of seq.toSeq().entries()) {
-    if (i >= e)
-      break;
-    if (i >= s)
-      visit(k, v, "sk");
-    i++;
-  }
-};
-var unkIter = () => {};
-var SEQ_INFO = Symbol.for("tutuca.seqInfo");
-
-// extra/klist.js
-class KList {
-  constructor(items = IMap2(), order = List2()) {
-    this.items = items;
-    this.order = order;
-    this.$ = 0;
-  }
-  _clonish(items, order) {
-    return new KList(items, order, this.$);
-  }
-  toJS() {
-    return this.order.toArray().map((k) => this.items.get(k));
-  }
-  set(k, v) {
-    const newOrder = this.items.has(k) ? this.order : this.order.push(k);
-    return this._clonish(this.items.set(k, v), newOrder, this.$);
-  }
-  get(k, dval = null) {
-    return this.items.get(k, dval);
-  }
-  _nextFreeKey() {
-    let cur = this.$;
-    while (true) {
-      const key = `§${cur}§`;
-      if (!this.items.has(key)) {
-        return [key, cur];
-      }
-      cur += 1;
-    }
-  }
-  push(v) {
-    const [key, next$] = this._nextFreeKey();
-    const newKList = this.set(key, v);
-    newKList.$ = next$;
-    return newKList;
-  }
-  get size() {
-    return this.items.size;
-  }
-  delete(k) {
-    if (this.items.has(k)) {
-      const newOrder = this.order.delete(this.order.indexOf(k));
-      return this._clonish(this.items.delete(k), newOrder);
-    }
-    return this;
-  }
-  moveKeyBeforeKey(k1, k2) {
-    const { order } = this;
-    return this.moveKeyIndexToIndex(order.indexOf(k1), order.indexOf(k2), 0);
-  }
-  moveKeyAfterKey(k1, k2) {
-    const { order } = this;
-    return this.moveKeyIndexToIndex(order.indexOf(k1), order.indexOf(k2), 1);
-  }
-  moveKeyIndexToIndex(source, target, offset) {
-    if (source === -1 || target === -1 || source === target) {
-      return this;
-    }
-    const { order } = this;
-    const newPos = target + offset;
-    const oldPos = newPos < source ? source + 1 : source;
-    const newOrder = order.insert(newPos, order.get(source)).delete(oldPos);
-    return this._clonish(this.items, newOrder);
-  }
-}
-var klistCoercer = (_) => null;
-
-class CheckTypeKList {
-  isValid(v) {
-    return v instanceof KList;
-  }
-  getMessage(_v) {
-    return "KList expected";
-  }
-}
-var CHECK_TYPE_KLIST = new CheckTypeKList;
-
-class FieldKList extends Field {
-  constructor(name, defaultValue = new KList) {
-    super("KList", name, CHECK_TYPE_KLIST, klistCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    extendProtoForKeyed(proto, this.name, uname);
-    const { name } = this;
-    extendProtoForKeyed(proto, name, uname);
-    proto[`pushIn${uname}`] = function(v) {
-      return this.set(name, this.get(name).push(v));
-    };
-  }
-}
-KList.prototype[FIELD_CLASS] = FieldKList;
-KList.prototype[SEQ_INFO] = (seq, visit) => {
-  for (const k of seq.order)
-    visit(k, seq.items.get(k), "data-sk");
-};
 // index.js
-import {
-  Collection,
-  List as List3,
-  Map as Map2,
-  OrderedMap as OrderedMap2,
-  OrderedSet,
-  PairSorting,
-  Range,
-  Record as Record2,
-  Repeat,
-  Seq,
-  Set as Set2,
-  Stack as Stack2,
-  fromJS,
-  get,
-  getIn,
-  has,
-  hasIn,
-  hash,
-  is as is2,
-  isAssociative,
-  isCollection,
-  isImmutable,
-  isIndexed as isIndexed2,
-  isKeyed as isKeyed2,
-  isList,
-  isMap,
-  isOrdered,
-  isOrderedMap,
-  isOrderedSet,
-  isPlainObject,
-  isRecord,
-  isSeq,
-  isSet,
-  isStack,
-  isValueObject,
-  merge,
-  mergeDeep,
-  mergeDeepWith,
-  mergeWith,
-  remove,
-  removeIn,
-  set,
-  setIn,
-  update,
-  updateIn,
-  version,
-  isMap as isMap2,
-  isOrderedMap as isOrderedMap2,
-  Map as Map3,
-  OrderedMap as OrderedMap3,
-  Set as Set3
-} from "immutable";
 var css = String.raw;
 var html = String.raw;
 var macro = (defaults, rawView) => new Macro(defaults, rawView);
@@ -4127,15 +4037,7 @@ async function compileClassesToStyle(app, compileClasses, styleId = "margaui-css
 async function compileClassesToStyleText(app, compileClasses, Ctx = ParseCtxClassSetCollector) {
   app.ParseContext = Ctx;
   app.compile();
-  const classes = new Set;
-  for (const Comp of app.comps.byId.values()) {
-    for (const key in Comp.views) {
-      const view = Comp.views[key];
-      for (const name of view.ctx.classes)
-        classes.add(name);
-    }
-  }
-  return await compileClasses(Array.from(classes));
+  return await compileClasses(Array.from(collectAppClassesInSet(app)));
 }
 export {
   version,
@@ -4198,8 +4100,7 @@ export {
   OrderedMap2 as OrderedMap,
   OrderedMap3 as OMap,
   Map2 as Map,
-  List3 as List,
-  KList,
+  List2 as List,
   Set3 as ISet,
   Map3 as IMap,
   FIELD_CLASS,