malinajs 0.7.2-a5 → 0.7.2-a7

package/CHANGELOG.md

@@ -15,6 +15,7 @@
 * else-if
 * refactoring $onMount
 * optional deep checking for passed props: prop={value} prop|deep={value}
+* keep-alive
 
 ## 0.6.x
 

package/malina.js

@@ -713,6 +713,7 @@
           switch(node.type) {
             case 'node':
             case 'slot':
+            case 'block':
             case 'fragment':
               if(node.body) go(node.body, node);
               break
@@ -835,121 +836,103 @@
     go(data.body);
   }
 
-  function parse() {
-    let source = this.source;
-    let index = 0;
+  class Reader {
+    constructor(source) {
+      if(source instanceof Reader) return source;
+      this.index = 0;
+      this.source = source;
+    }
 
-    const readNext = () => {
-      assert(index < source.length, 'EOF');
-      return source[index++];
-    };
+    read(pattern) {
+      assert(!this.end(), 'EOF');
+      if(pattern == null) {
+        return this.source[this.index++];
+      } else if(pattern instanceof RegExp) {
+        assert(pattern.source[0] == '^');
+        const rx = this.source.substring(this.index).match(pattern);
+        assert(rx && rx.index == 0, 'Wrong syntax');
+        let r = rx[1] || rx[0];
+        this.index += rx[0].length;
+        return r;
+      } else throw 'Not implemented';
+    }
 
-    const probeNext = () => source[index];
+    probe(pattern) {
+      if(pattern instanceof RegExp) {
+        assert(pattern.source[0] == '^');
+        const r = this.source.substring(this.index).match(pattern);
+        if(r) return r[0];
+      } else {
+        if(this.source[this.index] == pattern[0] && this.source.substr(this.index, pattern.length) == pattern) return pattern;
+      }
+      return null;
+    }
 
-    const readTag = () => {
-      let start = index;
-      let a = readNext();
-      assert(a === '<', 'Tag error');
-      let attributes = [];
-      let begin = true;
-      let name = '';
-      let eq, attr_start;
-      let elArg = null;
+    probeQuote() {
+      const a = this.source[this.index];
+      return a == '"' || a == "'" || a == '`';
+    }
 
-      const error = (name) => {
-        let e = new Error(name);
-        e.details = source.substring(start, index);
-        throw e;
-      };
+    readIf(pattern) {
+      const r = this.probe(pattern);
+      if(r != null) this.index += r.length;
+      return r;
+    }
 
-      function flush(shift) {
-        if(!attr_start) return;
-        shift = shift || 0;
-        let end = index - 1 + shift;
-        if(elArg === true) {
-          elArg = source.substring(attr_start, end);
-          attr_start = null;
-          eq = null;
-          return;
-        }
-        let a = {
-          content: source.substring(attr_start, end)
-        };
-        if(eq) {
-          a.name = source.substring(attr_start, eq);
-          a.value = source.substring(eq + 1, end);
-          if(a.value[0] == '"' || a.value[0] == '\'') a.value = a.value.substring(1);
-          let i = a.value.length - 1;
-          if(a.value[i] == '"' || a.value[i] == '\'') a.value = a.value.substring(0, i);
-        } else a.name = a.content;
-        attributes.push(a);
-        attr_start = null;
-        eq = null;
+    end() {
+      return this.index >= this.source.length;
+    }
+
+    skip() {
+      while(!this.end()) {
+        if(!this.source[this.index].match(/\s/)) break;
+        this.index++;
       }
+    }
 
+    readString() {
+      let q = this.read();
+      assert(q == '"' || q == '`' || q == `'`, 'Wrong syntax');
+      let a = null, p, result = q;
       while(true) {
-        a = readNext();
-        if(!begin && !attr_start && a.match(/\S/) && a != '/' && a != '>') attr_start = index - 1;
-        if(a == '"' || a == "'" || a == '`') {
-          while(a != readNext());
-          continue;
-        }
-        if(a == '{') {
-          index--;
-          readBinding();
-          flush(1);
-          continue;
-        }
-        if(a == '}') error('Wrong attr');
-        if(a == '<') error('Wrong tag');
-        if(a == '/') {
-          a = readNext();
-          assert(a == '>');
-          flush(-1);
-        }
-        if(a == '>') {
-          flush();
-          const voidTags = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
-          let voidTag = voidTags.indexOf(name) >= 0;
-          let closedTag = voidTag || source[index - 2] == '/';
-          return {
-            type: 'node',
-            name,
-            elArg,
-            openTag: source.substring(start, index),
-            start: start,
-            end: index,
-            closedTag,
-            voidTag,
-            attributes
-          };
-        }
-        if(begin) {
-          if(a.match(/[\da-zA-Z^\-]/)) {
-            name += a;
-            continue;
-          } else {
-            begin = false;
-            if(a == ':') {
-              elArg = true;
-              attr_start = index;
-            }
-          }
-        } else if(attr_start) {
-          if(a == '=' && !eq) eq = index - 1;
-          else if(a.match(/\s/)) flush();
-        }
+        p = a;
+        a = this.read();
+        result += a;
+        if(a == q && p != '\\') break;
       }
-    };
+      return result;
+    }
+
+    readAttribute() {
+      let name = '';
+      while(true) {
+        if(this.end()) break;
+        let a = this.source[this.index];
+        if(a == '=' || a == '/' || a == '>' || a == '\t' || a == '\n' || a == '\v' || a == '\f' || a == '\r' || a == ' ' || a == ' ') break;
+        name += a;
+        this.index++;
+      }
+      assert(name, 'Syntax error');
+      return name;
+    }
+
+    sub(start, end) {
+      return this.source.substring(start, end || this.index);
+    }
+  }
+
+  function parseHTML(source) {
+    const reader = new Reader(source);
 
-    const readScript = (tag) => {
-      let endTag = `</${tag}>`;
-      let q, a, p, start = index;
+    const readScript = (reader) => {
+      const start = reader.index;
 
       const readRegExp = () => {
+        assert(reader.read() == '/');
+        let a, p, q;
         while(true) {
           p = a;
-          a = readNext();
+          a = reader.read();
           if(q) {
             if(a != q) continue;
             if(p == '\\') continue;
@@ -962,108 +945,40 @@
       };
 
       while(true) {
-        p = a;
-        a = readNext();
-        if(q) {
-          if(a != q) continue;
-          if(p == '\\') continue;
-          q = null;
+        if(reader.probeQuote()) {
+          reader.readString();
           continue;
         }
-        if(a == '"' || a == '\'' || a == '`') {
-          q = a;
-          continue;
-        }
-        if(a == '/') {
-          let n = probeNext();
-          if(n == '/') {  // inline comment
-            while(readNext() != '\n');
-            a = null;
-            continue
+        if(reader.probe('/')) {
+          if(reader.readIf('//')) {
+            while(reader.read() != '\n');
+            continue;
           }
-          if(n == '*') {
-            readNext();
-            while(true) {  // multiline comment
-              if(readNext() == '*' && probeNext() == '/') break;
+          if(reader.readIf('/*')) {
+            while(true) {
+              if(reader.read() == '*' && reader.readIf('/')) break;
             }
-            readNext();
-            a = null;
             continue;
           }
           readRegExp();
           continue;
         }
-        if(a == '<') {
-          if(source.substring(index - 1, index + endTag.length - 1) == endTag) {
-            let end = index - 1;
-            index += endTag.length - 1;
-            return source.substring(start, end);
-          }
-        }
+        if(reader.readIf('</script>')) {
+          return reader.sub(start, reader.index - 9);
+        } else reader.read();
       }
     };
 
     const readStyle = () => {
-      let start = index;
-      let end = source.substring(start).indexOf('</style>') + start;
-      assert(end >= 0, '<style> is not closed');
-      index = end + 9;
-      return source.substring(start, end);
+      return reader.read(/^(.*?)<\/style>/s);
     };
 
-    const readBinding = () => {
-      let start = index;
-      assert(readNext() === '{', 'Bind error');
-      let a = null, p, q;
-      let bkt = 1;
-
-      while(true) {
-        p = a;
-        a = readNext();
-
-        if(q) {
-          if(a != q) continue;
-          if(p == '\\') continue;
-          q = null;
-          continue;
-        }
-        if(a == '"' || a == "'" || a == '`') {
-          q = a;
-          continue;
-        }
-        if(a == '*' && p == '/') {
-          // comment block
-          while(true) {
-            p = a;
-            a = readNext();
-            if(a == '/' && p == '*') break;
-          }
-          continue;
-        }
-
-        if(a == '{') {
-          bkt++;
-          continue;
-        }
-        if(a == '}') {
-          bkt--;
-          if(bkt > 0) continue;
-        } else continue;
-
-        return {
-          value: source.substring(start + 1, index - 1),
-          raw: source.substring(start, index)
-        };
-      }
+    const readComment = () => {
+      return reader.read(/^<!--.*?-->/s);
     };
 
-    const readComment = () => {
-      let start = index;
-      let end = source.indexOf('-->', start);
-      assert(end >= 0, 'Comment is not closed');
-      end += 3;
-      index = end;
-      return source.substring(start, end);
+    const readTemplate = () => {
+      return reader.read(/^(.*?)<\/template>/s);
     };
 
     const go = (parent, push) => {
@@ -1086,12 +1001,11 @@
         textNode = null;
       };
 
-      while(index < source.length) {
-        let a = source[index];
-        if(a === '<' && source[index + 1].match(/\S/)) {
+      while(!reader.end()) {
+        if(reader.probe('<') && reader.probe(/^<\S/)) {
           flushText();
 
-          if(source.substring(index, index + 4) === '<!--') {
+          if(reader.probe('<!--')) {
             push({
               type: 'comment',
               content: readComment()
@@ -1099,14 +1013,8 @@
             continue;
           }
 
-          if(source[index + 1] === '/') { // close tag
-            let name = '';
-            index += 2;
-            while(true) {
-              a = readNext();
-              if(a === '>') break;
-              name += a;
-            }
+          if(reader.readIf('</')) { // close tag
+            let name = reader.read(/^([^>]*)>/);
             name = name.trim();
             if(name) {
               name = name.split(':')[0];
@@ -1115,15 +1023,15 @@
             return;
           }
 
-          let tag = readTag();
+          let tag = readTag(reader);
           push(tag);
           if(tag.name === 'script') {
             tag.type = 'script';
-            tag.content = readScript('script');
+            tag.content = readScript(reader);
             continue;
           } else if(tag.name === 'template') {
             tag.type = 'template';
-            tag.content = readScript('template');
+            tag.content = readTemplate();
             continue;
           } else if(tag.name === 'style') {
             tag.type = 'style';
@@ -1144,9 +1052,9 @@
             throw e;
           }
           continue;
-        } else if(a === '{') {
-          if(['#', '/', ':', '@', '*'].indexOf(source[index + 1]) >= 0) {
-            let bind = readBinding();
+        } else if(reader.probe('{')) {
+          if(reader.probe(/^\{[#/:@*]/)) {
+            let bind = parseBinding(reader);
             if(bind.value[0] != '*') flushText();
             if(bind.value[0] == '*') {
               addText(bind.raw);
@@ -1245,14 +1153,29 @@
             } else if(bind.value == '/fragment') {
               assert(parent.type === 'fragment', 'Fragment error: /fragment');
               return;
+            } else if(bind.value.match(/^#([\w\-]+)/)) {
+              const name = bind.value.match(/^#([\w\-]+)/)[1];
+              let tag = {
+                type: 'block',
+                value: bind.value,
+                name,
+                body: []
+              };
+              push(tag);
+              go(tag);
+              continue;
+            } else if(bind.value.match(/^\/([\w\-]+)/)) {
+              const name = bind.value.match(/^\/([\w\-]+)/)[1];
+              assert(parent.type === 'block' && parent.name == name, `Fragment error: ${parent.name} - ${name}`);
+              return;
             } else throw 'Error binding: ' + bind.value;
           } else {
-              addText(readBinding().raw);
-              continue;
+            addText(parseBinding(reader).raw);
+            continue;
           }
         }
 
-        addText(readNext());
+        addText(reader.read());
       }
       flushText();
       assert(parent.type === 'root', 'File ends to early');
@@ -1264,9 +1187,41 @@
     };
     go(root);
 
-    this.DOM = root;
+    return root;
   }
 
+  function readTag(reader) {
+    const start = reader.index;
+    assert(reader.read() === '<', 'Tag error');
+
+    let name = reader.read(/^[\da-zA-Z^\-]+/);
+    let elArg = null;
+
+    if(reader.readIf(':')) {
+      elArg = reader.read(/^[^\s>/]+/);
+    }
+
+    let attributes = parseAttibutes(reader, {closedByTag: true});
+
+    let closedTag = false;
+    if(reader.readIf('/>')) closedTag = true;
+    else assert(reader.readIf('>'));
+
+    const voidTags = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+    let voidTag = voidTags.indexOf(name) >= 0;
+    if(voidTag) closedTag = true;
+    return {
+      type: 'node',
+      name,
+      elArg,
+      openTag: reader.sub(start),
+      start: start,
+      end: reader.index,
+      closedTag,
+      voidTag,
+      attributes
+    };
+  }
 
   function parseText(source) {
     let i = 0;
@@ -1336,7 +1291,107 @@
     return { result, parts, staticText };
   }
 
-  function parse$1() {
+
+  const parseBinding = (reader) => {
+    let start = reader.index;
+
+    assert(reader.read() === '{', 'Bind error');
+    let a = null, p, q;
+    let bkt = 1;
+
+    while(true) {
+      p = a;
+      a = reader.read();
+
+      if(q) {
+        if(a != q) continue;
+        if(p == '\\') continue;
+        q = null;
+        continue;
+      }
+      if(a == '"' || a == "'" || a == '`') {
+        q = a;
+        continue;
+      }
+      if(a == '*' && p == '/') {
+        // comment block
+        while(true) {
+          p = a;
+          a = reader.read();
+          if(a == '/' && p == '*') break;
+        }
+        continue;
+      }
+
+      if(a == '{') {
+        bkt++;
+        continue;
+      }
+      if(a == '}') {
+        bkt--;
+        if(bkt > 0) continue;
+      } else continue;
+
+      const raw = reader.sub(start);
+      return {
+        raw,
+        value: raw.substring(1, raw.length - 1),
+      };
+    }
+  };
+
+
+  const parseAttibutes = (source, option={}) => {
+    const r = new Reader(source);
+    let result = [];
+
+    while(!r.end()) {
+      r.skip();
+      if(option.closedByTag) {
+        if(r.probe('/>') || r.probe('>')) break;
+      } else if(r.end()) break;
+      let start = r.index;
+      if(r.probe('{*')) {
+        const {raw} = parseBinding(r);
+        result.push({name: raw, content: raw});
+      } else if(r.probe('*{')) {
+        r.read();
+        let {raw} = parseBinding(r);
+        raw = '*' + raw;
+        result.push({name: raw, content: raw});
+      } else if(r.probe('{...')) {
+        let {raw} = parseBinding(r);
+        result.push({name: raw, content: raw});
+      } else {
+        let name = r.readAttribute();
+        assert(name, 'Wrong syntax');
+        if(r.readIf('=')) {
+          if(r.probe('{')) {
+            const {raw} = parseBinding(r);
+            result.push({name, value: raw, raw, content: r.sub(start)});
+          } else if(r.probeQuote()) {
+            const raw = r.readString();
+            const value = raw.substring(1, raw.length - 1);
+            result.push({name, value, raw, content: r.sub(start)});
+          } else {
+            const value = r.readIf(/^\S+/);
+            result.push({name, value, raw: value, content: r.sub(start)});
+          }
+        } else {
+          let value;
+          if(name[0] == '{' && last(name) == '}' && !name.startsWith('{...')) {
+            value = name;
+            name = unwrapExp(name);
+          }
+          result.push({name, value, raw: value, content: r.sub(start)});
+        }
+      }
+    }
+
+    return result;
+  };
+
+  function parse() {
     let source = this.scriptNodes.length ? this.scriptNodes[0].content : null;
     this.script = {
       source,
@@ -1820,6 +1875,12 @@
       }
     }));
 
+    this.module.head.push(this.glob.keepAliveStore = xNode('$$keepAliveStore', {
+      value: false
+    }, (ctx, n) => {
+      if(n.value) ctx.write(true, `const $$keepAliveStore = new Map();`);
+    }));
+
     this.module.top.push(xNode(this.glob.$onMount, {
     }, (ctx, n) => {
       if(n.value) ctx.write(true, `import { $onMount } from 'malinajs/runtime.js';`);
@@ -2257,6 +2318,20 @@
           if(!n.closedTag) {
             go(n, false, el);
           }
+        } else if(n.type === 'block') {
+          if(n.name == 'keep') {
+            if(isRoot) requireFragment = true;
+            binds.push(xNode('attach-fragment', {
+              label: requireLabel(),
+              block: this.makeKeepAlive(n)
+            }, (ctx, n) => {
+              if(n.label.node) ctx.write(true, `$runtime.insertBlock(${n.label.name}, `);
+              else ctx.write(true, `$runtime.addBlock(${n.label.name}, `);
+              ctx.add(n.block);
+              ctx.write(')');
+            }));
+            return;
+          } else wrapException(`wrong block: "${n.name}"`, n);
         } else if(n.type === 'each') {
           if(data.type == 'node' && data.body.length == 1) {
             let eachBlock = this.makeEachBlock(n, {
@@ -2563,7 +2638,7 @@
       console.log('Node: ', n);
       if(n.type == 'text') e.details = n.value.trim();
       else if(n.type == 'node') e.details = n.openTag.trim();
-      else if(n.type == 'each') e.details = n.value.trim();
+      else if(n.type == 'each' || n.type == 'block') e.details = n.value.trim();
       else if(n.type == 'if') e.details = n.parts?.[0]?.value.trim() || 'if-block';
     }
     throw e;
@@ -4690,7 +4765,7 @@
   function makeDom(data) {
     function build(parent, list) {
       list.forEach(e => {
-        if(e.type == 'fragment' || e.type == 'slot') {
+        if(e.type == 'fragment' || e.type == 'slot' || e.type == 'block') {
           if(e.body && e.body.length) build(parent, e.body);
           return;
         } else if(e.type == 'each') {
@@ -6109,7 +6184,7 @@
   }
 
 
-  function parseAttibutes(attributes) {
+  function parseAttibutes$1(attributes) {
     let props = [];
     let events = [];
     let forwardAllEvents;
@@ -6154,7 +6229,7 @@
     let slot = null;
     if(node.body?.length) slot = this.buildBlock({ body: trimEmptyNodes(node.body) }, { inline: true });
 
-    let { props, events, forwardAllEvents, staticProps } = parseAttibutes.call(this, node.attributes);
+    let { props, events, forwardAllEvents, staticProps } = parseAttibutes$1.call(this, node.attributes);
 
     return xNode('call-fragment', {
       $compile: [slot?.source],
@@ -6254,7 +6329,7 @@
       // assert(!data.slot.template.svg, 'SVG is not supported for exported fragment');
     }
 
-    let pa = parseAttibutes.call(this, node.attributes);
+    let pa = parseAttibutes$1.call(this, node.attributes);
     data = { ...pa, ...data };
 
     return xNode('attach-exported-fragment', data, (ctx, n) => {
@@ -6638,7 +6713,44 @@
     return { event, fn, rootModifier };
   }
 
-  const version = '0.7.2-a5';
+  function makeKeepAlive(node) {
+    let block;
+    if(node.body && node.body.length) {
+      block = this.buildBlock({ body: trimEmptyNodes(node.body) }, { }).block;
+    } else {
+      this.warning(`Empty block: '${node.value}'`);
+      return xNode('empty-block', (ctx, n) => {
+        ctx.writeLine(`function $block() {};`);
+      });
+    }
+
+    let key = null;
+    let args = node.value.substr(6);
+    if(args) {
+      args = parseAttibutes(args);
+      const a = args.find(a => a.name == 'key');
+      if(a) {
+        let value = a.value;
+        if(value[0] == '{') value = unwrapExp(value);
+        key = `() => (${value})`;
+      }
+    }
+
+    if(!key) key = `() => '$$${this.uniqIndex++}'`;
+
+    this.glob.keepAliveStore.$value();
+
+    return xNode('keep-alive', {
+      block,
+      key
+    }, (ctx, n) => {
+      ctx.write(`$runtime.keepAlive($$keepAliveStore, ${n.key}, `);
+      ctx.add(n.block);
+      ctx.write(')');
+    });
+  }
+
+  const version = '0.7.2-a7';
 
 
   async function compile(source, config = {}) {
@@ -6684,6 +6796,7 @@
       inspectProp,
       attachPortal,
       makeEventProp,
+      makeKeepAlive,
       checkRootName: checkRootName,
 
       inuse: {},
@@ -6713,12 +6826,14 @@
       detectDependency,
 
       DOM: null,
-      parseHTML: parse,
+      parseHTML: function() {
+        this.DOM = parseHTML(this.source);
+      },
       compactDOM,
 
       script: null,
       scriptNodes: null,
-      js_parse: parse$1,
+      js_parse: parse,
       js_transform: transform,
 
       styleNodes: null,
@@ -6878,6 +6993,7 @@
   }
 
   exports.compile = compile;
+  exports.parseHTML = parseHTML;
   exports.version = version;
 
   Object.defineProperty(exports, '__esModule', { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "malinajs",
-  "version": "0.7.2-a5",
+  "version": "0.7.2-a7",
   "license": "MIT",
   "scripts": {
     "prepare": "npm run build",

package/runtime.js

@@ -1247,4 +1247,42 @@ const makeSlot = (fr, fn) => {
   };
 };
 
-export { $$eachBlock, $context, $digest, $onDestroy, $onMount, $tick, $watch, WatchObject, __app_onerror, __bindActionSubscribe, addBlock, addClass, addEvent, addStyles, attachAnchor, attachBlock, attachDynComponent, autoSubscribe, awaitBlock, bindAction, bindAttribute, bindAttributeBase, bindClass, bindClassExp, bindInput, bindStyle, bindText, callComponent, callComponentDyn, callExportedFragment, cd_attach, cd_component, cd_detach, cd_new, cloneDeep, compareArray, compareDeep, configure, createTextNode, current_cd, current_component, current_destroyList, current_mountList, deepComparator, destroyResults, eachDefaultKey, exportFragment, fire, htmlBlock, htmlBlockStatic, htmlToFragment, htmlToFragmentClean, ifBlock, ifBlockReadOnly, insertAfter, insertBlock, invokeSlot, invokeSlotBase, isArray, isFunction, iterNodes, keyComparator, makeAnchor, makeApply, makeBlock, makeBlockBound, makeClassResolver, makeComponent, makeEachBlock, makeEachElseBlock, makeEachSingleBlock, makeEmitter, makeExternalProperty, makeRootEvent, makeSlot, mergeAllEvents, mergeEvents, mount, mountStatic, noop, prefixPush, refer, removeElements, removeItem, setClassToElement, spreadAttributes, svgToFragment, unwrapProps };
+const keepAlive = (store, keyFn, builder) => {
+  if(!store.$$d) store.$$d = [];
+  const key = keyFn();
+  let block = store.get(key);
+  const parentCD = current_cd;
+
+  $onDestroy(() => {
+    if(!block.fr) block.fr = new DocumentFragment();
+    iterNodes(block.first, block.last, n => block.fr.appendChild(n));
+    cd_detach(block.$cd);
+  });
+
+  if(block) {
+    cd_attach(parentCD, block.$cd);
+    return block.fr;
+  } else {
+    let $dom, first, last, prev_destroyList = current_destroyList;
+    let destroyList = current_destroyList = [];
+    let $cd = current_cd = cd_new(parentCD);
+    try {
+      $dom = builder();
+    } finally {
+      current_destroyList = prev_destroyList;
+      current_cd = parentCD;
+    }
+    cd_attach(parentCD, $cd);
+    if($dom.nodeType == 11) {
+      first = $dom.firstChild;
+      last = $dom.lastChild;
+    } else first = last = $dom;
+
+    store.$$d.push(() => safeGroupCall(destroyList));
+    store.set(key, block = {first, last, $cd});
+
+    return $dom;
+  }
+};
+
+export { $$eachBlock, $context, $digest, $onDestroy, $onMount, $tick, $watch, WatchObject, __app_onerror, __bindActionSubscribe, addBlock, addClass, addEvent, addStyles, attachAnchor, attachBlock, attachDynComponent, autoSubscribe, awaitBlock, bindAction, bindAttribute, bindAttributeBase, bindClass, bindClassExp, bindInput, bindStyle, bindText, callComponent, callComponentDyn, callExportedFragment, cd_attach, cd_component, cd_detach, cd_new, cloneDeep, compareArray, compareDeep, configure, createTextNode, current_cd, current_component, current_destroyList, current_mountList, deepComparator, destroyResults, eachDefaultKey, exportFragment, fire, htmlBlock, htmlBlockStatic, htmlToFragment, htmlToFragmentClean, ifBlock, ifBlockReadOnly, insertAfter, insertBlock, invokeSlot, invokeSlotBase, isArray, isFunction, iterNodes, keepAlive, keyComparator, makeAnchor, makeApply, makeBlock, makeBlockBound, makeClassResolver, makeComponent, makeEachBlock, makeEachElseBlock, makeEachSingleBlock, makeEmitter, makeExternalProperty, makeRootEvent, makeSlot, mergeAllEvents, mergeEvents, mount, mountStatic, noop, prefixPush, refer, removeElements, removeItem, setClassToElement, spreadAttributes, svgToFragment, unwrapProps };