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

exports[`slots can define a default content 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(\`Dialog\`, {}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`slots can define a default content 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return text(\`default content\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = callSlot(ctx, node, key, 'default', false, {}, defaultContent1);
    return block1([], [b3]);
  }
}"
`;

exports[`slots can define and call slots 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<span>header</span>\`);
  let block3 = createBlock(\`<span>footer</span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return block2();
  }
  
  function slot2(ctx, node, key = \\"\\") {
    return block3();
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b4 = component(\`Dialog\`, {slots: markRaw({'header': {__render: slot1, __ctx: ctx1}, 'footer': {__render: slot2, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b4]);
  }
}"
`;

exports[`slots can define and call slots 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><div><block-child-0/></div><div><block-child-1/></div></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'header', false, {});
    let b3 = callSlot(ctx, node, key, 'footer', false, {});
    return block1([], [b2, b3]);
  }
}"
`;

exports[`slots can define and call slots with bound params 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, bind, markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`abc\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    return component(\`Child\`, {slots: markRaw({'abc': {__render: slot1, __ctx: ctx1, getValue: bind(ctx, ctx['getValue'])}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots can define and call slots with bound params 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'abc', false, {});
    let b3 = text(ctx['props'].slots['abc'].getValue());
    return multi([b2, b3]);
  }
}"
`;

exports[`slots can define and call slots with params 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<span>header</span>\`);
  let block3 = createBlock(\`<span>footer</span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return block2();
  }
  
  function slot2(ctx, node, key = \\"\\") {
    return block3();
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b4 = component(\`Dialog\`, {slots: markRaw({'header': {__render: slot1, __ctx: ctx1, param: ctx['var']}, 'footer': {__render: slot2, __ctx: ctx1, param: '5'}})}, key + \`__1\`, node, ctx);
    return block1([], [b4]);
  }
}"
`;

exports[`slots can define and call slots with params 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-text-0/><div><block-child-0/></div><block-text-1/><div><block-child-1/></div></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].slots['header'].param;
    let b2 = callSlot(ctx, node, key, 'header', false, {});
    let txt2 = ctx['props'].slots['footer'].param;
    let b3 = callSlot(ctx, node, key, 'footer', false, {});
    return block1([txt1, txt2], [b2, b3]);
  }
}"
`;

exports[`slots can render node with t-ref and Component in same slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block2 = createBlock(\`<div block-ref=\\"0\\"/>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    const refs = ctx.__owl__.refs;
    const ref1 = (el) => refs[\`div\`] = el;
    let b2 = block2([ref1]);
    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
  }
}"
`;

exports[`slots can render node with t-ref and Component in same slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots can render only empty slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots can use component in default-content of t-slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots can use component in default-content of t-slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {}, defaultContent1);
  }
}"
`;

exports[`slots can use component in default-content of t-slot 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`\`);
  }
}"
`;

exports[`slots can use t-call in default-content of t-slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots can use t-call in default-content of t-slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot, getTemplate } = helpers;
  const callTemplate_1 = getTemplate(\`__template__999\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return callTemplate_1.call(this, ctx, node, key + \`__1\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {}, defaultContent1);
  }
}"
`;

exports[`slots can use t-call in default-content of t-slot 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`\`);
  }
}"
`;

exports[`slots content is the default slot (variation) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<span>sts rocks</span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return block1();
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots content is the default slot (variation) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots content is the default slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<span>sts rocks</span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return block2();
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots content is the default slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots default content is not rendered if named slot is provided 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`hey\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Dialog\`, {slots: markRaw({'header': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots default content is not rendered if named slot is provided 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return text(\`default content\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = callSlot(ctx, node, key, 'header', false, {}, defaultContent1);
    return block1([], [b3]);
  }
}"
`;

exports[`slots default content is not rendered if slot is provided 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`hey\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots default content is not rendered if slot is provided 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return text(\`default content\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = callSlot(ctx, node, key, 'default', false, {}, defaultContent1);
    return block1([], [b3]);
  }
}"
`;

exports[`slots default slot next to named slot, with default content 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\` Overridden footer \`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Dialog\`, {slots: markRaw({'footer': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots default slot next to named slot, with default content 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div class=\\"Dialog\\"><div class=\\"content\\"><block-child-0/></div><div class=\\"footer\\"><block-child-1/></div></div>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return text(\` Default content \`);
  }
  
  function defaultContent2(ctx, node, key = \\"\\") {
    return text(\` Default footer \`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = callSlot(ctx, node, key, 'default', false, {}, defaultContent1);
    let b5 = callSlot(ctx, node, key, 'footer', false, {}, defaultContent2);
    return block1([], [b3, b5]);
  }
}"
`;

exports[`slots default slot with params with - in it 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(ctx['slotScope']['some-value']);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx, __scope: \\"slotScope\\"}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots default slot with params with - in it 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {'some-value': ctx['state'].value});
  }
}"
`;

exports[`slots default slot with slot scope: shorthand syntax 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['slotScope'].bool) {
      b2 = text(\`some text\`);
    } else {
      b3 = text(\`other text\`);
    }
    return multi([b2, b3]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx, __scope: \\"slotScope\\"}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots default slot with slot scope: shorthand syntax 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {bool: ctx['state'].bool});
    return block1([], [b2]);
  }
}"
`;

exports[`slots default slot work with text nodes (variation) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`sts rocks\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots default slot work with text nodes (variation) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots default slot work with text nodes 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`sts rocks\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots default slot work with text nodes 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots dynamic t-slot call 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block3 = createBlock(\`<p>slot1</p>\`);
  let block4 = createBlock(\`<span>content</span>\`);
  let block5 = createBlock(\`<h1>slot2</h1>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let b3 = block3();
    let b4 = block4();
    return multi([b3, b4]);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    return block5();
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b6 = component(\`Toggler\`, {slots: markRaw({'slot1': {__render: slot1, __ctx: ctx1}, 'slot2': {__render: slot2, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b6]);
  }
}"
`;

exports[`slots dynamic t-slot call 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-child-0/></button>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['toggle'], ctx];
    const slot1 = (ctx['current'].slot);
    let b2 = toggler(slot1, callSlot(ctx, node, key, slot1), true, {});
    return block1([hdlr1], [b2]);
  }
}"
`;

exports[`slots dynamic t-slot call with default 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block3 = createBlock(\`<p>slot1</p>\`);
  let block4 = createBlock(\`<span>content</span>\`);
  let block5 = createBlock(\`<h1>slot2</h1>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let b3 = block3();
    let b4 = block4();
    return multi([b3, b4]);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    return block5();
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b6 = component(\`Toggler\`, {slots: markRaw({'slot1': {__render: slot1, __ctx: ctx1}, 'slot2': {__render: slot2, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b6]);
  }
}"
`;

exports[`slots dynamic t-slot call with default 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-child-0/></button>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return text(\` owl \`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['toggle'], ctx];
    let b3 = callSlot(ctx, node, key, (ctx['current'].slot), true, {}, defaultContent1);
    return block1([hdlr1], [b3]);
  }
}"
`;

exports[`slots fun: two calls to the same slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`some text\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots fun: two calls to the same slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    let b3 = callSlot(ctx, node, key, 'default', false, {});
    return multi([b2, b3]);
  }
}"
`;

exports[`slots missing slots are ignored 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(\`Dialog\`, {}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`slots missing slots are ignored 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/><span>some content</span><block-child-1/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    let b3 = callSlot(ctx, node, key, 'footer', false, {});
    return block1([], [b2, b3]);
  }
}"
`;

exports[`slots mix of slots, t-call, t-call with body, and giving own props child 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`P\`, {}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots mix of slots, t-call, t-call with body, and giving own props child 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block2 = createBlock(\`<button block-handler-0=\\"click\\">inc</button>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['inc'], ctx];
    let b2 = block2([hdlr1]);
    let b3 = component(\`A\`, {number: ctx['state'].number}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`slots mix of slots, t-call, t-call with body, and giving own props child 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, getTemplate, markRaw } = helpers;
  const callTemplate_1 = getTemplate(\`__template__1002\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let b2 = text(\`[A]\`);
    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
    return multi([b2, b3]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    return component(\`B\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
  }
}"
`;

exports[`slots mix of slots, t-call, t-call with body, and giving own props child 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { isBoundary, withDefault, setContextValue, getTemplate } = helpers;
  const callTemplate_1 = getTemplate(\`__template__1001\`);
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    let b2 = text(\`[sub1] \`);
    setContextValue(ctx, \\"dummy\\", ctx['validate']);
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1;
    setContextValue(ctx, \\"v\\", ctx['props'].number);
    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
    return multi([b2, b3]);
  }
}"
`;

exports[`slots mix of slots, t-call, t-call with body, and giving own props child 5`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = text(\`[sub2\`);
    let b3 = text(ctx['v']);
    let b4 = text(\`]\`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`slots mix of slots, t-call, t-call with body, and giving own props child 6`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = text(\`[B]\`);
    let b3 = component(\`C\`, {slots: ctx['props'].slots}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`slots mix of slots, t-call, t-call with body, and giving own props child 7`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = text(\`[C]\`);
    let b3 = callSlot(ctx, node, key, 'default', false, {});
    return multi([b2, b3]);
  }
}"
`;

exports[`slots multiple roots are allowed in a default slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block3 = createBlock(\`<span>sts</span>\`);
  let block4 = createBlock(\`<span>rocks</span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let b3 = block3();
    let b4 = block4();
    return multi([b3, b4]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b5 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
    return block1([], [b5]);
  }
}"
`;

exports[`slots multiple roots are allowed in a default slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots multiple roots are allowed in a named slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block3 = createBlock(\`<span>sts</span>\`);
  let block4 = createBlock(\`<span>rocks</span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let b3 = block3();
    let b4 = block4();
    return multi([b3, b4]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b5 = component(\`Dialog\`, {slots: markRaw({'content': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b5]);
  }
}"
`;

exports[`slots multiple roots are allowed in a named slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'content', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots multiple slots containing components 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`C\`, {val: 1}, key + \`__1\`, node, ctx);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    return component(\`C\`, {val: 2}, key + \`__2\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    return component(\`B\`, {slots: markRaw({'s1': {__render: slot1, __ctx: ctx1}, 's2': {__render: slot2, __ctx: ctx1}})}, key + \`__3\`, node, ctx);
  }
}"
`;

exports[`slots multiple slots containing components 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 's1', false, {});
    let b3 = callSlot(ctx, node, key, 's2', false, {});
    return block1([], [b2, b3]);
  }
}"
`;

exports[`slots multiple slots containing components 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['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`slots named slot inside slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<p>A<block-text-0/></p>\`);
  let block3 = createBlock(\`<p>B<block-text-0/></p>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let txt1 = ctx['value'];
    return block2([txt1]);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    const ctx2 = capture(ctx);
    return component(\`Child\`, {slots: markRaw({'brol': {__render: slot3, __ctx: ctx2}})}, key + \`__1\`, node, ctx);
  }
  
  function slot3(ctx, node, key = \\"\\") {
    let txt2 = ctx['value'];
    return block3([txt2]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b5 = component(\`Child\`, {slots: markRaw({'brol': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
    return block1([], [b5]);
  }
}"
`;

exports[`slots named slot inside slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'brol', false, {});
    let b3 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2, b3]);
  }
}"
`;

exports[`slots named slot inside slot, part 3 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<p>A<block-text-0/></p>\`);
  let block3 = createBlock(\`<p>B<block-text-0/></p>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let txt1 = ctx['value'];
    return block2([txt1]);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    const ctx2 = capture(ctx);
    return component(\`Child\`, {slots: markRaw({'brol': {__render: slot3, __ctx: ctx2}})}, key + \`__1\`, node, ctx);
  }
  
  function slot3(ctx, node, key = \\"\\") {
    let txt2 = ctx['value'];
    return block3([txt2]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b5 = component(\`Child\`, {slots: markRaw({'brol': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
    return block1([], [b5]);
  }
}"
`;

exports[`slots named slot inside slot, part 3 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'brol', false, {});
    let b3 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2, b3]);
  }
}"
`;

exports[`slots named slots can define a default content 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(\`Dialog\`, {}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`slots named slots can define a default content 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return text(\`default content\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = callSlot(ctx, node, key, 'header', false, {}, defaultContent1);
    return block1([], [b3]);
  }
}"
`;

exports[`slots named slots inside slot, again 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<p>A<block-text-0/></p>\`);
  let block3 = createBlock(\`<p>B<block-text-0/></p>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let txt1 = ctx['value'];
    return block2([txt1]);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    const ctx2 = capture(ctx);
    return component(\`Child\`, {slots: markRaw({'brol2': {__render: slot3, __ctx: ctx2}})}, key + \`__1\`, node, ctx);
  }
  
  function slot3(ctx, node, key = \\"\\") {
    let txt2 = ctx['value'];
    return block3([txt2]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b5 = component(\`Child\`, {slots: markRaw({'brol1': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
    return block1([], [b5]);
  }
}"
`;

exports[`slots named slots inside slot, again 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<child><block-child-0/><block-child-1/><block-child-2/></child>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    return text(\`default1\`);
  }
  
  function defaultContent2(ctx, node, key = \\"\\") {
    return text(\`default2\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = callSlot(ctx, node, key, 'brol1', false, {}, defaultContent1);
    let b5 = callSlot(ctx, node, key, 'brol2', false, {}, defaultContent2);
    let b6 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b3, b5, b6]);
  }
}"
`;

exports[`slots nested slots in same template 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<span id=\\"parent\\"><block-child-0/></span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`Child2\`, {slots: markRaw({'default': {__render: slot2, __ctx: ctx}})}, key + \`__2\`, node, ctx);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    return component(\`Child3\`, {}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b4 = component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__3\`, node, ctx);
    return block1([], [b4]);
  }
}"
`;

exports[`slots nested slots in same template 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span id=\\"c1\\"><div><block-child-0/></div></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots nested slots in same template 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span id=\\"c2\\"><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots nested slots in same template 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>Child 3</span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`slots nested slots: evaluation context and parented relationship 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`Slot\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
  }
}"
`;

exports[`slots nested slots: evaluation context and parented relationship 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot, markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`GrandChild\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots nested slots: evaluation context and parented relationship 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots nested slots: evaluation context and parented relationship 4`] = `
"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[`slots no named slot content => just no children 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Dialog\`, {}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots no named slot content => just no children 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'header', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots simple default slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`some text\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots simple default slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots simple default slot with params 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['slotScope'].bool) {
      b2 = text(\`some text\`);
    } else {
      b3 = text(\`other text\`);
    }
    return multi([b2, b3]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots simple default slot with params 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {bool: ctx['state'].bool});
    return block1([], [b2]);
  }
}"
`;

exports[`slots simple default slot with params and bound function 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(ctx['slotScope'].fn());
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx, __scope: \\"slotScope\\"}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots simple default slot with params and bound function 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot, bind } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {fn: bind(ctx, ctx['getValue'])});
  }
}"
`;

exports[`slots simple default slot, variation 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`some text\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots simple default slot, variation 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots simple slot with slot scope 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['slotScope'].bool) {
      b2 = text(\`some text\`);
    } else {
      b3 = text(\`other text\`);
    }
    return multi([b2, b3]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    return component(\`Child\`, {slots: markRaw({'slotName': {__render: slot1, __ctx: ctx1, __scope: \\"slotScope\\"}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots simple slot with slot scope 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'slotName', false, {bool: ctx['state'].bool});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slot and (inline) t-call 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, getTemplate, markRaw } = helpers;
  const callTemplate_1 = getTemplate(\`__template__999\`);
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return callTemplate_1.call(this, ctx, node, key + \`__1\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slot and (inline) t-call 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p>sokka</p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`slots slot and (inline) t-call 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slot and t-call 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, getTemplate, markRaw } = helpers;
  const callTemplate_1 = getTemplate(\`__template__999\`);
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return callTemplate_1.call(this, ctx, node, key + \`__1\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slot and t-call 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<p>sokka</p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`slots slot and t-call 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slot and t-esc 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text('toph');
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slot and t-esc 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slot are properly rendered if inner props are changed 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><button block-handler-0=\\"click\\">Inc[<block-text-1/>]</button><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`SomeComponent\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['inc'], ctx];
    let txt1 = ctx['state'].val;
    let b3 = component(\`GenericComponent\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
    return block1([hdlr1, txt1], [b3]);
  }
}"
`;

exports[`slots slot are properly rendered if inner props are changed 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slot are properly rendered if inner props are changed 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div> SC:<block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`slots slot content has different key from other content -- dynamic slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`Child\`, {parent: 'Parent'}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`SlotDisplay\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
  }
}"
`;

exports[`slots slot content has different key from other content -- dynamic slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {parent: 'SlotDisplay'}, key + \`__1\`, node, ctx);
    const slot1 = (ctx['slotName']);
    let b3 = toggler(slot1, callSlot(ctx, node, key, slot1), true, {});
    return multi([b2, b3]);
  }
}"
`;

exports[`slots slot content has different key from other content -- dynamic slot 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'].parent;
    return block1([txt1]);
  }
}"
`;

exports[`slots slot content has different key from other content -- static slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`Child\`, {parent: 'Parent'}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`SlotDisplay\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
  }
}"
`;

exports[`slots slot content has different key from other content -- static slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {parent: 'SlotDisplay'}, key + \`__1\`, node, ctx);
    let b3 = callSlot(ctx, node, key, 'default', false, {});
    return multi([b2, b3]);
  }
}"
`;

exports[`slots slot content has different key from other content -- static slot 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'].parent;
    return block1([txt1]);
  }
}"
`;

exports[`slots slot content is bound to caller (variation) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, isBoundary, withDefault, setContextValue, markRaw } = helpers;
  
  let block1 = createBlock(\`<button block-handler-0=\\"click\\">some text</button>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    setContextValue(ctx, \\"var\\", 1);
    let hdlr1 = [()=>this.inc(), ctx];
    return block1([hdlr1]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots slot content is bound to caller (variation) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slot content is bound to caller 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<button block-handler-0=\\"click\\">some text</button>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['inc'], ctx];
    return block1([hdlr1]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots slot content is bound to caller 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slot preserves properly parented relationship 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slot preserves properly parented relationship 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots slot preserves properly parented relationship 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`Grand Child\`);
  }
}"
`;

exports[`slots slot preserves properly parented relationship, even through t-call 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, getTemplate, markRaw } = helpers;
  const callTemplate_1 = getTemplate(\`sub\`);
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return callTemplate_1.call(this, ctx, node, key + \`__1\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slot preserves properly parented relationship, even through t-call 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots slot preserves properly parented relationship, even through t-call 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots slot preserves properly parented relationship, even through t-call 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`Grand Child\`);
  }
}"
`;

exports[`slots slots and wrapper components 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  function slot1(ctx, node, key = \\"\\") {
    return text(\`hey\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Link\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots slots and wrapper components 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<a href=\\"abc\\"><block-child-0/></a>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots are properly bound to correct component 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots slots are properly bound to correct component 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot, isBoundary, withDefault, setContextValue } = helpers;
  
  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-text-1/></button>\`);
  
  function defaultContent1(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    setContextValue(ctx, \\"var\\", 1);
    let hdlr1 = [()=>this.increment(), ctx];
    let txt1 = ctx['state'].value;
    return block1([hdlr1, txt1]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {}, defaultContent1);
  }
}"
`;

exports[`slots slots are rendered with proper context 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><span class=\\"counter\\"><block-text-0/></span><block-child-0/></div>\`);
  let block2 = createBlock(\`<button block-handler-0=\\"click\\">do something</button>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['doSomething'], ctx];
    return block2([hdlr1]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['state'].val;
    const ctx1 = capture(ctx);
    let b3 = component(\`Dialog\`, {slots: markRaw({'footer': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([txt1], [b3]);
  }
}"
`;

exports[`slots slots are rendered with proper context 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'footer', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots are rendered with proper context, part 2 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, capture, markRaw, withKey } = helpers;
  
  let block1 = createBlock(\`<div><u><block-child-0/></u></div>\`);
  let block3 = createBlock(\`<li><block-child-0/></li>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let b5 = text(\`User \`);
    let b6 = text(ctx['user'].name);
    return multi([b5, b6]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].users);
    for (let i1 = 0; i1 < l_block2; i1++) {
      ctx[\`user\`] = v_block2[i1];
      let key1 = ctx['user'].id;
      const ctx1 = capture(ctx);
      let b7 = component(\`Link\`, {to: '/user/'+ctx['user'].id,slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1__\${key1}\`, node, ctx);
      c_block2[i1] = withKey(block3([], [b7]), key1);
    }
    let b2 = list(c_block2);
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots are rendered with proper context, part 2 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<a block-attribute-0=\\"href\\"><block-child-0/></a>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let attr1 = ctx['props'].to;
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([attr1], [b2]);
  }
}"
`;

exports[`slots slots are rendered with proper context, part 3 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, isBoundary, withDefault, setContextValue, capture, markRaw, withKey } = helpers;
  
  let block1 = createBlock(\`<div><u><block-child-0/></u></div>\`);
  let block3 = createBlock(\`<li><block-child-0/></li>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(ctx['userdescr']);
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    ctx = Object.create(ctx);
    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].users);
    for (let i1 = 0; i1 < l_block2; i1++) {
      ctx[\`user\`] = v_block2[i1];
      let key1 = ctx['user'].id;
      setContextValue(ctx, \\"userdescr\\", 'User '+ctx['user'].name);
      const ctx1 = capture(ctx);
      let b5 = component(\`Link\`, {to: '/user/'+ctx['user'].id,slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1__\${key1}\`, node, ctx);
      c_block2[i1] = withKey(block3([], [b5]), key1);
    }
    let b2 = list(c_block2);
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots are rendered with proper context, part 3 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<a block-attribute-0=\\"href\\"><block-child-0/></a>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let attr1 = ctx['props'].to;
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([attr1], [b2]);
  }
}"
`;

exports[`slots slots are rendered with proper context, part 4 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { isBoundary, withDefault, setContextValue, capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(ctx['userdescr']);
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    setContextValue(ctx, \\"userdescr\\", 'User '+ctx['state'].user.name);
    const ctx1 = capture(ctx);
    let b3 = component(\`Link\`, {to: '/user/'+ctx['state'].user.id,slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slots are rendered with proper context, part 4 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<a block-attribute-0=\\"href\\"><block-child-0/></a>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let attr1 = ctx['props'].to;
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([attr1], [b2]);
  }
}"
`;

exports[`slots slots in slots, with vars 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { isBoundary, withDefault, setContextValue, capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<p>hey<block-text-0/></p>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let txt1 = ctx['test'];
    return block2([txt1]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    setContextValue(ctx, \\"test\\", ctx['state'].name);
    const ctx1 = capture(ctx);
    let b3 = component(\`A\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slots in slots, with vars 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`B\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots slots in slots, with vars 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots in t-foreach and re-rendering 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, capture, markRaw, withKey } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(ctx['n_index']);
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(2));
    for (let i1 = 0; i1 < l_block2; i1++) {
      ctx[\`n\`] = v_block2[i1];
      ctx[\`n_index\`] = i1;
      let key1 = ctx['n_index'];
      const ctx1 = capture(ctx);
      c_block2[i1] = withKey(component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1__\${key1}\`, node, ctx), key1);
    }
    let b2 = list(c_block2);
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots in t-foreach and re-rendering 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-text-0/><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['state'].val;
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([txt1], [b2]);
  }
}"
`;

exports[`slots slots in t-foreach in t-foreach 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, capture, markRaw, withKey } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block4 = createBlock(\`<div><block-text-0/></div>\`);
  let block5 = createBlock(\`<ul><block-child-0/></ul>\`);
  let block7 = createBlock(\`<li><block-text-0/></li>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let txt2 = ctx['node1'].value;
    return block7([txt2]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['tree']);
    for (let i1 = 0; i1 < l_block2; i1++) {
      ctx[\`node1\`] = v_block2[i1];
      let key1 = ctx['node1'].key;
      let txt1 = ctx['node1'].value;
      let b4 = block4([txt1]);
      ctx = Object.create(ctx);
      const [k_block6, v_block6, l_block6, c_block6] = prepareList(ctx['node1'].nodes);
      for (let i2 = 0; i2 < l_block6; i2++) {
        ctx[\`node2\`] = v_block6[i2];
        let key2 = ctx['node2'].key;
        const ctx1 = capture(ctx);
        c_block6[i2] = withKey(component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1__\${key1}__\${key2}\`, node, ctx), key2);
      }
      ctx = ctx.__proto__;
      let b6 = list(c_block6);
      let b5 = block5([], [b6]);
      c_block2[i1] = withKey(multi([b4, b5]), key1);
    }
    let b2 = list(c_block2);
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots in t-foreach in t-foreach 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots in t-foreach with t-set and re-rendering 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, isBoundary, withDefault, setContextValue, capture, markRaw, withKey } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return text(ctx['dummy']);
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    ctx = Object.create(ctx);
    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(2));
    for (let i1 = 0; i1 < l_block2; i1++) {
      ctx[\`n\`] = v_block2[i1];
      ctx[\`n_index\`] = i1;
      let key1 = ctx['n_index'];
      setContextValue(ctx, \\"dummy\\", ctx['n_index']);
      const ctx1 = capture(ctx);
      c_block2[i1] = withKey(component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1__\${key1}\`, node, ctx), key1);
    }
    let b2 = list(c_block2);
    return block1([], [b2]);
  }
}"
`;

exports[`slots slots in t-foreach with t-set and re-rendering 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-text-0/><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['state'].val;
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([txt1], [b2]);
  }
}"
`;

exports[`slots t-debug on a t-set-slot (defining a slot) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    debugger;
    return text(\`abc\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Dialog\`, {slots: markRaw({'content': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots t-debug on a t-set-slot (defining a slot) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'content', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots t-set t-value in a slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, isBoundary, withDefault, setContextValue, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    setContextValue(ctx, \\"rainbow\\", 'dash');
    return text(ctx['rainbow']);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots t-set t-value in a slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots t-slot in recursive templates 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, prepareList, isBoundary, withDefault, setContextValue, getTemplate, withKey, markRaw } = helpers;
  const callTemplate_1 = getTemplate(\`_test_recursive_template\`);
  
  function slot1(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    let b2 = text(ctx['name']);
    ctx = Object.create(ctx);
    const [k_block3, v_block3, l_block3, c_block3] = prepareList(ctx['items']);
    for (let i1 = 0; i1 < l_block3; i1++) {
      ctx[\`item\`] = v_block3[i1];
      ctx[\`item_first\`] = i1 === 0;
      ctx[\`item_last\`] = i1 === v_block3.length - 1;
      ctx[\`item_index\`] = i1;
      ctx[\`item_value\`] = k_block3[i1];
      let key1 = ctx['item'].name;
      let b5,b6;
      if (!ctx['item'].children.length) {
        b5 = text(ctx['item'].name);
      } else {
        ctx = Object.create(ctx);
        ctx[isBoundary] = 1;
        setContextValue(ctx, \\"name\\", ctx['item'].name);
        setContextValue(ctx, \\"items\\", ctx['item'].children);
        b6 = callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`);
        ctx = ctx.__proto__;
      }
      c_block3[i1] = withKey(multi([b5, b6]), key1);
    }
    ctx = ctx.__proto__;
    let b3 = list(c_block3);
    return multi([b2, b3]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    return component(\`Wrapper\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
  }
}"
`;

exports[`slots t-slot in recursive templates 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<wrapper><block-child-0/></wrapper>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots t-slot nested within another slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<span id=\\"c1\\"><block-child-0/></span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`Child3\`, {}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots t-slot nested within another slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot, markRaw } = helpers;
  
  let block1 = createBlock(\`<span id=\\"c2\\"><block-child-0/></span>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`Portal\`, {slots: markRaw({'default': {__render: slot2, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
  
  function slot2(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b4 = component(\`Modal\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
    return block1([], [b4]);
  }
}"
`;

exports[`slots t-slot nested within another slot 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span id=\\"modal\\"><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots t-slot nested within another slot 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<span id=\\"portal\\"><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots t-slot nested within another slot 5`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span>Child 3</span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`slots t-slot scope context 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<button>The Button</button>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return block1();
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Dialog\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots t-slot scope context 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot, markRaw } = helpers;
  
  let block1 = createBlock(\`<div block-handler-0=\\"click\\"><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['onClick'], ctx];
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([hdlr1], [b2]);
  }
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Wrapper\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`slots t-slot scope context 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots t-slot within dynamic t-call 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { capture, call, markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    const template1 = (ctx['tcallTemplate']);
    return call(this, template1, ctx, node, key + \`__1\`);
  }
  
  return function template(ctx, node, key = \\"\\") {
    const ctx1 = capture(ctx);
    let b3 = component(\`Slotted\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots t-slot within dynamic t-call 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  let block1 = createBlock(\`<div class=\\"slotted\\"><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = callSlot(ctx, node, key, 'default', false, {});
    return block1([], [b2]);
  }
}"
`;

exports[`slots t-slot within dynamic t-call 3`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div class=\\"slot\\"><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`slots t-slot within dynamic t-call 4`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div class=\\"child\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    return block1();
  }
}"
`;

exports[`slots template can just return a slot 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { markRaw } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  function slot1(ctx, node, key = \\"\\") {
    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
  }
  
  return function template(ctx, node, key = \\"\\") {
    let b3 = component(\`SlotComponent\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`slots template can just return a slot 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { callSlot } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return callSlot(ctx, node, key, 'default', false, {});
  }
}"
`;

exports[`slots template can just return a slot 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['props'].value;
    return block1([txt1]);
  }
}"
`;