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

exports[`t-model directive .lazy modifier 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"change\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['state'].text;
    const b3 = block3([attr1, hdlr1, txt1]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive .number modifier 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'number';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = toNumber(ev.target.value); }];
    let txt1 = ctx['state'].number;
    const b3 = block3([attr1, hdlr1, txt1]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive .trim modifier 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value.trim(); }];
    let txt1 = ctx['state'].text;
    const b3 = block3([attr1, hdlr1, txt1]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive basic use, on an input 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['state'].text;
    const b3 = block3([attr1, hdlr1, txt1]);
    return multi([b2, b3]);
  }
}"
`;

exports[`t-model directive basic use, on an input with bracket expression 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['state'].text;
    const b3 = block3([attr1, hdlr1, txt1]);
    return multi([b2, b3]);
  }
}"
`;

exports[`t-model directive basic use, on another key in component 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block1 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const bExpr1 = ctx['some'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['some'].text;
    return block1([attr1, hdlr1, txt1]);
  }
}"
`;

exports[`t-model directive can also define t-on directive on same event, part 1 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-handler-0=\\"input\\" block-attribute-1=\\"value\\" block-handler-2=\\"input\\"/>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    let hdlr1 = [ctx['onInput'], ctx];
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr2 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    const b3 = block3([hdlr1, attr1, hdlr2]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive can also define t-on directive on same event, part 2 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-handler-0=\\"click\\" block-attribute-1=\\"checked\\" block-handler-2=\\"click\\"/>
 <input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-handler-3=\\"click\\" block-attribute-4=\\"checked\\" block-handler-5=\\"click\\"/>
 <input type=\\"radio\\" id=\\"three\\" value=\\"Three\\" block-handler-6=\\"click\\" block-attribute-7=\\"checked\\" block-handler-8=\\"click\\"/>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    let hdlr1 = [ctx['onClick'], ctx];
    const bExpr1 = ctx['state'];
    const expr1 = 'choice';
    let attr1 = bExpr1[expr1] === 'One';
    let hdlr2 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let hdlr3 = [ctx['onClick'], ctx];
    const bExpr2 = ctx['state'];
    const expr2 = 'choice';
    let attr2 = bExpr2[expr2] === 'Two';
    let hdlr4 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
    let hdlr5 = [ctx['onClick'], ctx];
    const bExpr3 = ctx['state'];
    const expr3 = 'choice';
    let attr3 = bExpr3[expr3] === 'Three';
    let hdlr6 = [(ev) => { bExpr3[expr3] = ev.target.value; }];
    const b3 = block3([hdlr1, attr1, hdlr2, hdlr3, attr2, hdlr4, hdlr5, attr3, hdlr6]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive following a scope protecting directive (e.g. t-set) 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { isBoundary, withDefault, setContextValue, toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    const b2 = text(\`
 \`);
    setContextValue(ctx, \\"admiral\\", 'Bruno');
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    const b3 = block3([attr1, hdlr1]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive in a t-foreach 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { prepareList, toNumber, withKey } = helpers;
  
  let block3 = createBlock(\`<div>
 <block-child-0/>
 </div>\`);
  let block7 = createBlock(\`<input type=\\"checkbox\\" block-attribute-0=\\"checked\\" block-handler-1=\\"input\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = 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[\`thing\`] = v_block4[i1];
      const key1 = ctx['thing'].id;
      const b6 = text(\`
 \`);
      const bExpr1 = ctx['thing'];
      const expr1 = 'f';
      let attr1 = bExpr1[expr1];
      let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.checked; }];
      const b7 = block7([attr1, hdlr1]);
      const b8 = text(\`
 \`);
      c_block4[i1] = withKey(multi([b6, b7, b8]), key1);
    }
    ctx = ctx.__proto__;
    const b4 = list(c_block4);
    const b3 = block3([], [b4]);
    const b9 = text(\`
 \`);
    return multi([b2, b3, b9]);
  }
}"
`;

exports[`t-model directive in a t-foreach, part 2 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { prepareList, toNumber, withKey } = helpers;
  
  let block3 = createBlock(\`<div>
 <block-child-0/>
 </div>\`);
  let block7 = createBlock(\`<input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = 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[\`thing\`] = v_block4[i1];
      ctx[\`thing_index\`] = i1;
      const key1 = ctx['thing_index'];
      const b6 = text(\`
 \`);
      const bExpr1 = ctx['state'];
      const expr1 = ctx['thing_index'];
      let attr1 = bExpr1[expr1];
      let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
      const b7 = block7([attr1, hdlr1]);
      const b8 = text(\`
 \`);
      c_block4[i1] = withKey(multi([b6, b7, b8]), key1);
    }
    ctx = ctx.__proto__;
    const b4 = list(c_block4);
    const b3 = block3([], [b4]);
    const b9 = text(\`
 \`);
    return multi([b2, b3, b9]);
  }
}"
`;

exports[`t-model directive in a t-foreach, part 3 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { prepareList, toNumber, withKey } = helpers;
  
  let block3 = createBlock(\`<div>
 <block-child-0/>
 </div>\`);
  let block7 = createBlock(\`<input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    ctx = Object.create(ctx);
    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['names']);;
    for (let i1 = 0; i1 < l_block4; i1++) {
      ctx[\`name\`] = v_block4[i1];
      ctx[\`name_index\`] = i1;
      const key1 = ctx['name_index'];
      const b6 = text(\`
 \`);
      const bExpr1 = ctx['state'].values;
      const expr1 = ctx['name'];
      let attr1 = bExpr1[expr1];
      let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
      const b7 = block7([attr1, hdlr1]);
      const b8 = text(\`
 \`);
      c_block4[i1] = withKey(multi([b6, b7, b8]), key1);
    }
    ctx = ctx.__proto__;
    const b4 = list(c_block4);
    const b3 = block3([], [b4]);
    const b9 = text(\`
 \`);
    return multi([b2, b3, b9]);
  }
}"
`;

exports[`t-model directive on a select 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block1 = createBlock(\`<div>
 <select block-attribute-0=\\"value\\" block-handler-1=\\"change\\">
 <option value=\\"\\">Please select one</option>
 <option value=\\"red\\">Red</option>
 <option value=\\"blue\\">Blue</option>
 </select>
 <span>Choice: <block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const bExpr1 = ctx['state'];
    const expr1 = 'color';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['state'].color;
    return block1([attr1, hdlr1, txt1]);
  }
}"
`;

exports[`t-model directive on a select, initial state 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <select block-attribute-0=\\"value\\" block-handler-1=\\"change\\">
 <option value=\\"\\">Please select one</option>
 <option value=\\"red\\">Red</option>
 <option value=\\"blue\\">Blue</option>
 </select>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'color';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    const b3 = block3([attr1, hdlr1]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive on a sub state key 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'].something;
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['state'].something.text;
    const b3 = block3([attr1, hdlr1, txt1]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive on an input type=radio 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block1 = createBlock(\`<div>
 <input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-attribute-0=\\"checked\\" block-handler-1=\\"click\\"/>
 <input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-attribute-2=\\"checked\\" block-handler-3=\\"click\\"/>
 <span>Choice: <block-text-4/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const bExpr1 = ctx['state'];
    const expr1 = 'choice';
    let attr1 = bExpr1[expr1] === 'One';
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    const bExpr2 = ctx['state'];
    const expr2 = 'choice';
    let attr2 = bExpr2[expr2] === 'Two';
    let hdlr2 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
    let txt1 = ctx['state'].choice;
    return block1([attr1, hdlr1, attr2, hdlr2, txt1]);
  }
}"
`;

exports[`t-model directive on an input type=radio, with initial value 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block1 = createBlock(\`<div>
 <input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-attribute-0=\\"checked\\" block-handler-1=\\"click\\"/>
 <input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-attribute-2=\\"checked\\" block-handler-3=\\"click\\"/>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const bExpr1 = ctx['state'];
    const expr1 = 'choice';
    let attr1 = bExpr1[expr1] === 'One';
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    const bExpr2 = ctx['state'];
    const expr2 = 'choice';
    let attr2 = bExpr2[expr2] === 'Two';
    let hdlr2 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
    return block1([attr1, hdlr1, attr2, hdlr2]);
  }
}"
`;

exports[`t-model directive on an input, type=checkbox 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block1 = createBlock(\`<div>
 <input type=\\"checkbox\\" block-attribute-0=\\"checked\\" block-handler-1=\\"input\\"/>
 <span>
 <block-child-0/><block-child-1/>
 </span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    const bExpr1 = ctx['state'];
    const expr1 = 'flag';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.checked; }];
    if (ctx['state'].flag) {
      b2 = text(\`yes\`);
    } else {
      b3 = text(\`no\`);
    }
    return block1([attr1, hdlr1], [b2, b3]);
  }
}"
`;

exports[`t-model directive on an textarea 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block1 = createBlock(\`<div>
 <textarea block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['state'].text;
    return block1([attr1, hdlr1, txt1]);
  }
}"
`;

exports[`t-model directive t-model on an input with an undefined value 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block1 = createBlock(\`<input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const bExpr1 = ctx['state'];
    const expr1 = 'text';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    return block1([attr1, hdlr1]);
  }
}"
`;

exports[`t-model directive t-model on select with static options 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <select block-attribute-0=\\"value\\" block-handler-1=\\"change\\">
 <option value=\\"a\\"><block-text-2/></option>
 <option value=\\"b\\"><block-text-3/></option>
 <option value=\\"c\\"><block-text-4/></option>
 </select>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'model';
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = 'a';
    let txt2 = 'b';
    let txt3 = 'c';
    const b3 = block3([attr1, hdlr1, txt1, txt2, txt3]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive t-model with dynamic values on select options -- 2 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <select block-handler-0=\\"change\\">
 <option block-attribute-1=\\"value\\" block-attribute-2=\\"selected\\"><block-text-3/></option>
 <option block-attribute-4=\\"value\\" block-attribute-5=\\"selected\\"><block-text-6/></option>
 </select>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'model';
    const bValue1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let attr1 = ctx['options'][0];
    let attr2 = bValue1 === ctx['options'][0];
    let txt1 = ctx['options'][0];
    let attr3 = (ctx['options'][1]);
    let attr4 = bValue1 === (ctx['options'][1]);
    let txt2 = ctx['options'][1];
    const b3 = block3([hdlr1, attr1, attr2, txt1, attr3, attr4, txt2]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive t-model with dynamic values on select options -- 3 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <select block-handler-0=\\"change\\">
 <option block-attribute-1=\\"value\\" block-attribute-2=\\"selected\\"><block-text-3/></option>
 <option value=\\"b\\" block-attribute-4=\\"selected\\"><block-text-5/></option>
 </select>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'model';
    const bValue1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let attr1 = ctx['options'][0];
    let attr2 = bValue1 === ctx['options'][0];
    let txt1 = ctx['options'][0];
    let attr3 = bValue1 === \\"b\\";
    let txt2 = ctx['options'][1];
    const b3 = block3([hdlr1, attr1, attr2, txt1, attr3, txt2]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive t-model with dynamic values on select options 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <select block-handler-0=\\"change\\">
 <option block-attribute-1=\\"value\\" block-attribute-2=\\"selected\\"><block-text-3/></option>
 <option block-attribute-4=\\"value\\" block-attribute-5=\\"selected\\"><block-text-6/></option>
 </select>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'model';
    const bValue1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let attr1 = ctx['options'][0];
    let attr2 = bValue1 === ctx['options'][0];
    let txt1 = ctx['options'][0];
    let attr3 = ctx['options'][1];
    let attr4 = bValue1 === ctx['options'][1];
    let txt2 = ctx['options'][1];
    const b3 = block3([hdlr1, attr1, attr2, txt1, attr3, attr4, txt2]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`t-model directive t-model with dynamic values on select options in foreach 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber, prepareList, withKey } = helpers;
  
  let block3 = createBlock(\`<div>
 <select block-handler-0=\\"change\\">
 <block-child-0/>
 </select>
 </div>\`);
  let block7 = createBlock(\`<option block-attribute-0=\\"value\\" block-attribute-1=\\"selected\\"><block-text-2/></option>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'];
    const expr1 = 'model';
    const bValue1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    ctx = Object.create(ctx);
    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['options']);;
    for (let i1 = 0; i1 < l_block4; i1++) {
      ctx[\`v\`] = v_block4[i1];
      const key1 = ctx['v'];
      const b6 = text(\`
 \`);
      let attr1 = ctx['v'];
      let attr2 = bValue1 === ctx['v'];
      let txt1 = ctx['v'];
      const b7 = block7([attr1, attr2, txt1]);
      const b8 = text(\`
 \`);
      c_block4[i1] = withKey(multi([b6, b7, b8]), key1);
    }
    ctx = ctx.__proto__;
    const b4 = list(c_block4);
    const b3 = block3([hdlr1], [b4]);
    const b9 = text(\`
 \`);
    return multi([b2, b3, b9]);
  }
}"
`;

exports[`t-model directive two inputs in a div alternating with a t-if 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <block-child-0/>
 <block-child-1/>
 </div>\`);
  let block4 = createBlock(\`<input class=\\"a\\" block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
  let block5 = createBlock(\`<input class=\\"b\\" block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    let b4,b5;
    if (ctx['state'].flag) {
      const bExpr1 = ctx['state'];
      const expr1 = 'text1';
      let attr1 = bExpr1[expr1];
      let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
      b4 = block4([attr1, hdlr1]);
    }
    if (!ctx['state'].flag) {
      const bExpr2 = ctx['state'];
      const expr2 = 'text2';
      let attr2 = bExpr2[expr2];
      let hdlr2 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
      b5 = block5([attr2, hdlr2]);
    }
    const b3 = block3([], [b4, b5]);
    const b6 = text(\`
 \`);
    return multi([b2, b3, b6]);
  }
}"
`;

exports[`t-model directive with expression having a changing key 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
  let { toNumber } = helpers;
  
  let block3 = createBlock(\`<div>
 <input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>
 <span><block-text-2/></span>
 </div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`
 \`);
    const bExpr1 = ctx['state'].something;
    const expr1 = ctx['text'].key;
    let attr1 = bExpr1[expr1];
    let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
    let txt1 = ctx['state'].something[ctx['text'].key];
    const b3 = block3([attr1, hdlr1, txt1]);
    const b4 = text(\`
 \`);
    return multi([b2, b3, b4]);
  }
}"
`;