text: /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  var __extends = (this && this.__extends) || function (d, b) {
      for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
  import { Inject, Injectable, ViewEncapsulation } from '@angular/core';
  import { Json, StringWrapper, isArray, isBlank, isPresent, isString, stringify } from '../facade/lang';
  import { AnimationDriver } from './animation_driver';
  import { getDOM } from './dom_adapter';
  import { DOCUMENT } from './dom_tokens';
  import { EventManager } from './events/event_manager';
  import { DomSharedStylesHost } from './shared_styles_host';
  import { camelCaseToDashCase } from './util';
  var NAMESPACE_URIS = {
      'xlink': 'http://www.w3.org/1999/xlink',
      'svg': 'http://www.w3.org/2000/svg',
      'xhtml': 'http://www.w3.org/1999/xhtml'
  };
  var TEMPLATE_COMMENT_TEXT = 'template bindings={}';
  var TEMPLATE_BINDINGS_EXP = /^template bindings=(.*)$/;
  export var DomRootRenderer = (function () {
      function DomRootRenderer(document, eventManager, sharedStylesHost, animationDriver) {
          this.document = document;
          this.eventManager = eventManager;
          this.sharedStylesHost = sharedStylesHost;
          this.animationDriver = animationDriver;
          this.registeredComponents = new Map();
      }
      DomRootRenderer.prototype.renderComponent = function (componentProto) {
          var renderer = this.registeredComponents.get(componentProto.id);
          if (isBlank(renderer)) {
              renderer = new DomRenderer(this, componentProto, this.animationDriver);
              this.registeredComponents.set(componentProto.id, renderer);
          }
          return renderer;
      };
      return DomRootRenderer;
  }());
  export var DomRootRenderer_ = (function (_super) {
      __extends(DomRootRenderer_, _super);
      function DomRootRenderer_(_document, _eventManager, sharedStylesHost, animationDriver) {
          _super.call(this, _document, _eventManager, sharedStylesHost, animationDriver);
      }
      DomRootRenderer_.decorators = [
          { type: Injectable },
      ];
      /** @nocollapse */
      DomRootRenderer_.ctorParameters = [
          { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] },] },
          { type: EventManager, },
          { type: DomSharedStylesHost, },
          { type: AnimationDriver, },
      ];
      return DomRootRenderer_;
  }(DomRootRenderer));
  export var DomRenderer = (function () {
      function DomRenderer(_rootRenderer, componentProto, _animationDriver) {
          this._rootRenderer = _rootRenderer;
          this.componentProto = componentProto;
          this._animationDriver = _animationDriver;
          this._styles = _flattenStyles(componentProto.id, componentProto.styles, []);
          if (componentProto.encapsulation !== ViewEncapsulation.Native) {
              this._rootRenderer.sharedStylesHost.addStyles(this._styles);
          }
          if (this.componentProto.encapsulation === ViewEncapsulation.Emulated) {
              this._contentAttr = _shimContentAttribute(componentProto.id);
              this._hostAttr = _shimHostAttribute(componentProto.id);
          }
          else {
              this._contentAttr = null;
              this._hostAttr = null;
          }
      }
      DomRenderer.prototype.selectRootElement = function (selectorOrNode, debugInfo) {
          var el;
          if (isString(selectorOrNode)) {
              el = getDOM().querySelector(this._rootRenderer.document, selectorOrNode);
              if (isBlank(el)) {
                  throw new Error("The selector \"" + selectorOrNode + "\" did not match any elements");
              }
          }
          else {
              el = selectorOrNode;
          }
          getDOM().clearNodes(el);
          return el;
      };
      DomRenderer.prototype.createElement = function (parent, name, debugInfo) {
          var nsAndName = splitNamespace(name);
          var el = isPresent(nsAndName[0]) ?
              getDOM().createElementNS(NAMESPACE_URIS[nsAndName[0]], nsAndName[1]) :
              getDOM().createElement(nsAndName[1]);
          if (isPresent(this._contentAttr)) {
              getDOM().setAttribute(el, this._contentAttr, '');
          }
          if (isPresent(parent)) {
              getDOM().appendChild(parent, el);
          }
          return el;
      };
      DomRenderer.prototype.createViewRoot = function (hostElement) {
          var nodesParent;
          if (this.componentProto.encapsulation === ViewEncapsulation.Native) {
              nodesParent = getDOM().createShadowRoot(hostElement);
              this._rootRenderer.sharedStylesHost.addHost(nodesParent);
              for (var i = 0; i < this._styles.length; i++) {
                  getDOM().appendChild(nodesParent, getDOM().createStyleElement(this._styles[i]));
              }
          }
          else {
              if (isPresent(this._hostAttr)) {
                  getDOM().setAttribute(hostElement, this._hostAttr, '');
              }
              nodesParent = hostElement;
          }
          return nodesParent;
      };
      DomRenderer.prototype.createTemplateAnchor = function (parentElement, debugInfo) {
          var comment = getDOM().createComment(TEMPLATE_COMMENT_TEXT);
          if (isPresent(parentElement)) {
              getDOM().appendChild(parentElement, comment);
          }
          return comment;
      };
      DomRenderer.prototype.createText = function (parentElement, value, debugInfo) {
          var node = getDOM().createTextNode(value);
          if (isPresent(parentElement)) {
              getDOM().appendChild(parentElement, node);
          }
          return node;
      };
      DomRenderer.prototype.projectNodes = function (parentElement, nodes) {
          if (isBlank(parentElement))
              return;
          appendNodes(parentElement, nodes);
      };
      DomRenderer.prototype.attachViewAfter = function (node, viewRootNodes) { moveNodesAfterSibling(node, viewRootNodes); };
      DomRenderer.prototype.detachView = function (viewRootNodes) {
          for (var i = 0; i < viewRootNodes.length; i++) {
              getDOM().remove(viewRootNodes[i]);
          }
      };
      DomRenderer.prototype.destroyView = function (hostElement, viewAllNodes) {
          if (this.componentProto.encapsulation === ViewEncapsulation.Native && isPresent(hostElement)) {
              this._rootRenderer.sharedStylesHost.removeHost(getDOM().getShadowRoot(hostElement));
          }
      };
      DomRenderer.prototype.listen = function (renderElement, name, callback) {
          return this._rootRenderer.eventManager.addEventListener(renderElement, name, decoratePreventDefault(callback));
      };
      DomRenderer.prototype.listenGlobal = function (target, name, callback) {
          return this._rootRenderer.eventManager.addGlobalEventListener(target, name, decoratePreventDefault(callback));
      };
      DomRenderer.prototype.setElementProperty = function (renderElement, propertyName, propertyValue) {
          getDOM().setProperty(renderElement, propertyName, propertyValue);
      };
      DomRenderer.prototype.setElementAttribute = function (renderElement, attributeName, attributeValue) {
          var attrNs;
          var nsAndName = splitNamespace(attributeName);
          if (isPresent(nsAndName[0])) {
              attributeName = nsAndName[0] + ':' + nsAndName[1];
              attrNs = NAMESPACE_URIS[nsAndName[0]];
          }
          if (isPresent(attributeValue)) {
              if (isPresent(attrNs)) {
                  getDOM().setAttributeNS(renderElement, attrNs, attributeName, attributeValue);
              }
              else {
                  getDOM().setAttribute(renderElement, attributeName, attributeValue);
              }
          }
          else {
              if (isPresent(attrNs)) {
                  getDOM().removeAttributeNS(renderElement, attrNs, nsAndName[1]);
              }
              else {
                  getDOM().removeAttribute(renderElement, attributeName);
              }
          }
      };
      DomRenderer.prototype.setBindingDebugInfo = function (renderElement, propertyName, propertyValue) {
          var dashCasedPropertyName = camelCaseToDashCase(propertyName);
          if (getDOM().isCommentNode(renderElement)) {
              var existingBindings = StringWrapper.replaceAll(getDOM().getText(renderElement), /\n/g, '')
                  .match(TEMPLATE_BINDINGS_EXP);
              var parsedBindings = Json.parse(existingBindings[1]);
              parsedBindings[dashCasedPropertyName] = propertyValue;
              getDOM().setText(renderElement, StringWrapper.replace(TEMPLATE_COMMENT_TEXT, '{}', Json.stringify(parsedBindings)));
          }
          else {
              this.setElementAttribute(renderElement, propertyName, propertyValue);
          }
      };
      DomRenderer.prototype.setElementClass = function (renderElement, className, isAdd) {
          if (isAdd) {
              getDOM().addClass(renderElement, className);
          }
          else {
              getDOM().removeClass(renderElement, className);
          }
      };
      DomRenderer.prototype.setElementStyle = function (renderElement, styleName, styleValue) {
          if (isPresent(styleValue)) {
              getDOM().setStyle(renderElement, styleName, stringify(styleValue));
          }
          else {
              getDOM().removeStyle(renderElement, styleName);
          }
      };
      DomRenderer.prototype.invokeElementMethod = function (renderElement, methodName, args) {
          getDOM().invoke(renderElement, methodName, args);
      };
      DomRenderer.prototype.setText = function (renderNode, text) { getDOM().setText(renderNode, text); };
      DomRenderer.prototype.animate = function (element, startingStyles, keyframes, duration, delay, easing) {
          return this._animationDriver.animate(element, startingStyles, keyframes, duration, delay, easing);
      };
      return DomRenderer;
  }());
  function moveNodesAfterSibling(sibling /** TODO #9100 */, nodes /** TODO #9100 */) {
      var parent = getDOM().parentElement(sibling);
      if (nodes.length > 0 && isPresent(parent)) {
          var nextSibling = getDOM().nextSibling(sibling);
          if (isPresent(nextSibling)) {
              for (var i = 0; i < nodes.length; i++) {
                  getDOM().insertBefore(nextSibling, nodes[i]);
              }
          }
          else {
              for (var i = 0; i < nodes.length; i++) {
                  getDOM().appendChild(parent, nodes[i]);
              }
          }
      }
  }
  function appendNodes(parent /** TODO #9100 */, nodes /** TODO #9100 */) {
      for (var i = 0; i < nodes.length; i++) {
          getDOM().appendChild(parent, nodes[i]);
      }
  }
  function decoratePreventDefault(eventHandler) {
      return function (event /** TODO #9100 */) {
          var allowDefaultBehavior = eventHandler(event);
          if (allowDefaultBehavior === false) {
              // TODO(tbosch): move preventDefault into event plugins...
              getDOM().preventDefault(event);
          }
      };
  }
  var COMPONENT_REGEX = /%COMP%/g;
  export var COMPONENT_VARIABLE = '%COMP%';
  export var HOST_ATTR = "_nghost-" + COMPONENT_VARIABLE;
  export var CONTENT_ATTR = "_ngcontent-" + COMPONENT_VARIABLE;
  function _shimContentAttribute(componentShortId) {
      return StringWrapper.replaceAll(CONTENT_ATTR, COMPONENT_REGEX, componentShortId);
  }
  function _shimHostAttribute(componentShortId) {
      return StringWrapper.replaceAll(HOST_ATTR, COMPONENT_REGEX, componentShortId);
  }
  function _flattenStyles(compId, styles, target) {
      for (var i = 0; i < styles.length; i++) {
          var style = styles[i];
          if (isArray(style)) {
              _flattenStyles(compId, style, target);
          }
          else {
              style = StringWrapper.replaceAll(style, COMPONENT_REGEX, compId);
              target.push(style);
          }
      }
      return target;
  }
  var NS_PREFIX_RE = /^:([^:]+):(.+)$/;
  function splitNamespace(name) {
      if (name[0] != ':') {
          return [null, name];
      }
      var match = name.match(NS_PREFIX_RE);
      return [match[1], match[2]];
  }
  //# sourceMappingURL=dom_renderer.js.map