# Source: src/ol/format/kmlformat.js

    // FIXME http://earth.google.com/kml/1.0 namespace?
    // FIXME why does node.getAttribute return an unknown type?
    // FIXME text

    goog.provide('ol.format.KML');

    goog.require('goog.Uri');
    goog.require('goog.array');
    goog.require('goog.asserts');
    goog.require('goog.dom.NodeType');
    goog.require('goog.math');
    goog.require('goog.object');
    goog.require('goog.string');
    goog.require('ol.Feature');
    goog.require('ol.array');
    goog.require('ol.feature');
    goog.require('ol.format.XMLFeature');
    goog.require('ol.format.XSD');
    goog.require('ol.geom.GeometryCollection');
    goog.require('ol.geom.GeometryType');
    goog.require('ol.geom.LineString');
    goog.require('ol.geom.MultiLineString');
    goog.require('ol.geom.MultiPoint');
    goog.require('ol.geom.MultiPolygon');
    goog.require('ol.geom.Point');
    goog.require('ol.geom.Polygon');
    goog.require('ol.proj');
    goog.require('ol.style.Fill');
    goog.require('ol.style.Icon');
    goog.require('ol.style.IconAnchorUnits');
    goog.require('ol.style.IconOrigin');
    goog.require('ol.style.Image');
    goog.require('ol.style.Stroke');
    goog.require('ol.style.Style');
    goog.require('ol.xml');

    /**
     * @typedef {{x: number, xunits: (ol.style.IconAnchorUnits|undefined),
     *            y: number, yunits: (ol.style.IconAnchorUnits|undefined)}}
     */
    ol.format.KMLVec2_;

    /**
     * @typedef {{flatCoordinates: Array.<number>,
     *            whens: Array.<number>}}
     */
    ol.format.KMLGxTrackObject_;

    /**
     * @classdesc
     * Feature format for reading and writing data in the KML format.
     *
     * @constructor
     * @extends {ol.format.XMLFeature}
     * @param {olx.format.KMLOptions=} opt_options Options.
     * @todo api
     */
    ol.format.KML = function(opt_options) {

      var options = goog.isDef(opt_options) ? opt_options : {};

      goog.base(this);

      var defaultStyle = goog.isDef(options.defaultStyle) ?
          options.defaultStyle : ol.format.KML.DEFAULT_STYLE_ARRAY_;

      /** @type {Object.<string, (Array.<ol.style.Style>|string)>} */
      var sharedStyles = {};

      var findStyle =
          /**
           * @param {Array.<ol.style.Style>|string|undefined} styleValue Style
           *     value.
           * @return {Array.<ol.style.Style>} Style.
           */
          function(styleValue) {
        if (goog.isArray(styleValue)) {
          return styleValue;
        } else if (goog.isString(styleValue)) {
          // KML files in the wild occasionally forget the leading `#` on styleUrls
          // defined in the same document.  Add a leading `#` if it enables to find
          // a style.
          if (!(styleValue in sharedStyles) && ('#' + styleValue in sharedStyles)) {
            styleValue = '#' + styleValue;
          }
          return findStyle(sharedStyles[styleValue]);
        } else {
          return defaultStyle;
        }
      };

      /**
       * @private
       * @type {Object.<string, (Array.<ol.style.Style>|string)>}
       */
      this.sharedStyles_ = sharedStyles;

      /**
       * @private
       * @type {ol.feature.FeatureStyleFunction}
       */
      this.featureStyleFunction_ =
          /**
           * @param {number} resolution Resolution.
           * @return {Array.<ol.style.Style>} Style.
           * @this {ol.Feature}
           */
          function(resolution) {
        var style = /** @type {Array.<ol.style.Style>|undefined} */
            (this.get('Style'));
        if (goog.isDef(style)) {
          return style;
        }
        var styleUrl = /** @type {string|undefined} */ (this.get('styleUrl'));
        if (goog.isDef(styleUrl)) {
          return findStyle(styleUrl);
        }
        return defaultStyle;
      };

    };
    goog.inherits(ol.format.KML, ol.format.XMLFeature);

    /**
     * @const
     * @type {Array.<string>}
     * @private
     */
    ol.format.KML.EXTENSIONS_ = ['.kml'];

    /**
     * @const
     * @type {Array.<string>}
     * @private
     */
    ol.format.KML.GX_NAMESPACE_URIS_ = [
      'http://www.google.com/kml/ext/2.2'
    ];

    /**
     * @const
     * @type {Array.<string>}
     * @private
     */
    ol.format.KML.NAMESPACE_URIS_ = [
      null,
      'http://earth.google.com/kml/2.0',
      'http://earth.google.com/kml/2.1',
      'http://earth.google.com/kml/2.2',
      'http://www.opengis.net/kml/2.2'
    ];

    /**
     * @const
     * @type {ol.Color}
     * @private
     */
    ol.format.KML.DEFAULT_COLOR_ = [255, 255, 255, 1];

    /**
     * @const
     * @type {ol.style.Fill}
     * @private
     */
    ol.format.KML.DEFAULT_FILL_STYLE_ = new ol.style.Fill({
      color: ol.format.KML.DEFAULT_COLOR_
    });

    /**
     * @const
     * @type {ol.Size}
     * @private
     */
    ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_ = [2, 20]; // FIXME maybe [8, 32] ?

    /**
     * @const
     * @type {ol.style.IconAnchorUnits}
     * @private
     */
    ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_X_UNITS_ =
        ol.style.IconAnchorUnits.PIXELS;

    /**
     * @const
     * @type {ol.style.IconAnchorUnits}
     * @private
     */
    ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_Y_UNITS_ =
        ol.style.IconAnchorUnits.PIXELS;

    /**
     * @const
     * @type {ol.Size}
     * @private
     */
    ol.format.KML.DEFAULT_IMAGE_STYLE_SIZE_ = [32, 32];

    /**
     * @const
     * @type {string}
     * @private
     */
    ol.format.KML.DEFAULT_IMAGE_STYLE_SRC_ =
        'https://maps.google.com/mapfiles/kml/pushpin/ylw-pushpin.png';

    /**
     * @const
     * @type {ol.style.Image}
     * @private
     */
    ol.format.KML.DEFAULT_IMAGE_STYLE_ = new ol.style.Icon({
      anchor: ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_,
      anchorXUnits: ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_X_UNITS_,
      anchorYUnits: ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_Y_UNITS_,
      crossOrigin: 'anonymous',
      rotation: 0,
      scale: 1,
      size: ol.format.KML.DEFAULT_IMAGE_STYLE_SIZE_,
      src: ol.format.KML.DEFAULT_IMAGE_STYLE_SRC_
    });

    /**
     * @const
     * @type {ol.style.Stroke}
     * @private
     */
    ol.format.KML.DEFAULT_STROKE_STYLE_ = new ol.style.Stroke({
      color: ol.format.KML.DEFAULT_COLOR_,
      width: 1
    });

    /**
     * @const
     * @type {ol.style.Style}
     * @private
     */
    ol.format.KML.DEFAULT_STYLE_ = new ol.style.Style({
      fill: ol.format.KML.DEFAULT_FILL_STYLE_,
      image: ol.format.KML.DEFAULT_IMAGE_STYLE_,
      text: null, // FIXME
      stroke: ol.format.KML.DEFAULT_STROKE_STYLE_,
      zIndex: 0
    });

    /**
     * @const
     * @type {Array.<ol.style.Style>}
     * @private
     */
    ol.format.KML.DEFAULT_STYLE_ARRAY_ = [ol.format.KML.DEFAULT_STYLE_];

    /**
     * @const
     * @type {Object.<string, ol.style.IconAnchorUnits>}
     * @private
     */
    ol.format.KML.ICON_ANCHOR_UNITS_MAP_ = {
      'fraction': ol.style.IconAnchorUnits.FRACTION,
      'pixels': ol.style.IconAnchorUnits.PIXELS
    };

    /**
     * @param {Node} node Node.
     * @private
     * @return {ol.Color|undefined} Color.
     */
    ol.format.KML.readColor_ = function(node) {
      var s = ol.xml.getAllTextContent(node, false);
      // The KML specification states that colors should not include a leading `#`
      // but we tolerate them.
      var m = /^\s*#?\s*([0-9A-Fa-f]{8})\s*$/.exec(s);
      if (m) {
        var hexColor = m[1];
        return [
          parseInt(hexColor.substr(6, 2), 16),
          parseInt(hexColor.substr(4, 2), 16),
          parseInt(hexColor.substr(2, 2), 16),
          parseInt(hexColor.substr(0, 2), 16) / 255
        ];

      } else {
        return undefined;
      }
    };

    /**
     * @param {Node} node Node.
     * @private
     * @return {Array.<number>|undefined} Flat coordinates.
     */
    ol.format.KML.readFlatCoordinates_ = function(node) {
      var s = ol.xml.getAllTextContent(node, false);
      var flatCoordinates = [];
      // The KML specification states that coordinate tuples should not include
      // spaces, but we tolerate them.
      var re =
          /^\s*([+\-]?\d*\.?\d+(?:e[+\-]?\d+)?)\s*,\s*([+\-]?\d*\.?\d+(?:e[+\-]?\d+)?)(?:\s*,\s*([+\-]?\d*\.?\d+(?:e[+\-]?\d+)?))?\s*/i;
      var m;
      while ((m = re.exec(s))) {
        var x = parseFloat(m[1]);
        var y = parseFloat(m[2]);
        var z = m[3] ? parseFloat(m[3]) : 0;
        flatCoordinates.push(x, y, z);
        s = s.substr(m[0].length);
      }
      if (s !== '') {
        return undefined;
      }
      return flatCoordinates;
    };

    /**
     * @param {Node} node Node.
     * @private
     * @return {string|undefined} Style URL.
     */
    ol.format.KML.readStyleUrl_ = function(node) {
      var s = goog.string.trim(ol.xml.getAllTextContent(node, false));
      if (goog.isDefAndNotNull(node.baseURI)) {
        return goog.Uri.resolve(node.baseURI, s).toString();
      } else {
        return s;
      }

    };

    /**
     * @param {Node} node Node.
     * @private
     * @return {string} URI.
     */
    ol.format.KML.readURI_ = function(node) {
      var s = ol.xml.getAllTextContent(node, false);
      if (goog.isDefAndNotNull(node.baseURI)) {
        return goog.Uri.resolve(node.baseURI, goog.string.trim(s)).toString();
      } else {
        return goog.string.trim(s);
      }
    };

    /**
     * @param {Node} node Node.
     * @private
     * @return {ol.format.KMLVec2_} Vec2.
     */
    ol.format.KML.readVec2_ = function(node) {
      var xunits = node.getAttribute('xunits');
      var yunits = node.getAttribute('yunits');
      return {
        x: parseFloat(node.getAttribute('x')),
        xunits: ol.format.KML.ICON_ANCHOR_UNITS_MAP_[xunits],
        y: parseFloat(node.getAttribute('y')),
        yunits: ol.format.KML.ICON_ANCHOR_UNITS_MAP_[yunits]
      };
    };

    /**
     * @param {Node} node Node.
     * @private
     * @return {number|undefined} Scale.
     */
    ol.format.KML.readScale_ = function(node) {
      var number = ol.format.XSD.readDecimal(node);
      if (goog.isDef(number)) {
        return Math.sqrt(number);
      } else {
        return undefined;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {Array.<ol.style.Style>|string|undefined} StyleMap.
     */
    ol.format.KML.readStyleMapValue_ = function(node, objectStack) {
      return ol.xml.pushParseAndPop(
          /** @type {Array.<ol.style.Style>|string|undefined} */ (undefined),
          ol.format.KML.STYLE_MAP_PARSERS_, node, objectStack);
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.IconStyleParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'IconStyle');
      // FIXME refreshMode
      // FIXME refreshInterval
      // FIXME viewRefreshTime
      // FIXME viewBoundScale
      // FIXME viewFormat
      // FIXME httpQuery
      var object = ol.xml.pushParseAndPop(
          {}, ol.format.KML.ICON_STYLE_PARSERS_, node, objectStack);
      if (!goog.isDef(object)) {
        return;
      }
      var styleObject = /** @type {Object} */ (objectStack[objectStack.length - 1]);
      goog.asserts.assert(goog.isObject(styleObject));
      var IconObject = /** @type {Object} */ (goog.object.get(object, 'Icon', {}));
      var src;
      var href = /** @type {string|undefined} */
          (goog.object.get(IconObject, 'href'));
      if (goog.isDef(href)) {
        src = href;
      } else {
        src = ol.format.KML.DEFAULT_IMAGE_STYLE_SRC_;
      }
      var anchor, anchorXUnits, anchorYUnits;
      var hotSpot = /** @type {ol.format.KMLVec2_|undefined} */
          (goog.object.get(object, 'hotSpot'));
      if (goog.isDef(hotSpot)) {
        anchor = [hotSpot.x, hotSpot.y];
        anchorXUnits = hotSpot.xunits;
        anchorYUnits = hotSpot.yunits;
      } else if (src === ol.format.KML.DEFAULT_IMAGE_STYLE_SRC_) {
        anchor = ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_;
        anchorXUnits = ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_X_UNITS_;
        anchorYUnits = ol.format.KML.DEFAULT_IMAGE_STYLE_ANCHOR_Y_UNITS_;
      } else if (/^http:\/\/maps\.(?:google|gstatic)\.com\//.test(src)) {
        anchor = [0.5, 0];
        anchorXUnits = ol.style.IconAnchorUnits.FRACTION;
        anchorYUnits = ol.style.IconAnchorUnits.FRACTION;
      }

      var offset;
      var x = /** @type {number|undefined} */
          (goog.object.get(IconObject, 'x'));
      var y = /** @type {number|undefined} */
          (goog.object.get(IconObject, 'y'));
      if (goog.isDef(x) && goog.isDef(y)) {
        offset = [x, y];
      }

      var size;
      var w = /** @type {number|undefined} */
          (goog.object.get(IconObject, 'w'));
      var h = /** @type {number|undefined} */
          (goog.object.get(IconObject, 'h'));
      if (goog.isDef(w) && goog.isDef(h)) {
        size = [w, h];
      }

      var rotation;
      var heading = /** @type {number|undefined} */
          (goog.object.get(object, 'heading'));
      if (goog.isDef(heading)) {
        rotation = goog.math.toRadians(heading);
      }

      var scale = /** @type {number|undefined} */
          (goog.object.get(object, 'scale'));
      if (src == ol.format.KML.DEFAULT_IMAGE_STYLE_SRC_) {
        size = ol.format.KML.DEFAULT_IMAGE_STYLE_SIZE_;
      }

      var imageStyle = new ol.style.Icon({
        anchor: anchor,
        anchorOrigin: ol.style.IconOrigin.BOTTOM_LEFT,
        anchorXUnits: anchorXUnits,
        anchorYUnits: anchorYUnits,
        crossOrigin: 'anonymous', // FIXME should this be configurable?
        offset: offset,
        offsetOrigin: ol.style.IconOrigin.BOTTOM_LEFT,
        rotation: rotation,
        scale: scale,
        size: size,
        src: src
      });
      goog.object.set(styleObject, 'imageStyle', imageStyle);
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.LineStyleParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'LineStyle');
      // FIXME colorMode
      // FIXME gx:outerColor
      // FIXME gx:outerWidth
      // FIXME gx:physicalWidth
      // FIXME gx:labelVisibility
      var object = ol.xml.pushParseAndPop(
          {}, ol.format.KML.LINE_STYLE_PARSERS_, node, objectStack);
      if (!goog.isDef(object)) {
        return;
      }
      var styleObject = objectStack[objectStack.length - 1];
      goog.asserts.assert(goog.isObject(styleObject));
      var strokeStyle = new ol.style.Stroke({
        color: /** @type {ol.Color} */
            (goog.object.get(object, 'color', ol.format.KML.DEFAULT_COLOR_)),
        width: /** @type {number} */ (goog.object.get(object, 'width', 1))
      });
      goog.object.set(styleObject, 'strokeStyle', strokeStyle);
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.PolyStyleParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'PolyStyle');
      // FIXME colorMode
      var object = ol.xml.pushParseAndPop(
          {}, ol.format.KML.POLY_STYLE_PARSERS_, node, objectStack);
      if (!goog.isDef(object)) {
        return;
      }
      var styleObject = objectStack[objectStack.length - 1];
      goog.asserts.assert(goog.isObject(styleObject));
      var fillStyle = new ol.style.Fill({
        color: /** @type {ol.Color} */
            (goog.object.get(object, 'color', ol.format.KML.DEFAULT_COLOR_))
      });
      goog.object.set(styleObject, 'fillStyle', fillStyle);
      var fill = /** @type {boolean|undefined} */ (goog.object.get(object, 'fill'));
      if (goog.isDef(fill)) {
        goog.object.set(styleObject, 'fill', fill);
      }
      var outline =
          /** @type {boolean|undefined} */ (goog.object.get(object, 'outline'));
      if (goog.isDef(outline)) {
        goog.object.set(styleObject, 'outline', outline);
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {Array.<number>} LinearRing flat coordinates.
     */
    ol.format.KML.readFlatLinearRing_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'LinearRing');
      return /** @type {Array.<number>} */ (ol.xml.pushParseAndPop(
          null, ol.format.KML.FLAT_LINEAR_RING_PARSERS_, node, objectStack));
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.gxCoordParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(goog.array.contains(
          ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI));
      goog.asserts.assert(node.localName == 'coord');
      var gxTrackObject = /** @type {ol.format.KMLGxTrackObject_} */
          (objectStack[objectStack.length - 1]);
      goog.asserts.assert(goog.isObject(gxTrackObject));
      var flatCoordinates = gxTrackObject.flatCoordinates;
      var s = ol.xml.getAllTextContent(node, false);
      var re =
          /^\s*([+\-]?\d+(?:\.\d*)?(?:e[+\-]?\d*)?)\s+([+\-]?\d+(?:\.\d*)?(?:e[+\-]?\d*)?)\s+([+\-]?\d+(?:\.\d*)?(?:e[+\-]?\d*)?)\s*$/i;
      var m = re.exec(s);
      if (m) {
        var x = parseFloat(m[1]);
        var y = parseFloat(m[2]);
        var z = parseFloat(m[3]);
        flatCoordinates.push(x, y, z, 0);
      } else {
        flatCoordinates.push(0, 0, 0, 0);
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.geom.MultiLineString|undefined} MultiLineString.
     */
    ol.format.KML.readGxMultiTrack_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(goog.array.contains(
          ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI));
      goog.asserts.assert(node.localName == 'MultiTrack');
      var lineStrings = ol.xml.pushParseAndPop(
          /** @type {Array.<ol.geom.LineString>} */ ([]),
          ol.format.KML.GX_MULTITRACK_GEOMETRY_PARSERS_, node, objectStack);
      if (!goog.isDef(lineStrings)) {
        return undefined;
      }
      var multiLineString = new ol.geom.MultiLineString(null);
      multiLineString.setLineStrings(lineStrings);
      return multiLineString;
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.geom.LineString|undefined} LineString.
     */
    ol.format.KML.readGxTrack_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(goog.array.contains(
          ol.format.KML.GX_NAMESPACE_URIS_, node.namespaceURI));
      goog.asserts.assert(node.localName == 'Track');
      var gxTrackObject = ol.xml.pushParseAndPop(
          /** @type {ol.format.KMLGxTrackObject_} */ ({
            flatCoordinates: [],
            whens: []
          }), ol.format.KML.GX_TRACK_PARSERS_, node, objectStack);
      if (!goog.isDef(gxTrackObject)) {
        return undefined;
      }
      var flatCoordinates = gxTrackObject.flatCoordinates;
      var whens = gxTrackObject.whens;
      goog.asserts.assert(flatCoordinates.length / 4 == whens.length);
      var i, ii;
      for (i = 0, ii = Math.min(flatCoordinates.length, whens.length); i < ii;
           ++i) {
        flatCoordinates[4 * i + 3] = whens[i];
      }
      var lineString = new ol.geom.LineString(null);
      lineString.setFlatCoordinates(ol.geom.GeometryLayout.XYZM, flatCoordinates);
      return lineString;
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {Object} Icon object.
     */
    ol.format.KML.readIcon_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Icon');
      var iconObject = ol.xml.pushParseAndPop(
          {}, ol.format.KML.ICON_PARSERS_, node, objectStack);
      if (goog.isDef(iconObject)) {
        return iconObject;
      } else {
        return null;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {Array.<number>} Flat coordinates.
     */
    ol.format.KML.readFlatCoordinatesFromNode_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      return /** @type {Array.<number>} */ (ol.xml.pushParseAndPop(null,
          ol.format.KML.GEOMETRY_FLAT_COORDINATES_PARSERS_, node, objectStack));
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.geom.LineString|undefined} LineString.
     */
    ol.format.KML.readLineString_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'LineString');
      var flatCoordinates =
          ol.format.KML.readFlatCoordinatesFromNode_(node, objectStack);
      if (goog.isDef(flatCoordinates)) {
        var lineString = new ol.geom.LineString(null);
        lineString.setFlatCoordinates(ol.geom.GeometryLayout.XYZ, flatCoordinates);
        return lineString;
      } else {
        return undefined;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.geom.Polygon|undefined} Polygon.
     */
    ol.format.KML.readLinearRing_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'LinearRing');
      var flatCoordinates =
          ol.format.KML.readFlatCoordinatesFromNode_(node, objectStack);
      if (goog.isDef(flatCoordinates)) {
        var polygon = new ol.geom.Polygon(null);
        polygon.setFlatCoordinates(ol.geom.GeometryLayout.XYZ, flatCoordinates,
            [flatCoordinates.length]);
        return polygon;
      } else {
        return undefined;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.geom.Geometry} Geometry.
     */
    ol.format.KML.readMultiGeometry_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'MultiGeometry');
      var geometries = ol.xml.pushParseAndPop(
          /** @type {Array.<ol.geom.Geometry>} */ ([]),
          ol.format.KML.MULTI_GEOMETRY_PARSERS_, node, objectStack);
      if (!goog.isDef(geometries)) {
        return null;
      }
      if (geometries.length === 0) {
        return new ol.geom.GeometryCollection(geometries);
      }
      var homogeneous = true;
      var type = geometries[0].getType();
      var geometry, i, ii;
      for (i = 1, ii = geometries.length; i < ii; ++i) {
        geometry = geometries[i];
        if (geometry.getType() != type) {
          homogeneous = false;
          break;
        }
      }
      if (homogeneous) {
        /** @type {ol.geom.GeometryLayout} */
        var layout;
        /** @type {Array.<number>} */
        var flatCoordinates;
        if (type == ol.geom.GeometryType.POINT) {
          var point = geometries[0];
          goog.asserts.assertInstanceof(point, ol.geom.Point);
          layout = point.getLayout();
          flatCoordinates = point.getFlatCoordinates();
          for (i = 1, ii = geometries.length; i < ii; ++i) {
            geometry = geometries[i];
            goog.asserts.assertInstanceof(geometry, ol.geom.Point);
            goog.asserts.assert(geometry.getLayout() == layout);
            ol.array.safeExtend(flatCoordinates, geometry.getFlatCoordinates());
          }
          var multiPoint = new ol.geom.MultiPoint(null);
          multiPoint.setFlatCoordinates(layout, flatCoordinates);
          return multiPoint;
        } else if (type == ol.geom.GeometryType.LINE_STRING) {
          var multiLineString = new ol.geom.MultiLineString(null);
          multiLineString.setLineStrings(geometries);
          return multiLineString;
        } else if (type == ol.geom.GeometryType.POLYGON) {
          var multiPolygon = new ol.geom.MultiPolygon(null);
          multiPolygon.setPolygons(geometries);
          return multiPolygon;
        } else if (type == ol.geom.GeometryType.GEOMETRY_COLLECTION) {
          return new ol.geom.GeometryCollection(geometries);
        } else {
          goog.asserts.fail();
          return null;
        }
      } else {
        return new ol.geom.GeometryCollection(geometries);
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.geom.Point|undefined} Point.
     */
    ol.format.KML.readPoint_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Point');
      var flatCoordinates =
          ol.format.KML.readFlatCoordinatesFromNode_(node, objectStack);
      if (goog.isDefAndNotNull(flatCoordinates)) {
        var point = new ol.geom.Point(null);
        goog.asserts.assert(flatCoordinates.length == 3);
        point.setFlatCoordinates(ol.geom.GeometryLayout.XYZ, flatCoordinates);
        return point;
      } else {
        return undefined;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.geom.Polygon|undefined} Polygon.
     */
    ol.format.KML.readPolygon_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Polygon');
      var flatLinearRings = ol.xml.pushParseAndPop(
          /** @type {Array.<Array.<number>>} */ ([null]),
          ol.format.KML.FLAT_LINEAR_RINGS_PARSERS_, node, objectStack);
      if (goog.isDefAndNotNull(flatLinearRings) &&
          !goog.isNull(flatLinearRings[0])) {
        var polygon = new ol.geom.Polygon(null);
        var flatCoordinates = flatLinearRings[0];
        var ends = [flatCoordinates.length];
        var i, ii;
        for (i = 1, ii = flatLinearRings.length; i < ii; ++i) {
          ol.array.safeExtend(flatCoordinates, flatLinearRings[i]);
          ends.push(flatCoordinates.length);
        }
        polygon.setFlatCoordinates(
            ol.geom.GeometryLayout.XYZ, flatCoordinates, ends);
        return polygon;
      } else {
        return undefined;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {Array.<ol.style.Style>} Style.
     */
    ol.format.KML.readStyle_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Style');
      var styleObject = ol.xml.pushParseAndPop(
          {}, ol.format.KML.STYLE_PARSERS_, node, objectStack);
      if (!goog.isDef(styleObject)) {
        return null;
      }
      var fillStyle = /** @type {ol.style.Fill} */ (goog.object.get(
          styleObject, 'fillStyle', ol.format.KML.DEFAULT_FILL_STYLE_));
      var fill = /** @type {boolean|undefined} */
          (goog.object.get(styleObject, 'fill'));
      if (goog.isDef(fill) && !fill) {
        fillStyle = null;
      }
      var imageStyle = /** @type {ol.style.Image} */ (goog.object.get(
          styleObject, 'imageStyle', ol.format.KML.DEFAULT_IMAGE_STYLE_));
      var strokeStyle = /** @type {ol.style.Stroke} */ (goog.object.get(
          styleObject, 'strokeStyle', ol.format.KML.DEFAULT_STROKE_STYLE_));
      var outline = /** @type {boolean|undefined} */
          (goog.object.get(styleObject, 'outline'));
      if (goog.isDef(outline) && !outline) {
        strokeStyle = null;
      }
      return [new ol.style.Style({
        fill: fillStyle,
        image: imageStyle,
        stroke: strokeStyle,
        text: null, // FIXME
        zIndex: undefined // FIXME
      })];
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.DataParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Data');
      var name = node.getAttribute('name');
      if (!goog.isNull(name)) {
        var data = ol.xml.pushParseAndPop(
            undefined, ol.format.KML.DATA_PARSERS_, node, objectStack);
        if (goog.isDef(data)) {
          var featureObject =
              /** @type {Object} */ (objectStack[objectStack.length - 1]);
          goog.asserts.assert(goog.isObject(featureObject));
          goog.object.set(featureObject, name, data);
        }
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.ExtendedDataParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'ExtendedData');
      ol.xml.parse(ol.format.KML.EXTENDED_DATA_PARSERS_, node, objectStack);
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.PairDataParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Pair');
      var pairObject = ol.xml.pushParseAndPop(
          {}, ol.format.KML.PAIR_PARSERS_, node, objectStack);
      if (!goog.isDef(pairObject)) {
        return;
      }
      var key = /** @type {string|undefined} */
          (goog.object.get(pairObject, 'key'));
      if (goog.isDef(key) && key == 'normal') {
        var styleUrl = /** @type {string|undefined} */
            (goog.object.get(pairObject, 'styleUrl'));
        if (goog.isDef(styleUrl)) {
          objectStack[objectStack.length - 1] = styleUrl;
        }
        var Style = /** @type {ol.style.Style} */
            (goog.object.get(pairObject, 'Style'));
        if (goog.isDef(Style)) {
          objectStack[objectStack.length - 1] = Style;
        }
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.PlacemarkStyleMapParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'StyleMap');
      var styleMapValue = ol.format.KML.readStyleMapValue_(node, objectStack);
      if (!goog.isDef(styleMapValue)) {
        return;
      }
      var placemarkObject = objectStack[objectStack.length - 1];
      goog.asserts.assert(goog.isObject(placemarkObject));
      if (goog.isArray(styleMapValue)) {
        goog.object.set(placemarkObject, 'Style', styleMapValue);
      } else if (goog.isString(styleMapValue)) {
        goog.object.set(placemarkObject, 'styleUrl', styleMapValue);
      } else {
        goog.asserts.fail();
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.SchemaDataParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'SchemaData');
      ol.xml.parse(ol.format.KML.SCHEMA_DATA_PARSERS_, node, objectStack);
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.SimpleDataParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'SimpleData');
      var name = node.getAttribute('name');
      if (!goog.isNull(name)) {
        var data = ol.format.XSD.readString(node);
        var featureObject =
            /** @type {Object} */ (objectStack[objectStack.length - 1]);
        goog.object.set(featureObject, name, data);
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.innerBoundaryIsParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'innerBoundaryIs');
      var flatLinearRing = ol.xml.pushParseAndPop(
          /** @type {Array.<number>|undefined} */ (undefined),
          ol.format.KML.INNER_BOUNDARY_IS_PARSERS_, node, objectStack);
      if (goog.isDef(flatLinearRing)) {
        var flatLinearRings = /** @type {Array.<Array.<number>>} */
            (objectStack[objectStack.length - 1]);
        goog.asserts.assert(goog.isArray(flatLinearRings));
        goog.asserts.assert(flatLinearRings.length > 0);
        flatLinearRings.push(flatLinearRing);
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.outerBoundaryIsParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'outerBoundaryIs');
      var flatLinearRing = ol.xml.pushParseAndPop(
          /** @type {Array.<number>|undefined} */ (undefined),
          ol.format.KML.OUTER_BOUNDARY_IS_PARSERS_, node, objectStack);
      if (goog.isDef(flatLinearRing)) {
        var flatLinearRings = /** @type {Array.<Array.<number>>} */
            (objectStack[objectStack.length - 1]);
        goog.asserts.assert(goog.isArray(flatLinearRings));
        goog.asserts.assert(flatLinearRings.length > 0);
        flatLinearRings[0] = flatLinearRing;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.whenParser_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'when');
      var gxTrackObject = /** @type {ol.format.KMLGxTrackObject_} */
          (objectStack[objectStack.length - 1]);
      goog.asserts.assert(goog.isObject(gxTrackObject));
      var whens = gxTrackObject.whens;
      var s = ol.xml.getAllTextContent(node, false);
      var re =
          /^\s*(\d{4})($|-(\d{2})($|-(\d{2})($|T(\d{2}):(\d{2}):(\d{2})(Z|(?:([+\-])(\d{2})(?::(\d{2}))?)))))\s*$/;
      var m = re.exec(s);
      if (m) {
        var year = parseInt(m[1], 10);
        var month = goog.isDef(m[3]) ? parseInt(m[3], 10) - 1 : 0;
        var day = goog.isDef(m[5]) ? parseInt(m[5], 10) : 1;
        var hour = goog.isDef(m[7]) ? parseInt(m[7], 10) : 0;
        var minute = goog.isDef(m[8]) ? parseInt(m[8], 10) : 0;
        var second = goog.isDef(m[9]) ? parseInt(m[9], 10) : 0;
        var when = Date.UTC(year, month, day, hour, minute, second);
        if (goog.isDef(m[10]) && m[10] != 'Z') {
          var sign = m[11] == '-' ? -1 : 1;
          when += sign * 60 * parseInt(m[12], 10);
          if (goog.isDef(m[13])) {
            when += sign * 60 * 60 * parseInt(m[13], 10);
          }
        }
        whens.push(when);
      } else {
        whens.push(0);
      }
    };

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.DATA_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'value': ol.xml.makeReplacer(ol.format.XSD.readString)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.EXTENDED_DATA_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'Data': ol.format.KML.DataParser_,
          'SchemaData': ol.format.KML.SchemaDataParser_
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.FLAT_LINEAR_RING_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'coordinates': ol.xml.makeReplacer(ol.format.KML.readFlatCoordinates_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.FLAT_LINEAR_RINGS_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'innerBoundaryIs': ol.format.KML.innerBoundaryIsParser_,
          'outerBoundaryIs': ol.format.KML.outerBoundaryIsParser_
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.GX_TRACK_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'when': ol.format.KML.whenParser_
        }, ol.xml.makeParsersNS(
            ol.format.KML.GX_NAMESPACE_URIS_, {
              'coord': ol.format.KML.gxCoordParser_
            }));

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.GEOMETRY_FLAT_COORDINATES_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'coordinates': ol.xml.makeReplacer(ol.format.KML.readFlatCoordinates_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.ICON_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'href': ol.xml.makeObjectPropertySetter(ol.format.KML.readURI_)
        }, ol.xml.makeParsersNS(
            ol.format.KML.GX_NAMESPACE_URIS_, {
              'x': ol.xml.makeObjectPropertySetter(ol.format.XSD.readDecimal),
              'y': ol.xml.makeObjectPropertySetter(ol.format.XSD.readDecimal),
              'w': ol.xml.makeObjectPropertySetter(ol.format.XSD.readDecimal),
              'h': ol.xml.makeObjectPropertySetter(ol.format.XSD.readDecimal)
            }));

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.ICON_STYLE_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'Icon': ol.xml.makeObjectPropertySetter(ol.format.KML.readIcon_),
          'heading': ol.xml.makeObjectPropertySetter(ol.format.XSD.readDecimal),
          'hotSpot': ol.xml.makeObjectPropertySetter(ol.format.KML.readVec2_),
          'scale': ol.xml.makeObjectPropertySetter(ol.format.KML.readScale_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.INNER_BOUNDARY_IS_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'LinearRing': ol.xml.makeReplacer(ol.format.KML.readFlatLinearRing_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.LINE_STYLE_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'color': ol.xml.makeObjectPropertySetter(ol.format.KML.readColor_),
          'width': ol.xml.makeObjectPropertySetter(ol.format.XSD.readDecimal)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.MULTI_GEOMETRY_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'LineString': ol.xml.makeArrayPusher(ol.format.KML.readLineString_),
          'LinearRing': ol.xml.makeArrayPusher(ol.format.KML.readLinearRing_),
          'MultiGeometry': ol.xml.makeArrayPusher(ol.format.KML.readMultiGeometry_),
          'Point': ol.xml.makeArrayPusher(ol.format.KML.readPoint_),
          'Polygon': ol.xml.makeArrayPusher(ol.format.KML.readPolygon_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.GX_MULTITRACK_GEOMETRY_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.GX_NAMESPACE_URIS_, {
          'Track': ol.xml.makeArrayPusher(ol.format.KML.readGxTrack_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.OUTER_BOUNDARY_IS_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'LinearRing': ol.xml.makeReplacer(ol.format.KML.readFlatLinearRing_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.PAIR_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'Style': ol.xml.makeObjectPropertySetter(ol.format.KML.readStyle_),
          'key': ol.xml.makeObjectPropertySetter(ol.format.XSD.readString),
          'styleUrl': ol.xml.makeObjectPropertySetter(ol.format.KML.readStyleUrl_)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.PLACEMARK_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'ExtendedData': ol.format.KML.ExtendedDataParser_,
          'MultiGeometry': ol.xml.makeObjectPropertySetter(
              ol.format.KML.readMultiGeometry_, 'geometry'),
          'LineString': ol.xml.makeObjectPropertySetter(
              ol.format.KML.readLineString_, 'geometry'),
          'LinearRing': ol.xml.makeObjectPropertySetter(
              ol.format.KML.readLinearRing_, 'geometry'),
          'Point': ol.xml.makeObjectPropertySetter(
              ol.format.KML.readPoint_, 'geometry'),
          'Polygon': ol.xml.makeObjectPropertySetter(
              ol.format.KML.readPolygon_, 'geometry'),
          'Style': ol.xml.makeObjectPropertySetter(ol.format.KML.readStyle_),
          'StyleMap': ol.format.KML.PlacemarkStyleMapParser_,
          'address': ol.xml.makeObjectPropertySetter(ol.format.XSD.readString),
          'description': ol.xml.makeObjectPropertySetter(ol.format.XSD.readString),
          'name': ol.xml.makeObjectPropertySetter(ol.format.XSD.readString),
          'open': ol.xml.makeObjectPropertySetter(ol.format.XSD.readBoolean),
          'phoneNumber': ol.xml.makeObjectPropertySetter(ol.format.XSD.readString),
          'styleUrl': ol.xml.makeObjectPropertySetter(ol.format.KML.readURI_),
          'visibility': ol.xml.makeObjectPropertySetter(ol.format.XSD.readBoolean)
        }, ol.xml.makeParsersNS(
            ol.format.KML.GX_NAMESPACE_URIS_, {
              'MultiTrack': ol.xml.makeObjectPropertySetter(
                  ol.format.KML.readGxMultiTrack_, 'geometry'),
              'Track': ol.xml.makeObjectPropertySetter(
                  ol.format.KML.readGxTrack_, 'geometry')
            }
        ));

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.POLY_STYLE_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'color': ol.xml.makeObjectPropertySetter(ol.format.KML.readColor_),
          'fill': ol.xml.makeObjectPropertySetter(ol.format.XSD.readBoolean),
          'outline': ol.xml.makeObjectPropertySetter(ol.format.XSD.readBoolean)
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.SCHEMA_DATA_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'SimpleData': ol.format.KML.SimpleDataParser_
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.STYLE_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'IconStyle': ol.format.KML.IconStyleParser_,
          'LineStyle': ol.format.KML.LineStyleParser_,
          'PolyStyle': ol.format.KML.PolyStyleParser_
        });

    /**
     * @const
     * @type {Object.<string, Object.<string, ol.xml.Parser>>}
     * @private
     */
    ol.format.KML.STYLE_MAP_PARSERS_ = ol.xml.makeParsersNS(
        ol.format.KML.NAMESPACE_URIS_, {
          'Pair': ol.format.KML.PairDataParser_
        });

    /**
     * @inheritDoc
     */
    ol.format.KML.prototype.getExtensions = function() {
      return ol.format.KML.EXTENSIONS_;
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {Array.<ol.Feature>|undefined} Features.
     */
    ol.format.KML.prototype.readDocumentOrFolder_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      var localName = ol.xml.getLocalName(node);
      goog.asserts.assert(localName == 'Document' || localName == 'Folder');
      // FIXME use scope somehow
      var parsersNS = ol.xml.makeParsersNS(
          ol.format.KML.NAMESPACE_URIS_, {
            'Folder': ol.xml.makeArrayExtender(this.readDocumentOrFolder_, this),
            'Placemark': ol.xml.makeArrayPusher(this.readPlacemark_, this),
            'Style': goog.bind(this.readSharedStyle_, this),
            'StyleMap': goog.bind(this.readSharedStyleMap_, this)
          });
      var features = ol.xml.pushParseAndPop(/** @type {Array.<ol.Feature>} */ ([]),
          parsersNS, node, objectStack, this);
      if (goog.isDef(features)) {
        return features;
      } else {
        return undefined;
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     * @return {ol.Feature|undefined} Feature.
     */
    ol.format.KML.prototype.readPlacemark_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Placemark');
      var object = ol.xml.pushParseAndPop({'geometry': null},
          ol.format.KML.PLACEMARK_PARSERS_, node, objectStack);
      if (!goog.isDef(object)) {
        return undefined;
      }
      var feature = new ol.Feature();
      var id = node.getAttribute('id');
      if (!goog.isNull(id)) {
        feature.setId(id);
      }
      feature.setValues(object);
      feature.setStyle(this.featureStyleFunction_);
      return feature;
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.prototype.readSharedStyle_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'Style');
      var id = node.getAttribute('id');
      if (!goog.isNull(id)) {
        var style = ol.format.KML.readStyle_(node, objectStack);
        if (goog.isDef(style)) {
          var styleUri;
          if (goog.isDefAndNotNull(node.baseURI)) {
            styleUri = goog.Uri.resolve(node.baseURI, '#' + id).toString();
          } else {
            styleUri = '#' + id;
          }
          this.sharedStyles_[styleUri] = style;
        }
      }
    };

    /**
     * @param {Node} node Node.
     * @param {Array.<*>} objectStack Object stack.
     * @private
     */
    ol.format.KML.prototype.readSharedStyleMap_ = function(node, objectStack) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      goog.asserts.assert(node.localName == 'StyleMap');
      var id = node.getAttribute('id');
      if (goog.isNull(id)) {
        return;
      }
      var styleMapValue = ol.format.KML.readStyleMapValue_(node, objectStack);
      if (!goog.isDef(styleMapValue)) {
        return;
      }
      var styleUri;
      if (goog.isDefAndNotNull(node.baseURI)) {
        styleUri = goog.Uri.resolve(node.baseURI, '#' + id).toString();
      } else {
        styleUri = '#' + id;
      }
      this.sharedStyles_[styleUri] = styleMapValue;
    };

    /**
     * Read the first feature from a KML source.
     *
     * @function
     * @param {ArrayBuffer|Document|Node|Object|string} source Source.
     * @return {ol.Feature} Feature.
     * @todo api
     */
    ol.format.KML.prototype.readFeature;

    /**
     * @inheritDoc
     */
    ol.format.KML.prototype.readFeatureFromNode = function(node) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      if (!goog.array.contains(ol.format.KML.NAMESPACE_URIS_, node.namespaceURI)) {
        return null;
      }
      goog.asserts.assert(node.localName == 'Placemark');
      var feature = this.readPlacemark_(node, []);
      if (goog.isDef(feature)) {
        return feature;
      } else {
        return null;
      }
    };

    /**
     * Read all features from a KML source.
     *
     * @function
     * @param {ArrayBuffer|Document|Node|Object|string} source Source.
     * @return {Array.<ol.Feature>} Features.
     * @todo api
     */
    ol.format.KML.prototype.readFeatures;

    /**
     * @inheritDoc
     */
    ol.format.KML.prototype.readFeaturesFromNode = function(node) {
      goog.asserts.assert(node.nodeType == goog.dom.NodeType.ELEMENT);
      if (!goog.array.contains(ol.format.KML.NAMESPACE_URIS_, node.namespaceURI)) {
        return [];
      }
      var features;
      var localName = ol.xml.getLocalName(node);
      if (localName == 'Document' || localName == 'Folder') {
        features = this.readDocumentOrFolder_(node, []);
        if (goog.isDef(features)) {
          return features;
        } else {
          return [];
        }
      } else if (localName == 'Placemark') {
        var feature = this.readPlacemark_(node, []);
        if (goog.isDef(feature)) {
          return [feature];
        } else {
          return [];
        }
      } else if (localName == 'kml') {
        features = [];
        var n;
        for (n = node.firstElementChild; !goog.isNull(n);
             n = n.nextElementSibling) {
          var fs = this.readFeaturesFromNode(n);
          if (goog.isDef(fs)) {
            goog.array.extend(features, fs);
          }
        }
        return features;
      } else {
        return [];
      }
    };

    /**
     * @param {Document|Node|string} source Souce.
     * @return {string|undefined} Name.
     */
    ol.format.KML.prototype.readName = function(source) {
      if (ol.xml.isDocument(source)) {
        return this.readNameFromDocument(/** @type {Document} */ (source));
      } else if (ol.xml.isNode(source)) {
        return this.readNameFromNode(/** @type {Node} */ (source));
      } else if (goog.isString(source)) {
        var doc = ol.xml.load(source);
        return this.readNameFromDocument(doc);
      } else {
        goog.asserts.fail();
        return undefined;
      }
    };

    /**
     * @param {Document} doc Document.
     * @return {string|undefined} Name.
     */
    ol.format.KML.prototype.readNameFromDocument = function(doc) {
      var n;
      for (n = doc.firstChild; !goog.isNull(n); n = n.nextSibling) {
        if (n.nodeType == goog.dom.NodeType.ELEMENT) {
          var name = this.readNameFromNode(n);
          if (goog.isDef(name)) {
            return name;
          }
        }
      }
      return undefined;
    };

    /**
     * @param {Node} node Node.
     * @return {string|undefined} Name.
     */
    ol.format.KML.prototype.readNameFromNode = function(node) {
      var n;
      for (n = node.firstElementChild; !goog.isNull(n); n = n.nextElementSibling) {
        if (goog.array.contains(ol.format.KML.NAMESPACE_URIS_, n.namespaceURI) &&
            n.localName == 'name') {
          return ol.format.XSD.readString(n);
        }
      }
      for (n = node.firstElementChild; !goog.isNull(n); n = n.nextElementSibling) {
        var localName = ol.xml.getLocalName(n);
        if (goog.array.contains(ol.format.KML.NAMESPACE_URIS_, n.namespaceURI) &&
            (localName == 'Document' ||
             localName == 'Folder' ||
             localName == 'Placemark' ||
             localName == 'kml')) {
          var name = this.readNameFromNode(n);
          if (goog.isDef(name)) {
            return name;
          }
        }
      }
      return undefined;
    };

    /**
     * Read the projection from a KML source.
     *
     * @function
     * @param {ArrayBuffer|Document|Node|Object|string} source Source.
     * @return {ol.proj.Projection} Projection.
     * @todo api
     */
    ol.format.KML.prototype.readProjection;

    /**
     * @inheritDoc
     */
    ol.format.KML.prototype.readProjectionFromDocument = function(doc) {
      return ol.proj.get('EPSG:4326');
    };

    /**
     * @inheritDoc
     */
    ol.format.KML.prototype.readProjectionFromNode = function(node) {
      return ol.proj.get('EPSG:4326');
    };