static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
      let parts = this._parseBindings(value, templateInfo);
      if (parts) {
        // Attribute or property
        let origName = name;
        let kind = 'property';
        // The only way we see a capital letter here is if the attr has
        // a capital letter in it per spec. In this case, to make sure
        // this binding works, we go ahead and make the binding to the attribute.
        if (capitalAttributeRegex.test(name)) {
          kind = 'attribute';
        } else if (name[name.length-1] == '$') {
          name = name.slice(0, -1);
          kind = 'attribute';
        }
        // Initialize attribute bindings with any literal parts
        let literal = literalFromParts(parts);
        if (literal && kind == 'attribute') {
          node.setAttribute(name, literal);
        }
        // Clear attribute before removing, since IE won't allow removing
        // `value` attribute if it previously had a value (can't
        // unconditionally set '' before removing since attributes with `$`
        // can't be set using setAttribute)
        if (node.localName === 'input' && origName === 'value') {
          node.setAttribute(origName, '');
        }
        // Remove annotation
        node.removeAttribute(origName);
        // Case hackery: attributes are lower-case, but bind targets
        // (properties) are case sensitive. Gambit is to map dash-case to
        // camel-case: `foo-bar` becomes `fooBar`.
        // Attribute bindings are excepted.
        if (kind === 'property') {
          name = dashToCamelCase(name);
        }
        addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);
        return true;
      } else {
        return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
      }
    }
/**
     * Overrides default `TemplateStamp` implementation to add support for
     * parsing bindings from attributes.  A `bindings`
     * array is added to `nodeInfo` and populated with binding metadata
     * with information capturing the binding target, and a `parts` array
     * with one or more metadata objects capturing the source(s) of the
     * binding.
     *
     * @override
     * @param {Element} node Node to parse
     * @param {TemplateInfo} templateInfo Template metadata for current template
     * @param {NodeInfo} nodeInfo Node metadata for current template node
     * @param {string} name Attribute name
     * @param {string} value Attribute value
     * @return {boolean} `true` if the visited node added node-specific
     *   metadata to `nodeInfo`
     * @protected
     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
     */
Overrides default `TemplateStamp` implementation to add support for
parsing bindings from attributes.


Overrides default ` TemplateStamp ` implementation to add support for parsing bindings from attributes .
static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
      let parts = this._parseBindings(value, templateInfo);
      if (parts) {
        let origName = name;
        let kind = 'property';
        if (capitalAttributeRegex.test(name)) {
          kind = 'attribute';
        } else if (name[name.length-1] == '$') {
          name = name.slice(0, -1);
          kind = 'attribute';
        }
        let literal = literalFromParts(parts);
        if (literal && kind == 'attribute') {
          node.setAttribute(name, literal);
        }
        if (node.localName === 'input' && origName === 'value') {
          node.setAttribute(origName, '');
        }
        node.removeAttribute(origName);
        if (kind === 'property') {
          name = dashToCamelCase(name);
        }
        addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);
        return true;
      } else {
        return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
      }
    }
static _parseTemplateNodeAttribute ( node , templateInfo , nodeInfo , name , value ) { let parts = this . _parseBindings ( value , templateInfo ) ; if ( parts ) { let origName = name ; let kind = 'property' ; if ( capitalAttributeRegex . test ( name ) ) { kind = 'attribute' ; } else if ( name [ name . length - 1 ] == '$' ) { name = name . slice ( 0 , - 1 ) ; kind = 'attribute' ; } let literal = literalFromParts ( parts ) ; if ( literal && kind == 'attribute' ) { node . setAttribute ( name , literal ) ; } if ( node . localName === 'input' && origName === 'value' ) { node . setAttribute ( origName , '' ) ; } node . removeAttribute ( origName ) ; if ( kind === 'property' ) { name = dashToCamelCase ( name ) ; } addBinding ( this , templateInfo , nodeInfo , kind , name , parts , literal ) ; return true ; } else { return super . _parseTemplateNodeAttribute ( node , templateInfo , nodeInfo , name , value ) ; } }
Overrides default `TemplateStamp` implementation to add support for
 parsing bindings from attributes.
Overrides default ` TemplateStamp ` implementation to add support for parsing bindings from attributes .
// Attribute or property // The only way we see a capital letter here is if the attr has // a capital letter in it per spec. In this case, to make sure // this binding works, we go ahead and make the binding to the attribute. // Initialize attribute bindings with any literal parts // Clear attribute before removing, since IE won't allow removing // `value` attribute if it previously had a value (can't // unconditionally set '' before removing since attributes with `$` // can't be set using setAttribute) // Remove annotation // Case hackery: attributes are lower-case, but bind targets // (properties) are case sensitive. Gambit is to map dash-case to // camel-case: `foo-bar` becomes `fooBar`. // Attribute bindings are excepted.