// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`Cascading renders after microtaskTick 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, withKey } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    let b3 = text(\` _ \`);
    ctx = Object.create(ctx);
    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['state']);
    for (let i1 = 0; i1 < l_block4; i1++) {
      ctx[\`elem\`] = v_block4[i1];
      let key1 = ctx['elem'].id;
      c_block4[i1] = withKey(text(ctx['elem'].id), key1);
    }
    let b4 = list(c_block4);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`Cascading renders after microtaskTick 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, withKey } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['state']);
    for (let i1 = 0; i1 < l_block1; i1++) {
      ctx[\`elem\`] = v_block1[i1];
      let key1 = ctx['elem'].id;
      c_block1[i1] = withKey(component(\`Element\`, {id: ctx['elem'].id}, key + \`__1__\${key1}\`, node, ctx), key1);
    }
    return list(c_block1);
  }
}"
`;

exports[`Cascading renders after microtaskTick 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].id);
  }
}"
`;

exports[`async rendering destroying a widget before start is over 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`calling render in destroy 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const tKey_1 = ctx['key'];
    return toggler(tKey_1, component(\`B\`, {fromA: ctx['state']}, tKey_1 + key + \`__1\`, node, ctx));
  }
}"
`;

exports[`calling render in destroy 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`C\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`calling render in destroy 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    return block1([txt1]);
  }
}"
`;

exports[`change state and call manually render: no unnecessary rendering 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['value'];
    return block1([txt1]);
  }
}"
`;

exports[`changing state before first render does not trigger a render (with parent) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['state'].flag) {
      b2 = component(\`TestW\`, {}, key + \`__1\`, node, ctx);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`changing state before first render does not trigger a render (with parent) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['value'];
    return block1([txt1]);
  }
}"
`;

exports[`changing state before first render does not trigger a render 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['value'];
    return block1([txt1]);
  }
}"
`;

exports[`concurrent renderings scenario 1 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 1 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 1 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/><block-text-1/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['someValue']();
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 2 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['state'].fromA;
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([txt1], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 2 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 2 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/><block-text-1/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['props'].fromB;
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 2bis 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 2bis 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 2bis 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/><block-text-1/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['props'].fromB;
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 3 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 3 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 3 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 3 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<i><block-text-0/><block-text-1/></i>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['someValue']();
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 4 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 4 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 4 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 4 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<i><block-text-0/><block-text-1/></i>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['someValue']();
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 5 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 5 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-text-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['someValue']();
    return block1([txt1]);
  }
}"
`;

exports[`concurrent renderings scenario 6 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 6 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-text-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['someValue']();
    return block1([txt1]);
  }
}"
`;

exports[`concurrent renderings scenario 7 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 7 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-text-0/><block-text-1/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['someValue']();
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 8 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 8 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-text-0/><block-text-1/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['state'].fromB;
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 9 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['state'].fromA;
    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    let b3 = component(\`ComponentC\`, {fromA: ctx['state'].fromA}, key + \`__2\`, node, ctx);
    return block1([txt1], [b2, b3]);
  }
}"
`;

exports[`concurrent renderings scenario 9 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<b><block-text-0/></b>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    return block1([txt1]);
  }
}"
`;

exports[`concurrent renderings scenario 9 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 9 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/><block-text-1/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['props'].fromC;
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 10 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ComponentB\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 10 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['state'].hasChild) {
      b2 = component(\`ComponentC\`, {value: ctx['props'].value}, key + \`__1\`, node, ctx);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 10 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['value'];
    return block1([txt1]);
  }
}"
`;

exports[`concurrent renderings scenario 11 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 11 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/>|<block-text-1/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    let txt2 = ctx['val'];
    return block1([txt1, txt2]);
  }
}"
`;

exports[`concurrent renderings scenario 12 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 12 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`concurrent renderings scenario 13 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    if (ctx['state'].bool) {
      b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`concurrent renderings scenario 13 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['state'].val;
    return block1([txt1]);
  }
}"
`;

exports[`concurrent renderings scenario 14 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 14 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`C\`, {fromB: ctx['state'].fromB, fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 14 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><span><block-text-0/></span><span><block-text-1/></span><span><block-text-2/></span></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['props'].fromB;
    let txt3 = ctx['state'].fromC;
    return block1([txt1, txt2, txt3]);
  }
}"
`;

exports[`concurrent renderings scenario 15 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 15 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><block-child-0/></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`C\`, {fromB: ctx['state'].fromB, fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`concurrent renderings scenario 15 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p><span><block-text-0/></span><span><block-text-1/></span><span><block-text-2/></span></p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].fromA;
    let txt2 = ctx['props'].fromB;
    let txt3 = ctx['state'].fromC;
    return block1([txt1, txt2, txt3]);
  }
}"
`;

exports[`concurrent renderings scenario 16 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`concurrent renderings scenario 16 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`C\`, {fromB: ctx['state'].fromB, fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`concurrent renderings scenario 16 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3,b4,b5,b6,b7,b8;
    b2 = text(ctx['props'].fromA);
    b3 = text(\`:\`);
    b4 = text(ctx['props'].fromB);
    b5 = text(\`:\`);
    b6 = text(ctx['state'].fromC);
    b7 = text(\`: \`);
    if (ctx['state'].fromC===13) {
      b8 = component(\`D\`, {}, key + \`__1\`, node, ctx);
    }
    return multi([b2, b3, b4, b5, b6, b7, b8]);
  }
}"
`;

exports[`concurrent renderings scenario 16 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`D\`);
  }
}"
`;

exports[`creating two async components, scenario 1 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['state'].flagA) {
      b2 = component(\`ChildA\`, {}, key + \`__1\`, node, ctx);
    }
    if (ctx['state'].flagB) {
      b3 = component(\`ChildB\`, {}, key + \`__2\`, node, ctx);
    }
    return multi([b2, b3]);
  }
}"
`;

exports[`creating two async components, scenario 1 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['getValue']();
    return block1([txt1]);
  }
}"
`;

exports[`creating two async components, scenario 1 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>b</span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`creating two async components, scenario 2 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
    if (ctx['state'].flagB) {
      b3 = component(\`ChildB\`, {val: ctx['state'].valB}, key + \`__2\`, node, ctx);
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`creating two async components, scenario 2 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>a<block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`creating two async components, scenario 2 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>b<block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`creating two async components, scenario 3 (patching in the same frame) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
    if (ctx['state'].flagB) {
      b3 = component(\`ChildB\`, {val: ctx['state'].valB}, key + \`__2\`, node, ctx);
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`creating two async components, scenario 3 (patching in the same frame) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>a<block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`creating two async components, scenario 3 (patching in the same frame) 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>b<block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`delay willUpdateProps 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`delay willUpdateProps 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = text(ctx['props'].value);
    let b3 = text(\`_\`);
    let b4 = text(ctx['state'].int);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`delay willUpdateProps with rendering grandchild 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Parent\`, {state: ctx['state']}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`delay willUpdateProps with rendering grandchild 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`DelayedChild\`, {value: ctx['props'].state.value}, key + \`__1\`, node, ctx);
    let b3 = component(\`ReactiveChild\`, {}, key + \`__2\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`delay willUpdateProps with rendering grandchild 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = text(ctx['props'].value);
    let b3 = text(\`_\`);
    let b4 = text(ctx['state'].int);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`delay willUpdateProps with rendering grandchild 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`destroying/recreating a subwidget with different props (if start is not over) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['state'].val>1) {
      b2 = component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`destroying/recreating a subwidget with different props (if start is not over) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>child:<block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`parent and child rendered at exact same time 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`parent and child rendered at exact same time 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].value);
  }
}"
`;

exports[`properly behave when destroyed/unmounted while rendering  1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['state'].flag) {
      b2 = component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`properly behave when destroyed/unmounted while rendering  2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`SubChild\`, {}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`properly behave when destroyed/unmounted while rendering  3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`rendering component again in next microtick 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><button block-handler-0=\\"click\\">Click</button><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    let hdlr1 = [ctx['onClick'], ctx];
    if (ctx['env'].config.flag) {
      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    }
    return block1([hdlr1], [b2]);
  }
}"
`;

exports[`rendering component again in next microtick 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div>Child</div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`t-foreach with dynamic async component 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, withKey } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['list']);
    for (let i1 = 0; i1 < l_block1; i1++) {
      ctx[\`arr\`] = v_block1[i1];
      ctx[\`arr_index\`] = i1;
      let key1 = ctx['arr_index'];
      let b3;
      if (ctx['arr']) {
        let Comp1 = ctx['myComp'];
        b3 = toggler(Comp1, component(Comp1, {key: ctx['arr'][0]}, key + \`__1__\${key1}\`, node, ctx));
      }
      c_block1[i1] = withKey(multi([b3]), key1);
    }
    return list(c_block1);
  }
}"
`;

exports[`t-foreach with dynamic async component 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].key;
    return block1([txt1]);
  }
}"
`;

exports[`t-key on dom node having a component 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const tKey_1 = ctx['key'];
    let Comp1 = ctx['myComp'];
    let b2 = toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx)));
    return toggler(tKey_1, block1([], [b2]));
  }
}"
`;

exports[`t-key on dom node having a component 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].key);
  }
}"
`;

exports[`t-key on dynamic async component (toggler is never patched) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const tKey_1 = ctx['key'];
    let Comp1 = ctx['myComp'];
    return toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx)));
  }
}"
`;

exports[`t-key on dynamic async component (toggler is never patched) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].key;
    return block1([txt1]);
  }
}"
`;

exports[`two renderings initiated between willPatch and patched 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['state'].flag) {
      const tKey_1 = 'panel_'+ctx['state'].panel;
      b2 = toggler(tKey_1, component(\`Panel\`, {val: ctx['state'].panel}, tKey_1 + key + \`__1\`, node, ctx));
    }
    return block1([], [b2]);
  }
}"
`;

exports[`two renderings initiated between willPatch and patched 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<abc><block-text-0/><block-text-1/></abc>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    let txt2 = ctx['mounted'];
    return block1([txt1, txt2]);
  }
}"
`;

exports[`two sequential renderings before an animation frame 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`two sequential renderings before an animation frame 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].value);
  }
}"
`;

exports[`update a sub-component twice in the same frame 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`update a sub-component twice in the same frame 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`update a sub-component twice in the same frame, 2 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`update a sub-component twice in the same frame, 2 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['val']();
    return block1([txt1]);
  }
}"
`;