hunk.code_window:                 }
                   return r.join('');
               } else {
                   if (typeof XMLSerializer !== 'undefined') {
                       return (new XMLSerializer()).serializeToString(node);
                   } else {
  
hunk.labels: keep keep add keep keep keep
hunk.after_edit:                 // avoid XMLSerializer with text node for IE
                   if (node.nodeType == 3) {
                       return node.data;
                   }
  
hunk.file_path: addons/web/static/lib/qweb/qweb2.js
hunk.type: add
file: /*
  Copyright (c) 2013, Fabien Meghazi
  
  Released under the MIT license
  
  Permission is hereby granted, free of charge, to any person obtaining a copy of
  this software and associated documentation files (the "Software"), to deal in
  the Software without restriction, including without limitation the rights to use,
  copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
  Software, and to permit persons to whom the Software is furnished to do so,
  subject to the following conditions:
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
  
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
  
  // TODO: trim support
  // TODO: line number -> https://bugzilla.mozilla.org/show_bug.cgi?id=618650
  // TODO: templates orverwritten could be called by t-call="__super__" ?
  // TODO: t-set + t-value + children node == scoped variable ?
  var QWeb2 = {
      expressions_cache: { },
      RESERVED_WORDS: 'true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,this,typeof,eval,void,Math,RegExp,Array,Object,Date'.split(','),
      ACTIONS_PRECEDENCE: 'foreach,if,call,set,esc,raw,js,debug,log'.split(','),
      WORD_REPLACEMENT: {
          'and': '&&',
          'or': '||',
          'gt': '>',
          'gte': '>=',
          'lt': '<',
          'lte': '<='
      },
      VOID_ELEMENTS: 'area,base,br,col,embed,hr,img,input,keygen,link,menuitem,meta,param,source,track,wbr'.split(','),
      tools: {
          exception: function(message, context) {
              context = context || {};
              var prefix = 'QWeb2';
              if (context.template) {
                  prefix += " - template['" + context.template + "']";
              }
              throw new Error(prefix + ": " + message);
          },
          warning : function(message) {
              if (typeof(window) !== 'undefined' && window.console) {
                  window.console.warn(message);
              }
          },
          trim: function(s, mode) {
              switch (mode) {
                  case "left":
                      return s.replace(/^\s*/, "");
                  case "right":
                      return s.replace(/\s*$/, "");
                  default:
                      return s.replace(/^\s*|\s*$/g, "");
              }
          },
          js_escape: function(s, noquotes) {
              return (noquotes ? '' : "'") + s.replace(/\r?\n/g, "\\n").replace(/'/g, "\\'") + (noquotes ? '' : "'");
          },
          html_escape: function(s, attribute) {
              if (s == null) {
                  return '';
              }
              s = String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
              if (attribute) {
                  s = s.replace(/"/g, '&quot;');
              }
              return s;
          },
          gen_attribute: function(o) {
              if (o !== null && o !== undefined) {
                  if (o.constructor === Array) {
                      if (o[1] !== null && o[1] !== undefined) {
                          return this.format_attribute(o[0], o[1]);
                      }
                  } else if (typeof o === 'object') {
                      var r = '';
                      for (var k in o) {
                          if (o.hasOwnProperty(k)) {
                              r += this.gen_attribute([k, o[k]]);
                          }
                      }
                      return r;
                  }
              }
              return '';
          },
          format_attribute: function(name, value) {
              return ' ' + name + '="' + this.html_escape(value, true) + '"';
          },
          extend: function(dst, src, exclude) {
              for (var p in src) {
                  if (src.hasOwnProperty(p) && !(exclude && this.arrayIndexOf(exclude, p) !== -1)) {
                      dst[p] = src[p];
                  }
              }
              return dst;
          },
          arrayIndexOf : function(array, item) {
              for (var i = 0, ilen = array.length; i < ilen; i++) {
                  if (array[i] === item) {
                      return i;
                  }
              }
              return -1;
          },
          xml_node_to_string : function(node, childs_only) {
              if (childs_only) {
                  var childs = node.childNodes, r = [];
                  for (var i = 0, ilen = childs.length; i < ilen; i++) {
                      r.push(this.xml_node_to_string(childs[i]));
                  }
                  return r.join('');
              } else {
                  if (typeof XMLSerializer !== 'undefined') {
                      return (new XMLSerializer()).serializeToString(node);
                  } else {
                      switch(node.nodeType) {
                      case 1: return node.outerHTML;
                      case 3: return node.data;
                      case 4: return '<![CDATA[' + node.data + ']]>';
                      case 8: return '<!-- ' + node.data + '-->';
                      }
                      throw new Error('Unknown node type ' + node.nodeType);
                  }
              }
          },
          call: function(context, template, old_dict, _import, callback) {
              var new_dict = this.extend({}, old_dict);
              new_dict['__caller__'] = old_dict['__template__'];
              if (callback) {
                  new_dict[0] = callback(context, new_dict);
              }
              return context.engine._render(template, new_dict);
          },
          foreach: function(context, enu, as, old_dict, callback) {
              if (enu != null) {
                  var index, jlen, cur;
                  var size, new_dict = this.extend({}, old_dict);
                  new_dict[as + "_all"] = enu;
                  var as_value = as + "_value",
                      as_index = as + "_index",
                      as_first = as + "_first",
                      as_last = as + "_last",
                      as_parity = as + "_parity";
                  if (size = enu.length) {
                      new_dict[as + "_size"] = size;
                      for (index = 0, jlen = enu.length; index < jlen; index++) {
                          cur = enu[index];
                          new_dict[as_value] = cur;
                          new_dict[as_index] = index;
                          new_dict[as_first] = index === 0;
                          new_dict[as_last] = index + 1 === size;
                          new_dict[as_parity] = (index % 2 == 1 ? 'odd' : 'even');
                          if (cur.constructor === Object) {
                              this.extend(new_dict, cur);
                          }
                          new_dict[as] = cur;
                          callback(context, new_dict);
                      }
                  } else if (enu.constructor == Number) {
                      var _enu = [];
                      for (var i = 0; i < enu; i++) {
                          _enu.push(i);
                      }
                      this.foreach(context, _enu, as, old_dict, callback);
                  } else {
                      index = 0;
                      for (var k in enu) {
                          if (enu.hasOwnProperty(k)) {
                              cur = enu[k];
                              new_dict[as_value] = cur;
                              new_dict[as_index] = index;
                              new_dict[as_first] = index === 0;
                              new_dict[as_parity] = (index % 2 == 1 ? 'odd' : 'even');
                              new_dict[as] = k;
                              callback(context, new_dict);
                              index += 1;
                          }
                        }
                  }
  
                  _.each(Object.keys(old_dict), function(z) {
                      old_dict[z] = new_dict[z];
                  });
              } else {
                  this.exception("No enumerator given to foreach", context);
              }
          }
      }
  };
  
  QWeb2.Engine = (function() {
      function Engine() {
          // TODO: handle prefix at template level : t-prefix="x", don't forget to lowercase it
          this.prefix = 't';
          this.debug = false;
          this.templates_resources = []; // TODO: implement this.reload()
          this.templates = {};
          this.compiled_templates = {};
          this.extend_templates = {};
          this.default_dict = {};
          this.tools = QWeb2.tools;
          this.jQuery = window.jQuery;
          this.reserved_words = QWeb2.RESERVED_WORDS.slice(0);
          this.actions_precedence = QWeb2.ACTIONS_PRECEDENCE.slice(0);
          this.void_elements = QWeb2.VOID_ELEMENTS.slice(0);
          this.word_replacement = QWeb2.tools.extend({}, QWeb2.WORD_REPLACEMENT);
          this.preprocess_node = null;
          for (var i = 0; i < arguments.length; i++) {
              this.add_template(arguments[i]);
          }
      }
  
      QWeb2.tools.extend(Engine.prototype, {
          /**
           * Add a template to the engine
           *
           * @param {String|Document} template Template as string or url or DOM Document
           * @param {Function} [callback] Called when the template is loaded, force async request
           */
          add_template : function(template, callback) {
              var self = this;
              this.templates_resources.push(template);
              if (template.constructor === String) {
                  return this.load_xml(template, function (err, xDoc) {
                      if (err) {
                          if (callback) {
                              return callback(err);
                          } else {
                              throw err;
                          }
                      }
                      self.add_template(xDoc, callback);
                  });
              }
              var ec = (template.documentElement && template.documentElement.childNodes) || template.childNodes || [];
              for (var i = 0; i < ec.length; i++) {
                  var node = ec[i];
                  if (node.nodeType === 1) {
                      if (node.nodeName == 'parsererror') {
                          return this.tools.exception(node.innerText);
                      }
                      var name = node.getAttribute(this.prefix + '-name');
                      var extend = node.getAttribute(this.prefix + '-extend');
                      if (name && extend) {
                          // Clone template and extend it
                          if (!this.templates[extend]) {
                              return this.tools.exception("Can't clone undefined template " + extend);
                          }
                          this.templates[name] = this.templates[extend].cloneNode(true);
                          extend = name;
                          name = undefined;
                      }
                      if (name) {
                          this.templates[name] = node;
                          this.compiled_templates[name] = null;
                      } else if (extend) {
                          delete(this.compiled_templates[extend]);
                          if (this.extend_templates[extend]) {
                              this.extend_templates[extend].push(node);
                          } else {
                              this.extend_templates[extend] = [node];
                          }
                      }
                  }
              }
              if (callback) {
                  callback(null, template);
              }
              return true;
          },
          load_xml : function(s, callback) {
              var self = this;
              var async = !!callback;
              s = this.tools.trim(s);
              if (s.charAt(0) === '<') {
                  var tpl = this.load_xml_string(s);
                  if (callback) {
                      callback(null, tpl);
                  }
                  return tpl;
              } else {
                  var req = this.get_xhr();
                  if (this.debug) {
                      s += '?debug=' + (new Date()).getTime(); // TODO fme: do it properly in case there's already url parameters
                  }
                  req.open('GET', s, async);
                  if (async) {
                      req.addEventListener("load", function() {
                          if (req.status == 200) {
                              callback(null, self._parse_from_request(req));
                          } else {
                              callback(new Error("Can't load template " + s + ", http status " + req.status));
                          }
                      });
                  }
                  req.send(null);
                  if (!async) {
                      return this._parse_from_request(req);
                  }
              }
          },
          _parse_from_request: function(req) {
              var xDoc = req.responseXML;
              if (xDoc) {
                  if (!xDoc.documentElement) {
                      throw new Error("QWeb2: This xml document has no root document : " + xDoc.responseText);
                  }
                  if (xDoc.documentElement.nodeName == "parsererror") {
                      throw new Error("QWeb2: Could not parse document :" + xDoc.documentElement.childNodes[0].nodeValue);
                  }
                  return xDoc;
              } else {
                  return this.load_xml_string(req.responseText);
              }
          },
          load_xml_string : function(s) {
              if (window.DOMParser) {
                  var dp = new DOMParser();
                  var r = dp.parseFromString(s, "text/xml");
                  if (r.body && r.body.firstChild && r.body.firstChild.nodeName == 'parsererror') {
                      throw new Error("QWeb2: Could not parse document :" + r.body.innerText);
                  }
                  return r;
              }
              var xDoc;
              try {
                  xDoc = new ActiveXObject("MSXML2.DOMDocument");
              } catch (e) {
                  throw new Error("Could not find a DOM Parser: " + e.message);
              }
              xDoc.async = false;
              xDoc.preserveWhiteSpace = true;
              xDoc.loadXML(s);
              return xDoc;
          },
          has_template : function(template) {
              return !!this.templates[template];
          },
          get_xhr : function() {
              if (window.XMLHttpRequest) {
                  return new window.XMLHttpRequest();
              }
              try {
                  return new ActiveXObject('MSXML2.XMLHTTP.3.0');
              } catch (e) {
                  throw new Error("Could not get XHR");
              }
          },
          compile : function(node) {
              var e = new QWeb2.Element(this, node);
              var template = node.getAttribute(this.prefix + '-name');
              return  "   /* 'this' refers to Qweb2.Engine instance */\n" +
                      "   var context = { engine : this, template : " + (this.tools.js_escape(template)) + " };\n" +
                      "   dict = dict || {};\n" +
                      "   dict['__template__'] = '" + template + "';\n" +
                      "   var r = [];\n" +
                      "   /* START TEMPLATE */" +
                      (this.debug ? "" : " try {\n") +
                      (e.compile()) + "\n" +
                      "   /* END OF TEMPLATE */" +
                      (this.debug ? "" : " } catch(error) {\n" +
                      "       if (console && console.exception) console.exception(error);\n" +
                      "       context.engine.tools.exception('Runtime Error: ' + error, context);\n") +
                      (this.debug ? "" : "   }\n") +
                      "   return r.join('');";
          },
          render : function(template, dict) {
              dict = dict || {};
              QWeb2.tools.extend(dict, this.default_dict);
              /*if (this.debug && window['console'] !== undefined) {
                  console.time("QWeb render template " + template);
              }*/
              var r = this._render(template, dict);
              /*if (this.debug && window['console'] !== undefined) {
                  console.timeEnd("QWeb render template " + template);
              }*/
              return r;
          },
          _render : function(template, dict) {
              if (this.compiled_templates[template]) {
                  return this.compiled_templates[template].apply(this, [dict || {}]);
              } else if (this.templates[template]) {
                  var ext;
                  if (ext = this.extend_templates[template]) {
                      var extend_node;
                      while (extend_node = ext.shift()) {
                          this.extend(template, extend_node);
                      }
                  }
                  var code = this.compile(this.templates[template]), tcompiled;
                  try {
                      tcompiled = new Function(['dict'], code);
                  } catch (error) {
                      if (this.debug && window.console) {
                          console.log(code);
                      }
                      this.tools.exception("Error evaluating template: " + error, { template: name });
                  }
                  if (!tcompiled) {
                      this.tools.exception("Error evaluating template: (IE?)" + error, { template: name });
                  }
                  this.compiled_templates[template] = tcompiled;
                  return this.render(template, dict);
              } else {
                  return this.tools.exception("Template '" + template + "' not found");
              }
          },
          extend : function(template, extend_node) {
              var jQuery = this.jQuery;
              if (!jQuery) {
                  return this.tools.exception("Can't extend template " + template + " without jQuery");
              }
              var template_dest = this.templates[template];
              for (var i = 0, ilen = extend_node.childNodes.length; i < ilen; i++) {
                  var child = extend_node.childNodes[i];
                  if (child.nodeType === 1) {
                      var jquery = child.getAttribute(this.prefix + '-jquery'),
                          operation = child.getAttribute(this.prefix + '-operation'),
                          target,
                          error_msg = "Error while extending template '" + template;
                      if (jquery) {
                          target = jQuery(jquery, template_dest);
                          if (!target.length && window.console) {
                              console.debug('Can\'t find "'+jquery+'" when extending template '+template);
                          }
                      } else {
                          this.tools.exception(error_msg + "No expression given");
                      }
                      error_msg += "' (expression='" + jquery + "') : ";
                      if (operation) {
                          var allowed_operations = "append,prepend,before,after,replace,inner,attributes".split(',');
                          if (this.tools.arrayIndexOf(allowed_operations, operation) == -1) {
                              this.tools.exception(error_msg + "Invalid operation : '" + operation + "'");
                          }
                          operation = {'replace' : 'replaceWith', 'inner' : 'html'}[operation] || operation;
                          if (operation === 'attributes') {
                              jQuery('attribute', child).each(function () {
                                  var attrib = jQuery(this);
                                  target.attr(attrib.attr('name'), attrib.text());
                              });
                          } else {
                              target[operation](child.cloneNode(true).childNodes);
                          }
                      } else {
                          try {
                              var f = new Function(['$', 'document'], this.tools.xml_node_to_string(child, true));
                          } catch(error) {
                              return this.tools.exception("Parse " + error_msg + error);
                          }
                          try {
                              f.apply(target, [jQuery, template_dest.ownerDocument]);
                          } catch(error) {
                              return this.tools.exception("Runtime " + error_msg + error);
                          }
                      }
                  }
              }
          }
      });
      return Engine;
  })();
  
  QWeb2.Element = (function() {
      function Element(engine, node) {
          this.engine = engine;
          this.node = node;
          this.tag = node.tagName;
          this.actions = {};
          this.actions_done = [];
          this.attributes = {};
          this.children = [];
          this._top = [];
          this._bottom = [];
          this._indent = 1;
          this.process_children = true;
          this.is_void_element = ~QWeb2.tools.arrayIndexOf(this.engine.void_elements, this.tag);
          var childs = this.node.childNodes;
          if (childs) {
              for (var i = 0, ilen = childs.length; i < ilen; i++) {
                  this.children.push(new QWeb2.Element(this.engine, childs[i]));
              }
          }
          var attrs = this.node.attributes;
          if (attrs) {
              for (var j = 0, jlen = attrs.length; j < jlen; j++) {
                  var attr = attrs[j];
                  var name = attr.name;
                  var m = name.match(new RegExp("^" + this.engine.prefix + "-(.+)"));
                  if (m) {
                      name = m[1];
                      if (name === 'name') {
                          continue;
                      }
                      this.actions[name] = attr.value;
                  } else {
                      this.attributes[name] = attr.value;
                  }
              }
          }
          if (this.engine.preprocess_node) {
              this.engine.preprocess_node.call(this);
          }
      }
  
      QWeb2.tools.extend(Element.prototype, {
          compile : function() {
              var r = [],
                  instring = false,
                  lines = this._compile().split('\n');
              for (var i = 0, ilen = lines.length; i < ilen; i++) {
                  var m, line = lines[i];
                  if (m = line.match(/^(\s*)\/\/@string=(.*)/)) {
                      if (instring) {
                          if (this.engine.debug) {
                              // Split string lines in indented r.push arguments
                              r.push((m[2].indexOf("\\n") != -1 ? "',\n\t" + m[1] + "'" : '') + m[2]);
                          } else {
                              r.push(m[2]);
                          }
                      } else {
                          r.push(m[1] + "r.push('" + m[2]);
                          instring = true;
                      }
                  } else {
                      if (instring) {
                          r.push("');\n");
                      }
                      instring = false;
                      r.push(line + '\n');
                  }
              }
              return r.join('');
          },
          _compile : function() {
              switch (this.node.nodeType) {
                  case 3:
                  case 4:
                      this.top_string(this.node.data);
                  break;
                  case 1:
                      this.compile_element();
              }
              var r = this._top.join('');
              if (this.process_children) {
                  for (var i = 0, ilen = this.children.length; i < ilen; i++) {
                      var child = this.children[i];
                      child._indent = this._indent;
                      r += child._compile();
                  }
              }
              r += this._bottom.join('');
              return r;
          },
          format_expression : function(e) {
              /* Naive format expression builder. Replace reserved words and variables to dict[variable]
               * Does not handle spaces before dot yet, and causes problems for anonymous functions. Use t-js="" for that */
               if (QWeb2.expressions_cache[e]) {
                return QWeb2.expressions_cache[e];
              }
              var chars = e.split(''),
                  instring = '',
                  invar = '',
                  invar_pos = 0,
                  r = '';
              chars.push(' ');
              for (var i = 0, ilen = chars.length; i < ilen; i++) {
                  var c = chars[i];
                  if (instring.length) {
                      if (c === instring && chars[i - 1] !== "\\") {
                          instring = '';
                      }
                  } else if (c === '"' || c === "'") {
                      instring = c;
                  } else if (c.match(/[a-zA-Z_\$]/) && !invar.length) {
                      invar = c;
                      invar_pos = i;
                      continue;
                  } else if (c.match(/\W/) && invar.length) {
                      // TODO: Should check for possible spaces before dot
                      if (chars[invar_pos - 1] !== '.' && QWeb2.tools.arrayIndexOf(this.engine.reserved_words, invar) < 0) {
                          invar = this.engine.word_replacement[invar] || ("dict['" + invar + "']");
                      }
                      r += invar;
                      invar = '';
                  } else if (invar.length) {
                      invar += c;
                      continue;
                  }
                  r += c;
              }
              r = r.slice(0, -1);
              QWeb2.expressions_cache[e] = r;
              return r;
          },
          format_str: function (e) {
              if (e == '0') {
                  return 'dict[0]';
              }
              return this.format_expression(e);
          },
          string_interpolation : function(s) {
              var _this = this;
              if (!s) {
                return "''";
              }
              function append_literal(s) {
                  s && r.push(_this.engine.tools.js_escape(s));
              }
  
              var re = /(?:#{(.+?)}|{{(.+?)}})/g, start = 0, r = [], m;
              while (m = re.exec(s)) {
                  // extract literal string between previous and current match
                  append_literal(s.slice(start, re.lastIndex - m[0].length));
                  // extract matched expression
                  r.push('(' + this.format_str(m[2] || m[1]) + ')');
                  // update position of new matching
                  start = re.lastIndex;
              }
              // remaining text after last expression
              append_literal(s.slice(start));
  
              return r.join(' + ');
          },
          indent : function() {
              return this._indent++;
          },
          dedent : function() {
              if (this._indent !== 0) {
                  return this._indent--;
              }
          },
          get_indent : function() {
              return new Array(this._indent + 1).join("\t");
          },
          top : function(s) {
              return this._top.push(this.get_indent() + s + '\n');
          },
          top_string : function(s) {
              return this._top.push(this.get_indent() + "//@string=" + this.engine.tools.js_escape(s, true) + '\n');
          },
          bottom : function(s) {
              return this._bottom.unshift(this.get_indent() + s + '\n');
          },
          bottom_string : function(s) {
              return this._bottom.unshift(this.get_indent() + "//@string=" + this.engine.tools.js_escape(s, true) + '\n');
          },
          compile_element : function() {
              for (var i = 0, ilen = this.engine.actions_precedence.length; i < ilen; i++) {
                  var a = this.engine.actions_precedence[i];
                  if (a in this.actions) {
                      var value = this.actions[a];
                      var key = 'compile_action_' + a;
                      if (this[key]) {
                          this[key](value);
                      } else if (this.engine[key]) {
                          this.engine[key].call(this, value);
                      } else {
                          this.engine.tools.exception("No handler method for action '" + a + "'");
                      }
                  }
              }
              if (this.tag.toLowerCase() !== this.engine.prefix) {
                  var tag = "<" + this.tag;
                  for (var a in this.attributes) {
                      tag += this.engine.tools.gen_attribute([a, this.attributes[a]]);
                  }
                  this.top_string(tag);
                  if (this.actions.att) {
                      this.top("r.push(context.engine.tools.gen_attribute(" + (this.format_expression(this.actions.att)) + "));");
                  }
                  for (var a in this.actions) {
                      var v = this.actions[a];
                      var m = a.match(/att-(.+)/);
                      if (m) {
                          this.top("r.push(context.engine.tools.gen_attribute(['" + m[1] + "', (" + (this.format_expression(v)) + ")]));");
                      }
                      var m = a.match(/attf-(.+)/);
                      if (m) {
                          this.top("r.push(context.engine.tools.gen_attribute(['" + m[1] + "', (" + (this.string_interpolation(v)) + ")]));");
                      }
                  }
                  if (this.actions.opentag === 'true' || (!this.children.length && this.is_void_element)) {
                      // We do not enforce empty content on void elements
                      // because QWeb rendering is not necessarily html.
                      this.top_string("/>");
                  } else {
                      this.top_string(">");
                      this.bottom_string("</" + this.tag + ">");
                  }
              }
          },
          compile_action_if : function(value) {
              this.top("if (" + (this.format_expression(value)) + ") {");
              this.bottom("}");
              this.indent();
          },
          compile_action_foreach : function(value) {
              var as = this.actions['as'] || value.replace(/[^a-zA-Z0-9]/g, '_');
              //TODO: exception if t-as not valid
              this.top("context.engine.tools.foreach(context, " + (this.format_expression(value)) + ", " + (this.engine.tools.js_escape(as)) + ", dict, function(context, dict) {");
              this.bottom("});");
              this.indent();
          },
          compile_action_call : function(value) {
              if (this.children.length === 0) {
                  return this.top("r.push(context.engine.tools.call(context, " + (this.engine.tools.js_escape(value)) + ", dict));");
              } else {
                  this.top("r.push(context.engine.tools.call(context, " + (this.engine.tools.js_escape(value)) + ", dict, null, function(context, dict) {");
                  this.bottom("}));");
                  this.indent();
                  this.top("var r = [];");
                  return this.bottom("return r.join('');");
              }
          },
          compile_action_set : function(value) {
              var variable = this.format_expression(value);
              if (this.actions['value']) {
                  if (this.children.length) {
                      this.engine.tools.warning("@set with @value plus node chidren found. Children are ignored.");
                  }
                  this.top(variable + " = (" + (this.format_expression(this.actions['value'])) + ");");
                  this.process_children = false;
              } else {
                  if (this.children.length === 0) {
                      this.top(variable + " = '';");
                  } else if (this.children.length === 1 && this.children[0].node.nodeType === 3) {
                      this.top(variable + " = " + (this.engine.tools.js_escape(this.children[0].node.data)) + ";");
                      this.process_children = false;
                  } else {
                      this.top(variable + " = (function(dict) {");
                      this.bottom("})(dict);");
                      this.indent();
                      this.top("var r = [];");
                      this.bottom("return r.join('');");
                  }
              }
          },
          compile_action_esc : function(value) {
              this.top("r.push(context.engine.tools.html_escape("
                      + this.format_expression(value)
                      + "));");
          },
          compile_action_raw : function(value) {
              this.top("r.push(" + (this.format_str(value)) + ");");
          },
          compile_action_js : function(value) {
              this.top("(function(" + value + ") {");
              this.bottom("})(dict);");
              this.indent();
              var lines = this.engine.tools.xml_node_to_string(this.node, true).split(/\r?\n/);
              for (var i = 0, ilen = lines.length; i < ilen; i++) {
                  this.top(lines[i]);
              }
              this.process_children = false;
          },
          compile_action_debug : function(value) {
              this.top("debugger;");
          },
          compile_action_log : function(value) {
              this.top("console.log(" + this.format_expression(value) + ");");
          }
      });
      return Element;
  })();
  